View source for Show ASCII table

{{task}}

;Task:
Show &nbsp;[https://upload.wikimedia.org/wikipedia/commons/thumb/d/dd/ASCII-Table.svg/1261px-ASCII-Table.svg.png the ASCII character set] &nbsp;from values &nbsp; '''32''' &nbsp; to &nbsp; '''127''' &nbsp; (decimal) &nbsp; in a table format.


{{Template:Strings}}
<br><br>

=={{header|11l}}==
{{trans|Python}}

<syntaxhighlight lang="11l">L(i) 16
   L(j) (32 + i .. 127).step(16)
      String k
      I j == 32
         k = ‘Spc’
      E I j == 127
         k = ‘Del’
      E
         k = Char(code' j)
      print(‘#3 : #<3’.format(j, k), end' ‘’)
   print()</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|6502 Assembly}}==
<syntaxhighlight lang="asm">==========================================================================
; task    : show ascii table 
; language: 6502 Assembly
; for:    : rosettacode.org
; run     : on a Commodore 64 with command
;           sys 49152
;
; same logic of "Commodore BASIC"
;
; assembler win2c64 by Aart Bik
; http://www.aartbik.com/
;
; 2020-05-01 alvalongo
;==========================================================================
; constants 
cr         = 13    ; carriage-return
white      = 5     ; color white
; ----------------------------------------------
; memory on zero page
linnum     = $14
; ----------------------------------------------
; kernel routines
linstr    = $bdcd   ; C64 ROM       : convert a 16-bit value to string and print on current device (default screen)
chrout    = $ffd2   ; C64 ROM kernel: output a character to current device, default screen
			        ;                 use $fded for Apple 2
;
; ----------------------------------------------
;
        .org   $c000   ; start at free RAM, on Commodore 64
; ----------------------------------------------
l100    lda #147       ; clear screen
        jsr chrout
        ;
l110    lda #14         ;character set 2, upper/lower case mode
        jsr chrout
        ;
        lda #white      ; color for characters
        jsr chrout
        ;
l120    lda #<msg1
        ldx #>msg1
        jsr prtmsg
        ;
l130    lda #<msg2
        ldx #>msg2
        jsr prtmsg
        ;
l140    lda #cr
        jsr chrout
        ;
l150    lda #0
        sta row
        ;
l160    lda #0
        sta column
        ;
l170    clc
        lda row
        adc #32
        sta ascii
        lda column
        asl     ; times 2,  2
        asl     ; times 2,  4
        asl     ; times 2,  8
        asl     ; times 2, 16
        adc ascii
        sta ascii
        ;
l180    cmp #100
        bcs l185     ; equal or greater than
        lda #" "     ; a space before values less than 100
        jsr chrout
        ;
l185    ldx ascii
        lda #0
        jsr linstr       ; convert to string and print on screen
        lda #":"
        jsr chrout
        lda ascii
        jsr chrout
        lda #" "
        jsr chrout
        ;
l190    inc column  ; next column
        lda column
        cmp #5
        bcc l170
        beq l170
        ;
l200    lda #cr
        jsr chrout
        ;
l210    inc row    ; next row
        lda row
        cmp #15
        bcc l160
        beq l160
        ;
l220    rts      ; return to operating system
; ----------------------------------------------
; print message
;
prtmsg  sta linnum
        stx linnum+1
        ldy #0
l310    lda (linnum),y
        beq l320
        jsr chrout
        iny
        bne l310
l320    lda #cr
        jsr chrout
        rts 
; ----------------------------------------------
msg1    .byte "COMMODORE 64 - BASIC V2",0
msg2    .byte "CHARACTER SET 2 UPPER/LOWER CASE MODE",0
row     .byte 0
column  .byte 0
ascii   .byte 0
</syntaxhighlight>

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

<syntaxhighlight lang="8080asm">	org	100h
	mvi	a,32		; Start with space
	mvi	d,16		; 16 lines
dochar:	mov	c,a		; Print number
	call	putnum
	mov	a,c
	lxi	h,spc		; Is it space?
	cpi	32
	jz	print
	lxi	h,del
	cpi	127		; Is it del?
	jz	print
	lxi	h,chr		; Character
	mov	m,a
print:	call	puts
	adi	16		; Next column
	jp	dochar		; Done with this line?
	lxi	h,nl
	call	puts
	sui	95		; Next line
	dcr	d
	jnz	dochar
	ret
	;;;	Print number in A. C, D preserved.
putnum:	lxi	h,num		; Set number string to spaces
	push	h
	mvi	b,' '
	mov	m,b
	inx	h
	mov	m,b
	inx	h
	mov	m,b
dgts:	mvi 	b,-1
divmod:	sui	10		; B = A/10, A = (A mod 10)-10
	inr	b
	jnc	divmod
	adi	58		; Make digit
	mov	m,a		; Store digit
	dcx	h
	mov	a,b		; Next digit
	ana	a
	jnz	dgts
	pop	h		; Print number
	;;;	Print zero-terminated (...ish) string
puts:	mov	e,m
	call	putch
	inx	h
	dcr	e
	jp	puts
	ret
	;;;	Output character in E using CP/M call, 
	;;;	preserving registers
putch:	push	psw
	push	b
	push	d
	push	h
	mvi	c,2
	call	5
	pop	h
	pop	d
	pop	b
	pop	psw
	ret 
nl:	db	13,10,0		; Newline
num:	db	'   : ',0	; Placeholder for number string
spc:	db	'Spc  ',0	; Space
del:	db 	'Del  ',0	; Del
chr: 	db	'*    ',0	; Placeholder for character</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|8086 Assembly}}==

<syntaxhighlight lang="asm">	cpu	8086
	bits	16
putch:	equ	2h
section	.text
	org	100h
	mov	cx,16		; 16 lines
	mov	bh,32		; Start at 32
dochar:	mov	al,bh		; Print number
	call	putnum
	cmp	bh,32 		; Space?
	je	.spc
	cmp	bh,127 		; Del?
	je	.del
	mov	[chr],bh	; Otherwise, print character
	mov	di,chr
	jmp 	.out
.spc:	mov	di,spc
	jmp 	.out
.del:	mov	di,del
.out:	call	putstr
	add	bh,16		; Next column
	cmp	bh,128		; Done with this line?
	jb	dochar
	mov	di,nl		; Print newline
	call	putstr
	sub	bh,95		; Do next line
	loop	dochar
	ret
	;;;	Print number in AL as ASCII, right-aligned in 3 characters
putnum:	mov	dx,2020h	; Put spaces in number
	mov	di,num		; Two spaces
	mov	[di],dx
	inc	di
	inc	di
	mov	[di],dh		; Third space
	mov	bl,10		; Divisor
.div:	xor	ah,ah		; Write digits
	div	bl
	add	ah,'0'
	mov	[di],ah
	dec	di
	test	al,al
	jnz	.div
	mov	di,num		; Print number
putstr:	mov	ah,putch	; Use zero-terminated strings
.loop:	mov	dl,[di]
	test	dl,dl
	jz	.done
	int	21h
	inc	di
	jmp	.loop
.done:	ret
section	.data
num:	db	'   : ',0	; Placeholder for number string
nl:	db	13,10,0		; Newline
spc:	db	'Spc  ',0	; Space
del:	db	'Del  ',0	; Del
chr:	db	'*    ',0	; Placeholder for character</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|Action!}}==
Atari 8-bit computers use [https://en.wikipedia.org/wiki/ATASCII ATASCII] character set which is a variation of ASCII. 
<syntaxhighlight lang="action!">PROC Main()
  BYTE
    count=[96],rows=[16],
    first=[32],last=[127],
    i,j

  Put(125) ;clear screen
  
  FOR i=0 TO rows-1
  DO
    Position(2,3+i)

    FOR j=first+i TO last STEP rows
    DO
      IF j>=96 AND j<=99 THEN
        Put(' )
      FI
      PrintB(j)
      Put(' )

      IF j=32 THEN
        Print("SP ")
      ELSEIF j=125 THEN 
        Print("CL")
      ELSEIF j=126 THEN
        Print("DL")
      ELSEIF j=127 THEN
        Print("TB")
      ELSE
        PrintF("%C  ",j)
      FI
    OD
    PutE()
  OD
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Show_ASCII_table.png Screenshot from Atari 8-bit computer]
<pre>
32 SP 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 CL
46 .  62 >  78 N  94 ^  110 n  126 DL
47 /  63 ?  79 O  95 _  111 o  127 TB
</pre>

=={{header|Ada}}==
<syntaxhighlight lang="ada">with Ada.Text_IO;         use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure Ascii_Table is
   N : Integer;
begin
   for R in 0 .. 15 loop
      for C in 0 .. 5 loop
         N := 32 + 16 * C + R;
         Put (N, 3);
         Put (" : ");
         case N is
            when 32 =>
               Put ("Spc  ");
            when 127 =>
               Put ("Del  ");
            when others =>
               Put (Character'Val (N) & "    ");
         end case;
      end loop;
      New_Line;
   end loop;
end Ascii_Table;</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|ALGOL 68}}==
<syntaxhighlight lang="algol68">
# generate an ascii table for characters 32 - 127 #
FOR c FROM 32 TO 32 + 15 DO
    FOR ach FROM c BY 16 TO c + ( 16 * 5 ) DO
        print( ( whole( ach, -4 )
               , ": "
               , IF   ach =  32 THEN "SPC"
                 ELIF ach = 127 THEN "DEL"
                 ELSE " " + REPR ach + " "
                 FI
               )
             )
    OD;
    print( ( newline ) )
OD
</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|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">% generate an ascii table for chars 32 - 127            %
for i := 32 until 32 + 15 do begin
    write();
    for c := i step 16 until i + ( 16 * 5 ) do begin
        writeon( i_w := 3, s_w := 0, c, ": " );
        if      c =  32 then writeon( "Spc ")
        else if c = 127 then writeon( "Del " )
        else                 writeon( code( c ), "   " )
    end for_ach
end for_i.
</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|APL}}==

<syntaxhighlight lang="apl">{(¯3↑⍕⍵),': ',∊('Spc' 'Del'(⎕UCS ⍵))[32 127⍳⍵]}¨⍉6 16⍴31+⍳96</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|AppleScript}}==
<syntaxhighlight lang="applescript">-- asciiTable :: () -> String
on asciiTable()
    script row
        on |λ|(x)
            concat(map(justifyLeft(12, space), x))
        end |λ|
    end script
    
    unlines(map(row, ¬
        transpose(chunksOf(16, map(my asciiEntry, ¬
            enumFromTo(32, 127))))))
end asciiTable


-------------------------- TEST ---------------------------
on run
    
    asciiTable()
    
end run


------------------------- DISPLAY -------------------------

-- asciiEntry :: Int -> String
on asciiEntry(n)
    set k to asciiName(n)
    if "" ≠ k then
        justifyRight(4, space, n as string) & " : " & k
    else
        k
    end if
end asciiEntry

-- asciiName :: Int -> String
on asciiName(n)
    if 32 > n or 127 < n then
        ""
    else if 32 = n then
        "Spc"
    else if 127 = n then
        "Del"
    else
        chr(n)
    end if
end asciiName


-------------------- GENERIC FUNCTIONS --------------------

-- chr :: Int -> Char
on chr(n)
    character id n
end chr


-- chunksOf :: Int -> [a] -> [[a]]
on chunksOf(k, xs)
    script
        on go(ys)
            set ab to splitAt(k, ys)
            set a to |1| of ab
            if {} ≠ a then
                {a} & go(|2| of ab)
            else
                a
            end if
        end go
    end script
    result's go(xs)
end chunksOf


-- concat :: [[a]] -> [a]
-- concat :: [String] -> String
on concat(xs)
    set lng to length of xs
    if 0 < lng and string is class of (item 1 of xs) then
        set acc to ""
    else
        set acc to {}
    end if
    repeat with i from 1 to lng
        set acc to acc & item i of xs
    end repeat
    acc
end concat


-- concatMap :: (a -> [b]) -> [a] -> [b]
on concatMap(f, xs)
    set lng to length of xs
    if 0 < lng and class of xs is string then
        set acc to ""
    else
        set acc to {}
    end if
    tell mReturn(f)
        repeat with i from 1 to lng
            set acc to acc & |λ|(item i of xs, i, xs)
        end repeat
    end tell
    return acc
end concatMap


-- enumFromTo :: Int -> Int -> [Int]
on enumFromTo(m, n)
    if m ≤ n then
        set lst to {}
        repeat with i from m to n
            set end of lst to i
        end repeat
        return lst
    else
        return {}
    end if
end enumFromTo


-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
    tell mReturn(f)
        set v to startValue
        set lng to length of xs
        repeat with i from 1 to lng
            set v to |λ|(v, item i of xs, i, xs)
        end repeat
        return v
    end tell
end foldl


-- justifyLeft :: Int -> Char -> String -> String
on justifyLeft(n, cFiller)
    script
        on |λ|(strText)
            if n > length of strText then
                text 1 thru n of (strText & replicate(n, cFiller))
            else
                strText
            end if
        end |λ|
    end script
end justifyLeft


-- justifyRight :: Int -> Char -> String -> String
on justifyRight(n, cFiller, strText)
    if n > length of strText then
        text -n thru -1 of ((replicate(n, cFiller) as text) & strText)
    else
        strText
    end if
end justifyRight


-- length :: [a] -> Int
on |length|(xs)
    length of xs
end |length|


-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
    tell mReturn(f)
        set lng to length of xs
        set lst to {}
        repeat with i from 1 to lng
            set end of lst to |λ|(item i of xs, i, xs)
        end repeat
        return lst
    end tell
end map


-- Lift 2nd class handler function into 1st class script wrapper 
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
    if class of f is script then
        f
    else
        script
            property |λ| : f
        end script
    end if
end mReturn


-- Egyptian multiplication - progressively doubling a list, appending
-- stages of doubling to an accumulator where needed for binary 
-- assembly of a target length
-- replicate :: Int -> a -> [a]
on replicate(n, a)
    set out to {}
    if n < 1 then return out
    set dbl to {a}
    
    repeat while (n > 1)
        if (n mod 2) > 0 then set out to out & dbl
        set n to (n div 2)
        set dbl to (dbl & dbl)
    end repeat
    return out & dbl
end replicate


-- splitAt :: Int -> [a] -> ([a],[a])
on splitAt(n, xs)
    if n > 0 and n < length of xs then
        if class of xs is text then
            Tuple(items 1 thru n of xs as text, items (n + 1) thru -1 of xs as text)
        else
            Tuple(items 1 thru n of xs, items (n + 1) thru -1 of xs)
        end if
    else
        if n < 1 then
            Tuple({}, xs)
        else
            Tuple(xs, {})
        end if
    end if
end splitAt


-- Tuple (,) :: a -> b -> (a, b)
on Tuple(a, b)
    {type:"Tuple", |1|:a, |2|:b, length:2}
end Tuple


-- Simplified version - assuming rows of unvarying length.
-- transpose :: [[a]] -> [[a]]
on transpose(rows)
    script cols
        on |λ|(_, iCol)
            script cell
                on |λ|(row)
                    item iCol of row
                end |λ|
            end script
            concatMap(cell, rows)
        end |λ|
    end script
    map(cols, item 1 of rows)
end transpose


-- unlines :: [String] -> String
on unlines(xs)
    set {dlm, my text item delimiters} to ¬
        {my text item delimiters, linefeed}
    set str to xs as text
    set my text item delimiters to dlm
    str
end unlines</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|Applesoft BASIC}}==
This is similar to the Commodore BASIC program in that it clears the screen and displays the version of BASIC. It uses enterable Applesoft BASIC to embed a 6502 machine language routine that XORs $87 with the character stored at $41 and prints the character.<syntaxhighlight lang="basic"> 0  GOTO 10: ONERR AI READ LY RND 
 10  LET X = 256 *  PEEK (104)
 11  LET X = X +  PEEK (103) + 7
 20  CALL  - 1184:B$ =  CHR$ (8)
 21  NORMAL : PRINT :E = 61588
 22  PRINT  TAB( 29)"APPLESOFT";
 23  PRINT " II"B$:M =  - 1
 24  PRINT  TAB( 22)"BASED ON ";
 25  FOR I = E + 9 TO E STEP M
 26  POKE 65, PEEK (I): CALL X
 27  NEXT : PRINT B$:S$ = "  "
 28  PRINT  TAB( 28)"6502 ";
 29  PRINT "BASIC V2" CHR$ (8)
 30  PRINT "CHARACTER SET"
 40  FOR R = 0 TO 15: PRINT 
 50  FOR C = 2 TO 7:A = C * 16
 60  LET N$ = S$ +  STR$ (A + R)
 70  LET N$ =  RIGHT$ (N$,4)
 80  PRINT N$":" CHR$ (A + R);
 90  NEXT C,R: PRINT</syntaxhighlight>
The 6502 routine is embedded at line 0 and is used to display the string "!TFOSORCIM" backwards.
<syntaxhighlight lang="asm">	LDA  $41   ; ONERR A 
	EOR #$87   ; I READ
	JMP  $DB59 ; LY RND</syntaxhighlight>
=={{header|ARM Assembly}}==
Thanks to Keith of [https://www.chibiakumas.com ChibiAkumas] for creating the GBA bitmap font and I/O routines.

<syntaxhighlight lang="arm assembly">.equ CursorX,0x02000000
.equ CursorY,0x02000001
ProgramStart:
	mov sp,#0x03000000			;Init Stack Pointer
	
	mov r4,#0x04000000  		        ;DISPCNT -LCD Control
	mov r2,#0x403    			;4= Layer 2 on / 3= ScreenMode 3
	str	r2,[r4]         	        ;now the screen is visible
	bl ResetTextCursors			;set text cursors to top left of screen
	
	mov r2,#32
	mov r3,#32+20				;screen height is 20 chars
	mov r5,#0				;column spacer
	mov r6,#5
	
	;R0 = Character to print (working copy)
	;R2 = real copy
	;R3 = compare factor
loop_printAscii:
	mov r0,r2
	bl ShowHex
	
	mov r0,#32
	bl PrintChar
	
	mov r0,r2
	bl PrintChar
	
	bl CustomNewLine
	add r2,r2,#1
	
	cmp r2,#128
	beq forever		;exit early
	
	cmp r2,r3
	bne loop_printAscii
	
	
	add r3,r3,#20	;next section
	
	;inc to next column
	add r5,r5,#5
	mov r0,r5
	mov r1,#0
	bl SetTextCursors
	subs r6,r6,#1
	bne loop_printAscii
	



forever:
	b forever
	


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;		INPUT/OUTPUT SUBROUTINES   		- 		CREATED BY KEITH OF CHIBIAKUMAS.COM
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

PrintString:					;Print 255 terminated string 
	STMFD sp!,{r0-r12, lr}
PrintStringAgain:
		ldrB r0,[r1],#1
		cmp r0,#255
		beq PrintStringDone		;Repeat until 255
		bl printchar 			;Print Char
		b PrintStringAgain
PrintStringDone:
	LDMFD sp!,{r0-r12, pc}
	
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
PrintChar:
	STMFD sp!,{r0-r12, lr}
	mov r4,#0
		mov r5,#0
		
		mov r3,#CursorX
		ldrB r4,[r3]			;X pos
		mov r3,#CursorY
		ldrB r5,[r3]			;Y pos
		
		mov r3,#0x06000000 		;VRAM base
		
		mov r6,#8*2				;Xpos, 2 bytes per pixel, 8 bytes per char
		mul r2,r4,r6
		add r3,r3,r2
		
		mov r4,#240*8*2			;Ypos, 240 pixels per line,
		mul r2,r5,r4			;2 bytes per pixel, 8 lines per char
		add r3,r3,r2
		
		adr r4,BitmapFont 		;Font source
		
		sub r0,r0,#32			;First Char is 32 (space)
		add r4,r4,r0,asl #3		;8 bytes per char
		
		mov r1,#8				;8 lines 
DrawLine:
		mov r7,#8 				;8 pixels per line
		ldrb r8,[r4],#1			;Load Letter
		mov r9,#0b100000000		;Mask
				
		mov r2, #0b1111111101000000; Color: ABBBBBGGGGGRRRRR   A=Alpha
DrawPixel:
		tst r8,r9				;Is bit 1?
		strneh r2,[r3]			;Yes? then fill pixel (HalfWord)
		add r3,r3,#2
		mov r9,r9,ror #1		;Bitshift Mask
		subs r7,r7,#1
		bne DrawPixel			;Next Hpixel
		
		add r3,r3,#480-16	   ;Move Down a line (240 pixels *2 bytes) 
		subs r1,r1,#1								;-1 char (16 px)
		bne DrawLine			;Next Vline
		
LineDone:	
		mov r3,#CursorX
		ldrB r0,[r3]	
		add r0,r0,#1			;Move across screen
		strB r0,[r3]	
		mov r10,#30
		cmp r0,r10
		bleq NewLine
	LDMFD sp!,{r0-r12, pc}

NewLine:
	STMFD sp!,{r0-r12, lr}
		mov r3,#CursorX
		mov r0,#0
		strB r0,[r3]
		mov r4,#CursorY
		ldrB r0,[r4]
		add r0,r0,#1
		strB r0,[r4]
	LDMFD sp!,{r0-r12, pc}
	
CustomNewLine:
	STMFD sp!,{r0-r12, lr}
		mov r3,#CursorX
		mov r0,r5
		strB r0,[r3]
		mov r4,#CursorY
		ldrB r0,[r4]
		add r0,r0,#1
		strB r0,[r4]
	LDMFD sp!,{r0-r12, pc}	
	
ResetTextCursors:
	STMFD sp!,{r4-r6,lr}
		mov r4,#0
		mov r5,#CursorX
		mov r6,#CursorY
		strB r4,[r5]
		strB r4,[r6]
	LDMFD sp!,{r4-r6,lr}
	bx lr
	
SetTextCursors:
	;input: R0 = new X
	;	R1 = new Y
	STMFD sp!,{r5-r6}
		mov r5,#CursorX
		mov r6,#CursorY
		strB r0,[r5]
		strB r1,[r6]
	LDMFD sp!,{r5-r6}
	bx lr
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

ShowHex:
	STMFD sp!,{r0-r12, lr}
		mov r2,r0,ror #4
		bl ShowHexChar	
		mov r2,r0
		bl ShowHexChar	
	LDMFD sp!,{r0-r12, pc}		
	
ShowHexChar:
	STMFD sp!,{r0-r12, lr}
		;mov r3,
		and r0,r2,#0x0F ; r3
		cmp r0,#10
		addge r0,r0,#7			;if 10 or greater convert to alphabet letters a-f
		add r0,r0,#48
		bl PrintChar	
	LDMFD sp!,{r0-r12, pc}	
	
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
	
BitmapFont:
;each byte represents a row of 8 pixels. This is a 1BPP font that is converted to the GBA's 16bpp screen format at runtime
        .byte 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00     ; 20
        .byte 0x10,0x18,0x18,0x18,0x18,0x00,0x18,0x00     ; 21
        .byte 0x28,0x6C,0x28,0x00,0x00,0x00,0x00,0x00     ; 22
        .byte 0x00,0x28,0x7C,0x28,0x7C,0x28,0x00,0x00     ; 23
        .byte 0x18,0x3E,0x48,0x3C,0x12,0x7C,0x18,0x00     ; 24
        .byte 0x02,0xC4,0xC8,0x10,0x20,0x46,0x86,0x00     ; 25
        .byte 0x10,0x28,0x28,0x72,0x94,0x8C,0x72,0x00     ; 26
        .byte 0x0C,0x1C,0x30,0x00,0x00,0x00,0x00,0x00     ; 27
        .byte 0x18,0x18,0x30,0x30,0x30,0x18,0x18,0x00     ; 28
        .byte 0x18,0x18,0x0C,0x0C,0x0C,0x18,0x18,0x00     ; 29
        .byte 0x08,0x49,0x2A,0x1C,0x14,0x22,0x41,0x00     ; 2A
        .byte 0x00,0x18,0x18,0x7E,0x18,0x18,0x00,0x00     ; 2B
        .byte 0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x30     ; 2C
        .byte 0x00,0x00,0x00,0x7E,0x7E,0x00,0x00,0x00     ; 2D
        .byte 0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00     ; 2E
        .byte 0x02,0x04,0x08,0x10,0x20,0x40,0x80,0x00     ; 2F
        .byte 0x7C,0xC6,0xD6,0xD6,0xD6,0xC6,0x7C,0x00     ; 30
        .byte 0x10,0x18,0x18,0x18,0x18,0x18,0x08,0x00     ; 31
        .byte 0x3C,0x7E,0x06,0x3C,0x60,0x7E,0x3C,0x00     ; 32
        .byte 0x3C,0x7E,0x06,0x1C,0x06,0x7E,0x3C,0x00     ; 33
        .byte 0x18,0x3C,0x64,0xCC,0x7C,0x0C,0x08,0x00     ; 34
        .byte 0x3C,0x7E,0x60,0x7C,0x06,0x7E,0x3E,0x00     ; 35
        .byte 0x3C,0x7E,0x60,0x7C,0x66,0x66,0x3C,0x00     ; 36
        .byte 0x3C,0x7E,0x06,0x0C,0x18,0x18,0x10,0x00     ; 37
        .byte 0x3C,0x66,0x66,0x3C,0x66,0x66,0x3C,0x00     ; 38
        .byte 0x3C,0x66,0x66,0x3E,0x06,0x7E,0x3C,0x00     ; 39
        .byte 0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x00     ; 3A
        .byte 0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x30     ; 3B
        .byte 0x0C,0x1C,0x38,0x60,0x38,0x1C,0x0C,0x00     ; 3C
        .byte 0x00,0x00,0x7E,0x00,0x00,0x7E,0x00,0x00     ; 3D
        .byte 0x60,0x70,0x38,0x0C,0x38,0x70,0x60,0x00     ; 3E
        .byte 0x3C,0x76,0x06,0x1C,0x00,0x18,0x18,0x00     ; 3F
        .byte 0x7C,0xCE,0xA6,0xB6,0xC6,0xF0,0x7C,0x00     ; 40 @
        .byte 0x18,0x3C,0x66,0x66,0x7E,0x66,0x24,0x00     ; 41 A
        .byte 0x3C,0x66,0x66,0x7C,0x66,0x66,0x3C,0x00     ; 42 B
        .byte 0x38,0x7C,0xC0,0xC0,0xC0,0x7C,0x38,0x00     ; 43 C
        .byte 0x3C,0x64,0x66,0x66,0x66,0x64,0x38,0x00     ; 44 D
        .byte 0x3C,0x7E,0x60,0x78,0x60,0x7E,0x3C,0x00     ; 45 E
        .byte 0x38,0x7C,0x60,0x78,0x60,0x60,0x20,0x00     ; 46 F
        .byte 0x3C,0x66,0xC0,0xC0,0xCC,0x66,0x3C,0x00     ; 47 G
        .byte 0x24,0x66,0x66,0x7E,0x66,0x66,0x24,0x00     ; 48 H
        .byte 0x10,0x18,0x18,0x18,0x18,0x18,0x08,0x00     ; 49 I
        .byte 0x08,0x0C,0x0C,0x0C,0x4C,0xFC,0x78,0x00     ; 4A J
        .byte 0x24,0x66,0x6C,0x78,0x6C,0x66,0x24,0x00     ; 4B K
        .byte 0x20,0x60,0x60,0x60,0x60,0x7E,0x3E,0x00     ; 4C L
        .byte 0x44,0xEE,0xFE,0xD6,0xD6,0xD6,0x44,0x00     ; 4D M
        .byte 0x44,0xE6,0xF6,0xDE,0xCE,0xC6,0x44,0x00     ; 4E N
        .byte 0x38,0x6C,0xC6,0xC6,0xC6,0x6C,0x38,0x00     ; 4F O
        .byte 0x38,0x6C,0x64,0x7C,0x60,0x60,0x20,0x00     ; 50 P
        .byte 0x38,0x6C,0xC6,0xC6,0xCA,0x74,0x3A,0x00     ; 51 Q
        .byte 0x3C,0x66,0x66,0x7C,0x6C,0x66,0x26,0x00     ; 52 R
        .byte 0x3C,0x7E,0x60,0x3C,0x06,0x7E,0x3C,0x00     ; 53 S
        .byte 0x3C,0x7E,0x18,0x18,0x18,0x18,0x08,0x00     ; 54 T
        .byte 0x24,0x66,0x66,0x66,0x66,0x66,0x3C,0x00     ; 55 U
        .byte 0x24,0x66,0x66,0x66,0x66,0x3C,0x18,0x00     ; 56 V
        .byte 0x44,0xC6,0xD6,0xD6,0xFE,0xEE,0x44,0x00     ; 57 W
        .byte 0xC6,0x6C,0x38,0x38,0x6C,0xC6,0x44,0x00     ; 58 X
        .byte 0x24,0x66,0x66,0x3C,0x18,0x18,0x08,0x00     ; 59 Y
        .byte 0x7C,0xFC,0x0C,0x18,0x30,0x7E,0x7C,0x00     ; 5A Z
        .byte 0x1C,0x30,0x30,0x30,0x30,0x30,0x1C,0x00     ; 5B [
        .byte 0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x00     ; 5C Backslash
        .byte 0x38,0x0C,0x0C,0x0C,0x0C,0x0C,0x38,0x00     ; 5D ]
        .byte 0x10,0x28,0x44,0x00,0x00,0x00,0x00,0x00     ; 5E ^
        .byte 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3C     ; 5F _
        .byte 0x10,0x08,0x00,0x00,0x00,0x00,0x00,0x00     ; 60 `
        .byte 0x00,0x00,0x38,0x0C,0x7C,0xCC,0x78,0x00     ; 61
        .byte 0x20,0x60,0x7C,0x66,0x66,0x66,0x3C,0x00     ; 62
        .byte 0x00,0x00,0x3C,0x66,0x60,0x66,0x3C,0x00     ; 63
        .byte 0x08,0x0C,0x7C,0xCC,0xCC,0xCC,0x78,0x00     ; 64
        .byte 0x00,0x00,0x3C,0x66,0x7E,0x60,0x3C,0x00     ; 65
        .byte 0x1C,0x36,0x30,0x38,0x30,0x30,0x10,0x00     ; 66
        .byte 0x00,0x00,0x3C,0x66,0x66,0x3E,0x06,0x3C     ; 67
        .byte 0x20,0x60,0x6C,0x76,0x66,0x66,0x24,0x00     ; 68
        .byte 0x18,0x00,0x18,0x18,0x18,0x18,0x08,0x00     ; 69
        .byte 0x06,0x00,0x04,0x06,0x06,0x26,0x66,0x3C     ; 6A
        .byte 0x20,0x60,0x66,0x6C,0x78,0x6C,0x26,0x00     ; 6B
        .byte 0x10,0x18,0x18,0x18,0x18,0x18,0x08,0x00     ; 6C
        .byte 0x00,0x00,0x6C,0xFE,0xD6,0xD6,0xC6,0x00     ; 6D
        .byte 0x00,0x00,0x3C,0x66,0x66,0x66,0x24,0x00     ; 6E
        .byte 0x00,0x00,0x3C,0x66,0x66,0x66,0x3C,0x00     ; 6F
        .byte 0x00,0x00,0x3C,0x66,0x66,0x7C,0x60,0x20     ; 70
        .byte 0x00,0x00,0x78,0xCC,0xCC,0x7C,0x0C,0x08     ; 71
        .byte 0x00,0x00,0x38,0x7C,0x60,0x60,0x20,0x00     ; 72
        .byte 0x00,0x00,0x3C,0x60,0x3C,0x06,0x7C,0x00     ; 73
        .byte 0x10,0x30,0x3C,0x30,0x30,0x3E,0x1C,0x00     ; 74
        .byte 0x00,0x00,0x24,0x66,0x66,0x66,0x3C,0x00     ; 75
        .byte 0x00,0x00,0x24,0x66,0x66,0x3C,0x18,0x00     ; 76
        .byte 0x00,0x00,0x44,0xD6,0xD6,0xFE,0x6C,0x00     ; 77
        .byte 0x00,0x00,0xC6,0x6C,0x38,0x6C,0xC6,0x00     ; 78
        .byte 0x00,0x00,0x24,0x66,0x66,0x3E,0x06,0x7C     ; 79
        .byte 0x00,0x00,0x7E,0x0C,0x18,0x30,0x7E,0x00     ; 7A
        .byte 0x10,0x20,0x20,0x40,0x40,0x20,0x20,0x10     ; 7B {
        .byte 0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10     ; 7C |
        .byte 0x08,0x04,0x04,0x02,0x02,0x04,0x04,0x08     ; 7D }
        .byte 0x00,0x00,0x00,0x20,0x52,0x0C,0x00,0x00     ; 7E ~
        .byte 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00     ; 7F
	.byte 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF	  ; 80</syntaxhighlight>

{{out}}
[https://ibb.co/gyfdwhJ Picture of output on VisualBoyAdvance screen]

=={{header|Arturo}}==

<syntaxhighlight lang="rebol">loop 32..127 'num [
    k: ø
    case [num]
        when? [=32]  -> k: "␠"
        when? [=127] -> k: "␡"
        else         -> k: to :string to :char num

    prints pad ~"|num|: |k|" 10
    if 1 = num%6 -> print ""
]</syntaxhighlight>

{{out}}

<pre>     32: ␠     33: !     34: "     35: #     36: $     37: %
     38: &     39: '     40: (     41: )     42: *     43: +
     44: ,     45: -     46: .     47: /     48: 0     49: 1
     50: 2     51: 3     52: 4     53: 5     54: 6     55: 7
     56: 8     57: 9     58: :     59: ;     60: <     61: =
     62: >     63: ?     64: @     65: A     66: B     67: C
     68: D     69: E     70: F     71: G     72: H     73: I
     74: J     75: K     76: L     77: M     78: N     79: O
     80: P     81: Q     82: R     83: S     84: T     85: U
     86: V     87: W     88: X     89: Y     90: Z     91: [
     92: \     93: ]     94: ^     95: _     96: `     97: a
     98: b     99: c    100: d    101: e    102: f    103: g
    104: h    105: i    106: j    107: k    108: l    109: m
    110: n    111: o    112: p    113: q    114: r    115: s
    116: t    117: u    118: v    119: w    120: x    121: y
    122: z    123: {    124: |    125: }    126: ~    127: ␡</pre>

=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">AutoTrim,Off ;Allows for whitespace at end of variable to separate converted characters

MessageText := ;The text to display in the final message box. 
CurrentASCII := 32 ;Current ASCII number to convert and add to MessageText
ConvertedCharacter := ;Stores the currently converted ASCII code
RowLength := 0 ;Keeps track of the number of converted ASCII numbers in each row

Loop { ;Loops through each ASCII character and makes a list in MessageText
	if CurrentASCII > 127 ;When the current ASCII number goes over 127, terminate the loop 
		Break
	if (RowLength = 6) { ;Checks if the row is 6 converted characters long, and if so, inserts a line break (`n)
		MessageText = %MessageText%`n
		RowLength := 0
	}
	if (CurrentASCII = 32) {
		ConvertedCharacter = SPC
	} else {
		if (CurrentASCII = 127) {
			ConvertedCharacter = DEL
		}
		else {
			ConvertedCharacter := Chr(CurrentASCII) ;Converts CurrentASCII number using Chr() and stores it in ConvertedCharacter
		}
	}
	MessageText = %MessageText%%CurrentASCII%: %ConvertedCharacter%`t ;Adds converted ASCII to end of MessageText
	CurrentASCII := CurrentASCII + 1
	RowLength := RowLength + 1
}
MsgBox, % MessageText ;Displays a message box with the ASCII conversion table, from the MessageText variable
return</syntaxhighlight>
{{out}}
<pre>
32: SPC	33: !	34: "	35: #	36: $	37: %	
38: &	39: '	40: (	41: )	42: *	43: +	
44: ,	45: -	46: .	47: /	48: 0	49: 1	
50: 2	51: 3	52: 4	53: 5	54: 6	55: 7	
56: 8	57: 9	58: :	59: ;	60: <	61: =	
62: >	63: ?	64: @	65: A	66: B	67: C	
68: D	69: E	70: F	71: G	72: H	73: I	
74: J	75: K	76: L	77: M	78: N	79: O	
80: P	81: Q	82: R	83: S	84: T	85: U	
86: V	87: W	88: X	89: Y	90: Z	91: [	
92: \	93: ]	94: ^	95: _	96: `	97: a	
98: b	99: c	100: d	101: e	102: f	103: g	
104: h	105: i	106: j	107: k	108: l	109: m	
110: n	111: o	112: p	113: q	114: r	115: s	
116: t	117: u	118: v	119: w	120: x	121: y	
122: z	123: {	124: |	125: }	126: ~	127: DEL	</pre>

=={{header|AWK}}==
{{works with|GAWK}}
{{works with|MAWK}}
<syntaxhighlight lang="awk"># syntax: GAWK -f SHOW_ASCII_TABLE.AWK
# syntax: MAWK -f SHOW_ASCII_TABLE.AWK
BEGIN {
    for (i=0; i<16; i++) {
      for (j=32+i; j<128; j+=16) {
        if (j == 32) { x = "SPC" }
        else if (j == 127) { x = "DEL" }
        else { x = sprintf("%c",j) }
        printf("%3d: %-5s",j,x)
      }
      print ""
    }
}</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|BASIC}}==
==={{header|BASIC256}}===
<syntaxhighlight lang="vb">for i = 32 to 47
	for j = i to i + 80 step 16
		begin case
			case j = 32
				s$ = "Spc"
			case j = 127
				s$ = "Del"
			else
				s$ = chr(j)
		end case
		print rjust("  "+string(j),5); ": "; ljust(s$,3);
	next j
	print
next i</syntaxhighlight>

==={{header|Chipmunk Basic}}===
{{works with|Chipmunk Basic|3.6.4}}
{{works with|QBasic}}
<syntaxhighlight lang="qbasic">10 cls
20 for r = 0 to 15
30  for c = 1 to 6
40   a = 16+r+c*16
50   print right$("  "+str$(a),4)": " chr$(a)tab (10*c);
60  next c
70  print
80 next r</syntaxhighlight>
{{out}}
<pre>  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: ⌂</pre>

==={{header|GW-BASIC}}===
{{works with|BASICA}}
<syntaxhighlight lang="gwbasic">10 DEFINT I,J: DEFSTR S: DIM S(2)
20 S(0)="*  "
30 S(1)="Spc"
40 S(2)="Del"
50 FOR I=32 TO 47
60 FOR J=I TO 127 STEP 16
70 MID$(S(0),1,1) = CHR$(J)
80 PRINT USING "###: \ \ ";J;S(-(J=32)-2*(J=127));
90 NEXT J
100 PRINT
110 NEXT I</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|IS-BASIC}}===
<syntaxhighlight lang="is-basic">100 TEXT 80
110 FOR R=0 TO 15
120   FOR C=32+R TO 112+R STEP 16
130     PRINT USING "###":C;:PRINT ": ";CHR$(C),
140   NEXT
150   PRINT
160 NEXT</syntaxhighlight>

==={{header|MSX Basic}}===
The [[#GW-BASIC|GW-BASIC]] solution works without any changes.

==={{header|QBasic}}===
The [[#QB64|QB64]] solution works without any changes.

==={{header|Run BASIC}}===
{{works with|Just BASIC}}
{{works with|Liberty BASIC}}
<syntaxhighlight lang="vb">for i = 32 to 47
    for j = i to i + 80 step 16
        select case j
        case 32
            s$ = "Spc"
        case 127
            s$ = "Del"
        case else
            s$ = chr$(j)
        end select
        print right$("  "+str$(j),4); ": "; s$; space$(3);
    next j
    print
next i</syntaxhighlight>

==={{header|True BASIC}}===
<syntaxhighlight lang="qbasic">FOR i = 32 TO 47
    FOR j = i TO i+80 STEP 16
        SELECT CASE j
        CASE 32
             LET s$ = "Spc"
        CASE 127
             LET s$ = "Del"
        CASE else
             LET s$ = CHR$(j)
        END SELECT
        PRINT USING "###: ###   ": j, s$;
    NEXT j
    PRINT
NEXT</syntaxhighlight>
{{out}}
<pre>Same as QB64 entry.</pre>

==={{header|XBasic}}===
{{works with|Windows XBasic}}
<syntaxhighlight lang="qbasic">PROGRAM  "ASCII table"
VERSION  "0.0000"

DECLARE FUNCTION Entry ()

FUNCTION  Entry ()
	FOR i = 32 TO 47
		FOR j = i TO i + 80 STEP 16
			SELECT CASE j
			CASE 32
				s$ = "Spc"
			CASE 127
				s$ = "Del"
			CASE ELSE
				s$ = CHR$(j)
			END SELECT
			PRINT RJUST$("  "+STRING(j),4); ": "; LJUST$(s$,3);
		NEXT j
		PRINT
	NEXT i
END FUNCTION
END PROGRAM</syntaxhighlight>

==={{header|Yabasic}}===
<syntaxhighlight lang="vb">for i = 32 to 47
    for j = i to i + 80 step 16
	    s$ = chr$(j)
        if j = 32  s$ = "Spc"
        if j = 127 s$ = "Del"
		print str$(j, "#####"), ": ", s$;
    next j
    print
next i</syntaxhighlight>

=={{header|BaCon}}==
<syntaxhighlight lang="bacon">FOR j = 0 TO 15
    FOR i = 32+j TO 127 STEP 16
        PRINT i FORMAT "  %3d - ";
        SELECT i
            CASE 32
                PRINT "Spc";
            CASE 127
                PRINT "Del";
            DEFAULT
                PRINT i FORMAT "%c  "
        ENDSELECT
    NEXT
    PRINT
NEXT</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|BCPL}}==
<syntaxhighlight lang="bcpl">get "libhdr"

let str(n) =
    n=32  -> "%I3: Spc  ",
    n=127 -> "%I3: Del  ",
    "%I3: %C    "
    
let start() be
    for i=32 to 47 do
    $(  for j=i to 127 by 16 do 
            writef(str(j), j, j)
        wrch('*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|BQN}}==
The final result is a 2D array of characters which is output line by line with <code>•Out</code>.
<syntaxhighlight lang="bqn">chs←⟨"SPC"⟩∾(@+33+↕94)∾⟨"DEL"⟩
J←{𝕨∾' '∾𝕩}´
_pad←{(𝕗×·⌈´≠¨)⊸(↑¨)}
•Out˘J˘J¨⍉6‿16⥊<˘⍉(∾⟜':'¨¯1 _pad •Fmt¨32+↕96)≍1 _pad chs</syntaxhighlight>
<syntaxhighlight lang="text"> 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</syntaxhighlight>

=={{header|Brainf***}}==
{{trans|M2000 Interpreter}}

<syntaxhighlight lang="bf">
> ++++++ ; 6 rows
> ++++ ++++ ++++ ++++ ; 16 columns
> ++++ ++++ ++++ ++++ ++++ ++++ ++++ ++++ ; 32: the starting character
<< ; move to row counter
[
 > ; move to the column counter
 [>  ; move to character
  .  ; print it
  +  ; increase it
  <- ; decrease  the column counter
 ]
 +++++ +++++.[-] ; print newline
 ++++ ++++ ++++ ++++ ; set column counter again
 <-] ; decrease row counter and loop
</syntaxhighlight>

{{out}}

<pre>
 !"#$%&'()*+,-./
0123456789:;<=>?
@ABCDEFGHIJKLMNO
PQRSTUVWXYZ[\]^_
`abcdefghijklmno
pqrstuvwxyz{|}~
</pre>

=={{header|C}}==
{{trans|Go}}
<syntaxhighlight lang="c">#include <stdio.h>

int main() {
    int i, j;
    char k[4];
    for (i = 0; i < 16; ++i) {
        for (j = 32 + i; j < 128; j += 16) {
            switch (j) {
                default:  sprintf(k, "%c", j); break;
                case 32:  sprintf(k, "Spc"); break;
                case 127: sprintf(k, "Del"); break;
            }
            printf("%3d : %-3s   ", j, k);
        }
        printf("\n");
    }
    return 0;
}</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|C++}}== 
<syntaxhighlight lang="cpp">#include <string> 
#include <iomanip> 
#include <iostream>

inline constexpr auto HEIGHT      = 16;
inline constexpr auto WIDTH       = 6;
inline constexpr auto ASCII_START = 32;
// ASCII special characters
inline constexpr auto SPACE  = 32;
inline constexpr auto DELETE = 127;

std::string displayAscii(char ascii) {
    switch (ascii) {
        case SPACE: return "Spc";
        case DELETE: return "Del";
        default: return std::string(1, ascii);
    }
}

int main() {
    for (std::size_t row = 0; row < HEIGHT; ++row) {
        for (std::size_t col = 0; col < WIDTH; ++col) {
            const auto ascii = ASCII_START + row + col * HEIGHT; 
            std::cout << std::right << std::setw(3) << ascii << " : " << std::left << std::setw(6) << displayAscii(ascii);   
        }
        std::cout << '\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|C sharp}}==
<syntaxhighlight lang="csharp">using static System.Console;
using static System.Linq.Enumerable;

public class Program
{
    static void Main()
    {
        for (int start = 32; start + 16 * 5 < 128; start++) {
            WriteLine(string.Concat(Range(0, 6).Select(i => $"{start+16*i, 3} : {Text(start+16*i), -6}")));
        }

        string Text(int index) => index == 32 ? "Sp" : index == 127 ? "Del" : (char)index + "";
    }
}</syntaxhighlight>
{{out}}
<pre> 32 : Sp     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|Caché ObjectScript}}==
<syntaxhighlight lang="caché objectscript">SHOWASCII
  ; this is 96 characters, so do 6 columns of 16
  for i = 32:1:127 {
    ; get remainder when div by 6, sort columns by remainder 2 3 4 5 0 1
    set rem = i # 6
    if rem = 2 {
      write !
    }

    ; spacing (tabs)
    set x = $case(rem,2:0,3:8,4:16,5:24,0:32,:40)

    ; char to write
    set wrtchr = $case(i,32:"Spc",127:"Del",:$char(i))
    write ?x,$justify(i,3)_": "_wrtchr
  }

  quit</syntaxhighlight>

{{out}}
<pre>SAMPLES>do ^SHOWASCII

 32: Spc 33: !   34: "   35: #   36: $   37: %
 38: &   39: '   40: (   41: )   42: *   43: +
 44: ,   45: -   46: .   47: /   48: 0   49: 1
 50: 2   51: 3   52: 4   53: 5   54: 6   55: 7
 56: 8   57: 9   58: :   59: ;   60: <   61: =
 62: >   63: ?   64: @   65: A   66: B   67: C
 68: D   69: E   70: F   71: G   72: H   73: I
 74: J   75: K   76: L   77: M   78: N   79: O
 80: P   81: Q   82: R   83: S   84: T   85: U
 86: V   87: W   88: X   89: Y   90: Z   91: [
 92: \   93: ]   94: ^   95: _   96: `   97: a
 98: b   99: c  100: d  101: e  102: f  103: g
104: h  105: i  106: j  107: k  108: l  109: m
110: n  111: o  112: p  113: q  114: r  115: s
116: t  117: u  118: v  119: w  120: x  121: y
122: z  123: {  124: |  125: }  126: ~  127: Del   </pre>


=={{header|Clojure}}==
The first code shown is flexible enough to lay the grid out in any number of columns that divides evenly into the number of ASCII codes to be displayed.

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.
<syntaxhighlight lang="clojure">
(defn cell [code]
  (let [text (get {32 "Spc", 127 "Del"} code (char code))]
    (format "%3d: %3s" code text)))

(defn ascii-table [n-cols st-code end-code]
  (let [n-cells (inc (- end-code st-code))
        n-rows  (/ n-cells n-cols)
        code    (fn [r c] (+ st-code r (* c n-rows)))
        row-str (fn [r]
                  (clojure.string/join "  "
                                       (map #(cell (code r %))
                                            (range n-cols))))]
    (->> (for [r (range n-rows)]
           (row-str r))
         (clojure.string/join "\n"))))

(defn pr-ascii-table [n-cols st-code end-code]
  (println (ascii-table n-cols st-code end-code)))
</syntaxhighlight>

{{out}}
<pre>
(pr-ascii-table 6 32 127)

 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


(pr-ascii-table 8 32 127)

 32: Spc   44:   ,   56:   8   68:   D   80:   P   92:   \  104:   h  116:   t
 33:   !   45:   -   57:   9   69:   E   81:   Q   93:   ]  105:   i  117:   u
 34:   "   46:   .   58:   :   70:   F   82:   R   94:   ^  106:   j  118:   v
 35:   #   47:   /   59:   ;   71:   G   83:   S   95:   _  107:   k  119:   w
 36:   $   48:   0   60:   <   72:   H   84:   T   96:   `  108:   l  120:   x
 37:   %   49:   1   61:   =   73:   I   85:   U   97:   a  109:   m  121:   y
 38:   &   50:   2   62:   >   74:   J   86:   V   98:   b  110:   n  122:   z
 39:   '   51:   3   63:   ?   75:   K   87:   W   99:   c  111:   o  123:   {
 40:   (   52:   4   64:   @   76:   L   88:   X  100:   d  112:   p  124:   |
 41:   )   53:   5   65:   A   77:   M   89:   Y  101:   e  113:   q  125:   }
 42:   *   54:   6   66:   B   78:   N   90:   Z  102:   f  114:   r  126:   ~
 43:   +   55:   7   67:   C   79:   O   91:   [  103:   g  115:   s  127: Del
</pre>

Now, if we want to handle the more general case of being able to print tables where the number of columns creates a final column that is shorter than the others, the code needs to be a little more complicated.  But the amount of change needed isn't really that large.

For readers new to Clojure, the calculation of "n-rows" has a couple points to note.  First, this makes use of the (fairly seamless) Java-interop capability, using the "ceil" function in Java's Math class.  Secondly, Clojure has a "ratio" data type that Java doesn't understand, so we coerce the input to the Java function into a floating-point value by adding 1.0 into the list of divisors.

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.

<syntaxhighlight lang="clojure">
(defn cell [code]
  (if (nil? code)
    ""
    (let [text (get {32 "Spc", 127 "Del"} code (char code))]
      (format "%3d: %3s" code text))))

(defn ascii-table [n-cols st-code end-code]
  (let [n-cells (inc (- end-code st-code))
        n-rows  (int (Math/ceil (/ n-cells n-cols 1.0)))
        code    (fn [r c]
                  (let [cd (+ st-code r (* c n-rows))]
                    (if (> cd end-code) nil cd)))
        row-str (fn [r]
                  (clojure.string/join "  "
                                       (map #(cell (code r %))
                                            (range n-cols))))]
    (->> (for [r (range n-rows)]
           (row-str r))
         (clojure.string/join "\n"))))

(defn pr-ascii-table [n-cols st-code end-code]
  (println (ascii-table n-cols st-code end-code)))
</syntaxhighlight>

{{out}}
<pre>
(pr-ascii-table 7 32 127)

 32: Spc   46:   .   60:   <   74:   J   88:   X  102:   f  116:   t
 33:   !   47:   /   61:   =   75:   K   89:   Y  103:   g  117:   u
 34:   "   48:   0   62:   >   76:   L   90:   Z  104:   h  118:   v
 35:   #   49:   1   63:   ?   77:   M   91:   [  105:   i  119:   w
 36:   $   50:   2   64:   @   78:   N   92:   \  106:   j  120:   x
 37:   %   51:   3   65:   A   79:   O   93:   ]  107:   k  121:   y
 38:   &   52:   4   66:   B   80:   P   94:   ^  108:   l  122:   z
 39:   '   53:   5   67:   C   81:   Q   95:   _  109:   m  123:   {
 40:   (   54:   6   68:   D   82:   R   96:   `  110:   n  124:   |
 41:   )   55:   7   69:   E   83:   S   97:   a  111:   o  125:   }
 42:   *   56:   8   70:   F   84:   T   98:   b  112:   p  126:   ~
 43:   +   57:   9   71:   G   85:   U   99:   c  113:   q  127: Del
 44:   ,   58:   :   72:   H   86:   V  100:   d  114:   r  
 45:   -   59:   ;   73:   I   87:   W  101:   e  115:   s  


(pr-ascii-table 7 36 120)

 36:   $   49:   1   62:   >   75:   K   88:   X  101:   e  114:   r
 37:   %   50:   2   63:   ?   76:   L   89:   Y  102:   f  115:   s
 38:   &   51:   3   64:   @   77:   M   90:   Z  103:   g  116:   t
 39:   '   52:   4   65:   A   78:   N   91:   [  104:   h  117:   u
 40:   (   53:   5   66:   B   79:   O   92:   \  105:   i  118:   v
 41:   )   54:   6   67:   C   80:   P   93:   ]  106:   j  119:   w
 42:   *   55:   7   68:   D   81:   Q   94:   ^  107:   k  120:   x
 43:   +   56:   8   69:   E   82:   R   95:   _  108:   l  
 44:   ,   57:   9   70:   F   83:   S   96:   `  109:   m  
 45:   -   58:   :   71:   G   84:   T   97:   a  110:   n  
 46:   .   59:   ;   72:   H   85:   U   98:   b  111:   o  
 47:   /   60:   <   73:   I   86:   V   99:   c  112:   p  
 48:   0   61:   =   74:   J   87:   W  100:   d  113:   q  
</pre>

=={{header|CLU}}==
<syntaxhighlight lang="clu">ascii = proc (n: int) returns (string)
    if n=32 then return("Spc")
    elseif n=127 then return("Del")
    else return(string$c2s(char$i2c(n)))
    end
end ascii

start_up = proc ()
    po: stream := stream$primary_output()
    for i: int in int$from_to(32, 47) do
        for j: int in int$from_to_by(i, 127, 16) do
            stream$putright(po, int$unparse(j), 3)
            stream$puts(po, ": ")
            stream$putleft(po, ascii(j), 5)
        end
        stream$putl(po, "")
    end
end start_up</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|COBOL}}==
{{works with|OpenCOBOL|3.1.2}}
Uses free form syntax.
<syntaxhighlight lang="cobol">
IDENTIFICATION DIVISION.
PROGRAM-ID. CHARSET.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 CHARCODE PIC 9(3) VALUE 32.
PROCEDURE DIVISION.
MAIN-PROCEDURE.
PERFORM UNTIL CHARCODE=128
DISPLAY FUNCTION CONCATENATE(
    FUNCTION CONCATENATE(
        CHARCODE,
        " : "
    ),
    FUNCTION CONCATENATE(
        FUNCTION CHAR(CHARCODE),
        "   "
    )
)
WITH NO ADVANCING
ADD 1 TO CHARCODE
END-PERFORM.
END PROGRAM CHARSET.
</syntaxhighlight>

{{out}}
<pre>
032 :    033 :     034 : !   035 : "   036 : #   037 : $   038 : %   039 : &   040 : '   041 : (   042 : )   043 : *   044 : +   045 : ,   046 : -   047 : .   048 : /   049 : 0   050 : 1   051 : 2   052 : 3   053 : 4   054 : 5   055 : 6   056 : 7   057 : 8   058 : 9   059 : :   060 : ;   061 : <   062 : =   063 : >   064 : ?   065 : @   066 : A   067 : B   068 : C   069 : D   070 : E   071 : F   072 : G   073 : H   074 : I   075 : J   076 : K   077 : L   078 : M   079 : N   080 : O   081 : P   082 : Q   083 : R   084 : S   085 : T   086 : U   087 : V   088 : W   089 : X   090 : Y   091 : Z   092 : [   093 : \   094 : ]   095 : ^   096 : _   097 : `   098 : a   099 : b   100 : c   101 : d   102 : e   103 : f   104 : g   105 : h   106 : i   107 : j   108 : k   109 : l   110 : m   111 : n   112 : o   113 : p   114 : q   115 : r   116 : s   117 : t   118 : u   119 : v   120 : w   121 : x   122 : y   123 : z   124 : {   125 : |   126 : }   127 : ~ 
</pre>

=={{header|Commodore BASIC}}==
<syntaxhighlight lang="qbasic">100 PRINT CHR$(147);:REM CLEAR SCREEN
110 PRINT CHR$(14);:REM CHARACTER SET 2
120 PRINT "COMMODORE 64 - BASIC V2"
130 PRINT "CHARACTER SET 2"
140 PRINT
150 FOR R=0 TO 15
160 FOR C=0 TO 5
170 A=32+R+C*16
180 PRINT RIGHT$("  "+STR$(A),4);":";CHR$(A);
190 NEXT C
200 PRINT
210 NEXT R
</syntaxhighlight>
{{out}}
[[File:c64asciitable.jpg]]



=={{header|Common Lisp}}==
<syntaxhighlight lang="lisp">(setq startVal 32)
(setq endVal 127)
(setq cols 6)

(defun print-val (val) "Prints the value for that ascii number"
	(cond 
		((= val 32) (format t " 32: SPC "))
		((= val 127) (format t "127: DEL~%"))
		((and (zerop (mod (- val startVal) cols)) (< val 100)) (format t "~% ~d: ~a   " val (int-char val)))
		((and (zerop (mod (- val startVal) cols)) (>= val 100)) (format t "~%~d: ~a   " val (int-char val)))
		((< val 100) (format t " ~d:  ~a   " val (int-char val)))
		((>= val 100) (format t "~d:  ~a   " val (int-char val)))
		(t nil)))

        (defun get-range (lower upper) "Returns a list of range lower to upper"
	(if (> lower upper) '() (cons lower (get-range (+ 1 lower) upper))))

(mapcar #'print-val (get-range startVal endVal))</syntaxhighlight>
{{out}}
<pre> 32: SPC  33:  !    34:  "    35:  #    36:  $    37:  %   
 38: &    39:  '    40:  (    41:  )    42:  *    43:  +   
 44: ,    45:  -    46:  .    47:  /    48:  0    49:  1   
 50: 2    51:  3    52:  4    53:  5    54:  6    55:  7   
 56: 8    57:  9    58:  :    59:  ;    60:  <    61:  =   
 62: >    63:  ?    64:  @    65:  A    66:  B    67:  C   
 68: D    69:  E    70:  F    71:  G    72:  H    73:  I   
 74: J    75:  K    76:  L    77:  M    78:  N    79:  O   
 80: P    81:  Q    82:  R    83:  S    84:  T    85:  U   
 86: V    87:  W    88:  X    89:  Y    90:  Z    91:  [   
 92: \    93:  ]    94:  ^    95:  _    96:  `    97:  a   
 98: b    99:  c   100:  d   101:  e   102:  f   103:  g   
104: h   105:  i   106:  j   107:  k   108:  l   109:  m   
110: n   111:  o   112:  p   113:  q   114:  r   115:  s   
116: t   117:  u   118:  v   119:  w   120:  x   121:  y   
122: z   123:  {   124:  |   125:  }   126:  ~   127: DEL</pre>

=={{header|Cowgol}}==
<syntaxhighlight lang="cowgol">include "cowgol.coh";

# Print number with preceding space if <100 and trailing colon
sub print_num(n: uint8) is
    if n < 100 then print_char(' '); end if;
    print_i8(n);
    print(": ");
end sub;

# Print character / Spc / Del padded to 5 spaces
sub print_ch(c: uint8) is
    if c == ' ' then print("Spc  ");
    elseif c == 127 then print("Del  ");
    else    
        print_char(c);
        print("    ");
    end if;
end sub;

var c: uint8 := 32;
loop
    print_num(c);
    print_ch(c);
    if c == 127 then
        break;
    end if;
    c := c + 16;
    if c > 127 then
        print_nl();
        c := c - 95;
    end if;
end loop;
print_nl();</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|D}}==
{{trans|C}}
<syntaxhighlight lang="d">import std.stdio;

void main() {
    for (int i = 0; i < 16; ++i) {
        for (int j = 32 + i; j < 128; j += 16) {
            switch (j) {
                case 32:
                    writef("%3d : Spc   ", j);
                    break;
                case 127:
                    writef("%3d : Del   ", j);
                    break;
                default:
                    writef("%3d : %-3s     ", j, cast(char)j);
                    break;
            }
        }
        writeln;
    }
}</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|Dc}}==
{{Trans|Go}}
{{Works with|GNU dc|1.3.95}}

<syntaxhighlight lang="dc">[ [1q]S.[>.0]xs.L. ] sl         ## l: islt
     
## for  initcode condcode incrcode body
##       [1]      [2]      [3]      [4]
[ [q]S. 4:. 3:. 2:. 1:.  1;.x [2;.x 0=. 4;.x 3;.x 0;.x]d0:.x Os.L.o ] sf
## f: for
     
##      for( i=0 ; i<16 ; ++i ) {
##          for( j=32+i ; j<128 ; j+=16 ) {
##              pr "%3d", j, " : "
##              ok = 0;
##              if( j == 32  ) { pr "Spc"; ok=1; }
##              if( j == 127 ) { pr "Del"; ok=1; }
##              if( !ok      ) { pr "%c  ", j; }
##              pr "   "
##          }
##          pr NL
##      }
     
[0si] [li 16 llx] [li1+si] [
    [32 li+ sj] [lj 128 llx] [lj 16+ sj] [
        [[ ]P]sT 100 lj <T
                  10 lj <T
        ljn [ : ]P
        0so
        [[Spc]P 1so]sT lj  32 =T
        [[Del]P 1so]sT lj 127 =T 
        [ljP [  ]P ]sT lo 0   =T
        [   ]P
    ] lfx
    []pP
] lfx</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|Delphi}}==
{{Trans|Go}}

<syntaxhighlight lang="delphi">
program Show_Ascii_table;

{$APPTYPE CONSOLE}

var
  i, j: Integer;
  k: string;

begin
  for i := 0 to 15 do
  begin
    j := 32 + i;
    while j < 128 do
    begin
      case j of
        32:
          k := 'Spc';
        127:
          k := 'Del';
      else
        k := chr(j);
      end;
      Write(j: 3, ' : ', k: 3, '   ');
      inc(j, 16);
    end;
    Writeln;
  end;
  Readln;
end.

</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|Draco}}==
<syntaxhighlight lang="draco">proc write_item(byte n) void:
    *char chrstr = "*     ";
    chrstr* := pretend(n, char);
    write(n:3, " : ",
        case n
            incase 32:  "Spc   "
            incase 127: "Del   "
            default:    chrstr
        esac)
corp

proc main() void:
    byte row, col;
    for row from 32 upto 47 do
        for col from row by 16 upto 127 do
            write_item(col)
        od;
        writeln()
    od
corp</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|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 ShowAsciiTable {
    @Inject Console console;
    void run() {
        for (Int offset : 0..<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();
        }
    }
}
</syntaxhighlight>

{{out}}
<pre>
 32/0x20: ' '   48/0x30: '0'   64/0x40: '@'   80/0x50: 'P'   96/0x60: '`'  112/0x70: 'p'  
 33/0x21: '!'   49/0x31: '1'   65/0x41: 'A'   81/0x51: 'Q'   97/0x61: 'a'  113/0x71: 'q'  
 34/0x22: '\"'  50/0x32: '2'   66/0x42: 'B'   82/0x52: 'R'   98/0x62: 'b'  114/0x72: 'r'  
 35/0x23: '#'   51/0x33: '3'   67/0x43: 'C'   83/0x53: 'S'   99/0x63: 'c'  115/0x73: 's'  
 36/0x24: '$'   52/0x34: '4'   68/0x44: 'D'   84/0x54: 'T'  100/0x64: 'd'  116/0x74: 't'  
 37/0x25: '%'   53/0x35: '5'   69/0x45: 'E'   85/0x55: 'U'  101/0x65: 'e'  117/0x75: 'u'  
 38/0x26: '&'   54/0x36: '6'   70/0x46: 'F'   86/0x56: 'V'  102/0x66: 'f'  118/0x76: 'v'  
 39/0x27: '\''  55/0x37: '7'   71/0x47: 'G'   87/0x57: 'W'  103/0x67: 'g'  119/0x77: 'w'  
 40/0x28: '('   56/0x38: '8'   72/0x48: 'H'   88/0x58: 'X'  104/0x68: 'h'  120/0x78: 'x'  
 41/0x29: ')'   57/0x39: '9'   73/0x49: 'I'   89/0x59: 'Y'  105/0x69: 'i'  121/0x79: 'y'  
 42/0x2A: '*'   58/0x3A: ':'   74/0x4A: 'J'   90/0x5A: 'Z'  106/0x6A: 'j'  122/0x7A: 'z'  
 43/0x2B: '+'   59/0x3B: ';'   75/0x4B: 'K'   91/0x5B: '['  107/0x6B: 'k'  123/0x7B: '{'  
 44/0x2C: ','   60/0x3C: '<'   76/0x4C: 'L'   92/0x5C: '\\' 108/0x6C: 'l'  124/0x7C: '|'  
 45/0x2D: '-'   61/0x3D: '='   77/0x4D: 'M'   93/0x5D: ']'  109/0x6D: 'm'  125/0x7D: '}'  
 46/0x2E: '.'   62/0x3E: '>'   78/0x4E: 'N'   94/0x5E: '^'  110/0x6E: 'n'  126/0x7E: '~'  
 47/0x2F: '/'   63/0x3F: '?'   79/0x4F: 'O'   95/0x5F: '_'  111/0x6F: 'o'  127/0x7F: '\d' 
</pre>

=={{header|Excel}}==
===LAMBDA===

Binding the name '''asciiTable''' to the following lambda expression in the Name Manager of the Excel WorkBook:

(See [https://www.microsoft.com/en-us/research/blog/lambda-the-ultimatae-excel-worksheet-function/ LAMBDA: The ultimate Excel worksheet function])

{{Works with|Office 365 betas 2021}}
<syntaxhighlight lang="lisp">asciiTable
=LAMBDA(i,
    justifyRight(3)(" ")(i) & ": " & (
        justifyRight(
           3
        )(" ")(
            IF(32 = i,
                "Spc",
                IF(127 = i,
                    "Del",
                    CHAR(i)
                )
            )
        )
    )
)(
    SEQUENCE(16, 6, 32, 1)
)</syntaxhighlight>

and also assuming the following generic binding in the Name Manager for the WorkBook:

<syntaxhighlight lang="lisp">justifyRight
=LAMBDA(n,
    LAMBDA(c,
        LAMBDA(s,
            LET(
                lng, LEN(s),

                IF(
                    lng < n,
                    MID(
                        REPT(c, n),
                        lng, n - lng
                    ) & s,
                    s
                )
            )
        )
    )
)</syntaxhighlight>

{{Out}}
The formula in cell B2 defines an array which populates the whole '''B2:G17''' range.

(Justification within the cells depends on applying a monospaced font in Excel).

{| class="wikitable" 
|-
|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx
! colspan="7" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=asciiTable
|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"
| 
| A
| B
| C
| D
| E
| F
| G
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1
|  style="font-weight:bold" | Ascii Table
| 
| 
| 
| 
| 
| 
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2
| 
|  style="background-color:#cbcefb" |  32:&nbsp;Spc
|  33:&nbsp;&nbsp;&nbsp;!
|  34:&nbsp;&nbsp;&nbsp;"
|  35:&nbsp;&nbsp;&nbsp;#
|  36:&nbsp;&nbsp;&nbsp;$
|  37:&nbsp;&nbsp;&nbsp;%
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 3
| 
|  38:&nbsp;&nbsp;&nbsp;&
|  39:&nbsp;&nbsp;&nbsp;'
|  40:&nbsp;&nbsp;&nbsp;(
|  41:&nbsp;&nbsp;&nbsp;)
|  42:&nbsp;&nbsp;&nbsp;*
|  43:&nbsp;&nbsp;&nbsp;+
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 4
| 
|  44:&nbsp;&nbsp;&nbsp;,
|  45:&nbsp;&nbsp;&nbsp;-
|  46:&nbsp;&nbsp;&nbsp;.
|  47:&nbsp;&nbsp;&nbsp;/
|  48:&nbsp;&nbsp;&nbsp;0
|  49:&nbsp;&nbsp;&nbsp;1
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 5
| 
|  50:&nbsp;&nbsp;&nbsp;2
|  51:&nbsp;&nbsp;&nbsp;3
|  52:&nbsp;&nbsp;&nbsp;4
|  53:&nbsp;&nbsp;&nbsp;5
|  54:&nbsp;&nbsp;&nbsp;6
|  55:&nbsp;&nbsp;&nbsp;7
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 6
| 
|  56:&nbsp;&nbsp;&nbsp;8
|  57:&nbsp;&nbsp;&nbsp;9
|  58:&nbsp;&nbsp;&nbsp;:
|  59:&nbsp;&nbsp;&nbsp;;
|  60:&nbsp;&nbsp;&nbsp;<
|  61:&nbsp;&nbsp;&nbsp;=
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 7
| 
|  62:&nbsp;&nbsp;&nbsp;>
|  63:&nbsp;&nbsp;&nbsp;?
|  64:&nbsp;&nbsp;&nbsp;@
|  65:&nbsp;&nbsp;&nbsp;A
|  66:&nbsp;&nbsp;&nbsp;B
|  67:&nbsp;&nbsp;&nbsp;C
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 8
| 
|  68:&nbsp;&nbsp;&nbsp;D
|  69:&nbsp;&nbsp;&nbsp;E
|  70:&nbsp;&nbsp;&nbsp;F
|  71:&nbsp;&nbsp;&nbsp;G
|  72:&nbsp;&nbsp;&nbsp;H
|  73:&nbsp;&nbsp;&nbsp;I
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 9
| 
|  74:&nbsp;&nbsp;&nbsp;J
|  75:&nbsp;&nbsp;&nbsp;K
|  76:&nbsp;&nbsp;&nbsp;L
|  77:&nbsp;&nbsp;&nbsp;M
|  78:&nbsp;&nbsp;&nbsp;N
|  79:&nbsp;&nbsp;&nbsp;O
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 10
| 
|  80:&nbsp;&nbsp;&nbsp;P
|  81:&nbsp;&nbsp;&nbsp;Q
|  82:&nbsp;&nbsp;&nbsp;R
|  83:&nbsp;&nbsp;&nbsp;S
|  84:&nbsp;&nbsp;&nbsp;T
|  85:&nbsp;&nbsp;&nbsp;U
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 11
| 
|  86:&nbsp;&nbsp;&nbsp;V
|  87:&nbsp;&nbsp;&nbsp;W
|  88:&nbsp;&nbsp;&nbsp;X
|  89:&nbsp;&nbsp;&nbsp;Y
|  90:&nbsp;&nbsp;&nbsp;Z
|  91:&nbsp;&nbsp;&nbsp;[
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 12
| 
|  92:&nbsp;&nbsp;&nbsp;\
|  93:&nbsp;&nbsp;&nbsp;]
|  94:&nbsp;&nbsp;&nbsp;^
|  95:&nbsp;&nbsp;&nbsp;_
|  96:&nbsp;&nbsp;&nbsp;`
|  97:&nbsp;&nbsp;&nbsp;a
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 13
| 
|  98:&nbsp;&nbsp;&nbsp;b
|  99:&nbsp;&nbsp;&nbsp;c
| 100:&nbsp;&nbsp;d
| 101:&nbsp;&nbsp;e
| 102:&nbsp;&nbsp;f
| 103:&nbsp;&nbsp;g
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 14
| 
| 104:&nbsp;&nbsp;h
| 105:&nbsp;&nbsp;i
| 106:&nbsp;&nbsp;j
| 107:&nbsp;&nbsp;k
| 108:&nbsp;&nbsp;l
| 109:&nbsp;&nbsp;m
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 15
| 
| 110:&nbsp;&nbsp;n
| 111:&nbsp;&nbsp;o
| 112:&nbsp;&nbsp;p
| 113:&nbsp;&nbsp;q
| 114:&nbsp;&nbsp;r
| 115:&nbsp;&nbsp;s
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 16
| 
| 116:&nbsp;&nbsp;t
| 117:&nbsp;&nbsp;u
| 118:&nbsp;&nbsp;v
| 119:&nbsp;&nbsp;w
| 120:&nbsp;&nbsp;x
| 121:&nbsp;&nbsp;y
|- style="font-family:monospace"
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 17
| 
| 122:&nbsp;&nbsp;z
| 123:&nbsp;&nbsp;{
| 124:&nbsp;&nbsp;|
| 125:&nbsp;&nbsp;}
| 126:&nbsp;&nbsp;~
| 127: Del
|}


Or, separating code and character into adjacent Excel cells:

<syntaxhighlight lang="lisp">asciiTable2
=LAMBDA(i,
    IF(0 <> MOD(i, 1),
        LET(
            code, FLOOR.MATH(i),
            
            IF(32 = code,
                "Spc",
                IF(127 = code,
                    "Del",
                    CHAR(code)
                )
            )
        ),
        i
    )
)(
    SEQUENCE(16, 12, 32, 0.5)
)</syntaxhighlight>

{{Out}}
The formula in cell B2 defines an array which populates the whole '''B2:M17''' range:

{| class="wikitable" 
|-
|||style="text-align:right; font-family:serif; font-style:italic; font-size:120%;"|fx
! colspan="13" style="text-align:left; vertical-align: bottom; font-family:Arial, Helvetica, sans-serif !important;"|=asciiTable2
|- style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff;"
| 
| A
| B
| C
| D
| E
| F
| G
| H
| I
| J
| K
| L
| M
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 1
| Ascii table
| 
| 
| 
| 
| 
| 
| 
| 
| 
| 
| 
| 
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 2
| 
|  style="text-align:right; background-color:#cbcefb" | 32
|  style="font-weight:bold" | Spc
|  style="text-align:right" | 33
|  style="font-weight:bold" | !
|  style="text-align:right" | 34
|  style="font-weight:bold" | "
|  style="text-align:right" | 35
|  style="font-weight:bold" | #
|  style="text-align:right" | 36
|  style="font-weight:bold" | $
|  style="text-align:right" | 37
|  style="font-weight:bold" | %
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 3
| 
|  style="text-align:right" | 38
|  style="font-weight:bold" | &
|  style="text-align:right" | 39
|  style="font-weight:bold" | '
|  style="text-align:right" | 40
|  style="font-weight:bold" | (
|  style="text-align:right" | 41
|  style="font-weight:bold" | )
|  style="text-align:right" | 42
|  style="font-weight:bold" | *
|  style="text-align:right" | 43
|  style="font-weight:bold" | +
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 4
| 
|  style="text-align:right" | 44
|  style="font-weight:bold" | ,
|  style="text-align:right" | 45
|  style="font-weight:bold" | -
|  style="text-align:right" | 46
|  style="font-weight:bold" | .
|  style="text-align:right" | 47
|  style="font-weight:bold" | /
|  style="text-align:right" | 48
|  style="font-weight:bold" | 0
|  style="text-align:right" | 49
|  style="font-weight:bold" | 1
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 5
| 
|  style="text-align:right" | 50
|  style="font-weight:bold" | 2
|  style="text-align:right" | 51
|  style="font-weight:bold" | 3
|  style="text-align:right" | 52
|  style="font-weight:bold" | 4
|  style="text-align:right" | 53
|  style="font-weight:bold" | 5
|  style="text-align:right" | 54
|  style="font-weight:bold" | 6
|  style="text-align:right" | 55
|  style="font-weight:bold" | 7
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 6
| 
|  style="text-align:right" | 56
|  style="font-weight:bold" | 8
|  style="text-align:right" | 57
|  style="font-weight:bold" | 9
|  style="text-align:right" | 58
|  style="font-weight:bold" | :
|  style="text-align:right" | 59
|  style="font-weight:bold" | ;
|  style="text-align:right" | 60
|  style="font-weight:bold" | <
|  style="text-align:right" | 61
|  style="font-weight:bold" | =
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 7
| 
|  style="text-align:right" | 62
|  style="font-weight:bold" | >
|  style="text-align:right" | 63
|  style="font-weight:bold" | ?
|  style="text-align:right" | 64
|  style="font-weight:bold" | @
|  style="text-align:right" | 65
|  style="font-weight:bold" | A
|  style="text-align:right" | 66
|  style="font-weight:bold" | B
|  style="text-align:right" | 67
|  style="font-weight:bold" | C
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 8
| 
|  style="text-align:right" | 68
|  style="font-weight:bold" | D
|  style="text-align:right" | 69
|  style="font-weight:bold" | E
|  style="text-align:right" | 70
|  style="font-weight:bold" | F
|  style="text-align:right" | 71
|  style="font-weight:bold" | G
|  style="text-align:right" | 72
|  style="font-weight:bold" | H
|  style="text-align:right" | 73
|  style="font-weight:bold" | I
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 9
| 
|  style="text-align:right" | 74
|  style="font-weight:bold" | J
|  style="text-align:right" | 75
|  style="font-weight:bold" | K
|  style="text-align:right" | 76
|  style="font-weight:bold" | L
|  style="text-align:right" | 77
|  style="font-weight:bold" | M
|  style="text-align:right" | 78
|  style="font-weight:bold" | N
|  style="text-align:right" | 79
|  style="font-weight:bold" | O
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 10
| 
|  style="text-align:right" | 80
|  style="font-weight:bold" | P
|  style="text-align:right" | 81
|  style="font-weight:bold" | Q
|  style="text-align:right" | 82
|  style="font-weight:bold" | R
|  style="text-align:right" | 83
|  style="font-weight:bold" | S
|  style="text-align:right" | 84
|  style="font-weight:bold" | T
|  style="text-align:right" | 85
|  style="font-weight:bold" | U
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 11
| 
|  style="text-align:right" | 86
|  style="font-weight:bold" | V
|  style="text-align:right" | 87
|  style="font-weight:bold" | W
|  style="text-align:right" | 88
|  style="font-weight:bold" | X
|  style="text-align:right" | 89
|  style="font-weight:bold" | Y
|  style="text-align:right" | 90
|  style="font-weight:bold" | Z
|  style="text-align:right" | 91
|  style="font-weight:bold" | [
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 12
| 
|  style="text-align:right" | 92
|  style="font-weight:bold" | \
|  style="text-align:right" | 93
|  style="font-weight:bold" | ]
|  style="text-align:right" | 94
|  style="font-weight:bold" | ^
|  style="text-align:right" | 95
|  style="font-weight:bold" | _
|  style="text-align:right" | 96
|  style="font-weight:bold" | `
|  style="text-align:right" | 97
|  style="font-weight:bold" | a
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 13
| 
|  style="text-align:right" | 98
|  style="font-weight:bold" | b
|  style="text-align:right" | 99
|  style="font-weight:bold" | c
|  style="text-align:right" | 100
|  style="font-weight:bold" | d
|  style="text-align:right" | 101
|  style="font-weight:bold" | e
|  style="text-align:right" | 102
|  style="font-weight:bold" | f
|  style="text-align:right" | 103
|  style="font-weight:bold" | g
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 14
| 
|  style="text-align:right" | 104
|  style="font-weight:bold" | h
|  style="text-align:right" | 105
|  style="font-weight:bold" | i
|  style="text-align:right" | 106
|  style="font-weight:bold" | j
|  style="text-align:right" | 107
|  style="font-weight:bold" | k
|  style="text-align:right" | 108
|  style="font-weight:bold" | l
|  style="text-align:right" | 109
|  style="font-weight:bold" | m
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 15
| 
|  style="text-align:right" | 110
|  style="font-weight:bold" | n
|  style="text-align:right" | 111
|  style="font-weight:bold" | o
|  style="text-align:right" | 112
|  style="font-weight:bold" | p
|  style="text-align:right" | 113
|  style="font-weight:bold" | q
|  style="text-align:right" | 114
|  style="font-weight:bold" | r
|  style="text-align:right" | 115
|  style="font-weight:bold" | s
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 16
| 
|  style="text-align:right" | 116
|  style="font-weight:bold" | t
|  style="text-align:right" | 117
|  style="font-weight:bold" | u
|  style="text-align:right" | 118
|  style="font-weight:bold" | v
|  style="text-align:right" | 119
|  style="font-weight:bold" | w
|  style="text-align:right" | 120
|  style="font-weight:bold" | x
|  style="text-align:right" | 121
|  style="font-weight:bold" | y
|-
| style="text-align:center; font-family:Arial, Helvetica, sans-serif !important; background-color:#000000; color:#ffffff" | 17
| 
|  style="text-align:right" | 122
|  style="font-weight:bold" | z
|  style="text-align:right" | 123
|  style="font-weight:bold" | {
|  style="text-align:right" | 124
|  style="font-weight:bold" | |
|  style="text-align:right" | 125
|  style="font-weight:bold" | }
|  style="text-align:right" | 126
|  style="font-weight:bold" | ~
|  style="text-align:right" | 127
|  style="font-weight:bold" | Del
|}

=={{header|Factor}}==
===Idiomatic version===
{{Works with|Factor|0.98}}
<syntaxhighlight lang="factor">USING: combinators formatting io kernel math math.ranges
pair-rocket sequences ;
IN: rosetta-code.ascii-table

: row-values ( n -- seq ) [ 32 + ] [ 112 + ] bi 16 <range> ;

: ascii>output ( n -- str )
    { 32 => [ "Spc" ] 127 => [ "Del" ] [ "" 1sequence ] } case ;

: print-row ( n -- )
    row-values [ dup ascii>output "%3d : %-3s   " printf ] each nl ;

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

MAIN: print-ascii-table</syntaxhighlight>
===Go translation===
{{Trans|Go}}
{{Works with|Factor|0.98}}
<syntaxhighlight lang="factor">USING: combinators formatting io kernel math math.ranges
pair-rocket sequences ;
IN: rosetta-code.ascii-table

: main ( -- )
    16 <iota> [
        32 + 127 16 <range> [
            dup {
                32  => [ "Spc" ]
                127 => [ "Del" ]
                [ "" 1sequence ]
            } case
            "%3d : %-3s   " printf
        ] each
        nl
    ] each
;

MAIN: main</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|Forth}}==
Idiomatic Forth version is factored differently than conventional languages, allowing each factor to be tested independently at the console, bottom up.
<syntaxhighlight lang="forth">DECIMAL
: ###: ( c -- ) 3 .R ." : " ;

: .CHAR  ( c -- )
        DUP
        CASE
         BL OF  ###: ." spc"  ENDOF
        127 OF  ###: ." del"  ENDOF
            DUP ###: EMIT  2 SPACES
        ENDCASE
        3 SPACES ;

: .ROW ( n2 n1 -- ) 
       CR DO   I .CHAR   16 +LOOP ;

: ASCII.TABLE ( -- )
        16 0 DO   113 I +   32 I +  .ROW     LOOP ;</syntaxhighlight>

Test Output at the console
<syntaxhighlight lang="forth">ASCII.TABLE
 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    ok
</syntaxhighlight>


=={{header|Fortran}}==
{{works with|f2c|20160102}}
{{works with|gfortran|8.3.0}}
The dollar sign $ in the format string isn't part of the standard but is a common extension.
ACHAR may not be part of the standard, either.
<syntaxhighlight lang="fortran">       PROGRAM ASCTBL  ! show the ASCII characters from 32-127
       IMPLICIT NONE
       INTEGER I, J
       CHARACTER*3 H

  10   FORMAT (I3, ':', A3, '   ', $)
  20   FORMAT ()
       DO J = 0, 15, +1
         DO I = 32+J, 127, +16
           IF (I > 32 .AND. I < 127) THEN
             H = ' ' // ACHAR(I) // ' '
           ELSE IF (I .EQ. 32) THEN
             H = 'Spc'
           ELSE IF (I .EQ. 127) THEN
             H = 'Del'
           ELSE
             STOP 'bad value of i'
           END IF
           PRINT 10, I, H
         END DO
         PRINT 20
       END DO

       END
</syntaxhighlight>
output:
<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|FreeBASIC}}==

<syntaxhighlight lang="freebasic">function getasc( n as unsigned byte ) as string
    if n=32 then return "Spc"
    if n=127 then return "Del"
    return chr(n)+"  "
end function

function padto( i as ubyte, j as integer ) as string
    return wspace(i-len(str(j)))+str(j)
end function

dim as unsigned byte r, c, n
dim as string disp

for r = 0 to 15
    disp = ""
    for c = 0 to 5
        n = 32 + 6*r + c
        disp = disp + padto(3, n) + ": " + getasc(n) + "    "
    next c
    print disp
next r
</syntaxhighlight>

{{out}}
<pre> 32: Spc     33: !       34: "       35: #       36: $       37: %      
 38: &       39: '       40: (       41: )       42: *       43: +      
 44: ,       45: -       46: .       47: /       48: 0       49: 1      
 50: 2       51: 3       52: 4       53: 5       54: 6       55: 7      
 56: 8       57: 9       58: :       59: ;       60: <       61: =      
 62: >       63: ?       64: @       65: A       66: B       67: C      
 68: D       69: E       70: F       71: G       72: H       73: I      
 74: J       75: K       76: L       77: M       78: N       79: O      
 80: P       81: Q       82: R       83: S       84: T       85: U      
 86: V       87: W       88: X       89: Y       90: Z       91: [      
 92: \       93: ]       94: ^       95: _       96: `       97: a      
 98: b       99: c      100: d      101: e      102: f      103: g      
104: h      105: i      106: j      107: k      108: l      109: m      
110: n      111: o      112: p      113: q      114: r      115: s      
116: t      117: u      118: v      119: w      120: x      121: y      
122: z      123: {      124: |      125: }      126: ~      127: Del   
</pre>


=={{header|Free Pascal}}==

<syntaxhighlight lang="pascal">// The FPC (FreePascal compiler) discards the program header
// (except in ISO-compliant “compiler modes”).
program showAsciiTable(output);

const
	columnsTotal = 6;

type
	// The hash indicates a char-data type.
	asciiCharacter = #32..#127;
	asciiCharacters = set of asciiCharacter;

var
	character: asciiCharacter;
	characters: asciiCharacters;
	column, line: integer;
begin
	// characters needs to be initialized,
	// because the next `include` below
	// will _read_ the value `characters`.
	// Reading _unintialized_ values, however,
	// is considered bad practice in Pascal.
	characters := [];
	// `div` denotes integer division in Pascal,
	// that means the result will be an _integer_-value.
	line := (ord(high(asciiCharacter)) - ord(low(asciiCharacter)))
		div columnsTotal + 1;
	// Note: In Pascal for-loop limits are _inclusive_.
	for column := 0 to columnsTotal do
	begin
		// This is equivalent to
		//   characters := characters + […];
		// i.e. the union of two sets.
		include(characters, chr(ord(low(asciiCharacter)) + column * line));
	end;
	
	for line := line downto 1 do
	begin
		// the for..in..do statement is an Extended Pascal extension
		for character in characters do
		begin
			// `:6` specifies minimum width of argument
			// [only works for write/writeLn/writeStr]
			write(ord(character):6, ' : ', character);
		end;
		// emit proper newline character on `output`
		writeLn;
		
		// `characters` is evaluated prior entering the loop,
		// not every time an iteration finished.
		for character in characters do
		begin
			// These statements are equivalent to
			//   characters := characters + [character];
			//   characters := characters - [succ(character)];
			// respectively, but shorter to write,
			// i.e. less susceptible to spelling mistakes.
			exclude(characters, character);
			include(characters, succ(character));
		end;
	end;
end.</syntaxhighlight>

{{out}}
<pre>    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 :
</pre>

=={{header|Frink}}==
<syntaxhighlight lang="frink">a = ["32 Space"]
for i = 33 to 126
   a.push["$i " + char[i]]
a.push["127 Delete"]

println[formatTableBoxed[columnize[a,8].transpose[], "left"]]</syntaxhighlight>
{{out}}
<pre>
┌────────┬────┬────┬────┬────┬────┬────┬────┬─────┬─────┬─────┬──────────┐
│32 Space│40 (│48 0│56 8│64 @│72 H│80 P│88 X│96 ` │104 h│112 p│120 x     │
├────────┼────┼────┼────┼────┼────┼────┼────┼─────┼─────┼─────┼──────────┤
│33 !    │41 )│49 1│57 9│65 A│73 I│81 Q│89 Y│97 a │105 i│113 q│121 y     │
├────────┼────┼────┼────┼────┼────┼────┼────┼─────┼─────┼─────┼──────────┤
│34 "    │42 *│50 2│58 :│66 B│74 J│82 R│90 Z│98 b │106 j│114 r│122 z     │
├────────┼────┼────┼────┼────┼────┼────┼────┼─────┼─────┼─────┼──────────┤
│35 #    │43 +│51 3│59 ;│67 C│75 K│83 S│91 [│99 c │107 k│115 s│123 {     │
├────────┼────┼────┼────┼────┼────┼────┼────┼─────┼─────┼─────┼──────────┤
│36 $    │44 ,│52 4│60 <│68 D│76 L│84 T│92 \│100 d│108 l│116 t│124 |     │
├────────┼────┼────┼────┼────┼────┼────┼────┼─────┼─────┼─────┼──────────┤
│37 %    │45 -│53 5│61 =│69 E│77 M│85 U│93 ]│101 e│109 m│117 u│125 }     │
├────────┼────┼────┼────┼────┼────┼────┼────┼─────┼─────┼─────┼──────────┤
│38 &    │46 .│54 6│62 >│70 F│78 N│86 V│94 ^│102 f│110 n│118 v│126 ~     │
├────────┼────┼────┼────┼────┼────┼────┼────┼─────┼─────┼─────┼──────────┤
│39 '    │47 /│55 7│63 ?│71 G│79 O│87 W│95 _│103 g│111 o│119 w│127 Delete│
└────────┴────┴────┴────┴────┴────┴────┴────┴─────┴─────┴─────┴──────────┘
</pre>

=={{header|Fōrmulæ}}==

{{FormulaeEntry|page=https://formulae.org/?script=examples/Show_ASCII_table}}

'''Solution'''

[[File:Fōrmulæ - Show ASCII table 01.png]]

[[File:Fōrmulæ - Show ASCII table 02.png]]

=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
include "NSLog.incl"

local fn ASCIITable as CFStringRef
  NSinteger   i
  CFStringRef temp
  
  CFMutableStringRef mutStr = fn MutableStringWithCapacity( 0 )
  for i = 32 to 127
    temp = fn StringWithFormat( @"%c", i )
    if i ==  32 then temp = @"Spc"
    if i == 127 then temp = @"Del"
    MutableStringAppendString( mutStr, fn StringWithFormat( @"%-1d : %@\n", i, temp ) )
  next
  
  CFArrayRef colArr = fn StringComponentsSeparatedByString( mutStr, @"\n" )
  MutableStringSetString( mutStr, @"" )
  for i = 0 to 15
    ObjectRef col0 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i      ) )
    ObjectRef col1 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 16 ) )
    ObjectRef col2 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 32 ) )
    ObjectRef col3 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 48 ) )
    ObjectRef col4 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 64 ) )
    ObjectRef col5 = fn StringUTF8String( fn ArrayObjectAtIndex( colArr, i + 80 ) )
    MutableStringAppendString( mutStr, fn StringWithFormat( @"%-10s %-10s %-10s %-10s %-10s %-10s\n", col0, col1, col2, col3, col4, col5 ) )
  next
end fn = fn StringWithString( mutStr )

NSLog( @"%@", fn ASCIITable )

HandleEvents
</syntaxhighlight>
{{output}}
<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|Go}}==
<syntaxhighlight lang="go">package main

import "fmt"

func main() {
    for i := 0; i < 16; i++ {
        for j := 32 + i; j < 128; j += 16 {
            k := string(j)
            switch j {
            case 32:
                k = "Spc"
            case 127:
                k = "Del"
            }
            fmt.Printf("%3d : %-3s   ", j, k)
        }
        fmt.Println()
    }
}</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|Groovy}}==
{{trans|Java}}
<syntaxhighlight lang="groovy">class ShowAsciiTable {
    static void main(String[] args) {
        for (int i = 32; i <= 127; i++) {
            if (i == 32 || i == 127) {
                String s = i == 32 ? "Spc" : "Del"
                printf("%3d: %s ", i, s)
            } else {
                printf("%3d: %c   ", i, i)
            }
            if ((i - 1) % 6 == 0) {
                println()
            }
        }
    }
}</syntaxhighlight>
{{out}}
<pre> 32: Spc  33: !    34: "    35: #    36: $    37: %   
 38: &    39: '    40: (    41: )    42: *    43: +   
 44: ,    45: -    46: .    47: /    48: 0    49: 1   
 50: 2    51: 3    52: 4    53: 5    54: 6    55: 7   
 56: 8    57: 9    58: :    59: ;    60: <    61: =   
 62: >    63: ?    64: @    65: A    66: B    67: C   
 68: D    69: E    70: F    71: G    72: H    73: I   
 74: J    75: K    76: L    77: M    78: N    79: O   
 80: P    81: Q    82: R    83: S    84: T    85: U   
 86: V    87: W    88: X    89: Y    90: Z    91: [   
 92: \    93: ]    94: ^    95: _    96: `    97: a   
 98: b    99: c   100: d   101: e   102: f   103: g   
104: h   105: i   106: j   107: k   108: l   109: m   
110: n   111: o   112: p   113: q   114: r   115: s   
116: t   117: u   118: v   119: w   120: x   121: y   
122: z   123: {   124: |   125: }   126: ~   127: Del </pre>

=={{header|Haskell}}==
<syntaxhighlight lang="haskell">import Data.Char (chr)
import Data.List (transpose)
import Data.List.Split (chunksOf)
import Text.Printf (printf)

----------------------- ASCII TABLE ----------------------

asciiTable :: String
asciiTable =
  unlines $
    (printf "%-12s" =<<)
      <$> transpose
        (chunksOf 16 $ asciiEntry <$> [32 .. 127])

asciiEntry :: Int -> String
asciiEntry n
  | null k = k
  | otherwise = concat [printf "%3d" n, " : ", k]
  where
    k = asciiName n

asciiName :: Int -> String
asciiName n
  | 32 > n = []
  | 127 < n = []
  | 32 == n = "Spc"
  | 127 == n = "Del"
  | otherwise = [chr n]


--------------------------- TEST -------------------------
main :: IO ()
main = putStrLn asciiTable</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|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 (_9{.":,': ',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
    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: 
</pre>

Note that ascii 127 does not have a standard representation, so its appearance will depend on a variety of issues.

=={{header|Java}}==
<syntaxhighlight lang="java">
public class ShowAsciiTable {

    public static void main(String[] args) {
        for ( int i = 32 ; i <= 127 ; i++ ) {
            if ( i == 32 || i == 127 ) {
                String s = i == 32 ? "Spc" : "Del";
                System.out.printf("%3d: %s ", i, s);
            }
            else {
                System.out.printf("%3d: %c   ", i, i);
            }
            if ( (i-1) % 6 == 0 ) {
                System.out.println();
            }
        }
    }

}
</syntaxhighlight>
{{out}}
<pre>
 32: Spc  33: !    34: "    35: #    36: $    37: %   
 38: &    39: '    40: (    41: )    42: *    43: +   
 44: ,    45: -    46: .    47: /    48: 0    49: 1   
 50: 2    51: 3    52: 4    53: 5    54: 6    55: 7   
 56: 8    57: 9    58: :    59: ;    60: <    61: =   
 62: >    63: ?    64: @    65: A    66: B    67: C   
 68: D    69: E    70: F    71: G    72: H    73: I   
 74: J    75: K    76: L    77: M    78: N    79: O   
 80: P    81: Q    82: R    83: S    84: T    85: U   
 86: V    87: W    88: X    89: Y    90: Z    91: [   
 92: \    93: ]    94: ^    95: _    96: `    97: a   
 98: b    99: c   100: d   101: e   102: f   103: g   
104: h   105: i   106: j   107: k   108: l   109: m   
110: n   111: o   112: p   113: q   114: r   115: s   
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>

=={{header|JavaScript}}==
<syntaxhighlight lang="javascript">(() => {

    "use strict";

    // ------------------- ASCII TABLE -------------------

    // asciiTable :: String
    const asciiTable = () =>
        transpose(
            chunksOf(16)(
                enumFromTo(32)(127)
                .map(asciiEntry)
            )
        )
        .map(
            xs => xs.map(justifyLeft(12)(" "))
            .join("")
        )
        .join("\n");

    // asciiEntry :: Int -> String
    const asciiEntry = n => {
        const k = asciiName(n);

        return "" === k ? (
            ""
        ) : `${justifyRight(4)(" ")(n.toString())} : ${k}`;
    };

    // asciiName :: Int -> String
    const asciiName = n =>
        32 > n || 127 < n ? (
            ""
        ) : 32 === n ? (
            "Spc"
        ) : 127 === n ? (
            "Del"
        ) : chr(n);

    // ---------------- GENERIC FUNCTIONS ----------------

    // chr :: Int -> Char
    const chr = x =>
        // The character at unix code-point x.
        String.fromCodePoint(x);


    // chunksOf :: Int -> [a] -> [[a]]
    const chunksOf = n => {
        // xs split into sublists of length n.
        // The last sublist will be short if n
        // does not evenly divide the length of xs .
        const go = xs => {
            const chunk = xs.slice(0, n);

            return 0 < chunk.length ? (
                [chunk].concat(
                    go(xs.slice(n))
                )
            ) : [];
        };

        return go;
    };


    // enumFromTo :: Int -> Int -> [Int]
    const enumFromTo = m =>
        n => Array.from({
            length: 1 + n - m
        }, (_, i) => m + i);


    // justifyLeft :: Int -> Char -> String -> String
    const justifyLeft = n =>
        // The string s, followed by enough padding (with
        // the character c) to reach the string length n.
        c => s => n > s.length ? (
            s.padEnd(n, c)
        ) : s;


    // justifyRight :: Int -> Char -> String -> String
    const justifyRight = n =>
        // The string s, preceded by enough padding (with
        // the character c) to reach the string length n.
        c => s => Boolean(s) ? (
            s.padStart(n, c)
        ) : "";


    // transpose :: [[a]] -> [[a]]
    const transpose = rows =>
        // The columns of the input transposed
        // into new rows.
        // This version assumes input rows of even length.
        0 < rows.length ? rows[0].map(
            (x, i) => rows.flatMap(
                v => v[i]
            )
        ) : [];


    // MAIN ---
    return asciiTable();
})();</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|Jsish}}==
<syntaxhighlight lang="javascript">#!/usr/bin/env jsish

/* Show ASCII table, -showAll true to include control codes */
function showASCIITable(args:array|string=void, conf:object=void) {
    var options = {           // Rosetta Code, Show ASCII table
        rootdir      :'',      // Root directory.
        showAll      : false  // include control code labels if true
    };
    var self = {};
    parseOpts(self, options, conf);

    function main() {
        var e;
        var first = (self.showAll) ? 0 : 2;
        var filler = '='.repeat(19 + ((first) ? 0 : 9));
        puts(filler, "ASCII table", filler + '=');
        var labels = [
            'NUL', 'SOH', 'STX', 'ETX', 'EOT', 'ENQ', 'ACK', 'BEL',
            'BS ', 'HT ', 'LF ', 'VT ', 'FF ', 'CR ', 'SO ', 'SI ',
            'DLE', 'DC1', 'DC2', 'DC3', 'DC4', 'NAK', 'SYN', 'ETB',
            'CAN', 'EM ', 'SUB', 'ESC', 'FS ', 'GS ', 'RS ', 'US '];
        var table = new Array(128);
        for (e = 0; e < 32; e++) table[e] = labels[e];
        for (e = 32; e < 127; e++) table[e] = ' ' + Util.fromCharCode(e) + ' ';
        table[32] = 'SPC';
        table[127] = 'DEL';

        for (var row = 0; row < 16; row++) {
            for (var col = first; col < 8; col++) {
                e = row + col * 16;
                printf('%03d %s  ', e, table[e]);
            }
            printf('\n');
        }
    }
    return main();
}

provide(showASCIITable, 1);

if (isMain()) {
    if (Interp.conf('unitTest')) showASCIITable('', {showAll:true});
    else runModule(showASCIITable);
}


/*
=!EXPECTSTART!=
============================ ASCII table =============================
000 NUL  016 DLE  032 SPC  048  0   064  @   080  P   096  `   112  p
001 SOH  017 DC1  033  !   049  1   065  A   081  Q   097  a   113  q
002 STX  018 DC2  034  "   050  2   066  B   082  R   098  b   114  r
003 ETX  019 DC3  035  #   051  3   067  C   083  S   099  c   115  s
004 EOT  020 DC4  036  $   052  4   068  D   084  T   100  d   116  t
005 ENQ  021 NAK  037  %   053  5   069  E   085  U   101  e   117  u
006 ACK  022 SYN  038  &   054  6   070  F   086  V   102  f   118  v
007 BEL  023 ETB  039  '   055  7   071  G   087  W   103  g   119  w
008 BS   024 CAN  040  (   056  8   072  H   088  X   104  h   120  x
009 HT   025 EM   041  )   057  9   073  I   089  Y   105  i   121  y
010 LF   026 SUB  042  *   058  :   074  J   090  Z   106  j   122  z
011 VT   027 ESC  043  +   059  ;   075  K   091  [   107  k   123  {
012 FF   028 FS   044  ,   060  <   076  L   092  \   108  l   124  |
013 CR   029 GS   045  -   061  =   077  M   093  ]   109  m   125  }
014 SO   030 RS   046  .   062  >   078  N   094  ^   110  n   126  ~
015 SI   031 US   047  /   063  ?   079  O   095  _   111  o   127 DEL
=!EXPECTEND!=
*/</syntaxhighlight>
{{out}}
<pre>prompt$ jsish -u showASCIITable.jsi
[PASS] showASCIITable.jsi

prompt$ ./showASCIITable.jsi
=================== ASCII table ====================
032 SPC  048  0   064  @   080  P   096  `   112  p
033  !   049  1   065  A   081  Q   097  a   113  q
034  "   050  2   066  B   082  R   098  b   114  r
035  #   051  3   067  C   083  S   099  c   115  s
036  $   052  4   068  D   084  T   100  d   116  t
037  %   053  5   069  E   085  U   101  e   117  u
038  &   054  6   070  F   086  V   102  f   118  v
039  '   055  7   071  G   087  W   103  g   119  w
040  (   056  8   072  H   088  X   104  h   120  x
041  )   057  9   073  I   089  Y   105  i   121  y
042  *   058  :   074  J   090  Z   106  j   122  z
043  +   059  ;   075  K   091  [   107  k   123  {
044  ,   060  <   076  L   092  \   108  l   124  |
045  -   061  =   077  M   093  ]   109  m   125  }
046  .   062  >   078  N   094  ^   110  n   126  ~
047  /   063  ?   079  O   095  _   111  o   127 DEL</pre>

=={{header|jq}}==
{{works with|jq}}
'''Works with gojq, the Go implementation of jq'''

The following program generalizes the task to produce a table for wide stretches of Unicode characters, not just 32 .. 127. In addition, the functions for producing both row-wise and column-wise tables are provided and illustrated.
<syntaxhighlight lang="jq">
# Pretty printing
def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

def nwise($n):
  def n: if length <= $n then . else .[0:$n] , (.[$n:] | n) end;
  n;

def table($ncols; $colwidth):
  nwise($ncols) | map(lpad($colwidth)) | join(" ");

# transposed table
def ttable($rows):
  [nwise($rows)] | transpose[] | join(" ");

# Representation of control characters, etc
def humanize:
  def special:
  { "0": "NUL",    "7": "BEL",    "8": "BKS",
    "9": "TAB",   "10": "LF ",   "13": "CR ",
   "27": "ESC",  "127": "DEL",  "155": "CSI" };

  if . < 32 or . == 127 or . == 155
  then (special[tostring] // "^" + ([64+.]|implode))
  elif . > 127 and . < 160 then "\\\(.+72|tostring)"
  else [.] | implode
  end
  | lpad(4) ;
</syntaxhighlight>
===Base Task===
<syntaxhighlight lang="jq"># produce a flat array
def prepare($m;$n):
  [range($m; $n) | "\(lpad(7)): \(humanize)" ];

# Row-wise presentation of 32 through 127 in 6 columns
prepare(32;128) | table(6; 10)

# Column-wise with 16 rows would be produced by:
# prepare(32;128) | ttable(16)
</syntaxhighlight>
{{out}}
<pre>
  32 :       33 :   !   34 :   "   35 :   #   36 :   $   37 :   %
  38 :   &   39 :   '   40 :   (   41 :   )   42 :   *   43 :   +
  44 :   ,   45 :   -   46 :   .   47 :   /   48 :   0   49 :   1
  50 :   2   51 :   3   52 :   4   53 :   5   54 :   6   55 :   7
  56 :   8   57 :   9   58 :   :   59 :   ;   60 :   <   61 :   =
  62 :   >   63 :   ?   64 :   @   65 :   A   66 :   B   67 :   C
  68 :   D   69 :   E   70 :   F   71 :   G   72 :   H   73 :   I
  74 :   J   75 :   K   76 :   L   77 :   M   78 :   N   79 :   O
  80 :   P   81 :   Q   82 :   R   83 :   S   84 :   T   85 :   U
  86 :   V   87 :   W   88 :   X   89 :   Y   90 :   Z   91 :   [
  92 :   \   93 :   ]   94 :   ^   95 :   _   96 :   `   97 :   a
  98 :   b   99 :   c  100 :   d  101 :   e  102 :   f  103 :   g
 104 :   h  105 :   i  106 :   j  107 :   k  108 :   l  109 :   m
 110 :   n  111 :   o  112 :   p  113 :   q  114 :   r  115 :   s
 116 :   t  117 :   u  118 :   v  119 :   w  120 :   x  121 :   y
 122 :   z  123 :   {  124 :   |  125 :   }  126 :   ~  127 : DEL
</pre>

===Column-wise table of 128..255===
<syntaxhighlight lang="jq">
# Column-wise representation with 16 rows
(prepare(128;256) | ttable(16))
</syntaxhighlight>
{{out}}
<pre>
    128: \200     144: \216     160:          176:    °     192:    À     208:    Ð     224:    à     240:    ð
    129: \201     145: \217     161:    ¡     177:    ±     193:    Á     209:    Ñ     225:    á     241:    ñ
    130: \202     146: \218     162:    ¢     178:    ²     194:    Â     210:    Ò     226:    â     242:    ò
    131: \203     147: \219     163:    £     179:    ³     195:    Ã     211:    Ó     227:    ã     243:    ó
    132: \204     148: \220     164:    ¤     180:    ´     196:    Ä     212:    Ô     228:    ä     244:    ô
    133: \205     149: \221     165:    ¥     181:    µ     197:    Å     213:    Õ     229:    å     245:    õ
    134: \206     150: \222     166:    ¦     182:    ¶     198:    Æ     214:    Ö     230:    æ     246:    ö
    135: \207     151: \223     167:    §     183:    ·     199:    Ç     215:    ×     231:    ç     247:    ÷
    136: \208     152: \224     168:    ¨     184:    ¸     200:    È     216:    Ø     232:    è     248:    ø
    137: \209     153: \225     169:    ©     185:    ¹     201:    É     217:    Ù     233:    é     249:    ù
    138: \210     154: \226     170:    ª     186:    º     202:    Ê     218:    Ú     234:    ê     250:    ú
    139: \211     155:  CSI     171:    «     187:    »     203:    Ë     219:    Û     235:    ë     251:    û
    140: \212     156: \228     172:    ¬     188:    ¼     204:    Ì     220:    Ü     236:    ì     252:    ü
    141: \213     157: \229     173:         189:    ½     205:    Í     221:    Ý     237:    í     253:    ý
    142: \214     158: \230     174:    ®     190:    ¾     206:    Î     222:    Þ     238:    î     254:    þ
    143: \215     159: \231     175:    ¯     191:    ¿     207:    Ï     223:    ß     239:    ï     255:    ÿ 
</pre>

=={{header|Julia}}==
===Base Task===
<syntaxhighlight lang="julia">for i in 32:127
    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("  ")
end</syntaxhighlight>{{out}}
<pre>
 32 20 | |   33 21 |!|   34 22 |"|   35 23 |#|   36 24 |$|   37 25 |%|   38 26 |&|   39 27 |'|
 40 28 |(|   41 29 |)|   42 2a |*|   43 2b |+|   44 2c |,|   45 2d |-|   46 2e |.|   47 2f |/|
 48 30 |0|   49 31 |1|   50 32 |2|   51 33 |3|   52 34 |4|   53 35 |5|   54 36 |6|   55 37 |7|
 56 38 |8|   57 39 |9|   58 3a |:|   59 3b |;|   60 3c |<|   61 3d |=|   62 3e |>|   63 3f |?|
 64 40 |@|   65 41 |A|   66 42 |B|   67 43 |C|   68 44 |D|   69 45 |E|   70 46 |F|   71 47 |G|
 72 48 |H|   73 49 |I|   74 4a |J|   75 4b |K|   76 4c |L|   77 4d |M|   78 4e |N|   79 4f |O|
 80 50 |P|   81 51 |Q|   82 52 |R|   83 53 |S|   84 54 |T|   85 55 |U|   86 56 |V|   87 57 |W|
 88 58 |X|   89 59 |Y|   90 5a |Z|   91 5b |[|   92 5c |\|   93 5d |]|   94 5e |^|   95 5f |_|
 96 60 |`|   97 61 |a|   98 62 |b|   99 63 |c|  100 64 |d|  101 65 |e|  102 66 |f|  103 67 |g|
104 68 |h|  105 69 |i|  106 6a |j|  107 6b |k|  108 6c |l|  109 6d |m|  110 6e |n|  111 6f |o|
112 70 |p|  113 71 |q|  114 72 |r|  115 73 |s|  116 74 |t|  117 75 |u|  118 76 |v|  119 77 |w|
120 78 |x|  121 79 |y|  122 7a |z|  123 7b |{|  124 7c |||  125 7d |}|  126 7e |~|  127 7f |�|
</pre>
===Extended Ascii===
The appearance of the table with the extended ASCII characters below depends on the font (code page) used in the terminal and in your browser (DejaVu Sans Mono is a reasonable choice). The output shown is copied from the console ConEmu in Windows 10.
{{works with|Julia|1.0}}

<syntaxhighlight lang="julia">for i in 0:255
    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("  ")
end</syntaxhighlight>
{{out}}
<pre>  0 00 NUL    1 01 |☺|    2 02 |☻|    3 03 |♥|    4 04 |♦|    5 05 |♣|    6 06 |♠|    7 07 BEL
  8 08 BKS    9 09 TAB   10 0a LF    11 0b |♂|   12 0c |♀|   13 0d CR    14 0e |♫|   15 0f |☼|
 16 10 |►|   17 11 |◄|   18 12 |↕|   19 13 |‼|   20 14 |¶|   21 15 |§|   22 16 |■|   23 17 |↨|
 24 18 |↑|   25 19 |↓|   26 1a |→|   27 1b ESC   28 1c |∟|   29 1d |↔|   30 1e |▲|   31 1f |▼|
 32 20 | |   33 21 |!|   34 22 |"|   35 23 |#|   36 24 |$|   37 25 |%|   38 26 |&|   39 27 |'|
 40 28 |(|   41 29 |)|   42 2a |*|   43 2b |+|   44 2c |,|   45 2d |-|   46 2e |.|   47 2f |/|
 48 30 |0|   49 31 |1|   50 32 |2|   51 33 |3|   52 34 |4|   53 35 |5|   54 36 |6|   55 37 |7|
 56 38 |8|   57 39 |9|   58 3a |:|   59 3b |;|   60 3c |<|   61 3d |=|   62 3e |>|   63 3f |?|
 64 40 |@|   65 41 |A|   66 42 |B|   67 43 |C|   68 44 |D|   69 45 |E|   70 46 |F|   71 47 |G|
 72 48 |H|   73 49 |I|   74 4a |J|   75 4b |K|   76 4c |L|   77 4d |M|   78 4e |N|   79 4f |O|
 80 50 |P|   81 51 |Q|   82 52 |R|   83 53 |S|   84 54 |T|   85 55 |U|   86 56 |V|   87 57 |W|
 88 58 |X|   89 59 |Y|   90 5a |Z|   91 5b |[|   92 5c |\|   93 5d |]|   94 5e |^|   95 5f |_|
 96 60 |`|   97 61 |a|   98 62 |b|   99 63 |c|  100 64 |d|  101 65 |e|  102 66 |f|  103 67 |g|
104 68 |h|  105 69 |i|  106 6a |j|  107 6b |k|  108 6c |l|  109 6d |m|  110 6e |n|  111 6f |o|
112 70 |p|  113 71 |q|  114 72 |r|  115 73 |s|  116 74 |t|  117 75 |u|  118 76 |v|  119 77 |w|
120 78 |x|  121 79 |y|  122 7a |z|  123 7b |{|  124 7c |||  125 7d |}|  126 7e |~|  127 7f |�|
128 80 |�|  129 81 |�|  130 82 |�|  131 83 |�|  132 84 |�|  133 85 |�|  134 86 |�|  135 87 |�|
136 88 |�|  137 89 |�|  138 8a |�|  139 8b |�|  140 8c |�|  141 8d |�|  142 8e |�|  143 8f |�|
144 90 |�|  145 91 |�|  146 92 |�|  147 93 |�|  148 94 |�|  149 95 |�|  150 96 |�|  151 97 |�|
152 98 |�|  153 99 |�|  154 9a |�|  155 9b CSI  156 9c |�|  157 9d |�|  158 9e |�|  159 9f |�|
160 a0 | |  161 a1 |¡|  162 a2 |¢|  163 a3 |£|  164 a4 |¤|  165 a5 |¥|  166 a6 |¦|  167 a7 |§|
168 a8 |¨|  169 a9 |©|  170 aa |ª|  171 ab |«|  172 ac |¬|  173 ad | |  174 ae |®|  175 af |¯|
176 b0 |°|  177 b1 |±|  178 b2 |²|  179 b3 |³|  180 b4 |´|  181 b5 |µ|  182 b6 |¶|  183 b7 |·|
184 b8 |¸|  185 b9 |¹|  186 ba |º|  187 bb |»|  188 bc |¼|  189 bd |½|  190 be |¾|  191 bf |¿|
192 c0 |À|  193 c1 |Á|  194 c2 |Â|  195 c3 |Ã|  196 c4 |Ä|  197 c5 |Å|  198 c6 |Æ|  199 c7 |Ç|
200 c8 |È|  201 c9 |É|  202 ca |Ê|  203 cb |Ë|  204 cc |Ì|  205 cd |Í|  206 ce |Î|  207 cf |Ï|
208 d0 |Ð|  209 d1 |Ñ|  210 d2 |Ò|  211 d3 |Ó|  212 d4 |Ô|  213 d5 |Õ|  214 d6 |Ö|  215 d7 |×|
216 d8 |Ø|  217 d9 |Ù|  218 da |Ú|  219 db |Û|  220 dc |Ü|  221 dd |Ý|  222 de |Þ|  223 df |ß|
224 e0 |à|  225 e1 |á|  226 e2 |â|  227 e3 |ã|  228 e4 |ä|  229 e5 |å|  230 e6 |æ|  231 e7 |ç|
232 e8 |è|  233 e9 |é|  234 ea |ê|  235 eb |ë|  236 ec |ì|  237 ed |í|  238 ee |î|  239 ef |ï|
240 f0 |ð|  241 f1 |ñ|  242 f2 |ò|  243 f3 |ó|  244 f4 |ô|  245 f5 |õ|  246 f6 |ö|  247 f7 |÷|
248 f8 |ø|  249 f9 |ù|  250 fa |ú|  251 fb |û|  252 fc |ü|  253 fd |ý|  254 fe |þ|  255 ff |ÿ|</pre>


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

<syntaxhighlight lang="julia">print("\e[2J")          # clear screen
print("""
                    0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
                  ╔═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╗
                  ║nul│soh│stx│etx│eot│enq│ack│bel│ bs│tab│ lf│ vt│ ff│ cr│ so│ si║
                """)    # indent is set by this (least indented) line
for i = 0:14
    a = string(i,base=16)
println(      "$a ║   │   │   │   │   │   │   │   │   │   │   │   │   │   │   │   ║ $a")
println(       "  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢")
println(i==0 ? "  ║dle│dc1│dc2│dc3│dc4│nak│syn│etb│can│ em│eof│esc│ fs│ gs│ rs│ us║"
             : "  ║   │   │   │   │   │   │   │   │   │   │   │   │   │   │   │   ║")
end
println("""
                f ║   │   │   │   │   │   │   │   │   │   │   │   │   │   │   │   ║ f
                  ╚═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╝
                    0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
                """)    # """ string is indented here
for i = 1:255
    r,c = divrem(i,16)
    r,c = 3r+4,4c+5
    i > 31 && print("\e[$(r-1);$(c-1)H$(lpad(i,3))")
    6<i<11 || i==155 || i==173 || print("\e[$r;$(c)H$(Char(i))")
end
print("\e[54;1H")</syntaxhighlight>
{{out}}
<pre>    0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F    
  ╔═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╗  
  ║nul│soh│stx│etx│eot│enq│ack│bel│ bs│tab│ lf│ vt│ ff│ cr│ so│ si║  
0 ║   │ ☺ │ ☻ │ ♥ │ ♦ │ ♣ │ ♠ │   │   │   │   │ ♂ │ ♀ │   │ ♫ │ ☼ ║ 0
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║dle│dc1│dc2│dc3│dc4│nak│syn│etb│can│ em│eof│esc│ fs│ gs│ rs│ us║  
1 ║ ► │ ◄ │ ↕ │ ‼ │ ¶ │ § │ ■ │ ↨ │ ↑ │ ↓ │ → │   │ ∟ │ ↔ │ ▲ │ ▼ ║ 1
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║ 32│ 33│ 34│ 35│ 36│ 37│ 38│ 39│ 40│ 41│ 42│ 43│ 44│ 45│ 46│ 47║  
2 ║   │ ! │ " │ # │ $ │ % │ & │ ' │ ( │ ) │ * │ + │ , │ - │ . │ / ║ 2
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║ 48│ 49│ 50│ 51│ 52│ 53│ 54│ 55│ 56│ 57│ 58│ 59│ 60│ 61│ 62│ 63║  
3 ║ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ : │ ; │ < │ = │ > │ ? ║ 3
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║ 64│ 65│ 66│ 67│ 68│ 69│ 70│ 71│ 72│ 73│ 74│ 75│ 76│ 77│ 78│ 79║  
4 ║ @ │ A │ B │ C │ D │ E │ F │ G │ H │ I │ J │ K │ L │ M │ N │ O ║ 4
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║ 80│ 81│ 82│ 83│ 84│ 85│ 86│ 87│ 88│ 89│ 90│ 91│ 92│ 93│ 94│ 95║  
5 ║ P │ Q │ R │ S │ T │ U │ V │ W │ X │ Y │ Z │ [ │ \ │ ] │ ^ │ _ ║ 5
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║ 96│ 97│ 98│ 99│100│101│102│103│104│105│106│107│108│109│110│111║  
6 ║ ` │ a │ b │ c │ d │ e │ f │ g │ h │ i │ j │ k │ l │ m │ n │ o ║ 6
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║112│113│114│115│116│117│118│119│120│121│122│123│124│125│126│127║  
7 ║ p │ q │ r │ s │ t │ u │ v │ w │ x │ y │ z │ { │ | │ } │ ~ │ � ║ 7
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║128│129│130│131│132│133│134│135│136│137│138│139│140│141│142│143║  
8 ║ � │ � │ � │ � │ � │ � │ � │ � │ � │ � │ � │ � │ � │ � │ � │ � ║ 8
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║144│145│146│147│148│149│150│151│152│153│154│155│156│157│158│159║  
9 ║ � │ � │ � │ � │ � │ � │ � │ � │ � │ � │ � │   │ � │ � │ � │ � ║ 9
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║160│161│162│163│164│165│166│167│168│169│170│171│172│173│174│175║  
a ║   │ ¡ │ ¢ │ £ │ ¤ │ ¥ │ ¦ │ § │ ¨ │ © │ ª │ « │ ¬ │   │ ® │ ¯ ║ a
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║176│177│178│179│180│181│182│183│184│185│186│187│188│189│190│191║  
b ║ ° │ ± │ ² │ ³ │ ´ │ µ │ ¶ │ · │ ¸ │ ¹ │ º │ » │ ¼ │ ½ │ ¾ │ ¿ ║ b
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║192│193│194│195│196│197│198│199│200│201│202│203│204│205│206│207║  
c ║ À │ Á │ Â │ Ã │ Ä │ Å │ Æ │ Ç │ È │ É │ Ê │ Ë │ Ì │ Í │ Î │ Ï ║ c
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║208│209│210│211│212│213│214│215│216│217│218│219│220│221│222│223║  
d ║ Ð │ Ñ │ Ò │ Ó │ Ô │ Õ │ Ö │ × │ Ø │ Ù │ Ú │ Û │ Ü │ Ý │ Þ │ ß ║ d
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║224│225│226│227│228│229│230│231│232│233│234│235│236│237│238│239║  
e ║ à │ á │ â │ ã │ ä │ å │ æ │ ç │ è │ é │ ê │ ë │ ì │ í │ î │ ï ║ e
  ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢  
  ║240│241│242│243│244│245│246│247│248│249│250│251│252│253│254│255║  
f ║ ð │ ñ │ ò │ ó │ ô │ õ │ ö │ ÷ │ ø │ ù │ ú │ û │ ü │ ý │ þ │ ÿ ║ f
  ╚═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╝  
    0   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F</pre>

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.
<syntaxhighlight lang="julia">#= CONSOLE TABLES =============================================================
   rn: nrows, rh: height of rows
   cn: ncols, cw: width of columns
   T[rn,cn,rh] table data strings
   cr: rows in colum headers
   CH[cn,cr] column header strings of max cw length
   hl: lengths of row header strings
   RH[rn,rh] row header strings of max length hl
==============================================================================#

struct Table
  rn::Int; rh::Int; cn::Int; cw::Int; T::Array{String,3}
  cr::Int; CH::Array{String,2} 
  hl::Int; RH::Array{String,2} 
  function Table(rn,rh,cn,cw,cr,hl) # constructor
    new(rn,rh,cn,cw,fill("",(rn,cn,rh)), # arrays initialized with empty strings
        cr,fill("",(cr,cn)), hl,fill("",(rn,rh))) 
  end
end
Base.iterate(T::Table,i=1) = i<=nfields(T) ? (getfield(T,i),i+1) : nothing

cpad(s::String,n::Integer) = (m=length(s))<n ? lpad(rpad(s,(n+m)>>1),n) : first(s,n)

function prt((rn,rh,cn,cw,T, cr,CH, hl,RH)::Table)
  TL,TX,TR,BH  = '╔','╤','╗','═'
  IL,IX,IR,IV,IH='╟','┼','╢','│','─'
  BL,BX,BR,BV  = '╚','╧','╝','║'

  u,v,w,d,t = BH^cw, IH^cw, " "^hl, cn-2, " "^hl
  b = w*(cn==1 ? IL*v*IR : IL*v*(IX*v)^d*IX*v*IR)*'\n' # internal separator
  for r = 1:cr
    for c = 1:cn t*=cpad(CH[r,c],cw+1) end
    t *= "\n$w"
  end

  t *= (cn==1 ? TL*u*TR : TL*u*(TX*u)^d*TX*u*TR)*'\n' # top border
  for r = 1:rn
    for p = 1:rh
      s = cpad(RH[r,p],hl)*BV
      for c = 1:cn-1
        s *= cpad(T[r,c,p],cw) * IV
      end
      t*= s * cpad(T[r,cn,p],cw) * BV *'\n'
    end
    t*=r<rn ? b : cn<2 ? w*BL*u*BR : w*BL*u*(BX*u)^d*BX*u*BR # bottom border
  end
  println("\n$t\n")
end</syntaxhighlight>
Using these is simple, only provide the data, and prt it.
<syntaxhighlight lang="julia">Tbl = Table(16,2,16,3, 2,3)     # construct table
Tbl.CH[1,:] = string.(0:15,base=16) # Column headers
Tbl.RH[:,2] = string.(0:15,base=16) # Row headers
for i = 0:255                   # populate table, exclude special characters
  Tbl.T[i>>4+1,i&15+1,1:2]=["$i",i∈(0,7,8,9,10,13,27,155) ? "" : "$(Char(i))"]
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}}==
{{trans|Go}}
<syntaxhighlight lang="scala">// Version 1.2.60

fun main(args: Array<String>) {
    for (i in 0..15) {
        for (j in 32 + i..127 step 16) {
            val k = when (j) {
                32   -> "Spc"
                127  -> "Del"
                else -> j.toChar().toString()
            }
            System.out.printf("%3d : %-3s   ", j, k)
        }
        println()
    }
}</syntaxhighlight>

{{output}}
<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|Lambdatalk}}==
<syntaxhighlight lang="scheme">
{def format
 {lambda {:i :c} 
  {if {< :i 100} 
   then {span {@ style="color:white;"}.}:i : :c
   else :i : :c}}}
-> format

{S.map
 {lambda {:i} 
  {div}
  {S.map {lambda {:i}
          {if {= :i 32} then {format :i {span {@ style="color:#fff;"}.}}
           else {if {= :i 123} then {format :i left brace}
           else {if {= :i 125} then {format :i right brace}
           else {if {= :i 127} then {format :i del}
           else {format :i {code2char :i}}}}}}}
 {S.serie {+ 32 :i} 127 16}}}
 {S.serie 0 15}} 

 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 : left brace 
 44 : ,  60 : <  76 : L  92 : \ 108 : l 124 : | 
 45 : -  61 : =  77 : M  93 : ] 109 : m 125 : right brace 
 46 : .  62 : >  78 : N  94 : ^ 110 : n 126 : ~ 
 47 : /  63 : ?  79 : O  95 : _ 111 : o 127 : del

</syntaxhighlight>



=={{header|Lang}}==
<syntaxhighlight lang="lang">
$i
repeat($[i], 16) {
	$j $= $i + 32
	
	while($j < 128) {
		if($j == 32) {
			$val = SPC
		}elif($j == 127) {
			$val = DEL
		}else {
			$val = fn.char($j)
		}
		fn.printf(%4d : %-3s, $j, $val)
		
		$j += 16
	}
	
	fn.println()
}
</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|langur}}==
{{trans|Go}}
<syntaxhighlight lang="langur">for .i of 16 {
    for .j = 31 + .i ; .j < 128 ; .j += 16 {
        val .L = switch(.j; 32: "spc"; 127: "del"; cp2s .j)
        write "{{.j:3}} : {{.L:-4}}"
    }
    writeln()
}
</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|Locomotive Basic}}==

<syntaxhighlight lang="locobasic">10 mode 1:defint a-z
20 for x=1 to 6
30 for y=1 to 16
40 n=16*(x-1)+y+31
50 locate 6*(x-1)+1,y
60 print using "###";n;
70 print " ";chr$(n);
80 next
90 next</syntaxhighlight>

{{out}}
<pre> 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 🮕</pre>

=={{header|Lua}}==
{{trans|Go}}
<syntaxhighlight lang="lua">
-- map of character values to desired representation
local chars = setmetatable({[32] = "Spc", [127] = "Del"}, {__index = function(_, k) return string.char(k) end})

-- row iterator
local function iter(s,a) 
  a = (a or s) + 16
  if a <= 127 then return a, chars[a] end 
end

-- print loop
for i = 0, 15 do 
   for j, repr in iter, i+16 do 
      io.write(("%3d : %3s    "):format(j, repr))
   end
   io.write"\n"
end</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|M2000 Interpreter}}==
Addition: Show all Ascii from 0, using 0x2400 to 0x2420 unicode symbols.

<syntaxhighlight lang="m2000 interpreter">
Function ProduceAscii$ {
	Document Ascii$="\"
	DelUnicode$=ChrCode$(0x2421)
	j=0
	Print Ascii$;
	For i=0 to 15
	Print Hex$(i, .5);
	Ascii$=Hex$(i, .5)
	Next
	For i=0 to 32
		If pos>16 then
			Ascii$={
			}+Hex$(j, .5)
			Print : Print Hex$(j, .5);: j++
		End if
		Print Chrcode$(i+0x2400);
		Ascii$=Chrcode$(i+0x2400)
	Next
	For i=33 to 126
		If pos>16 then
			Ascii$={
			}+Hex$(j, .5)
			Print : Print Hex$(j, .5);: j++
		End if
		Print Chr$(i);
		Ascii$=Chr$(i)
	Next
	Print DelUnicode$
	=Ascii$+DelUnicode$+{
	}
}
Clipboard ProduceAscii$()
</syntaxhighlight>
{{out}}
<pre>
\0123456789ABCDEF
0␀␁␂␃␄␅␆␇␈␉␊␋␌␍␎␏
1␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟
2␠!"#$%&'()*+,-./
30123456789:;<=>?
4@ABCDEFGHIJKLMNO
5PQRSTUVWXYZ[\]^_
6`abcdefghijklmno
7pqrstuvwxyz{|}~␡

</pre>

=={{header|MACRO-11}}==
<syntaxhighlight lang="macro11">        .TITLE  ASCTAB
        .MCALL  .PRINT,.EXIT
ASCTAB::MOV     #40,R5
        MOV     #20,R4
1$:     MOV     #NBUF,R1
        MOV     R5,R2
2$:     MOV     #-1,R3
3$:     INC     R3
        SUB     #12,R2
        BCC     3$
        ADD     #72,R2
        MOVB    R2,-(R1)
        MOV     R3,R2
        BNE     2$
        CMP     R1,#NUM
        BEQ     4$
        MOVB    #40,-(R1)
4$:     .PRINT  #NUM
        CMP     #40,R5
        BEQ     5$
        CMP     #177,R5
        BEQ     6$
        MOVB    R5,CHR
        .PRINT  #CHR
        BR      7$
5$:     .PRINT  #SPC
        BR      7$
6$:     .PRINT  #DEL
7$:     ADD     #20,R5
        CMP     R5,#200
        BLT     1$
        SUB     #137,R5
        .PRINT  #NL
        DEC     R4
        BNE     1$
        .EXIT
NUM:    .ASCII  /   /
NBUF:   .ASCII  /: /<200>
CHR:    .ASCII  /.     /<200>
SPC:    .ASCII  /SPC   /<200>
DEL:    .ASCII  /DEL   /<200>
NL:     .ASCIZ  //
        .END    ASCTAB</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|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">StringRiffle[StringJoin@@@Transpose[Partition[ToString[#]<>": "<>Switch[#,32,"Spc  ",127,"Del  ",_,FromCharacterCode[#]<>"    "]&/@Range[32,127],16]],"\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|Miranda}}==
<syntaxhighlight lang="miranda">main :: [sys_message]
main = [Stdout table]

table :: [char]
table = lay [concat [item n | n<-[row, (row+16)..127]] | row<-[32..47]]

item :: num->[char]
item n = num ++ " : " ++ desc
         where num  = reverse (take 3 (reverse (shownum n) ++ repeat ' '))
               desc = "Spc   ", if n = 32
                    = "Del   ", if n = 127
                    = decode n : "     ", otherwise</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|MiniScript}}==
<syntaxhighlight lang="miniscript">// Prints ASCII table
// Note changing the values of startChar and endChar will print
// a flexible table in that range
 
startChar = 32
endChar = 127
characters = []
 
for i in range(startChar, endChar)
    addString = char(i) + "  "
    if i == 32 then addString = "SPC"
    if i == 127 then addString = "DEL"
    characters.push addString
end for
 
for i in characters.indexes
    iNum = i + startChar
    iChar = "     " + str(iNum)
    characters[i] = iChar[-5:] + " : " + characters[i]
end for
 
columns = 6
line = ""
col = 0
for out in characters
    col = col + 1
    line = line + out
    if col == columns then
        print line
        line = ""
        col = 0
    end if
end for
if line then print line // final check for odd incomplete line output</syntaxhighlight>
{{out}}
<pre>
   32 : SPC   33 : !     34 : "     35 : #     36 : $     37 : %
   38 : &     39 : '     40 : (     41 : )     42 : *     43 : +
   44 : ,     45 : -     46 : .     47 : /     48 : 0     49 : 1
   50 : 2     51 : 3     52 : 4     53 : 5     54 : 6     55 : 7
   56 : 8     57 : 9     58 : :     59 : ;     60 : <     61 : =
   62 : >     63 : ?     64 : @     65 : A     66 : B     67 : C
   68 : D     69 : E     70 : F     71 : G     72 : H     73 : I
   74 : J     75 : K     76 : L     77 : M     78 : N     79 : O
   80 : P     81 : Q     82 : R     83 : S     84 : T     85 : U
   86 : V     87 : W     88 : X     89 : Y     90 : Z     91 : [
   92 : \     93 : ]     94 : ^     95 : _     96 : `     97 : a
   98 : b     99 : c    100 : d    101 : e    102 : f    103 : g
  104 : h    105 : i    106 : j    107 : k    108 : l    109 : m
  110 : n    111 : o    112 : p    113 : q    114 : r    115 : s
  116 : t    117 : u    118 : v    119 : w    120 : x    121 : y
  122 : z    123 : {    124 : |    125 : }    126 : ~    127 : DEL
</pre>

=={{header|Modula-2}}==
<syntaxhighlight lang="modula2">MODULE AsciiTable;
FROM InOut IMPORT Write, WriteCard, WriteString, WriteLn;

VAR row, col: CARDINAL;

PROCEDURE WriteItem(n: CARDINAL);
BEGIN
    WriteCard(n, 3);
    WriteString(": ");
    CASE n OF
        32: WriteString("Spc   ")
    |  127: WriteString("Del   ")
    ELSE
        Write(CHR(n));
        WriteString("     ")
    END
END WriteItem;

BEGIN
    FOR row := 32 TO 47 DO
        FOR col := row TO 127 BY 16 DO
            WriteItem(col)
        END;
        WriteLn
    END
END AsciiTable.</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|Nanoquery}}==
{{trans|C}}
<syntaxhighlight lang="nanoquery">k = ""
for i in range(0, 15)
	for j in range(32 + i, 127, 16)
		if j = 32
			k = "Spc"
		else if j = 127
			k = "Del"
		else
			k = chr(j)
		end
		print format("%3d : %-3s   ", j, k)
	end
	println
end</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|Nim}}==
<syntaxhighlight lang="nim">import strformat
 
for i in 0..15:
  for j in countup(32 + i, 127, step = 16):
    let k = case j
            of 32: "Spc"
            of 127: "Del"
            else: $chr(j)
    write(stdout, fmt"{j:3d} : {k:<6s}")
  write(stdout, "\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|Objeck}}==
{{trans|Java}}
<syntaxhighlight lang="objeck">class AsciiTable {
  function : Main(args : String[]) ~ Nil {
    for(i := 32; i <= 127 ; i += 1;) {
      if(i = 32 | i = 127) {
        s := i = 32 ? "Spc" : "Del";
        "{$i}:\t{$s}\t"->Print();
      }
      else {
        c := i->ToChar();
        "{$i}:\t{$c}\t"->Print();
      };
      if((i-1) % 6 = 0 ) {
        "\n"->Print();
      };
    };
  }
}</syntaxhighlight>

{{output}}
<pre>
32:     Spc     33:     !       34:     "       35:     #       36:     $       37:     %
38:     &       39:     '       40:     (       41:     )       42:     *       43:     +
44:     ,       45:     -       46:     .       47:     /       48:     0       49:     1
50:     2       51:     3       52:     4       53:     5       54:     6       55:     7
56:     8       57:     9       58:     :       59:     ;       60:     <       61:     =
62:     >       63:     ?       64:     @       65:     A       66:     B       67:     C
68:     D       69:     E       70:     F       71:     G       72:     H       73:     I
74:     J       75:     K       76:     L       77:     M       78:     N       79:     O
80:     P       81:     Q       82:     R       83:     S       84:     T       85:     U
86:     V       87:     W       88:     X       89:     Y       90:     Z       91:     [
92:     \       93:     ]       94:     ^       95:     _       96:     `       97:     a
98:     b       99:     c       100:    d       101:    e       102:    f       103:    g
104:    h       105:    i       106:    j       107:    k       108:    l       109:    m
110:    n       111:    o       112:    p       113:    q       114:    r       115:    s
116:    t       117:    u       118:    v       119:    w       120:    x       121:    y
122:    z       123:    {       124:    |       125:    }       126:    ~       127:    Del
</pre>

=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let show_char i =
  Printf.printf "%5u: %s" i (match i with 32 -> "SPC" | 127 -> "DEL"
    | _ -> Printf.sprintf " %c " (char_of_int i))

let () =
  for i = 32 to 47 do
    for j = 0 to 5 do show_char (j lsl 4 + i) done |> print_newline
  done</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|OxygenBasic}}==
<syntaxhighlight lang="text">
uses console
int i,j
string c
for i=32 to 127
  select case i
    case 32 : c="spc"
    case 127: c="del"
    case else c=chr i
  end select
  print i ": " c tab
  j++
  if j = 8 'columns
    print cr
    j=0
  endif
next
pause
</syntaxhighlight>

=={{header|Perl}}==
Output in the same style as Raku.
{{trans|Raku}}
<syntaxhighlight lang="perl">use charnames ':full';
binmode STDOUT, ':utf8';

sub glyph {
    my($n) = @_;
    if    ($n < 33) { chr 0x2400 + $n } # display symbol names for invisible glyphs
    elsif ($n==124) { '<nowiki>|</nowiki>' }
    elsif ($n==127) { 'DEL' }
    else            { chr $n }
}

print qq[{|class="wikitable" style="text-align:center;background-color:hsl(39, 90%, 95%)"\n];

for (0..127) {
    print qq[|-\n] unless $_ % 16;;
        printf qq[|%d<br>0x%02X<br><big><big title="%s">%s</big></big>\n], 
                $_, $_, charnames::viacode($_), glyph($_);
    }
}
print qq[|}\n];</syntaxhighlight>

=={{header|Phix}}==
{{libheader|Phix/basics}}
<!--<syntaxhighlight lang="phix">(phixonline)-->
 <span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
 
 <span style="color: #004080;">sequence</span> <span style="color: #000000;">ascii</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{}</span>
 <span style="color: #008080;">for</span> <span style="color: #000000;">ch</span><span style="color: #0000FF;">=</span><span style="color: #000000;">32</span> <span style="color: #008080;">to</span> <span style="color: #000000;">127</span> <span style="color: #008080;">do</span>
     <span style="color: #000000;">ascii</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">append</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ascii</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"%4d (#%02x): %c "</span><span style="color: #0000FF;">,</span><span style="color: #000000;">ch</span><span style="color: #0000FF;">))</span>
 <span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
 <span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">substitute</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">join_by</span><span style="color: #0000FF;">(</span><span style="color: #000000;">ascii</span><span style="color: #0000FF;">,</span><span style="color: #000000;">16</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"\x7F"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"del"</span><span style="color: #0000FF;">))</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>  32 (#20):        48 (#30): 0      64 (#40): @      80 (#50): P      96 (#60): `     112 (#70): p
  33 (#21): !      49 (#31): 1      65 (#41): A      81 (#51): Q      97 (#61): a     113 (#71): q
  34 (#22): "      50 (#32): 2      66 (#42): B      82 (#52): R      98 (#62): b     114 (#72): r
  35 (#23): #      51 (#33): 3      67 (#43): C      83 (#53): S      99 (#63): c     115 (#73): s
  36 (#24): $      52 (#34): 4      68 (#44): D      84 (#54): T     100 (#64): d     116 (#74): t
  37 (#25): %      53 (#35): 5      69 (#45): E      85 (#55): U     101 (#65): e     117 (#75): u
  38 (#26): &      54 (#36): 6      70 (#46): F      86 (#56): V     102 (#66): f     118 (#76): v
  39 (#27): '      55 (#37): 7      71 (#47): G      87 (#57): W     103 (#67): g     119 (#77): w
  40 (#28): (      56 (#38): 8      72 (#48): H      88 (#58): X     104 (#68): h     120 (#78): x
  41 (#29): )      57 (#39): 9      73 (#49): I      89 (#59): Y     105 (#69): i     121 (#79): y
  42 (#2A): *      58 (#3A): :      74 (#4A): J      90 (#5A): Z     106 (#6A): j     122 (#7A): z
  43 (#2B): +      59 (#3B): ;      75 (#4B): K      91 (#5B): [     107 (#6B): k     123 (#7B): {
  44 (#2C): ,      60 (#3C): <      76 (#4C): L      92 (#5C): \     108 (#6C): l     124 (#7C): |
  45 (#2D): -      61 (#3D): =      77 (#4D): M      93 (#5D): ]     109 (#6D): m     125 (#7D): }
  46 (#2E): .      62 (#3E): >      78 (#4E): N      94 (#5E): ^     110 (#6E): n     126 (#7E): ~
  47 (#2F): /      63 (#3F): ?      79 (#4F): O      95 (#5F): _     111 (#6F): o     127 (#7F): del</pre>

=={{header|PHP}}==

<syntaxhighlight lang="php"><?php

echo '+' . str_repeat('----------+', 6), PHP_EOL;
for ($j = 0 ; $j < 16 ; $j++) {
    for ($i = 0 ; $i < 6 ; $i++) {
        $val = 32 + $i * 16 + $j;
        switch ($val) {
            case  32: $chr = 'Spc';      break;
            case 127: $chr = 'Del';      break;
            default:  $chr = chr($val) ; break;
        }
        echo sprintf('| %3d: %3s ', $val, $chr);
    }
    echo '|', PHP_EOL;
}
echo '+' . str_repeat('----------+', 6), PHP_EOL;</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|PL/M}}==
<syntaxhighlight lang="pli">
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;
   /* I/O ROUTINES                                                          */
   PR$CHAR:   PROCEDURE( C ); DECLARE C BYTE;    CALL BDOS( 2, C );  END;
   PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S );  END;
   PR$BYTE: PROCEDURE( N );
      DECLARE N BYTE;
      DECLARE V BYTE;
      V = N MOD 100;
      CALL PR$CHAR( ' ' );
      CALL PR$CHAR( '0' + ( N  / 100 ) );
      CALL PR$CHAR( '0' + ( V  /  10 ) );
      CALL PR$CHAR( '0' + ( V MOD 10 ) );
   END PR$BYTE;
   /* ASCII TABLE                                                           */
   DECLARE ( A, C ) BYTE;
   DO C = 32 TO 32 + 15;
      DO A = C TO C + ( 16 * 5 ) BY 16;
         CALL PR$BYTE( A );
         CALL PR$STRING( .': $' );
         IF      A =  32 THEN CALL PR$STRING( .'SPC$' );
         ELSE IF A = 127 THEN CALL PR$STRING( .'DEL$' );
         ELSE DO;
            CALL PR$CHAR( ' ' );
            CALL PR$CHAR(  A  );
            CALL PR$CHAR( ' ' );
         END;
      END;
      CALL PR$STRING( .( 0DH, 0AH, '$' ) );
   END;
EOF
</syntaxhighlight>
{{out}}
<pre>
 032: SPC 048:  0  064:  @  080:  P  096:  `  112:  p
 033:  !  049:  1  065:  A  081:  Q  097:  a  113:  q
 034:  "  050:  2  066:  B  082:  R  098:  b  114:  r
 035:  #  051:  3  067:  C  083:  S  099:  c  115:  s
 036:  $  052:  4  068:  D  084:  T  100:  d  116:  t
 037:  %  053:  5  069:  E  085:  U  101:  e  117:  u
 038:  &  054:  6  070:  F  086:  V  102:  f  118:  v
 039:  '  055:  7  071:  G  087:  W  103:  g  119:  w
 040:  (  056:  8  072:  H  088:  X  104:  h  120:  x
 041:  )  057:  9  073:  I  089:  Y  105:  i  121:  y
 042:  *  058:  :  074:  J  090:  Z  106:  j  122:  z
 043:  +  059:  ;  075:  K  091:  [  107:  k  123:  {
 044:  ,  060:  <  076:  L  092:  \  108:  l  124:  |
 045:  -  061:  =  077:  M  093:  ]  109:  m  125:  }
 046:  .  062:  >  078:  N  094:  ^  110:  n  126:  ~
 047:  /  063:  ?  079:  O  095:  _  111:  o  127: DEL
</pre>

=={{header|Prolog}}==
<syntaxhighlight lang="prolog">ascii :-
    forall(between(32, 47, N), row(N)).

row(N) :- N > 127, nl, !.
row(N) :-
    code(N),
    ascii(N),  
    Nn is N + 16,
    row(Nn).

code(N) :- N < 100, format('  ~d : ', N).
code(N) :- N >= 100, format(' ~d : ', N).

ascii(32) :- write(' Spc    '), !.
ascii(127) :- write(' Del   '), !.
ascii(A) :- char_code(D,A), format(' ~w      ', D).</syntaxhighlight>
{{out}}
<pre>
?- ascii.
  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
true.

?-
</pre>

=={{header|PureBasic}}==
<syntaxhighlight lang="purebasic">If OpenConsole("Show_Ascii_table: rosettacode.org")
  Define r.i, c.i
  For r=0 To 15
    For c=32+r To 112+r Step 16
      Print(RSet(Str(c),3)+" : ")
      Select c
        Case 32
          Print("Spc")
        Case 127
          Print("Del")
        Default
          Print(LSet(Chr(c),3))
      EndSelect
      Print(Space(3))
    Next
    PrintN("")
  Next
  Input()
EndIf</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 : &quot;      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 : &amp;      54 : 6      70 : F      86 : V     102 : f     118 : v     
 39 : &apos;      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 : &lt;      76 : L      92 : \     108 : l     124 : |     
 45 : -      61 : =      77 : M      93 : ]     109 : m     125 : }     
 46 : .      62 : &gt;      78 : N      94 : ^     110 : n     126 : ~     
 47 : /      63 : ?      79 : O      95 : _     111 : o     127 : Del   </pre>

=={{header|Python}}==
===Imperative===
{{trans|Go}}
<syntaxhighlight lang="python">
for i in range(16):
    for j in range(32+i, 127+1, 16):
        if j == 32:
            k = 'Spc'
        elif j == 127:
            k = 'Del'
        else:
            k = chr(j)
        print("%3d : %-3s" % (j,k), end="")
    print()
</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>

===HTML===
After Raku, but creating an HTML table:
<syntaxhighlight lang="python">from unicodedata import name
from html import escape

def pp(n):
    if n <= 32:
        return chr(0x2400 + n)
    if n == 127:
        return '␡'
    return chr(n)

print('<table border="3px" style="background-color:LightCyan;text-align:center">\n <tr>')
for n in range(128):
    if n %16 == 0 and 1 < n: 
        print(" </tr><tr>")
    print(f'  <td style="center">{n}<br>0x{n:02x}<br><big><b title="{escape(name(pp(n)))}">{escape(pp(n))}</b></big></td>')
print(""" </tr>\n</table>""")</syntaxhighlight>

{{out}}
<table border="3px" style="background-color:LightCyan;text-align:center">
 <tr>
  <td style="center">0<br>0x00<br><big><b title="SYMBOL FOR NULL">␀</b></big></td>
  <td style="center">1<br>0x01<br><big><b title="SYMBOL FOR START OF HEADING">␁</b></big></td>
  <td style="center">2<br>0x02<br><big><b title="SYMBOL FOR START OF TEXT">␂</b></big></td>
  <td style="center">3<br>0x03<br><big><b title="SYMBOL FOR END OF TEXT">␃</b></big></td>
  <td style="center">4<br>0x04<br><big><b title="SYMBOL FOR END OF TRANSMISSION">␄</b></big></td>
  <td style="center">5<br>0x05<br><big><b title="SYMBOL FOR ENQUIRY">␅</b></big></td>
  <td style="center">6<br>0x06<br><big><b title="SYMBOL FOR ACKNOWLEDGE">␆</b></big></td>
  <td style="center">7<br>0x07<br><big><b title="SYMBOL FOR BELL">␇</b></big></td>
  <td style="center">8<br>0x08<br><big><b title="SYMBOL FOR BACKSPACE">␈</b></big></td>
  <td style="center">9<br>0x09<br><big><b title="SYMBOL FOR HORIZONTAL TABULATION">␉</b></big></td>
  <td style="center">10<br>0x0a<br><big><b title="SYMBOL FOR LINE FEED">␊</b></big></td>
  <td style="center">11<br>0x0b<br><big><b title="SYMBOL FOR VERTICAL TABULATION">␋</b></big></td>
  <td style="center">12<br>0x0c<br><big><b title="SYMBOL FOR FORM FEED">␌</b></big></td>
  <td style="center">13<br>0x0d<br><big><b title="SYMBOL FOR CARRIAGE RETURN">␍</b></big></td>
  <td style="center">14<br>0x0e<br><big><b title="SYMBOL FOR SHIFT OUT">␎</b></big></td>
  <td style="center">15<br>0x0f<br><big><b title="SYMBOL FOR SHIFT IN">␏</b></big></td>
 </tr><tr>
  <td style="center">16<br>0x10<br><big><b title="SYMBOL FOR DATA LINK ESCAPE">␐</b></big></td>
  <td style="center">17<br>0x11<br><big><b title="SYMBOL FOR DEVICE CONTROL ONE">␑</b></big></td>
  <td style="center">18<br>0x12<br><big><b title="SYMBOL FOR DEVICE CONTROL TWO">␒</b></big></td>
  <td style="center">19<br>0x13<br><big><b title="SYMBOL FOR DEVICE CONTROL THREE">␓</b></big></td>
  <td style="center">20<br>0x14<br><big><b title="SYMBOL FOR DEVICE CONTROL FOUR">␔</b></big></td>
  <td style="center">21<br>0x15<br><big><b title="SYMBOL FOR NEGATIVE ACKNOWLEDGE">␕</b></big></td>
  <td style="center">22<br>0x16<br><big><b title="SYMBOL FOR SYNCHRONOUS IDLE">␖</b></big></td>
  <td style="center">23<br>0x17<br><big><b title="SYMBOL FOR END OF TRANSMISSION BLOCK">␗</b></big></td>
  <td style="center">24<br>0x18<br><big><b title="SYMBOL FOR CANCEL">␘</b></big></td>
  <td style="center">25<br>0x19<br><big><b title="SYMBOL FOR END OF MEDIUM">␙</b></big></td>
  <td style="center">26<br>0x1a<br><big><b title="SYMBOL FOR SUBSTITUTE">␚</b></big></td>
  <td style="center">27<br>0x1b<br><big><b title="SYMBOL FOR ESCAPE">␛</b></big></td>
  <td style="center">28<br>0x1c<br><big><b title="SYMBOL FOR FILE SEPARATOR">␜</b></big></td>
  <td style="center">29<br>0x1d<br><big><b title="SYMBOL FOR GROUP SEPARATOR">␝</b></big></td>
  <td style="center">30<br>0x1e<br><big><b title="SYMBOL FOR RECORD SEPARATOR">␞</b></big></td>
  <td style="center">31<br>0x1f<br><big><b title="SYMBOL FOR UNIT SEPARATOR">␟</b></big></td>
 </tr><tr>
  <td style="center">32<br>0x20<br><big><b title="SYMBOL FOR SPACE">␠</b></big></td>
  <td style="center">33<br>0x21<br><big><b title="EXCLAMATION MARK">!</b></big></td>
  <td style="center">34<br>0x22<br><big><b title="QUOTATION MARK">&quot;</b></big></td>
  <td style="center">35<br>0x23<br><big><b title="NUMBER SIGN">#</b></big></td>
  <td style="center">36<br>0x24<br><big><b title="DOLLAR SIGN">$</b></big></td>
  <td style="center">37<br>0x25<br><big><b title="PERCENT SIGN">%</b></big></td>
  <td style="center">38<br>0x26<br><big><b title="AMPERSAND">&amp;</b></big></td>
  <td style="center">39<br>0x27<br><big><b title="APOSTROPHE">&#x27;</b></big></td>
  <td style="center">40<br>0x28<br><big><b title="LEFT PARENTHESIS">(</b></big></td>
  <td style="center">41<br>0x29<br><big><b title="RIGHT PARENTHESIS">)</b></big></td>
  <td style="center">42<br>0x2a<br><big><b title="ASTERISK">*</b></big></td>
  <td style="center">43<br>0x2b<br><big><b title="PLUS SIGN">+</b></big></td>
  <td style="center">44<br>0x2c<br><big><b title="COMMA">,</b></big></td>
  <td style="center">45<br>0x2d<br><big><b title="HYPHEN-MINUS">-</b></big></td>
  <td style="center">46<br>0x2e<br><big><b title="FULL STOP">.</b></big></td>
  <td style="center">47<br>0x2f<br><big><b title="SOLIDUS">/</b></big></td>
 </tr><tr>
  <td style="center">48<br>0x30<br><big><b title="DIGIT ZERO">0</b></big></td>
  <td style="center">49<br>0x31<br><big><b title="DIGIT ONE">1</b></big></td>
  <td style="center">50<br>0x32<br><big><b title="DIGIT TWO">2</b></big></td>
  <td style="center">51<br>0x33<br><big><b title="DIGIT THREE">3</b></big></td>
  <td style="center">52<br>0x34<br><big><b title="DIGIT FOUR">4</b></big></td>
  <td style="center">53<br>0x35<br><big><b title="DIGIT FIVE">5</b></big></td>
  <td style="center">54<br>0x36<br><big><b title="DIGIT SIX">6</b></big></td>
  <td style="center">55<br>0x37<br><big><b title="DIGIT SEVEN">7</b></big></td>
  <td style="center">56<br>0x38<br><big><b title="DIGIT EIGHT">8</b></big></td>
  <td style="center">57<br>0x39<br><big><b title="DIGIT NINE">9</b></big></td>
  <td style="center">58<br>0x3a<br><big><b title="COLON">:</b></big></td>
  <td style="center">59<br>0x3b<br><big><b title="SEMICOLON">;</b></big></td>
  <td style="center">60<br>0x3c<br><big><b title="LESS-THAN SIGN">&lt;</b></big></td>
  <td style="center">61<br>0x3d<br><big><b title="EQUALS SIGN">=</b></big></td>
  <td style="center">62<br>0x3e<br><big><b title="GREATER-THAN SIGN">&gt;</b></big></td>
  <td style="center">63<br>0x3f<br><big><b title="QUESTION MARK">?</b></big></td>
 </tr><tr>
  <td style="center">64<br>0x40<br><big><b title="COMMERCIAL AT">@</b></big></td>
  <td style="center">65<br>0x41<br><big><b title="LATIN CAPITAL LETTER A">A</b></big></td>
  <td style="center">66<br>0x42<br><big><b title="LATIN CAPITAL LETTER B">B</b></big></td>
  <td style="center">67<br>0x43<br><big><b title="LATIN CAPITAL LETTER C">C</b></big></td>
  <td style="center">68<br>0x44<br><big><b title="LATIN CAPITAL LETTER D">D</b></big></td>
  <td style="center">69<br>0x45<br><big><b title="LATIN CAPITAL LETTER E">E</b></big></td>
  <td style="center">70<br>0x46<br><big><b title="LATIN CAPITAL LETTER F">F</b></big></td>
  <td style="center">71<br>0x47<br><big><b title="LATIN CAPITAL LETTER G">G</b></big></td>
  <td style="center">72<br>0x48<br><big><b title="LATIN CAPITAL LETTER H">H</b></big></td>
  <td style="center">73<br>0x49<br><big><b title="LATIN CAPITAL LETTER I">I</b></big></td>
  <td style="center">74<br>0x4a<br><big><b title="LATIN CAPITAL LETTER J">J</b></big></td>
  <td style="center">75<br>0x4b<br><big><b title="LATIN CAPITAL LETTER K">K</b></big></td>
  <td style="center">76<br>0x4c<br><big><b title="LATIN CAPITAL LETTER L">L</b></big></td>
  <td style="center">77<br>0x4d<br><big><b title="LATIN CAPITAL LETTER M">M</b></big></td>
  <td style="center">78<br>0x4e<br><big><b title="LATIN CAPITAL LETTER N">N</b></big></td>
  <td style="center">79<br>0x4f<br><big><b title="LATIN CAPITAL LETTER O">O</b></big></td>
 </tr><tr>
  <td style="center">80<br>0x50<br><big><b title="LATIN CAPITAL LETTER P">P</b></big></td>
  <td style="center">81<br>0x51<br><big><b title="LATIN CAPITAL LETTER Q">Q</b></big></td>
  <td style="center">82<br>0x52<br><big><b title="LATIN CAPITAL LETTER R">R</b></big></td>
  <td style="center">83<br>0x53<br><big><b title="LATIN CAPITAL LETTER S">S</b></big></td>
  <td style="center">84<br>0x54<br><big><b title="LATIN CAPITAL LETTER T">T</b></big></td>
  <td style="center">85<br>0x55<br><big><b title="LATIN CAPITAL LETTER U">U</b></big></td>
  <td style="center">86<br>0x56<br><big><b title="LATIN CAPITAL LETTER V">V</b></big></td>
  <td style="center">87<br>0x57<br><big><b title="LATIN CAPITAL LETTER W">W</b></big></td>
  <td style="center">88<br>0x58<br><big><b title="LATIN CAPITAL LETTER X">X</b></big></td>
  <td style="center">89<br>0x59<br><big><b title="LATIN CAPITAL LETTER Y">Y</b></big></td>
  <td style="center">90<br>0x5a<br><big><b title="LATIN CAPITAL LETTER Z">Z</b></big></td>
  <td style="center">91<br>0x5b<br><big><b title="LEFT SQUARE BRACKET">[</b></big></td>
  <td style="center">92<br>0x5c<br><big><b title="REVERSE SOLIDUS">\</b></big></td>
  <td style="center">93<br>0x5d<br><big><b title="RIGHT SQUARE BRACKET">]</b></big></td>
  <td style="center">94<br>0x5e<br><big><b title="CIRCUMFLEX ACCENT">^</b></big></td>
  <td style="center">95<br>0x5f<br><big><b title="LOW LINE">_</b></big></td>
 </tr><tr>
  <td style="center">96<br>0x60<br><big><b title="GRAVE ACCENT">`</b></big></td>
  <td style="center">97<br>0x61<br><big><b title="LATIN SMALL LETTER A">a</b></big></td>
  <td style="center">98<br>0x62<br><big><b title="LATIN SMALL LETTER B">b</b></big></td>
  <td style="center">99<br>0x63<br><big><b title="LATIN SMALL LETTER C">c</b></big></td>
  <td style="center">100<br>0x64<br><big><b title="LATIN SMALL LETTER D">d</b></big></td>
  <td style="center">101<br>0x65<br><big><b title="LATIN SMALL LETTER E">e</b></big></td>
  <td style="center">102<br>0x66<br><big><b title="LATIN SMALL LETTER F">f</b></big></td>
  <td style="center">103<br>0x67<br><big><b title="LATIN SMALL LETTER G">g</b></big></td>
  <td style="center">104<br>0x68<br><big><b title="LATIN SMALL LETTER H">h</b></big></td>
  <td style="center">105<br>0x69<br><big><b title="LATIN SMALL LETTER I">i</b></big></td>
  <td style="center">106<br>0x6a<br><big><b title="LATIN SMALL LETTER J">j</b></big></td>
  <td style="center">107<br>0x6b<br><big><b title="LATIN SMALL LETTER K">k</b></big></td>
  <td style="center">108<br>0x6c<br><big><b title="LATIN SMALL LETTER L">l</b></big></td>
  <td style="center">109<br>0x6d<br><big><b title="LATIN SMALL LETTER M">m</b></big></td>
  <td style="center">110<br>0x6e<br><big><b title="LATIN SMALL LETTER N">n</b></big></td>
  <td style="center">111<br>0x6f<br><big><b title="LATIN SMALL LETTER O">o</b></big></td>
 </tr><tr>
  <td style="center">112<br>0x70<br><big><b title="LATIN SMALL LETTER P">p</b></big></td>
  <td style="center">113<br>0x71<br><big><b title="LATIN SMALL LETTER Q">q</b></big></td>
  <td style="center">114<br>0x72<br><big><b title="LATIN SMALL LETTER R">r</b></big></td>
  <td style="center">115<br>0x73<br><big><b title="LATIN SMALL LETTER S">s</b></big></td>
  <td style="center">116<br>0x74<br><big><b title="LATIN SMALL LETTER T">t</b></big></td>
  <td style="center">117<br>0x75<br><big><b title="LATIN SMALL LETTER U">u</b></big></td>
  <td style="center">118<br>0x76<br><big><b title="LATIN SMALL LETTER V">v</b></big></td>
  <td style="center">119<br>0x77<br><big><b title="LATIN SMALL LETTER W">w</b></big></td>
  <td style="center">120<br>0x78<br><big><b title="LATIN SMALL LETTER X">x</b></big></td>
  <td style="center">121<br>0x79<br><big><b title="LATIN SMALL LETTER Y">y</b></big></td>
  <td style="center">122<br>0x7a<br><big><b title="LATIN SMALL LETTER Z">z</b></big></td>
  <td style="center">123<br>0x7b<br><big><b title="LEFT CURLY BRACKET">{</b></big></td>
  <td style="center">124<br>0x7c<br><big><b title="VERTICAL LINE">|</b></big></td>
  <td style="center">125<br>0x7d<br><big><b title="RIGHT CURLY BRACKET">}</b></big></td>
  <td style="center">126<br>0x7e<br><big><b title="TILDE">~</b></big></td>
  <td style="center">127<br>0x7f<br><big><b title="SYMBOL FOR DELETE">␡</b></big></td>
 </tr>
</table>

===Plain text===

Composed from generic abstractions:
<syntaxhighlight lang="python">'''Plain text ASCII code table'''

from functools import reduce
from itertools import chain


# asciiTable :: String
def asciiTable():
    '''Table of ASCII codes arranged in 16 rows * 6 columns.'''
    return unlines(
        concat(c.ljust(12, ' ') for c in xs) for xs in (
            transpose(chunksOf(16)(
                [asciiEntry(n) for n in enumFromTo(32)(127)]
            ))
        )
    )


# asciiEntry :: Int -> String
def asciiEntry(n):
    '''Number, and name or character, for given point in ASCII code.'''
    k = asciiName(n)
    return k if '' == k else (
        concat([str(n).rjust(3, ' '), ' : ', k])
    )


# asciiName :: Int -> String
def asciiName(n):
    '''Name or character for given ASCII code.'''
    return '' if 32 > n or 127 < n else (
        'Spc' if 32 == n else (
            'Del' if 127 == n else chr(n)
        )
    )


# TEST ----------------------------------------------------
# main :: IO ()
def main():
    '''Test'''
    print(
        asciiTable()
    )


# GENERIC ABSTRACTIONS ------------------------------------

# chunksOf :: Int -> [a] -> [[a]]
def chunksOf(n):
    '''A series of lists of length n,
       subdividing the contents of xs.
       Where the length of xs is not evenly divible
       the final list will be shorter than n.'''
    return lambda xs: reduce(
        lambda a, i: a + [xs[i:n + i]],
        range(0, len(xs), n), []
    ) if 0 < n else []


# concat :: [[a]] -> [a]
# concat :: [String] -> String
def concat(xxs):
    '''The concatenation of all the elements in a list.'''
    xs = list(chain.from_iterable(xxs))
    unit = '' if isinstance(xs, str) else []
    return unit if not xs else (
        ''.join(xs) if isinstance(xs[0], str) else xs
    )


# enumFromTo :: (Int, Int) -> [Int]
def enumFromTo(m):
    '''Integer enumeration from m to n.'''
    return lambda n: list(range(m, 1 + n))


# splitAt :: Int -> [a] -> ([a], [a])
def splitAt(n):
    '''A tuple pairing the prefix of length n
       with the rest of xs.'''
    return lambda xs: (xs[0:n], xs[n:])


# transpose :: Matrix a -> Matrix a
def transpose(m):
    '''The rows and columns of the argument transposed.
       (The matrix containers and rows can be lists or tuples).'''
    if m:
        inner = type(m[0])
        z = zip(*m)
        return (type(m))(
            map(inner, z) if tuple != inner else z
        )
    else:
        return m


# unlines :: [String] -> String
def unlines(xs):
    '''A single newline-delimited string derived
       from a list of strings.'''
    return '\n'.join(xs)


# MAIN ---
if __name__ == '__main__':
    main()</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>

===List Comprehensions===
<syntaxhighlight lang="python">
# One-liner 
# print('\n'.join([''.join(["%3d : %-3s" % (a, 'Spc' if a == 32 else 'Del' if a == 127 else chr(a)) for a in lst]) for lst in [[i+c*16 for c in range(6)] for i in range(32, 47+1)]])

## Detailed version

# List of 16 lists of integers corresponding to
# each row of the table
rows_as_ints = [[i+c*16 for c in range(6)] for i in range(32, 47+1)]

# Function for converting numeric value to string
codepoint2str = lambda codepoint: 'Spc' if codepoint == 32 else 'Del' if codepoint == 127 else chr(codepoint)

rows_as_strings = [["%3d : %-3s" % (a, codepoint2str(a)) for a in row] for row in rows_as_ints]

# Joining columns into rows and printing rows one in a separate line
print('\n'.join([''.join(row) for row in rows_as_strings]))</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|QB64}}==
{{works with|QBasic|1.1}}
{{works with|QuickBasic|4.5}}
<syntaxhighlight lang="qbasic">DIM s AS STRING

FOR i% = 32 TO 47
    FOR j% = i% TO i% + 80 STEP 16
        SELECT CASE j%
            CASE 32
                s$ = "Spc"
            CASE 127
                s$ = "Del"
            CASE ELSE
                s$ = CHR$(j%)
        END SELECT
        PRINT USING "###: \   \"; j%; s$;
    NEXT j%
    PRINT
NEXT i%</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|Quackery}}==
<syntaxhighlight lang="quackery">
  [ dup 32  = iff
      [ drop say 'spc' ] done
    dup 127 = iff
      [ drop say 'del' ] done
    emit sp sp ]                    is echoascii  ( n --> )

  [ dup echo say ': '
    dup echoascii
    84 < 3 + times sp ]             is echoelt    ( n --> )

  [ sp 81 times
      [ dup i^ + echoelt 16 step ]
    drop cr ]                       is echorow    ( n --> )

  [ 16 times [ i^ 32 + echorow ] ]  is echotable  (   --> )

  echotable
</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|R}}==
<syntaxhighlight lang="rsplus">chr <- function(n) { 
  rawToChar(as.raw(n)) 
}

idx <- 32
while (idx < 128) {
  for (i in 0:5) {
	num <- idx + i
	if (num<100) cat(" ")
        cat(num,": ")
	if (num == 32) { cat("Spc "); next } 
        if (num == 127) { cat("Del "); next } 	
	cat(chr(num),"  ")
  }
  idx <- idx + 6
  cat("\n")
}</syntaxhighlight>
{{out}}
<pre> 32 : Spc  33 : !    34 : "    35 : #    36 : $    37 : %   
 38 : &    39 : '    40 : (    41 : )    42 : *    43 : +   
 44 : ,    45 : -    46 : .    47 : /    48 : 0    49 : 1   
 50 : 2    51 : 3    52 : 4    53 : 5    54 : 6    55 : 7   
 56 : 8    57 : 9    58 : :    59 : ;    60 : <    61 : =   
 62 : >    63 : ?    64 : @    65 : A    66 : B    67 : C   
 68 : D    69 : E    70 : F    71 : G    72 : H    73 : I   
 74 : J    75 : K    76 : L    77 : M    78 : N    79 : O   
 80 : P    81 : Q    82 : R    83 : S    84 : T    85 : U   
 86 : V    87 : W    88 : X    89 : Y    90 : Z    91 : [   
 92 : \    93 : ]    94 : ^    95 : _    96 : `    97 : a   
 98 : b    99 : c   100 : d   101 : e   102 : f   103 : g   
104 : h   105 : i   106 : j   107 : k   108 : l   109 : m   
110 : n   111 : o   112 : p   113 : q   114 : r   115 : s   
116 : t   117 : u   118 : v   119 : w   120 : x   121 : y   
122 : z   123 : {   124 : |   125 : }   126 : ~   127 : Del</pre>

=={{header|Racket}}==

<syntaxhighlight lang="racket">#lang racket

(for ([i (in-range 16)])
  (for ([j (in-range 6)])
    (define n (+ 32 (* j 16) i))
    (printf "~a : ~a"
            (~a n #:align 'right #:min-width 3)
            (~a (match n
                  [32 "SPC"]
                  [127 "DEL"]
                  [_ (integer->char n)]) #:min-width 5)))
  (newline))</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 : %br>     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|Raku}}==
(formerly Perl 6)

Alternately, and perhaps more usefully, output as a wiki-table rather than ASCII art. Hover mouse over the glyph to get the name.

<syntaxhighlight lang="raku" line>sub glyph ($_) {
    when * < 33 { (0x2400 + $_).chr } # display symbol names for invisible glyphs
    when 127    { '␡' }
    default     { .chr }
}

say '{|class="wikitable" style="text-align:center;background-color:hsl(39, 90%, 95%)"';

for (^128).rotor(16) -> @row {
    say '|-';
    printf(q[|%d<br>0x%02X<br><big><big title="%s">%s</big></big>] ~ "\n",
      $_, $_, .&glyph.uniname.subst('SYMBOL FOR ', ''),
      .&glyph.subst('|', '<nowiki>|</nowiki>')) for @row;
}

say '|}';</syntaxhighlight>
{{out}}
{|class="wikitable" style="text-align:center;background-color:hsl(39, 90%, 95%)"
|-
|0<br>0x00<br><big><big title="NULL">␀</big></big>
|1<br>0x01<br><big><big title="START OF HEADING">␁</big></big>
|2<br>0x02<br><big><big title="START OF TEXT">␂</big></big>
|3<br>0x03<br><big><big title="END OF TEXT">␃</big></big>
|4<br>0x04<br><big><big title="END OF TRANSMISSION">␄</big></big>
|5<br>0x05<br><big><big title="ENQUIRY">␅</big></big>
|6<br>0x06<br><big><big title="ACKNOWLEDGE">␆</big></big>
|7<br>0x07<br><big><big title="BELL">␇</big></big>
|8<br>0x08<br><big><big title="BACKSPACE">␈</big></big>
|9<br>0x09<br><big><big title="HORIZONTAL TABULATION">␉</big></big>
|10<br>0x0A<br><big><big title="LINE FEED">␊</big></big>
|11<br>0x0B<br><big><big title="VERTICAL TABULATION">␋</big></big>
|12<br>0x0C<br><big><big title="FORM FEED">␌</big></big>
|13<br>0x0D<br><big><big title="CARRIAGE RETURN">␍</big></big>
|14<br>0x0E<br><big><big title="SHIFT OUT">␎</big></big>
|15<br>0x0F<br><big><big title="SHIFT IN">␏</big></big>
|-
|16<br>0x10<br><big><big title="DATA LINK ESCAPE">␐</big></big>
|17<br>0x11<br><big><big title="DEVICE CONTROL ONE">␑</big></big>
|18<br>0x12<br><big><big title="DEVICE CONTROL TWO">␒</big></big>
|19<br>0x13<br><big><big title="DEVICE CONTROL THREE">␓</big></big>
|20<br>0x14<br><big><big title="DEVICE CONTROL FOUR">␔</big></big>
|21<br>0x15<br><big><big title="NEGATIVE ACKNOWLEDGE">␕</big></big>
|22<br>0x16<br><big><big title="SYNCHRONOUS IDLE">␖</big></big>
|23<br>0x17<br><big><big title="END OF TRANSMISSION BLOCK">␗</big></big>
|24<br>0x18<br><big><big title="CANCEL">␘</big></big>
|25<br>0x19<br><big><big title="END OF MEDIUM">␙</big></big>
|26<br>0x1A<br><big><big title="SUBSTITUTE">␚</big></big>
|27<br>0x1B<br><big><big title="ESCAPE">␛</big></big>
|28<br>0x1C<br><big><big title="FILE SEPARATOR">␜</big></big>
|29<br>0x1D<br><big><big title="GROUP SEPARATOR">␝</big></big>
|30<br>0x1E<br><big><big title="RECORD SEPARATOR">␞</big></big>
|31<br>0x1F<br><big><big title="UNIT SEPARATOR">␟</big></big>
|-
|32<br>0x20<br><big><big title="SPACE">␠</big></big>
|33<br>0x21<br><big><big title="EXCLAMATION MARK">!</big></big>
|34<br>0x22<br><big><big title="QUOTATION MARK">"</big></big>
|35<br>0x23<br><big><big title="NUMBER SIGN">#</big></big>
|36<br>0x24<br><big><big title="DOLLAR SIGN">$</big></big>
|37<br>0x25<br><big><big title="PERCENT SIGN">%</big></big>
|38<br>0x26<br><big><big title="AMPERSAND">&</big></big>
|39<br>0x27<br><big><big title="APOSTROPHE">'</big></big>
|40<br>0x28<br><big><big title="LEFT PARENTHESIS">(</big></big>
|41<br>0x29<br><big><big title="RIGHT PARENTHESIS">)</big></big>
|42<br>0x2A<br><big><big title="ASTERISK">*</big></big>
|43<br>0x2B<br><big><big title="PLUS SIGN">+</big></big>
|44<br>0x2C<br><big><big title="COMMA">,</big></big>
|45<br>0x2D<br><big><big title="HYPHEN-MINUS">-</big></big>
|46<br>0x2E<br><big><big title="FULL STOP">.</big></big>
|47<br>0x2F<br><big><big title="SOLIDUS">/</big></big>
|-
|48<br>0x30<br><big><big title="DIGIT ZERO">0</big></big>
|49<br>0x31<br><big><big title="DIGIT ONE">1</big></big>
|50<br>0x32<br><big><big title="DIGIT TWO">2</big></big>
|51<br>0x33<br><big><big title="DIGIT THREE">3</big></big>
|52<br>0x34<br><big><big title="DIGIT FOUR">4</big></big>
|53<br>0x35<br><big><big title="DIGIT FIVE">5</big></big>
|54<br>0x36<br><big><big title="DIGIT SIX">6</big></big>
|55<br>0x37<br><big><big title="DIGIT SEVEN">7</big></big>
|56<br>0x38<br><big><big title="DIGIT EIGHT">8</big></big>
|57<br>0x39<br><big><big title="DIGIT NINE">9</big></big>
|58<br>0x3A<br><big><big title="COLON">:</big></big>
|59<br>0x3B<br><big><big title="SEMICOLON">;</big></big>
|60<br>0x3C<br><big><big title="LESS-THAN SIGN"><</big></big>
|61<br>0x3D<br><big><big title="EQUALS SIGN">=</big></big>
|62<br>0x3E<br><big><big title="GREATER-THAN SIGN">></big></big>
|63<br>0x3F<br><big><big title="QUESTION MARK">?</big></big>
|-
|64<br>0x40<br><big><big title="COMMERCIAL AT">@</big></big>
|65<br>0x41<br><big><big title="LATIN CAPITAL LETTER A">A</big></big>
|66<br>0x42<br><big><big title="LATIN CAPITAL LETTER B">B</big></big>
|67<br>0x43<br><big><big title="LATIN CAPITAL LETTER C">C</big></big>
|68<br>0x44<br><big><big title="LATIN CAPITAL LETTER D">D</big></big>
|69<br>0x45<br><big><big title="LATIN CAPITAL LETTER E">E</big></big>
|70<br>0x46<br><big><big title="LATIN CAPITAL LETTER F">F</big></big>
|71<br>0x47<br><big><big title="LATIN CAPITAL LETTER G">G</big></big>
|72<br>0x48<br><big><big title="LATIN CAPITAL LETTER H">H</big></big>
|73<br>0x49<br><big><big title="LATIN CAPITAL LETTER I">I</big></big>
|74<br>0x4A<br><big><big title="LATIN CAPITAL LETTER J">J</big></big>
|75<br>0x4B<br><big><big title="LATIN CAPITAL LETTER K">K</big></big>
|76<br>0x4C<br><big><big title="LATIN CAPITAL LETTER L">L</big></big>
|77<br>0x4D<br><big><big title="LATIN CAPITAL LETTER M">M</big></big>
|78<br>0x4E<br><big><big title="LATIN CAPITAL LETTER N">N</big></big>
|79<br>0x4F<br><big><big title="LATIN CAPITAL LETTER O">O</big></big>
|-
|80<br>0x50<br><big><big title="LATIN CAPITAL LETTER P">P</big></big>
|81<br>0x51<br><big><big title="LATIN CAPITAL LETTER Q">Q</big></big>
|82<br>0x52<br><big><big title="LATIN CAPITAL LETTER R">R</big></big>
|83<br>0x53<br><big><big title="LATIN CAPITAL LETTER S">S</big></big>
|84<br>0x54<br><big><big title="LATIN CAPITAL LETTER T">T</big></big>
|85<br>0x55<br><big><big title="LATIN CAPITAL LETTER U">U</big></big>
|86<br>0x56<br><big><big title="LATIN CAPITAL LETTER V">V</big></big>
|87<br>0x57<br><big><big title="LATIN CAPITAL LETTER W">W</big></big>
|88<br>0x58<br><big><big title="LATIN CAPITAL LETTER X">X</big></big>
|89<br>0x59<br><big><big title="LATIN CAPITAL LETTER Y">Y</big></big>
|90<br>0x5A<br><big><big title="LATIN CAPITAL LETTER Z">Z</big></big>
|91<br>0x5B<br><big><big title="LEFT SQUARE BRACKET">[</big></big>
|92<br>0x5C<br><big><big title="REVERSE SOLIDUS">\</big></big>
|93<br>0x5D<br><big><big title="RIGHT SQUARE BRACKET">]</big></big>
|94<br>0x5E<br><big><big title="CIRCUMFLEX ACCENT">^</big></big>
|95<br>0x5F<br><big><big title="LOW LINE">_</big></big>
|-
|96<br>0x60<br><big><big title="GRAVE ACCENT">`</big></big>
|97<br>0x61<br><big><big title="LATIN SMALL LETTER A">a</big></big>
|98<br>0x62<br><big><big title="LATIN SMALL LETTER B">b</big></big>
|99<br>0x63<br><big><big title="LATIN SMALL LETTER C">c</big></big>
|100<br>0x64<br><big><big title="LATIN SMALL LETTER D">d</big></big>
|101<br>0x65<br><big><big title="LATIN SMALL LETTER E">e</big></big>
|102<br>0x66<br><big><big title="LATIN SMALL LETTER F">f</big></big>
|103<br>0x67<br><big><big title="LATIN SMALL LETTER G">g</big></big>
|104<br>0x68<br><big><big title="LATIN SMALL LETTER H">h</big></big>
|105<br>0x69<br><big><big title="LATIN SMALL LETTER I">i</big></big>
|106<br>0x6A<br><big><big title="LATIN SMALL LETTER J">j</big></big>
|107<br>0x6B<br><big><big title="LATIN SMALL LETTER K">k</big></big>
|108<br>0x6C<br><big><big title="LATIN SMALL LETTER L">l</big></big>
|109<br>0x6D<br><big><big title="LATIN SMALL LETTER M">m</big></big>
|110<br>0x6E<br><big><big title="LATIN SMALL LETTER N">n</big></big>
|111<br>0x6F<br><big><big title="LATIN SMALL LETTER O">o</big></big>
|-
|112<br>0x70<br><big><big title="LATIN SMALL LETTER P">p</big></big>
|113<br>0x71<br><big><big title="LATIN SMALL LETTER Q">q</big></big>
|114<br>0x72<br><big><big title="LATIN SMALL LETTER R">r</big></big>
|115<br>0x73<br><big><big title="LATIN SMALL LETTER S">s</big></big>
|116<br>0x74<br><big><big title="LATIN SMALL LETTER T">t</big></big>
|117<br>0x75<br><big><big title="LATIN SMALL LETTER U">u</big></big>
|118<br>0x76<br><big><big title="LATIN SMALL LETTER V">v</big></big>
|119<br>0x77<br><big><big title="LATIN SMALL LETTER W">w</big></big>
|120<br>0x78<br><big><big title="LATIN SMALL LETTER X">x</big></big>
|121<br>0x79<br><big><big title="LATIN SMALL LETTER Y">y</big></big>
|122<br>0x7A<br><big><big title="LATIN SMALL LETTER Z">z</big></big>
|123<br>0x7B<br><big><big title="LEFT CURLY BRACKET">{</big></big>
|124<br>0x7C<br><big><big title="VERTICAL LINE"><nowiki>|</nowiki></big></big>
|125<br>0x7D<br><big><big title="RIGHT CURLY BRACKET">}</big></big>
|126<br>0x7E<br><big><big title="TILDE">~</big></big>
|127<br>0x7F<br><big><big title="DELETE">␡</big></big>
|}

=={{header|Red}}==
<syntaxhighlight lang="rebol">Red ["ASCII table"]

repeat i 16 [
    repeat j 6 [
        n: j - 1 * 16 + i + 31
        prin append pad/left n 3 ": "
        prin pad switch/default n [
            32 ["spc"]
            127 ["del"]
        ] [to-char n] 4
    ]
    prin newline
]</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|REXX}}==
Note that some REXX interpreters can't display 
the &nbsp; <big> '1b'x </big> &nbsp; ('''esc''') &nbsp; character glyph properly, &nbsp; so a special check was 
<br>made for those two REXXes to not show that glyph.

A fair amount of code was added to show all possible characters (glyphs), &nbsp; with
special attention paid to:
:::* &nbsp; presenting an index &nbsp; (top and bottom; &nbsp; left and right).
:::* &nbsp; using a grid instead of using blanks for visual fidelity.
:::* &nbsp; using a two─tired type of grid &nbsp; (with single─ &nbsp; and &nbsp; double─lined cells).
:::* &nbsp; preserving indentation and other whitespace.
:::* &nbsp; showing the function of some characters &nbsp; (those that have a &nbsp;''lower'' &nbsp; value than a blank).
:::* &nbsp; showing the name of a blank &nbsp; (as '''bla''').
:::* &nbsp; the suppression of displaying particular glyphs by REXX that are preempted by the OS.
:::* &nbsp; adding homage to the adage of: &nbsp; ''anything worth doing is worth doing well''.
<syntaxhighlight lang="rexx">/*REXX program displays an  ASCII  table of characters  (within a  16x16  indexed grid).*/
parse upper version !ver .                       /*some REXXes can't display '1b'x glyph*/
!pcRexx= 'REXX/PERSONAL'==!ver | "REXX/PC"==!ver /*is this  PC/REXX  or  REXX/Personal? */
          func= '  nul soh stx etx eot enq ack bel  bs tab  lf  vt  ff  cr  so  si  '  ||,
                "  dle dc1 dc2 dc3 dc4 nak syn etb can  em eof esc  fs  gs  rs  us  "
@.=
@.1= "x'07'    x'08'       x'09'     x'0a'      x'0d'      x'1a'      x'1b'     x'20'"
@.2= "bel      b/s         tab       l/f        c/r        eof        esc       bla"
@.3= "bell     backspace   tabchar   linefeed   carriage   end-of-    escape    blank"
@.4= "                                          return     file"
@.5= copies('≈', 79)
            do a=1  for 8;   say @.a             /*display header info  (abbreviations).*/
            end   /*a*/                          /*also included are three blank lines. */
b= ' ';         hdr= left(b, 7)                  /*prepend blanks to HDR  (indentation).*/
call xhdr                                        /*construct a  top  index for the grid.*/
call grid '╔',  "╤",  '╗',  "═══"                /*construct & display bottom of a cell.*/
iidx= left(b, length(hdr) - 4 )                  /*the length of the indentation of idx.*/
cant= copies('═', 3)                             /*can't show a character with this REXX*/
                                                 /* [↓]  construct a sixteen-row grid.  */
   do j=0  by 16  for 16;  idx= left(d2x(j),1,2) /*prepend an index literal for the grid*/
   _= iidx idx b;           _h= iidx "   "       /*an index and indent; without an index*/
   sep= '║'                                      /*assign a character to cell separator.*/
             do #=j  to j+15;               chr= center( d2c(#), 3)   /*true char glyph.*/
             if #>6 & #<11  |  #==13   then chr= cant         /*can't show these glyphs.*/
   /*esc*/   if #==27 then if !pcRexx  then chr= cant         /*  "     "  this  glyph. */
                                       else chr= center( d2c(#), 3)   /*true char glyph.*/
             if # <32 then _h= _h || sep || right(word(func, #+1), 3) /*show a function.*/
             if #==32 then chr= 'bla'            /*spell out (within 3 chars) a "BLAnk".*/
             if # >31 then _h=                   /*Above a blank?  Then nullify 3rd line*/
             _= _ || sep || chr;     sep= '│'    /*append grid cell; use a new sep char.*/
             end   /*#*/
   if _h\==''  then say _h"║ "                   /*append the  last grid cell character.*/
   say _'║ '   idx                               /*append an   index   to the grid line.*/
   if j\==240  then call grid '╟',"┼",'╢',"───"  /*construct & display most cell bottoms*/
   end   /*j*/

call grid '╚',  "╧",  '╝',  "═══"                /*construct & display last cell bottom.*/
call xhdr                                        /*construct a bottom index for the grid*/
exit                                             /*stick a fork in it,  we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
xhdr: say; _= hdr;  sep= b;   do k=0  for 16; _=_||b d2x(k)b;  end;    say _; say;  return
grid: arg $1,$2,$3,$4; _=hdr; do 16;  _=_ || $1 || $4;  $1= $2;  end;  say _ || $3; return</syntaxhighlight>
{{out|output|text=&nbsp; showing a &nbsp; ''horizontal'' &nbsp; formatted grid (table):}}

(Code page &nbsp;'''437'''&nbsp; was used for the example below &nbsp; using DOS under Microsoft Windows.)
<pre>
x'07'    x'08'       x'09'     x'0a'      x'0d'      x'1a'      x'1b'     x'20'
bel      b/s         tab       l/f        c/r        eof        esc       bla
bell     backspace   tabchar   linefeed   carriage   end-of-    escape    blank
                                          return     file
≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈≈



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

       ╔═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╤═══╗
       ║nul│soh│stx│etx│eot│enq│ack│bel│ bs│tab│ lf│ vt│ ff│ cr│ so│ si║
    0  ║   │ ☺ │ ☻ │ ♥ │ ♦ │ ♣ │ ♠ │═══│═══│═══│═══│ ♂ │ ♀ │═══│ ♫ │ ☼ ║  0
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
       ║dle│dc1│dc2│dc3│dc4│nak│syn│etb│can│ em│eof│esc│ fs│ gs│ rs│ us║
    1  ║ ► │ ◄ │ ↕ │ ‼ │ ¶ │ § │ ▬ │ ↨ │ ↑ │ ↓ │ → │ ← │ ∟ │ ↔ │ ▲ │ ▼ ║  1
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    2  ║bla│ ! │ " │ # │ $ │ % │ & │ ' │ ( │ ) │ * │ + │ , │ - │ . │ / ║  2
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    3  ║ 0 │ 1 │ 2 │ 3 │ 4 │ 5 │ 6 │ 7 │ 8 │ 9 │ : │ ; │ < │ = │ > │ ? ║  3
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    4  ║ @ │ A │ B │ C │ D │ E │ F │ G │ H │ I │ J │ K │ L │ M │ N │ O ║  4
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    5  ║ P │ Q │ R │ S │ T │ U │ V │ W │ X │ Y │ Z │ [ │ \ │ ] │ ^ │ _ ║  5
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    6  ║ ` │ a │ b │ c │ d │ e │ f │ g │ h │ i │ j │ k │ l │ m │ n │ o ║  6
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    7  ║ p │ q │ r │ s │ t │ u │ v │ w │ x │ y │ z │ { │ | │ } │ ~ │ ⌂ ║  7
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    8  ║ Ç │ ü │ é │ â │ ä │ à │ å │ ç │ ê │ ë │ è │ ï │ î │ ì │ Ä │ Å ║  8
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    9  ║ É │ æ │ Æ │ ô │ ö │ ò │ û │ ù │ ÿ │ Ö │ Ü │ ¢ │ £ │ ¥ │ ₧ │ ƒ ║  9
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    A  ║ á │ í │ ó │ ú │ ñ │ Ñ │ ª │ º │ ¿ │ ⌐ │ ¬ │ ½ │ ¼ │ ¡ │ « │ » ║  A
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    B  ║ ░ │ ▒ │ ▓ │ │ │ ┤ │ ╡ │ ╢ │ ╖ │ ╕ │ ╣ │ ║ │ ╗ │ ╝ │ ╜ │ ╛ │ ┐ ║  B
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    C  ║ └ │ ┴ │ ┬ │ ├ │ ─ │ ┼ │ ╞ │ ╟ │ ╚ │ ╔ │ ╩ │ ╦ │ ╠ │ ═ │ ╬ │ ╧ ║  C
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    D  ║ ╨ │ ╤ │ ╥ │ ╙ │ ╘ │ ╒ │ ╓ │ ╫ │ ╪ │ ┘ │ ┌ │ █ │ ▄ │ ▌ │ ▐ │ ▀ ║  D
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    E  ║ α │ ß │ Γ │ π │ Σ │ σ │ µ │ τ │ Φ │ Θ │ Ω │ δ │ ∞ │ φ │ ε │ ∩ ║  E
       ╟───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───┼───╢
    F  ║ ≡ │ ± │ ≥ │ ≤ │ ⌠ │ ⌡ │ ÷ │ ≈ │ ° │ ∙ │ · │ √ │ ⁿ │ ² │ ■ │   ║  F
       ╚═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╧═══╝

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

=={{header|Ring}}==
<syntaxhighlight lang="ring">
# Project : Show Ascii table

load "guilib.ring"
load "stdlib.ring"

decarr = newlist(16,6)
ascarr = newlist(16,6)

new qapp 
        {
        win1 = new qwidget() {
                  setwindowtitle("Show Ascii table")
                  setgeometry(100,100,800,600)
                  for n = 1 to 16
                       for m = 1 to 6
                            decarr[n][m] = new qpushbutton(win1) {
                                                  x = 150+m*60
                                                  y = 30 + n*30
                                                  ind = string((m-1)*16+n+31)
                                                  setgeometry(x,y,30,30)
                                                  settext(ind)
                                                  }
                       next
                  next
                  for n = 1 to 16
                       for m = 1 to 6
                            ascarr[n][m] = new qpushbutton(win1) {
                                                  x = 180+m*60
                                                  y = 30 + n*30
                                                  ind = (m-1)*16+n+31
                                                  setgeometry(x,y,30,30)
                                                  if ind = 32
                                                     settext("Spc")
                                                     loop
                                                  ok
                                                  if ind = 127
                                                     settext("Del")
                                                     loop
                                                  ok
                                                  settext(char(ind))
                                                  }
                       next
                  next
                  show()
        }
        exec()
        }</syntaxhighlight>
Output:

[http://kepkezelo.com/images/anuscoqy8ejyr5bnhvnu.jpg Show Ascii table]

=={{header|Ruby}}==
<syntaxhighlight lang="ruby">chars = (32..127).map do |ord|
  k = case ord
    when 32  then "␠"
    when 127 then "␡"
    else ord.chr 
  end
  "#{ord.to_s.ljust(3)}: #{k}"
end
 
chars.each_slice(chars.size/6).to_a.transpose.each{|s| puts s.join("  ")}</syntaxhighlight>
{{out}}
<pre>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: ␡
</pre>

=={{header|Rust}}==
{{trans|Go}}
<syntaxhighlight lang="rust">fn main() {
    for i in 0u8..16 {
        for j in ((32+i)..128).step_by(16) {
            let k = (j as char).to_string();
            print!("{:3} : {:<3}   ", j, match j {
                32 => "Spc",
                127 => "Del",
                _ => &k,
            });
        }
        println!();
    }
}</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|Scala}}==
{{Out}}Best seen in running your browser either by [https://scalafiddle.io/sf/ouiyD9x/0 ScalaFiddle (your local ES aka JavaScript execution, non JVM)] or [https://scastie.scala-lang.org/OD7rBCSMQgKSyKKcGB24cg Scastie (remote JVM)].
{{works with|Scala|2.13}}
<syntaxhighlight lang="scala">object AsciiTable extends App {
  val (strtCharVal, lastCharVal, nColumns) = (' '.toByte, '\u007F'.toByte, 6)
  require(nColumns % 2 == 0, "Number of columns must be even.")

  val nChars = lastCharVal - strtCharVal + 1
  val step = nChars / nColumns
  val threshold = strtCharVal + (nColumns - 1) * step

  def indexGen(start: Byte): LazyList[Byte] =
    start #:: indexGen(
      (if (start >= threshold) strtCharVal + start % threshold + 1 else start + step).toByte
    )

  def k(j: Byte): Char = j match {
    case `strtCharVal` => '\u2420'
    case 0x7F => '\u2421'
    case _ => j.toChar
  }

  indexGen(strtCharVal)
    .take(nChars)
    .sliding(nColumns, nColumns)
    .map(_.map(byte => f"$byte%3d : ${k(byte)}"))
    .foreach(line => println(line.mkString("  ")))
}</syntaxhighlight>

=={{header|Seed7}}==
<syntaxhighlight lang="seed7">$ include "seed7_05.s7i";

const proc: main is func
  local
    var integer: row is 0;
    var integer: column is 0;
    var integer: number is 0;
  begin
    for row range 0 to 15 do
      for column range 0 to 5 do
        number := 32 + 16 * column + row;
        write(number lpad 3 <& " : ");
        case number of
          when {32}:  write("Spc  ");
          when {127}: write("Del  ");
          otherwise:  write(chr(number) <& "    ");
        end case;
      end for;
      writeln;
    end for;
  end func;</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|Spin}}==
{{works with|BST/BSTC}}
{{works with|FastSpin/FlexSpin}}
{{works with|HomeSpun}}
{{works with|OpenSpin}}
<syntaxhighlight lang="spin">con
  _clkmode = xtal1+pll16x
  _clkfreq = 80_000_000

obj
  ser : "FullDuplexSerial"

pub main | i, j

  ser.start(31, 30, 0, 115200)

  repeat i from 0 to 15
    repeat j from i + 32 to 127 step 16
      if j < 100
        ser.tx(32)
      ser.dec(j)
      ser.str(string(": "))
      case j
        32:
          ser.str(string("SPC"))
        127:
          ser.str(string("DEL"))
        other:
          ser.tx(j)
          ser.str(string("  "))
      ser.str(string("  "))
    ser.str(string(13, 10))

  waitcnt(_clkfreq + cnt)
  ser.stop</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|Standard ML}}==
<syntaxhighlight lang="text">fun Table  n 127 =  " 127: 'DEL'\n"
  | Table  0   x =  "\n" ^ (Table 10 x) 
  | Table  n   x =  (StringCvt.padLeft #" " 4 (Int.toString x)) ^ ": '" ^ (str (chr x)) ^ "' " ^ ( Table (n-1) (x+1)) ;

print (Table 10 32) ;</syntaxhighlight>
  32: ' '   33: '!'   34: '"'   35: '#'   36: '$'   37: '%'   38: '&'   39: '&apos;'   40: '('   41: ')' 
  42: '*'   43: '+'   44: ','   45: '-'   46: '.'   47: '/'   48: '0'   49: '1'   50: '2'   51: '3' 
  52: '4'   53: '5'   54: '6'   55: '7'   56: '8'   57: '9'   58: ':'   59: ';'   60: '<'   61: '=' 
  62: '>'   63: '?'   64: '@'   65: 'A'   66: 'B'   67: 'C'   68: 'D'   69: 'E'   70: 'F'   71: 'G' 
  72: 'H'   73: 'I'   74: 'J'   75: 'K'   76: 'L'   77: 'M'   78: 'N'   79: 'O'   80: 'P'   81: 'Q' 
  82: 'R'   83: 'S'   84: 'T'   85: 'U'   86: 'V'   87: 'W'   88: 'X'   89: 'Y'   90: 'Z'   91: '[' 
  92: '\'   93: ']'   94: '^'   95: '_'   96: '`'   97: 'a'   98: 'b'   99: 'c'  100: 'd'  101: 'e' 
 102: 'f'  103: 'g'  104: 'h'  105: 'i'  106: 'j'  107: 'k'  108: 'l'  109: 'm'  110: 'n'  111: 'o' 
 112: 'p'  113: 'q'  114: 'r'  115: 's'  116: 't'  117: 'u'  118: 'v'  119: 'w'  120: 'x'  121: 'y' 
 122: 'z'  123: '{'  124: '|'  125: '}'  126: '~'  127: 'DEL'

=={{header|Tcl}}==
{{trans|AWK}}
<syntaxhighlight lang="tcl">
for {set i 0} {$i < 16} {incr i} {
    for {set j $i} {$j < 128} {incr j 16} {
        if {$j <= 31} {
            continue                    ;# don't show values 0 - 31
        } elseif {$j ==  32} { set x "SP"
        } elseif {$j == 127} { set x "DEL"
        } else { set x [format %c $j] }
        puts -nonewline [format "%3d: %-5s" $j $x]
    }
    puts ""
}
</syntaxhighlight>
{{out}}
<pre>
 32: SP    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|TXR}}==

<syntaxhighlight lang="txrlisp">(let ((spcdel (relate " \x7f" #("Spc" "Del"))))
  (each ((r 32..48))
    (each ((c (take 6 (range r : 16))))
      (put-string (pic "###: <<<" c [spcdel (chr-num c)])))
    (put-line)))</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|VBA}}==
<syntaxhighlight lang="vb">
Public Sub ascii()
    Dim s As String, i As Integer, j As Integer
    For i = 0 To 15
        For j = 32 + i To 127 Step 16
            Select Case j
                Case 32: s = "Spc"
                Case 127: s = "Del"
                Case Else: s = Chr(j)
            End Select
            Debug.Print Tab(10 * (j - 32 - i) / 16); Spc(3 - Len(CStr(j))); j & ": " & s;
        Next j
        Debug.Print vbCrLf
    Next i
End Sub</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|Visual Basic .NET}}==
{{trans|C#}}
<syntaxhighlight lang="vbnet">Imports System.Console
Imports System.Linq.Enumerable

Module Program
    Sub Main()
        Dim Text = Function(index As Integer) If(index = 32, "Sp", If(index = 127, "Del", ChrW(index) & ""))

        Dim start = 32
        Do
            WriteLine(String.Concat(Range(0, 6).Select(Function(i) $"{start + 16 * i, -3} : {Text(start + 16 * i), -6}")))
            start += 1
        Loop While start + 16 * 5 < 128
    End Sub
End Module</syntaxhighlight>
{{out}}
<pre>32  : Sp    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|V (Vlang)}}==
{{trans|go}}
<syntaxhighlight lang="v (vlang)">fn main() {
    for i in 0..16{
        for j := 32 + i; j < 128; j += 16 {
            mut k := u8(j).ascii_str()
            match j {
                32 {
                    k = "Spc"
                }
                127 {
                    k = "Del"
                } else {
                }
            }
            print("${j:3} : ${k:-3}   ")
        }
        println('')
    }
}</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|VTL-2}}==
<syntaxhighlight lang="vtl2">10 C=32
20 L=16
30 #=C>100*50
40 $=32
50 ?=C
60 ?=": ";
70 #=C=32*120
80 #=C=127*140
90 $=C
100 ?="    ";
110 #=150
120 ?="Spc  ";
130 #=150
140 ?="Del  ";
150 C=C+16
160 #=C<128*30
170 C=C-95
180 L=L-1
190 ?=""
200 #=L=0=0*30</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|Wren}}==
{{trans|Go}}
{{libheader|Wren-fmt}}
<syntaxhighlight lang="wren">import "./fmt" for Fmt

for (i in 0...16) {
    var j = 32 + i
    while (j < 128) {
        var k = "%(String.fromByte(j))"
        if (j == 32) {
            k = "Spc"
        } else if (j == 127) {
            k = "Del"
        }
        System.write("%(Fmt.d(3, j)) : %(Fmt.s(-3, k))   ")
        j = j + 16
    }
    System.print()
}</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|XPL0}}==
<syntaxhighlight lang="xpl0">int Hi, Lo;
[SetHexDigits(2);
Text(0, "     ");
for Hi:= 2 to 7 do
        [HexOut(0, Hi*16);  Text(0, "    ")];
CrLf(0);
for Lo:= 0 to $F do
        [HexOut(0, Lo);  Text(0, "   ");
        for Hi:= 2 to 7 do
                [ChOut(0, Hi*16+Lo);  Text(0, "     ")];
        CrLf(0);
        ];
]</syntaxhighlight>

{{out}}
<pre>
     20    30    40    50    60    70    
00         0     @     P     `     p     
01   !     1     A     Q     a     q     
02   "     2     B     R     b     r     
03   #     3     C     S     c     s     
04   $     4     D     T     d     t     
05   %     5     E     U     e     u     
06   &     6     F     V     f     v     
07   '     7     G     W     g     w     
08   (     8     H     X     h     x     
09   )     9     I     Y     i     y     
0A   *     :     J     Z     j     z     
0B   +     ;     K     [     k     {     
0C   ,     <     L     \     l     |     
0D   -     =     M     ]     m     }     
0E   .     >     N     ^     n     ~     
0F   /     ?     O     _     o           
</pre>
=={{header|Z80 Assembly}}==
{{works with|CP/M 3.1|YAZE-AG-2.51.2 Z80 emulator}}
{{works with|ZSM4 macro assembler|YAZE-AG-2.51.2 Z80 emulator}}
Use the /S8 switch on the ZSM4 assembler for 8 significant characters for labels and names
<syntaxhighlight lang="z80">
	;
	; Print ASCII table using Z80 assembly language
	;
	; Runs under CP/M 3.1 on YAZE-AG-2.51.2 Z80 emulator
	; Assembled with zsm4 on same emulator/OS, uses macro capabilities of said assembler
	; Created with vim under Windows
	;
	; Thanks to https://wikiti.brandonw.net for the idea for the conversion routine hl -> decimal ASCII
	;
	; 2023-04-04 Xorph
	;

	;
	; Useful definitions
	;

	bdos	equ 05h		; Call to CP/M BDOS function
	strdel	equ 6eh		; Set string delimiter
	wrtstr	equ 09h		; Write string to console

	numrows	equ 16d		; Number of rows for output
	numcols	equ 6d		; Number of columns for output

	nul	equ 00h		; ASCII control characters
	esc	equ 1bh
	cr	equ 0dh
	lf	equ 0ah

	cnull	equ '0'		; ASCII character constants
	spc	equ 20h
	del	equ 7fh

	;
	; Macros for BDOS calls
	;

setdel 	macro	char		; Set string delimiter to char
	ld	c,strdel
	ld	e,char
	call	bdos
	endm

print 	macro	msg		; Output string to console
	ld	c,wrtstr
	ld	de,msg
	call	bdos
	endm

newline	macro			; Print newline
	ld	c,wrtstr
	ld	de,crlf
	call	bdos
	endm

pushall	macro			; Save all registers to stack
	push	af
	push	bc
	push	de
	push	hl
	push	ix
	push	iy
	endm

popall	macro			; Recall all registers from stack
	pop	iy
	pop	ix
	pop	hl
	pop	de
	pop	bc
	pop	af
	endm

	;
	; =====================
	; Start of main program
	; =====================
	;

	cseg

asciitab:
	setdel	nul		; Set string terminator to nul ('\0') - '$' is default in CP/M

	ld	a,spc		; First ASCII code to print
loop:
	ld	(char),a	; Put ASCII code in output placeholder
	ld	h,0		; Register pair hl is used for printing the number, register h remains 0
	ld	l,a		; Put ASCII code in hl for decimal conversion
	ld	ix,buffer
	call	dispHL		; Create decimal representation

	ld	d,3d		; Pad decimal representation to 3 places with leading blanks
	ld	e,' '		; Registers d and e are modified in macro, so assign each time
	ld	hl,buffer
	ld	bc,format
	call	padstrl

	print	format		; Print the whole thing
	print	colon

chkspc:
	ld	a,(char)	; Load again, register a was lost during BDOS calls
	cp	spc		; Check if Spc
	jr	nz,chkdel	; If not, check if Del
	print	txtspc		; If yes, print the text for Spc
	jr	nextcol		; ...and skip to the next column

chkdel:
	ld	a,(char)	; Load again, register a was lost during BDOS calls
	cp	del		; Check if Del
	jr	nz,printc	; If not, print normal char
	print	txtdel		; If yes, print the text for Del
	jr	nextcol		; ...and skip to the next column

printc:
	print	char		; Normal char

nextcol:
	ld	a,(curcol)	; Increase output column
	inc	a
	cp	numcols		; If last column, go to next row
	jr	z,nextrow
	
	ld	(curcol),a	; Save column counter
	ld	a,(char)	; Increase ASCII code by the number of rows for next column in same row
	add	a,numrows
	jr	loop		; Next code

nextrow:
	newline			; Display next row
	xor	a		; Set column counter back to 0
	ld	(curcol),a
	ld	a,(currow)	; Increase row counter
	inc	a
	cp	numrows		; When last row has been finished, we are done
	jr	z,exitprg

	ld	(currow),a	; Save row counter
	ld	a,(char)	; Set ASCII code back to starting code of next row
	sub	a,numrows * (numcols - 1d) - 1d
	jp	loop		; Use jp instead of jr because of jump distance!

exitprg:
	newline
	ret			; Return to CP/M

	;
	; ===================
	; End of main program
	; ===================
	;

	;
	; Helper routines - notice that the Z80 does not have a divide instruction
	; Notice further that CP/M does not have any support for pretty-printing
	; formatted numbers and stuff like that. So we have to do all this by hand...
	;

	;
	; Converts the value (unsigned int) in register hl to its decimal representation
	; Register ix has memory address of target for converted value
	; String is terminated with nul character (\0)
	;

dispHL:
	pushall
	ld	b,1		; Flag for leading '0'
	irp	x,<-10000,-1000,-100,-10,-1>
	ld	de,x		; Subtract powers of 10 and determine digit
	call	calcdig
	endm

	ld	a,nul		; Terminate result string with nul
	ld	(ix+0),a

	popall
	ret			; End of conversion routine

calcdig:
	ld	a,cnull-1	; Determine the digit character
incrdig:
	inc	a		; Start with '0'
	add	hl,de		; As long as subtraction is possible, increment digit character
	jr	c,incrdig

	sbc	hl,de		; If negative, undo last subtraction and continue with remainder
	cp	cnull		; Check for leading '0', these are ignored
	jr	nz,adddig
	bit	0,b		; Use bit instruction for check if flag set, register a contains digit
	ret	nz		; If '0' found and flag set, it is a leading '0' and we return
adddig:
	ld	b,0		; Reset flag for leading '0', we are now outputting digits
	ld	(ix+0),a	; Store character in memory and set ix to next location
	inc	ix

	ret			; End of conversion helper routine

	;
	; Formats a string to the specified minimum width with the specified filler character
	; Register hl has memory address of nul-terminated string
	; Register bc has memory address of target for padded string
	; Register d has width
	; Register e has filler character/byte
	; Padding is on the left (function is intended for padding integer numbers)
	;

padstrl:
	pushall
	push	hl		; Save address of source for copy later on
	ld	a,d		; Check if width is 0, just copy string if so
	cp	0
	jr	z,copysrc
	ld	a,nul		; Search for end of string. Each non-nul character decrements d

findnul:
	cp	(hl)
	jr	z,nulfound	; Found end of string, d contains number of padding to add
	dec	d
	jr	z,copysrc
	inc	hl
	jr	findnul		; Repeat with next character

nulfound:
	ld	a,e		; Store as many padding characters to target as specified in register d
inspad:
	ld	(bc),a
	inc	bc		; Move to next memory address and decrease d
	dec	d
	jr	nz,inspad

copysrc:
	pop	hl		; Transfer source to target, bc points to first memory address after padding
movechar:
	ld	a,(hl)
	ld	(bc),a
	inc	hl
	inc	bc
	cp	nul		; Check if nul character copied
	jr	nz,movechar	; If no, repeat with next character

	popall
	ret			; End of padding routine

	;
	; ================
	; Data definitions
	; ================
	;

	dseg

crlf:	defb	cr,lf,nul	; Generic newline
buffer:	defs	10		; Buffer for conversion of number to text
format:	defs	10		; Formatted number for output
colon:	defz	' : '		; Separator number/character, nul-terminated
char:	defz	'     '		; Placeholder for ASCII character, nul-terminated
txtspc:	defz	'Spc  '		; Space character 20h
txtdel:	defz	'Del  '		; Del character 7fh
currow:	defb	0d		; Current row
curcol:	defb	0d		; Current column
</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|Zig}}==
{{trans|Java}}
<syntaxhighlight lang="zig">const print = @import("std").debug.print;
pub fn main() void {
  var i: u8 = 33;
  print(" 32: Spc", .{});
  while (i < 127) : (i += 1) {
    print("{:03}: {c}  ", .{ i, i });
    if (@mod(i, 6) == 1) {
      print("\n", .{});
    }
  }
  print("127: Del", .{});
}</syntaxhighlight>

=={{header|zkl}}==
<syntaxhighlight lang="zkl">const width=9;
println("  ",[0..width].pump(String,"%4d".fmt));
[30..127].pump("".println,T(Void.Read,width,False), // don't fail on short lines
    fcn(a,b,c){
       String("%3d: ".fmt(a),
       vm.arglist.pump(String,"toChar", // parameters (ints) to list to text
          T("replace","\x1e",""),T("replace","\x1f",""),  // 30,31
          T("replace"," ","spc"),T("replace","\x7f","del"), "%-4s".fmt)
       )
    })</syntaxhighlight>
{{out}}
<pre>     0   1   2   3   4   5   6   7   8   9
 30:         spc !   "   #   $   %   &   '   
 40: (   )   *   +   ,   -   .   /   0   1   
 50: 2   3   4   5   6   7   8   9   :   ;   
 60: <   =   >   ?   @   A   B   C   D   E   
 70: F   G   H   I   J   K   L   M   N   O   
 80: P   Q   R   S   T   U   V   W   X   Y   
 90: Z   [   \   ]   ^   _   `   a   b   c   
100: d   e   f   g   h   i   j   k   l   m   
110: n   o   p   q   r   s   t   u   v   w   
120: x   y   z   {   |   }   ~   del </pre>

=={{header|ZX Spectrum Basic}}==
Note in particular entries 94, 96 and 127.
<syntaxhighlight lang="zxbasic">10 FOR x=0 TO 9
20 PRINT AT 0,4+2*x;x
30 PRINT AT x+1,0;10*(3+x)
40 NEXT x
50 FOR x=32 TO 127
60 LET d=x-10*INT (x/10)
70 LET t=(x-d)/10
80 PRINT AT t-2,4+2*d;CHR$ x
90 NEXT x</syntaxhighlight>

{{out}}
<pre>
    0   1   2   3   4   5   6   7   8   9
30              !   "   #   $   %   &   '   
40  (   )   *   +   ,   -   .   /   0   1   
50  2   3   4   5   6   7   8   9   :   ;   
60  <   =   >   ?   @   A   B   C   D   E   
70  F   G   H   I   J   K   L   M   N   O   
80  P   Q   R   S   T   U   V   W   X   Y   
90  Z   [   \   ]   ↑   _   £   a   b   c   
100 d   e   f   g   h   i   j   k   l   m   
110 n   o   p   q   r   s   t   u   v   w   
120 x   y   z   {   |   }   ~   © </pre>