Show ASCII table: Difference between revisions

 

;Task:

<br><br>

 

 

=={{header|6502 Assembly}}==

; task : show ascii table

; language: 6502 Assembly

column .byte 0

ascii .byte 0

 

=={{header|8080 Assembly}}==

 

mvi a,32 ; Start with space

mvi d,16 ; 16 lines

spc: db 'Spc ',0 ; Space

del: db 'Del ',0 ; Del

 

{{out}}

=={{header|8086 Assembly}}==

 

bits 16

putch: equ 2h

spc: db 'Spc ',0 ; Space

del: db 'Del ',0 ; Del

 

{{out}}

46: . 62: > 78: N 94: ^ 110: n 126: ~

47: / 63: ? 79: O 95: _ 111: o 127: Del</pre>

 

=={{header|Ada}}==

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

 

New_Line;

end loop;

{{out}}

<pre> 32 : Spc 48 : 0 64 : @ 80 : P 96 : ` 112 : p

 

=={{header|ALGOL 68}}==

, ": "

FI

)

{{out}}

 

=={{header|ALGOL W}}==

{{out}}

 

=={{header|APL}}==

 

 

{{out}}

 

=={{header|AppleScript}}==

on asciiTable()

script row

set my text item delimiters to dlm

str

{{Out}}

<pre> 32 : Spc 48 : 0 64 : @ 80 : P 96 : ` 112 : p

47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del </pre>

 

 

MessageText := ;The text to display in the final message box.

}

MsgBox, % MessageText ;Displays a message box with the ASCII conversion table, from the MessageText variable

{{out}}

<pre>

{{works with|GAWK}}

{{works with|MAWK}}

# syntax: MAWK -f SHOW_ASCII_TABLE.AWK

BEGIN {

for (i=0; i<16; i++) {

else if (j == 127) { x = "DEL" }

else { x = sprintf("%c",j) }

printf("%3d: %-5s",j,x)

}

}

{{out}}

33: ! 49: 1 65: A 81: Q 97: a 113: q

34: " 50: 2 66: B 82: R 98: b 114: r

46: . 62: > 78: N 94: ^ 110: n 126: ~

47: / 63: ? 79: O 95: _ 111: o 127: DEL</pre>

 

=={{header|C}}==

{{trans|Go}}

 

int main() {

}

return 0;

{{out}}

<pre> 32 : Spc 48 : 0 64 : @ 80 : P 96 : ` 112 : p

46 : . 62 : > 78 : N 94 : ^ 110 : n 126 : ~

47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del </pre>

 

=={{header|C sharp}}==

using static System.Linq.Enumerable;

 

string Text(int index) => index == 32 ? "Sp" : index == 127 ? "Del" : (char)index + "";

}

{{out}}

<pre> 32 : Sp 48 : 0 64 : @ 80 : P 96 : ` 112 : p

 

=={{header|Caché ObjectScript}}==

; this is 96 characters, so do 6 columns of 16

for i = 32:1:127 {

}

 

 

{{out}}

 

Further down, the code will be modified to handle the more general case of a grid where the number of codes to be displayed doesn't match the product of the numbers of rows and columns in the desired grid. That case is made a little trickier by the desire to print the table in "column-major order", which seems the friendlier to the end-user reading the table.

(defn cell [code]

(let [text (get {32 "Spc", 127 "Del"} code (char code))]

(defn pr-ascii-table [n-cols st-code end-code]

(println (ascii-table n-cols st-code end-code)))

 

{{out}}

There are 2 output examples, the first simply creates a grid with an incomplete final column. The second case additionally demonstrates the ability to modify the range of ASCII codes displayed.

 

(defn cell [code]

(if (nil? code)

(defn pr-ascii-table [n-cols st-code end-code]

(println (ascii-table n-cols st-code end-code)))

 

{{out}}

47: / 60: < 73: I 86: V 99: c 112: p

48: 0 61: = 74: J 87: W 100: d 113: q

</pre>

 

=={{header|Commodore BASIC}}==

110 PRINT CHR$(14);:REM CHARACTER SET 2

120 PRINT "COMMODORE 64 - BASIC V2"

200 PRINT

210 NEXT R

{{out}}

[[File:c64asciitable.jpg]]

 

=={{header|Common Lisp}}==

(setq endVal 127)

(setq cols 6)

(if (> lower upper) '() (cons lower (get-range (+ 1 lower) upper))))

 

{{out}}

<pre> 32: SPC 33: ! 34: " 35: # 36: $ 37: %

116: t 117: u 118: v 119: w 120: x 121: y

122: z 123: { 124: | 125: } 126: ~ 127: DEL</pre>

 

=={{header|Dc}}==

{{Works with|GNU dc|1.3.95}}

 

## for initcode condcode incrcode body

] lfx

[]pP

{{out}}

<pre>

47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del

</pre>

 

=={{header|Factor}}==

===Idiomatic version===

{{Works with|Factor|0.98}}

pair-rocket sequences ;

IN: rosetta-code.ascii-table

: print-ascii-table ( -- ) 16 <iota> [ print-row ] each ;

 

===Go translation===

{{Trans|Go}}

{{Works with|Factor|0.98}}

pair-rocket sequences ;

IN: rosetta-code.ascii-table

;

 

{{out}}

<pre> 32 : Spc 48 : 0 64 : @ 80 : P 96 : ` 112 : p

=={{header|Forth}}==

Idiomatic Forth version is factored differently than conventional languages, allowing each factor to be tested independently at the console, bottom up.

: ###: ( c -- ) 3 .R ." : " ;

 

 

: ASCII.TABLE ( -- )

 

Test Output at the console

32: spc 48: 0 64: @ 80: P 96: ` 112: p

33: ! 49: 1 65: A 81: Q 97: a 113: q

45: - 61: = 77: M 93: ] 109: m 125: }

46: . 62: > 78: N 94: ^ 110: n 126: ~

 

 

 

 

 

 

var

begin

 

 

 

{{out}}

 

=={{header|Go}}==

 

import "fmt"

fmt.Println()

}

 

{{out}}

46 : . 62 : > 78 : N 94 : ^ 110 : n 126 : ~

47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del </pre>

 

=={{header|Haskell}}==

 

asciiTable :: String

asciiTable =

unlines $

 

asciiEntry :: Int -> String

 

asciiName :: Int -> String

| otherwise = [chr n]

 

 

{{Out}}

<pre> 32 : Spc 48 : 0 64 : @ 80 : P 96 : ` 112 : p

47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del </pre>

 

 

=={{header|J}}==

 

 

=={{header|Java}}==

public class ShowAsciiTable {

 

 

}

{{out}}

<pre>

116: t 117: u 118: v 119: w 120: x 121: y

122: z 123: { 124: | 125: } 126: ~ 127: Del

</pre>

 

=={{header|JavaScript}}==

 

// asciiTable :: String

const asciiTable = () =>

)

 

// asciiEntry :: Int -> String

const asciiEntry = n => {

const k = asciiName(n);

};

 

const asciiName = n =>

32 > n || 127 < n ? (

) : 32 === n ? (

) : 127 === n ? (

) : chr(n);

 

 

// chr :: Int -> Char

 

};

 

 

 

// enumFromTo :: Int -> Int -> [Int]

 

 

// justifyLeft :: Int -> Char -> String -> String

 

// justifyRight :: Int -> Char -> String -> String

 

 

// transpose :: [[a]] -> [[a]]

 

 

return asciiTable();

{{Out}}

<pre> 32 : Spc 48 : 0 64 : @ 80 : P 96 : ` 112 : p

 

=={{header|Jsish}}==

 

/* Show ASCII table, -showAll true to include control codes */

015 SI 031 US 047 / 063 ? 079 O 095 _ 111 o 127 DEL

=!EXPECTEND!=

{{out}}

<pre>prompt$ jsish -u showASCIITable.jsi

046 . 062 > 078 N 094 ^ 110 n 126 ~

047 / 063 ? 079 O 095 _ 111 o 127 DEL</pre>

 

=={{header|Julia}}==

===Base Task===

c= i== 0 ? "NUL" : i== 7 ? "BEL" : i== 8 ? "BKS" : i== 9 ? "TAB" :

i==10 ? "LF " : i==13 ? "CR " : i==27 ? "ESC" : i==155 ? "CSI" : "|$(Char(i))|"

print("$(lpad(i,3)) $(string(i,base=16,pad=2)) $c")

(i&7)==7 ? println() : print(" ")

<pre>

32 20 | | 33 21 |!| 34 22 |"| 35 23 |#| 36 24 |$| 37 25 |%| 38 26 |&| 39 27 |'|

{{works with|Julia|1.0}}

 

c= i== 0 ? "NUL" : i== 7 ? "BEL" : i== 8 ? "BKS" : i== 9 ? "TAB" :

i==10 ? "LF " : i==13 ? "CR " : i==27 ? "ESC" : i==155 ? "CSI" : "|$(Char(i))|"

print("$(lpad(i,3)) $(string(i,base=16,pad=2)) $c")

(i&7)==7 ? println() : print(" ")

{{out}}

<pre> 0 00 NUL 1 01 |☺| 2 02 |☻| 3 03 |♥| 4 04 |♦| 5 05 |♣| 6 06 |♠| 7 07 BEL

This version draws a more fancy table, positioning the items on the console monitor with ANSI control sequences:

 

print("""

0 1 2 3 4 5 6 7 8 9 A B C D E F

6<i<11 || i==155 || i==173 || print("\e[$r;$(c)H$(Char(i))")

end

{{out}}

<pre> 0 1 2 3 4 5 6 7 8 9 A B C D E F

 

A similar output can be produced without ANSI control sequences, just filling up a huge string and printing it. Below is a general Object (struct) and the corresponding methods to draw a table of arbitrary shape in the console. It is the Julia way of OOP. The Table structure holds the relevant data and the constructor. The Base.iterate function extends the general iterate function, and allows using the field names in a function, w/o prefixing them with "<structName>." The function prt() fills up a string with data, formatting spaces and new-lines, and prints it to the console.

rn: nrows, rh: height of rows

cn: ncols, cw: width of columns

end

println("\n$t\n")

Using these is simple, only provide the data, and prt it.

Tbl.CH[1,:] = string.(0:15,base=16) # Column headers

Tbl.RH[:,2] = string.(0:15,base=16) # Row headers

Tbl.T[i>>4+1,i&15+1,1:2]=["$i",i∈(0,7,8,9,10,13,27,155) ? "" : "$(Char(i))"]

end

 

=={{header|Kotlin}}==

{{trans|Go}}

 

fun main(args: Array<String>) {

println()

}

 

{{output}}

46 : . 62 : > 78 : N 94 : ^ 110 : n 126 : ~

47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del </pre>

 

=={{header|langur}}==

{{trans|Go}}

for .j = 31 + .i ; .j < 128 ; .j += 16 {

}

writeln()

 

{{out}}

46 : . 62 : > 78 : N 94 : ^ 110 : n 126 : ~

47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : del </pre>

 

=={{header|Lua}}==

{{trans|Go}}

-- map of character values to desired representation

local chars = setmetatable({[32] = "Spc", [127] = "Del"}, {__index = function(_, k) return string.char(k) end})

end

io.write"\n"

 

{{out}}

46 : . 62 : > 78 : N 94 : ^ 110 : n 126 : ~

47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del </pre>

 

=={{header|MiniScript}}==

// Note changing the values of startChar and endChar will print

// a flexible table in that range

end if

end for

{{out}}

<pre>

122 : z 123 : { 124 : | 125 : } 126 : ~ 127 : DEL

</pre>

 

=={{header|Nanoquery}}==

{{trans|C}}

for i in range(0, 15)

for j in range(32 + i, 127, 16)

end

println

 

{{out}}

 

=={{header|Nim}}==

for i in 0..15:

for j in countup(32 + i, 127, step = 16):

write(stdout, fmt"{j:3d} : {k:<6s}")

{{out}}

<pre>

47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del

</pre>

 

=={{header|Perl}}==

Output in the same style as Raku.

{{trans|Raku}}

binmode STDOUT, ':utf8';

 

}

}

 

=={{header|Phix}}==

{{out}}

<pre> 32 (#20): 48 (#30): 0 64 (#40): @ 80 (#50): P 96 (#60): ` 112 (#70): p