Show ASCII table: Difference between revisions

{{trans|Python}}

 

L(j) (32 + i .. 127).step(16)

String k

k = Char(code' j)

print(‘#3 : #<3’.format(j, k), end' ‘’)

 

{{out}}

 

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

; task : show ascii table

; language: 6502 Assembly

column .byte 0

ascii .byte 0

 

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

 

mvi a,32 ; Start with space

mvi d,16 ; 16 lines

spc: db 'Spc ',0 ; Space

del: db 'Del ',0 ; Del

 

{{out}}

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

 

bits 16

putch: equ 2h

spc: db 'Spc ',0 ; Space

del: db 'Del ',0 ; Del

 

{{out}}

=={{header|Action!}}==

Atari 8-bit computers use [https://en.wikipedia.org/wiki/ATASCII ATASCII] character set which is a variation of ASCII.

BYTE

count=[96],rows=[16],

PutE()

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Show_ASCII_table.png Screenshot from Atari 8-bit computer]

 

=={{header|Ada}}==

with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

 

New_Line;

end loop;

{{out}}

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

 

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

# generate an ascii table for characters 32 - 127 #

INT char count := 1;

( char count PLUSAB 1 ) MODAB 6

OD

{{out}}

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

 

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

% generate an ascii table for chars 32 - 127 %

integer cPos;

else writeon( code( i ), " " )

end for_i

{{out}}

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

=={{header|APL}}==

 

 

{{out}}

 

=={{header|AppleScript}}==

on asciiTable()

script row

set my text item delimiters to dlm

str

{{Out}}

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

 

=={{header|Applesoft BASIC}}==

10 LET X = 256 * PEEK (104)

11 LET X = X + PEEK (103) + 7

70 LET N$ = RIGHT$ (N$,4)

80 PRINT N$":" CHR$ (A + R);

The 6502 routine is embedded at line 0 and is used to display the string "!TFOSORCIM" backwards.

EOR #$87 ; I READ

=={{header|ARM Assembly}}==

Thanks to Keith of [https://www.chibiakumas.com ChibiAkumas] for creating the GBA bitmap font and I/O routines.

 

.equ CursorY,0x02000001

ProgramStart:

.byte 0x00,0x00,0x00,0x20,0x52,0x0C,0x00,0x00 ; 7E ~

.byte 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00 ; 7F

 

{{out}}

=={{header|Arturo}}==

 

k: ø

case [num]

prints pad ~"|num|: |k|" 10

if 1 = num%6 -> print ""

 

{{out}}

 

=={{header|AutoHotkey}}==

 

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

}

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

{{out}}

<pre>

{{works with|GAWK}}

{{works with|MAWK}}

# syntax: MAWK -f SHOW_ASCII_TABLE.AWK

BEGIN {

print ""

}

{{out}}

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

 

=={{header|BASIC}}==

20 S(0)="* "

30 S(1)="Spc"

90 NEXT J

100 PRINT

{{out}}

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

 

=={{header|BaCon}}==

FOR i = 32+j TO 127 STEP 16

PRINT i FORMAT " %3d - ";

NEXT

PRINT

 

{{out}}

 

=={{header|BCPL}}==

 

let str(n) =

writef(str(j), j, j)

wrch('*N')

{{out}}

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

=={{header|BQN}}==

The final result is a 2D array of characters which is output line by line with <code>•Out</code>.

J←{𝕨∾' '∾𝕩}´

_pad←{(𝕗×·⌈´≠¨)⊸(↑¨)}

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

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

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

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

=={{header|C}}==

{{trans|Go}}

 

int main() {

}

return 0;

{{out}}

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

 

=={{header|C++}}==

#include <iomanip>

#include <iostream>

std::cout << std::endl;

}

{{out}}

<pre>

 

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

using static System.Linq.Enumerable;

 

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

}

{{out}}

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

 

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

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

for i = 32:1:127 {

}

 

 

{{out}}

 

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

(defn cell [code]

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

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

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

 

{{out}}

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

 

(defn cell [code]

(if (nil? code)

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

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

 

{{out}}

 

=={{header|CLU}}==

if n=32 then return("Spc")

elseif n=127 then return("Del")

stream$putl(po, "")

end

{{out}}

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

{{works with|OpenCOBOL|3.1.2}}

Uses free form syntax.

IDENTIFICATION DIVISION.

PROGRAM-ID. CHARSET.

END-PERFORM.

END PROGRAM CHARSET.

 

{{out}}

 

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

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

120 PRINT "COMMODORE 64 - BASIC V2"

200 PRINT

210 NEXT R

{{out}}

[[File:c64asciitable.jpg]]

 

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

(setq endVal 127)

(setq cols 6)

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

 

{{out}}

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

 

=={{header|Cowgol}}==

 

# Print number with preceding space if <100 and trailing colon

end if;

end loop;

 

{{out}}

=={{header|D}}==

{{trans|C}}

 

void main() {

writeln;

}

{{out}}

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

{{Works with|GNU dc|1.3.95}}

 

## for initcode condcode incrcode body

] lfx

[]pP

{{out}}

<pre>

{{Trans|Go}}

 

program Show_Ascii_table;

 

end.

 

 

{{out}}

 

{{Works with|Office 365 betas 2021}}

=LAMBDA(i,

justifyRight(3)(" ")(i) & ": " & (

)(

SEQUENCE(16, 6, 32, 1)

 

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

 

=LAMBDA(n,

LAMBDA(c,

)

)

 

{{Out}}

Or, separating code and character into adjacent Excel cells:

 

=LAMBDA(i,

IF(0 <> MOD(i, 1),

)(

SEQUENCE(16, 12, 32, 0.5)

 

{{Out}}

===Idiomatic version===

{{Works with|Factor|0.98}}

pair-rocket sequences ;

IN: rosetta-code.ascii-table

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

 

===Go translation===

{{Trans|Go}}

{{Works with|Factor|0.98}}

pair-rocket sequences ;

IN: rosetta-code.ascii-table

;

 

{{out}}

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

=={{header|Forth}}==

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

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

 

 

: ASCII.TABLE ( -- )

 

Test Output at the console

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

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

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

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

 

 

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.

IMPLICIT NONE

INTEGER I, J

 

END

output:

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

=={{header|FreeBASIC}}==

 

if n=32 then return "Spc"

if n=127 then return "Del"

print disp

next r

 

{{out}}

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

 

// (except in ISO-compliant “compiler modes”).

program showAsciiTable(output);

end;

end;

 

{{out}}

 

=={{header|Frink}}==

for i = 33 to 126

a.push["$i " + char[i]]

a.push["127 Delete"]

 

{{out}}

<pre>

 

=={{header|FutureBasic}}==

include "NSLog.incl"

 

 

HandleEvents

{{output}}

<pre>

 

=={{header|Go}}==

 

import "fmt"

fmt.Println()

}

 

{{out}}

=={{header|Groovy}}==

{{trans|Java}}

static void main(String[] args) {

for (int i = 32; i <= 127; i++) {

}

}

{{out}}

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

 

=={{header|Haskell}}==

import Data.List (transpose)

import Data.List.Split (chunksOf)

--------------------------- TEST -------------------------

main :: IO ()

{{Out}}

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

 

=={{header|IS-BASIC}}==

110 FOR R=0 TO 15

120 FOR C=32+R TO 112+R STEP 16

140 NEXT

150 PRINT

 

=={{header|J}}==

 

=={{header|Java}}==

public class ShowAsciiTable {

 

 

}

{{out}}

<pre>

 

=={{header|JavaScript}}==

 

"use strict";

// MAIN ---

return asciiTable();

{{Out}}

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

 

=={{header|Jsish}}==

 

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

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

=!EXPECTEND!=

{{out}}

<pre>prompt$ jsish -u showASCIITable.jsi

 

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.

# Pretty printing

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] + .;

end

| lpad(4) ;

===Base Task===

def prepare($m;$n):

[range($m; $n) | "\(lpad(7)): \(humanize)" ];

# Column-wise with 16 rows would be produced by:

# prepare(32;128) | ttable(16)

{{out}}

<pre>

 

===Column-wise table of 128..255===

# Column-wise representation with 16 rows

(prepare(128;256) | ttable(16))

{{out}}

<pre>

=={{header|Julia}}==

===Base Task===

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

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

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

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

<pre>

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

{{works with|Julia|1.0}}

 

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

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

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

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

{{out}}

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

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

 

print("""

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

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

end

{{out}}

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

 

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

rn: nrows, rh: height of rows

cn: ncols, cw: width of columns

end

println("\n$t\n")

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

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

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

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

end

 

=={{header|Kotlin}}==

{{trans|Go}}

 

fun main(args: Array<String>) {

println()

}

 

{{output}}

{{trans|Go}}

{{works with|langur|0.6.8}}

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

val .L = given(.j; 32: "spc"; 127: "del"; cp2s .j)

}

writeln()

 

{{out}}

=={{header|Locomotive Basic}}==

 

20 for x=1 to 6

30 for y=1 to 16

70 print " ";chr$(n);

80 next

 

{{out}}

=={{header|Lua}}==

{{trans|Go}}

-- map of character values to desired representation

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

end

io.write"\n"

 

{{out}}

 

=={{header|M2000 Interpreter}}==

Function ProduceAscii$ {

Document Ascii$="\"

}

Clipboard ProduceAscii$()

{{out}}

<pre>

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

{{out}}

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

 

=={{header|MiniScript}}==

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

// a flexible table in that range

end if

end for

{{out}}

<pre>

=={{header|Nanoquery}}==

{{trans|C}}

for i in range(0, 15)

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

end

println

 

{{out}}

 

=={{header|Nim}}==

for i in 0..15:

else: $chr(j)

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

 

{{out}}

=={{header|Objeck}}==

{{trans|Java}}

function : Main(args : String[]) ~ Nil {

for(i := 32; i <= 127 ; i += 1;) {

};

}

 

{{output}}

 

=={{header|OxygenBasic}}==

uses console

int i,j

next

pause

 

=={{header|Perl}}==

Output in the same style as Raku.

{{trans|Raku}}

binmode STDOUT, ':utf8';

 

}

}

 

=={{header|Phix}}==

{{libheader|Phix/basics}}

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</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>

{{out}}

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

=={{header|PHP}}==

 

 

echo '+' . str_repeat('----------+', 6), PHP_EOL;

echo '|', PHP_EOL;

}

 

{{out}}

 

=={{header|PL/M}}==

/* CP/M BDOS SYSTEM CALL */

BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END;

IF ( ( C - 31 ) MOD 6 ) = 0 THEN CALL PR$STRING( .( 0DH, 0AH, '$' ) );

END;

{{out}}

<pre>

 

=={{header|Prolog}}==

forall(between(32, 47, N), row(N)).

 

ascii(32) :- write(' Spc '), !.

ascii(127) :- write(' Del '), !.

{{out}}

<pre>

 

=={{header|PureBasic}}==

Define r.i, c.i

For r=0 To 15

Next

Input()

{{out}}

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

===Imperative===

{{trans|Go}}

for i in range(16):

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

print("%3d : %-3s" % (j,k), end="")

print()

{{Out}}

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

===HTML===

After Raku, but creating an HTML table:

from html import escape

 

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>')

 

{{out}}

 

Composed from generic abstractions:

 

from functools import reduce

# MAIN ---

if __name__ == '__main__':

{{Out}}

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

 

===List Comprehensions===

# 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)]])

 

# Joining columns into rows and printing rows one in a separate line

{{Out}}

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

 

=={{header|QB64}}==

 

FOR i% = 32 TO 47

NEXT j%

PRINT

{{out}}

<pre>

 

=={{header|Quackery}}==

[ dup 32 = iff

[ drop say 'spc' ] done

 

echotable

{{out}}

<pre>

 

=={{header|R}}==

rawToChar(as.raw(n))

}

idx <- idx + 6

cat("\n")

{{out}}

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

=={{header|Racket}}==

 

 

(for ([i (in-range 16)])

[127 "DEL"]

[_ (integer->char n)]) #:min-width 5)))

 

{{out}}

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

 

when * < 33 { (0x2400 + $_).chr } # display symbol names for invisible glyphs

when 127 { '␡' }

}

 

{{out}}

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

 

=={{header|Red}}==

 

repeat i 16 [

]

prin newline

{{out}}

<pre>

:::* &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''.

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? */

/*──────────────────────────────────────────────────────────────────────────────────────*/

xhdr: say; _= hdr; sep= b; do k=0 for 16; _=_||b d2x(k)b; end; say _; say; return

{{out|output|text=&nbsp; showing a &nbsp; ''horizontal'' &nbsp; formatted grid (table):}}

 

 

=={{header|Ring}}==

# Project : Show Ascii table

 

}

exec()

Output:

 

 

=={{header|Ruby}}==

k = case ord

when 32 then "␠"

end

{{out}}

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

=={{header|Rust}}==

{{trans|Go}}

for i in 0u8..16 {

for j in ((32+i)..128).step_by(16) {

println!();

}

 

{{out}}

{{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}}

val (strtCharVal, lastCharVal, nColumns) = (' '.toByte, '\u007F'.toByte, 6)

require(nColumns % 2 == 0, "Number of columns must be even.")

.map(_.map(byte => f"$byte%3d : ${k(byte)}"))

.foreach(line => println(line.mkString(" ")))

 

=={{header|Seed7}}==

 

const proc: main is func

writeln;

end for;

 

{{out}}

{{works with|HomeSpun}}

{{works with|OpenSpin}}

_clkmode = xtal1+pll16x

_clkfreq = 80_000_000

 

waitcnt(_clkfreq + cnt)

{{out}}

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

 

=={{header|Standard ML}}==

| Table 0 x = "\n" ^ (Table 10 x)

| Table n x = (StringCvt.padLeft #" " 4 (Int.toString x)) ^ ": '" ^ (str (chr x)) ^ "' " ^ ( Table (n-1) (x+1)) ;

 

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'

=={{header|Tcl}}==

{{trans|AWK}}

for {set i 0} {$i < 16} {incr i} {

for {set j $i} {$j < 128} {incr j 16} {

puts ""

}

{{out}}

<pre>

 

=={{header|VBA}}==

Public Sub ascii()

Dim s As String, i As Integer, j As Integer

Debug.Print vbCrLf

Next i

{{out}}

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

=={{header|Visual Basic .NET}}==

{{trans|C#}}

Imports System.Linq.Enumerable

 

Loop While start + 16 * 5 < 128

End Sub

{{out}}

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

=={{header|Vlang}}==

{{trans|go}}

for i in 0..16{

for j := 32 + i; j < 128; j += 16 {

println('')

}

 

{{out}}

{{trans|Go}}

{{libheader|Wren-fmt}}

 

for (i in 0...16) {

}

System.print()

 

{{out}}

 

=={{header|XPL0}}==

[SetHexDigits(2);

Text(0, " ");

CrLf(0);

];

 

{{out}}

 

=={{header|zkl}}==

println(" ",[0..width].pump(String,"%4d".fmt));

[30..127].pump("".println,T(Void.Read,width,False), // don't fail on short lines

T("replace"," ","spc"),T("replace","\x7f","del"), "%-4s".fmt)

)

{{out}}

<pre> 0 1 2 3 4 5 6 7 8 9

=={{header|ZX Spectrum Basic}}==

Note in particular entries 94, 96 and 127.

20 PRINT AT 0,4+2*x;x

30 PRINT AT x+1,0;10*(3+x)

70 LET t=(x-d)/10

80 PRINT AT t-2,4+2*d;CHR$ x

 

{{out}}