Rosetta Code

Show ASCII table: Difference between revisions

Page Discussion

Show ASCII table (view source)

Revision as of 13:54, 4 March 2024

4,584 bytes added ,  2 months ago
→‎{{header|langur}}
(Add Modula-2)
(19 intermediate revisions by 10 users not shown)
Line 437:
 
=={{header|ALGOL 68}}==
<syntaxhighlight lang="algol68">BEGIN
# generate an ascii table for characters 32 - 127 #
FOR c FROM 32 TO 32 + 15 DO
INT char count := 1;
FOR cach FROM 32c BY 16 TO 127c + ( 16 * 5 ) DO
print( ( whole( cach, -4 )
, ": "
, IF cach = 32 THEN "SPC"
ELIF cach = 127 THEN "DEL"
ELSE " " + REPR cach + " "
FI
)
);
OD;
IF char count = 0 THEN print( ( newline ) ) FI;
print( ( charnewline count PLUSAB 1) ) MODAB 6
OD
END</syntaxhighlight>
{{out}}
<pre> 32: SPC 3348: !0 3464: "@ 3580: #P 3696: $` 37112: %p
3833: &! 3949: '1 4065: (A 4181: )Q 4297: *a 43113: +q
4434: ," 4550: -2 4666: .B 4782: /R 4898: 0b 49114: 1r
5035: 2# 51: 3 5267: 4C 5383: 5S 5499: 6c 55115: 7s
5636: 8$ 5752: 94 5868: :D 5984: ;T 60100: < d 61116: =t
6237: >% 6353: ?5 6469: @E 6585: AU 66101: B e 67117: Cu
6838: D& 6954: E6 70: F 7186: GV 72102: H f 73118: Iv
7439: J' 7555: K7 7671: LG 7787: MW 78103: N g 79119: Ow
8040: P( 8156: Q8 8272: RH 8388: SX 84104: T h 85120: Ux
8641: V) 8757: W9 8873: XI 89: Y 90105: Z i 91121: [y
9242: \* 9358: ]: 9474: ^J 9590: _Z 96106: ` j 97122: az
9843: b+ 9959: c; 100 75: dK 10191: e[ 102107: fk 103123: g{
104 44: h, 105 60: i< 106 76: jL 10792: k\ 108: l 109124: m|
110 45: n- 111 61: o= 112 77: pM 11393: q] 114109: rm 115125: s}
116 46: t. 117 62: u> 118 78: vN 11994: w^ 120110: xn 121126: y~
122 47: z/ 123 63: {? 124 79: |O 125 95: }_ 126111: ~o 127: DEL</pre>
</pre>
 
=={{header|ALGOL W}}==
This assumes the ASCII character set is used by the Algol W compiler/runtime - the original Algol W implementation used EBCDIC.
<syntaxhighlight lang="algolw">begin
<syntaxhighlight lang="algolw">% generate an ascii table for chars 32 - 127 %
for i := 32 until 32 + 15 do begin
integer cPos;
cPos := 0write();
for ic := 32i step 16 until 127i + ( 16 * 5 ) do begin
ifwriteon( cPosi_w := 3, s_w := 0, thenc, ": " write();
cPosif := ( cPos + 1 )c rem= 6; 32 then writeon( "Spc ")
writeon(else i_wif c := 3,127 s_wthen := 0, i,writeon( ":Del " );
ifelse i = 32 then writeon( code( c ), "Spc " )
end for_ach
else if i = 127 then writeon( "Del " )
end for_i.
else writeon( code( i ), " " )
</syntaxhighlight>
end for_i
end.</syntaxhighlight>
{{out}}
<pre>
<pre> 32: Spc 33: ! 34: " 35: # 36: $ 37: %
3832: &Spc 3948: '0 4064: (@ 4180: )P 4296: * ` 43112: +p
4433: ,! 4549: -1 4665: .A 4781: /Q 4897: 0a 49113: 1q
5034: 2" 5150: 32 5266: 4B 5382: 5R 5498: 6 b 55114: 7r
5635: 8# 5751: 93 5867: :C 5983: ;S 6099: < c 61115: =s
6236: >$ 6352: ?4 6468: @D 6584: AT 66100: B d 67116: Ct
6837: D% 6953: E5 7069: FE 7185: GU 72101: H e 73117: Iu
7438: J& 7554: K6 7670: LF 7786: MV 78102: N f 79118: Ov
8039: P' 8155: Q7 8271: RG 8387: SW 84103: T g 85119: Uw
8640: V( 8756: W8 8872: XH 8988: YX 90104: Z h 91120: [x
9241: \) 9357: ]9 9473: ^I 9589: _Y 96105: ` i 97121: ay
9842: b* 9958: c: 100 74: dJ 10190: eZ 102106: fj 103122: gz
104 43: h+ 105 59: i; 106 75: jK 107 91: k[ 108107: lk 109123: m{
110 44: n, 111 60: o< 112 76: pL 11392: q\ 114108: rl 115124: s|
116 45: t- 117 61: u= 118 77: vM 11993: w] 120109: xm 121125: y}
122 46: z. 123 62: {> 124 78: |N 125 94: }^ 126110: ~n 127126: Del</pre>~
47: / 63: ? 79: O 95: _ 111: o 127: Del
</pre>
 
=={{header|APL}}==
Line 1,565 ⟶ 1,567:
#include <iostream>
 
inline constexpr auto HEIGHT = 16;
 
#defineinline HEIGHTconstexpr auto WIDTH 16 = 6;
inline constexpr auto ASCII_START = 32;
#define WIDTH 6
#define ASCII_START 32
#define ASCII_END 128
// ASCII special characters
inline constexpr auto SPACE = 32;
#define SPACE 32
inline constexpr auto DELETE = 127;
#define DELETE 127
 
std::string displayAscii(intchar ascii) {
switch (ascii) {
case SPACE: return "Spc";
case DELETE: return "SpcDel";
default: return std::string(1, ascii);
case DELETE:
return "Del";}
default:
return std::string(1,char(ascii));
}
}
 
int main(void) {
for (std::size_t row = 0; row < HEIGHT; ++row) {
 
for (intstd::size_t rowcol = 0; rowcol < HEIGHTWIDTH; ++rowcol) {
for(int col = 0; col < WIDTH; const auto ascii = ASCII_START + row + col) {* HEIGHT;
std::cout << std::right << std::setw(3) << ascii << " : " << std::left << std::setw(6) << displayAscii(ascii);
int ascii = ASCII_START + row + col*HEIGHT;
}
std::cout << std::right << std::setw(3) << ascii << " : " \
<< std::leftcout << std::setw(6) << displayAscii(ascii)'\n';
}
std::cout << std::endl;
}
}</syntaxhighlight>
{{out}}
Line 2,191 ⟶ 2,186:
46 : . 62 : > 78 : N 94 : ^ 110 : n 126 : ~
47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del</pre>
 
=={{header|EasyLang}}==
{{trans|AWK}}
 
<syntaxhighlight lang="easylang">
numfmt 0 3
for i range0 16
for j = 32 + i step 16 to 127
if j = 32
x$ = "Spc"
elif j = 127
x$ = "Del"
else
x$ = strchar j & " "
.
write j & ": " & x$
.
print ""
.
</syntaxhighlight>
 
=={{header|Ecstasy}}==
<syntaxhighlight lang="java">
module testShowAsciiTable {
{
@Inject Console console;
void run() {
for (Int offset : 0..<16) {
for (Int ascii = 32+offset; :ascii 0..< 128; ascii += 16) {
{
for (Int ascii = 32+offset; ascii < 128; ascii += 16)
{
console.print($|{ascii.toString().rightJustify(3)}/\
|{ascii.toByte().toByteArray()}: \
|{new Char(ascii).quoted().leftJustify(5)}
, suppressNewline=True);
}
console.print();
}
console.print();
}
}
}
</syntaxhighlight>
 
Line 3,066 ⟶ 3,077:
=={{header|Fōrmulæ}}==
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Show_ASCII_table}}
Fōrmulæ programs are not textual, visualization/edition of programs is done showing/manipulating structures but not text. Moreover, there can be multiple visual representations of the same program. Even though it is possible to have textual representation &mdash;i.e. XML, JSON&mdash; they are intended for storage and transfer purposes more than visualization and edition.
 
'''Solution'''
Programs in Fōrmulæ are created/edited online in its [https://formulae.org website], However they run on execution servers. By default remote servers are used, but they are limited in memory and processing power, since they are intended for demonstration and casual use. A local server can be downloaded and installed, it has no limitations (it runs in your own computer). Because of that, example programs can be fully visualized and edited, but some of them will not run if they require a moderate or heavy computation/memory resources, and no local server is being used.
 
[[File:Fōrmulæ - Show ASCII table 01.png]]
In '''[https://formulae.org/?example=Show_ASCII_table this]''' page you can see the program(s) related to this task and their results.
 
[[File:Fōrmulæ - Show ASCII table 02.png]]
 
=={{header|FutureBasic}}==
Line 3,078 ⟶ 3,090:
 
local fn ASCIITable as CFStringRef
NSinteger i
'~'1
CFStringRef temp
NSinteger i
CFStringRef temp
CFMutableStringRef mutStr = fn MutableStringWithCapacity( 0 )
 
for i = 32 to 127
CFMutableStringRef mutStr = fn MutableStringWithCapacity( 0 )
temp = fn StringWithFormat( @"%c", i )
for i = 32 to 127
if i == 32 then temp = @"Spc"
temp = fn StringWithFormat( @"%c", i )
if i == 32127 then temp = @"SpcDel"
MutableStringAppendString( mutStr, fn StringWithFormat( @"%-1d : %@\n", i, temp ) )
if i == 127 then temp = @"Del"
next
MutableStringAppendString( mutStr, fn StringWithFormat( @"%-1d : %@\n", i, temp ) )
next
CFArrayRef colArr = fn StringComponentsSeparatedByString( mutStr, @"\n" )
 
CFArrayRef colArr = fn StringComponentsSeparatedByStringMutableStringSetString( mutStr, @"\n" )
for i = 0 to 15
MutableStringSetString( mutStr, @"" )
ObjectRef col0 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i ) )
for i = 0 to 15
ObjectRef col0col1 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 16 ) )
ObjectRef col1col2 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 1632 ) )
ObjectRef col2col3 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 3248 ) )
ObjectRef col3col4 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 4864 ) )
ObjectRef col4col5 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 6480 ) )
MutableStringAppendString( mutStr, fn StringWithFormat( @"%-10s %-10s %-10s %-10s %-10s %-10s\n", col0, col1, col2, col3, col4, col5 ) )
ObjectRef col5 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 80 ) )
next
MutableStringAppendString( mutStr, fn StringWithFormat( @"%-10s %-10s %-10s %-10s %-10s %-10s\n", col0, col1, col2, col3, col4, col5 ) )
next
end fn = fn StringWithString( mutStr )
 
Line 3,126 ⟶ 3,137:
47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del
</pre>
 
 
=={{header|Go}}==
Line 3,254 ⟶ 3,264:
46 : . 62 : > 78 : N 94 : ^ 110 : n 126 : ~
47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del </pre>
 
=={{Header|Insitux}}==
<syntaxhighlight lang="insitux">
(-> (for i (range 16)
j (range (+ i 32) 128 16)
(let k (match j 32 "Spc" 127 "Del" (str (char-code j) " ")))
(strn ((< j 100) " ") j " : " k))
(partition 6)
(map (join " "))
(join "\n"))
</syntaxhighlight>
{{out}}
<pre>
32 : Spc 48 : 0 64 : @ 80 : P 96 : ` 112 : p
33 : ! 49 : 1 65 : A 81 : Q 97 : a 113 : q
34 : " 50 : 2 66 : B 82 : R 98 : b 114 : r
35 : # 51 : 3 67 : C 83 : S 99 : c 115 : s
36 : $ 52 : 4 68 : D 84 : T 100 : d 116 : t
37 : % 53 : 5 69 : E 85 : U 101 : e 117 : u
38 : & 54 : 6 70 : F 86 : V 102 : f 118 : v
39 : ' 55 : 7 71 : G 87 : W 103 : g 119 : w
40 : ( 56 : 8 72 : H 88 : X 104 : h 120 : x
41 : ) 57 : 9 73 : I 89 : Y 105 : i 121 : y
42 : * 58 : : 74 : J 90 : Z 106 : j 122 : z
43 : + 59 : ; 75 : K 91 : [ 107 : k 123 : {
44 : , 60 : < 76 : L 92 : \ 108 : l 124 : |
45 : - 61 : = 77 : M 93 : ] 109 : m 125 : }
46 : . 62 : > 78 : N 94 : ^ 110 : n 126 : ~
47 : / 63 : ? 79 : O 95 : _ 111 : o 127 : Del
</pre>
 
=={{header|J}}==
<pre> ;"1 ((_6_9{.":),': ',8 u:]ucp)each 32+|:i.6 16
32: 48: 0 64: @ 80: P 96: ` 112: p
33: ! 49: 1 65: A 81: Q 97: a 113: q
Line 3,316 ⟶ 3,356:
116: t 117: u 118: v 119: w 120: x 121: y
122: z 123: { 124: | 125: } 126: ~ 127: Del
</pre>
You could also do this:<br />
<syntaxhighlight lang="java">
String printASCIITable() {
StringBuilder string = new StringBuilder();
String newline = System.lineSeparator();
string.append("dec hex binary oct char").append(newline);
for (int decimal = 32; decimal <= 127; decimal++) {
string.append(format(decimal));
switch (decimal) {
case 32 -> string.append("[SPACE]");
case 127 -> string.append("[DELETE]");
default -> string.append((char) decimal);
}
string.append(newline);
}
return string.toString();
}
 
String format(int value) {
return "%-3d %01$-2x %7s %01$-3o ".formatted(value, Integer.toBinaryString(value));
}
</syntaxhighlight>
<pre>
dec hex binary oct char
32 20 100000 40 [SPACE]
33 21 100001 41 !
34 22 100010 42 "
35 23 100011 43 #
36 24 100100 44 $
37 25 100101 45 %
38 26 100110 46 &
39 27 100111 47 '
40 28 101000 50 (
41 29 101001 51 )
42 2a 101010 52 *
43 2b 101011 53 +
44 2c 101100 54 ,
45 2d 101101 55 -
46 2e 101110 56 .
47 2f 101111 57 /
48 30 110000 60 0
49 31 110001 61 1
50 32 110010 62 2
51 33 110011 63 3
52 34 110100 64 4
53 35 110101 65 5
54 36 110110 66 6
55 37 110111 67 7
56 38 111000 70 8
57 39 111001 71 9
58 3a 111010 72 :
59 3b 111011 73 ;
60 3c 111100 74 <
61 3d 111101 75 =
62 3e 111110 76 >
63 3f 111111 77 ?
64 40 1000000 100 @
65 41 1000001 101 A
66 42 1000010 102 B
67 43 1000011 103 C
68 44 1000100 104 D
69 45 1000101 105 E
70 46 1000110 106 F
71 47 1000111 107 G
72 48 1001000 110 H
73 49 1001001 111 I
74 4a 1001010 112 J
75 4b 1001011 113 K
76 4c 1001100 114 L
77 4d 1001101 115 M
78 4e 1001110 116 N
79 4f 1001111 117 O
80 50 1010000 120 P
81 51 1010001 121 Q
82 52 1010010 122 R
83 53 1010011 123 S
84 54 1010100 124 T
85 55 1010101 125 U
86 56 1010110 126 V
87 57 1010111 127 W
88 58 1011000 130 X
89 59 1011001 131 Y
90 5a 1011010 132 Z
91 5b 1011011 133 [
92 5c 1011100 134 \
93 5d 1011101 135 ]
94 5e 1011110 136 ^
95 5f 1011111 137 _
96 60 1100000 140 `
97 61 1100001 141 a
98 62 1100010 142 b
99 63 1100011 143 c
100 64 1100100 144 d
101 65 1100101 145 e
102 66 1100110 146 f
103 67 1100111 147 g
104 68 1101000 150 h
105 69 1101001 151 i
106 6a 1101010 152 j
107 6b 1101011 153 k
108 6c 1101100 154 l
109 6d 1101101 155 m
110 6e 1101110 156 n
111 6f 1101111 157 o
112 70 1110000 160 p
113 71 1110001 161 q
114 72 1110010 162 r
115 73 1110011 163 s
116 74 1110100 164 t
117 75 1110101 165 u
118 76 1110110 166 v
119 77 1110111 167 w
120 78 1111000 170 x
121 79 1111001 171 y
122 7a 1111010 172 z
123 7b 1111011 173 {
124 7c 1111100 174 |
125 7d 1111101 175 }
126 7e 1111110 176 ~
127 7f 1111111 177 [DELETE]
</pre>
 
Line 3,828 ⟶ 3,989:
end
prt(Tbl) # format and print table on console</syntaxhighlight>
 
=={{header|K}}==
{{works with|ngn/k}}
<syntaxhighlight lang=K>`0:"\n"/" "/'+6 16#{-6$($x),-2$`c$x}'32+!96
32 48 0 64 @ 80 P 96 ` 112 p
33 ! 49 1 65 A 81 Q 97 a 113 q
34 " 50 2 66 B 82 R 98 b 114 r
35 # 51 3 67 C 83 S 99 c 115 s
36 $ 52 4 68 D 84 T 100 d 116 t
37 % 53 5 69 E 85 U 101 e 117 u
38 & 54 6 70 F 86 V 102 f 118 v
39 ' 55 7 71 G 87 W 103 g 119 w
40 ( 56 8 72 H 88 X 104 h 120 x
41 ) 57 9 73 I 89 Y 105 i 121 y
42 * 58 : 74 J 90 Z 106 j 122 z
43 + 59 ; 75 K 91 [ 107 k 123 {
44 , 60 < 76 L 92 \ 108 l 124 |
45 - 61 = 77 M 93 ] 109 m 125 }
46 . 62 > 78 N 94 ^ 110 n 126 ~
47 / 63 ? 79 O 95 _ 111 o 127</syntaxhighlight>
 
=={{header|Kotlin}}==
Line 3,952 ⟶ 4,133:
=={{header|langur}}==
{{trans|Go}}
{{works with|langur|0.6.8}}
<syntaxhighlight lang="langur">for .i of 16 {
for .j = 31 + .i ; .j < 128 ; .j += 16 {
val .L = givenswitch(.j; 32: "spc"; 127: "del"; cp2s .j)
write $"\{.j:3;} : \{.L:-4;}"
}
writeln()
Line 4,561 ⟶ 4,741:
 
=={{header|PL/M}}==
<syntaxhighlight lang="pli">100H: /* SHOW AN ASCII TABLE FROM 32 TO 127 */
100H: /* SHOW AN ASCII TABLE FROM 32 TO 127 */
/* CP/M BDOS SYSTEM CALL */
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;
Line 4,577 ⟶ 4,758:
END PR$BYTE;
/* ASCII TABLE */
DECLARE ( A, C ) BYTE;
DO C = 32 TO 12732 + 15;
CALLDO PR$BYTE(A = C TO C + ( 16 * 5 ) BY 16;
CALL PR$STRINGBYTE( .': $'A );
IF C = 32 THEN CALL PR$STRING( .'SPC: $' );
ELSE IF C A = 127 32 THEN CALL PR$STRING( .'DELSPC$' );
ELSE DOIF A = 127 THEN CALL PR$STRING( .'DEL$' );
CALLELSE PR$CHAR( ' ' )DO;
CALL PR$CHAR( ' C ' );
CALL PR$CHAR( ' 'A );
CALL PR$CHAR( ' ' );
END;
END;
IF ( ( C - 31 ) MOD 6 ) = 0 THEN CALL PR$STRING( .( 0DH, 0AH, '$' ) );
END;
EOF
EOF</syntaxhighlight>
</syntaxhighlight>
{{out}}
<pre>
032: SPC 033048: !0 034064: "@ 035080: #P 036096: $` 037112: %p
038033: &! 039049: '1 040065: (A 041081: )Q 042097: *a 043113: +q
044034: ," 045050: -2 046066: .B 047082: /R 048098: 0b 049114: 1r
050035: 2# 051: 3 052067: 4C 053083: 5S 054099: 6c 055115: 7s
056036: 8$ 057052: 94 058068: :D 059084: ;T 060100: <d 061116: =t
062037: >% 063053: ?5 064069: @E 065085: AU 066101: Be 067117: Cu
068038: D& 069054: E6 070: F 071086: GV 072102: Hf 073118: Iv
074039: J' 075055: K7 076071: LG 077087: MW 078103: Ng 079119: Ow
080040: P( 081056: Q8 082072: RH 083088: SX 084104: Th 085120: Ux
086041: V) 087057: W9 088073: XI 089: Y 090105: Zi 091121: [y
092042: \* 093058: ]: 094074: ^J 095090: _Z 096106: `j 097122: az
098043: b+ 099059: c; 100075: dK 101091: e[ 102107: fk 103123: g{
104044: h, 105060: i< 106076: jL 107092: k\ 108: l 109124: m|
110045: n- 111061: o= 112077: pM 113093: q] 114109: rm 115125: s}
116046: t. 117062: u> 118078: vN 119094: w^ 120110: xn 121126: y~
122047: z/ 123063: {? 124079: |O 125095: }_ 126111: ~o 127: DEL
</pre>
 
Line 5,970 ⟶ 6,154:
{{trans|Go}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="ecmascriptwren">import "./fmt" for Fmt
 
for (i in 0...16) {
Langurmonkey
885

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/341972...361177"