他の課題、Reverse ASCII文字マップを必ず確認してください！

ASCII文字セット（情報交換用のアメリカ標準コード）は、最も広く使用されている文字エンコード標準です。ASCIIコードは、コンピューター、通信機器、およびその他のデバイスのテキストを表します。

チャレンジ

あなたの課題は、ユーザーが入力したASCII文字セットのマッピングを印刷することです。GIF：

ユーザーがすべてのASCII文字を入力すると、出力は次のようになります。

マッピング

各文字には、16x6論理グリッド上の割り当てられた位置があり、左上の位置のスペース文字で始まり、その下に数字0が表示されるように折り返します。

印刷可能なASCII入力を受信したら、現在画面に表示されている文字を削除せずに、割り当てられた画面の場所にそのASCII文字を印刷します。

ルール

• プログラムは、印刷可能なASCII文字をマッピングするだけで0x20、0x7E。
• すべての印刷可能なASCII文字が入力されるまで、プログラムを終了して文字を画面にマップし続けることはできません。ここから、プログラムを終了するか、Neverlandで実行できます。
• プログラムは、スプレッドシート、テーブル、コンソールウィンドウ、グラフィカルウィンドウなど、好きな方法で文字をマッピングできます。
• マッピングの表示方法に関係なく、リアルタイムで（ユーザー入力を受け取ったらすぐに）更新する必要があります。
• プログラムが静かに入力を読み取らない場合は、カーソルを邪魔にならないようにしなければならないので、テキストはマップの邪魔になりません。

助けて

以下は、GIFの生成に使用した擬似コードアルゴリズムです。

loop forever
    c = input
    y_coord = c / 16
    x_coord = c - y * 16
    if c is printable
        print c at (x_coord * 2 + 1, y_coord + 1)
    end if
end loop

必要な出力を達成する別の方法があるかもしれません。私のアルゴリズムを使用するか、独自のアルゴリズムを使用するかを選択できますが、出力は同じである必要があります。

便利なASCIIテーブルリファレンスを次に示します。

得点

各言語のバイト数が最も少ない答えが勝ちです。楽しむ！

QBIC、53 57バイト

間隔に4バイトを追加しました。

{locate 7,1┘_?┘i=asc(A)┘locate i/16-1,(i%16+1)*2┘?chr$(i)

QBIC began development as a shorthand for QBasic, so I thought translating my QBasic answer would demonstrate this nicely. We've saved some 40% in the byte-count for a functionally identical program - and that's even when LOCATE, ASC, and CHR have no QBIC-functions yet. Fortunately, QBIC can pass code directly to QBasic to compensate for this. A side-by-side:

QBIC              QBASIC
------------      ------------
{                 DO
locate 7,1        LOCATE 7,1
                  note that the lower-case alphabet is left unaltered in QBIC.
_?                LINE INPUT A$  (LINE INPUT used instead of INPUT to handle comma's)
i=asc(A)          i=ASC(A$)
locate i/16-1     LOCATE i/16-1
   ,(i%16+1)*2       ,(i MOD 16+1)*2
?chr$(i)          ?CHR$(i)
                  LOOP   (implicitly added to QBIC at EOF)

JavaScript (ES6) + HTML, 114 + 16 = 130 bytes

Saved 16 bytes thanks to @Shaggy

a=Array(96).fill` `;onkeypress=k=>(a[k.key.charCodeAt()-32]=k.key,O.innerText=a.join` `.match(/.{1,32}/g).join`
`)

<pre id=O></pre>

It's so unbelievably satisfying to just mash the keyboard...

QBasic 4.5, 81 85 bytes

Added 4 bytes to comply with the spacing-rule.

DO
LOCATE 7,1
LINE INPUT A$:i=ASC(A$)
LOCATE i\16-1,(i MOD 16+1)*2
?CHR$(i)
LOOP

And the output will look like this (NOTE: Old screenshot, now every character is separated by a space):

QBasic has the LOCATE command, which comes in handy here. A breakdown of this code:

DO                          Starts an infinite loop
LOCATE 7,1                  Moves the cursor out of the way
LINE INPUT A$:i=ASC(A$)     LINE INPUT gets user input; we need LINE INPUT instead of regular input
                            for support of <space> and <comma>. The ASC() function then takes the
                            ASCII value of the first character in the input, so it can deal with
                            inputs like 'Hello' - it will take ASC('H') and assign that to 'i'
LOCATE i\16-1               Here's the cool bit: LOCATE takes a row and a column to put the cursor on.
    ,(i MOD 16+1)*2         Row is determined by dividing the ASC value by 16, minus 1 (SPACE, ASC 32 
                            is placed on row 1), and for columns we take the modulo plus 1 (Again, SPACE 
                            mod 16 = 0, plus 1 = column 1). Multiplied by 2 gives us the spacing. 
                            We move the cursor to 1,2
?CHR$(i)                    PRINT a cast of the ASCII value to CHR at the specified location.
LOOP                        Ad infinitum

Java 8, 143 bytes

o->{for(;;){char c=System.console().readPassword()[0];if(c>31&c<127)System.out.println(String.format("\u001B[%d;%df%c",c/16+1,(c%16+1)*2,c));}}

Uses the ANSI control code CSI n ; m f to set the cursor position and Console.readPassword() to read the user input silently. Output of some characters:

BrainFuck, 355 Bytes

>>++++[->++++[->+>++++++<<]<]>>->[-<[-<<<<++++[->++++++++<]]>>>[<<<<<++++++++[->>++<<<+>]>>-<<<++>>]<<[>>>>>>[>>>]>+<<<<<[<<<]<<-]>>>>>>[>>>]++++[-<++++++++>]>[-<+>]<<[<<<]>>]<[-]<<,[[->+>+<<],[-]++++[->>--------<<]>>[>>>>[>>>]+[<<<]<-]>>>>[>>>]<<[-]<[<<<]<<[>>>>>[>>>]<<+<[<<<]<<-]>>>>>[>>>]<<<[[-]<<<]>[.>.>>]++++++++++[->+>++<<]>>[-<.>]<[-]<<<<[<<<]<,]

BrainFuck's options are pretty limited, so output is in the terminal and the screen is "cleared" with 20 newlines. Input should be the ASCII characters, separated by newlines.

Try it online!

Formatted and Documented

These are the debug notes I used to write the program. I used my interpreter which can optionally print the state of the tape at every '~' character for debugging.

[
    run.bf
    codegolf.stackexchange.com/questions/124306/map-inputted-ascii-characters
]


[
    Calculate 16 * 6
    Resulting tape state:
    [0 0 0 0 0 0 16 96 0 0 0 0 ...]
               ^
    Note that, to obtain a 16-by-6 grid, the 16
    immediately to the right is decreased to 15
    (since we will decrease it by 1 each loop
    until we reach 0 and immediately reset)
]
>>>>++++[->++++[->+>++++++<<]<]>~

[
    Our next goal is to make 96 sets of 3 cells each in the pattern [C D 0]
    The first cell will represent an entered character--when the corresponding
    input on the keyboard is pressed, it will change to the entered key.
    The first cell is initialized to 32 (' ').

    The second cell will represent the delimiter after that character.
    Every 16 cells, this should be 10 for '\n'. Otherwise, it should be 32 for ' '.

    The third cell is a buffer cell, used for traversal of the grid. In general,
    it should be only temporarily modified and then reset to 0.
]

>->[-<
    [
       -<<<<++++[->++++++++<]
       [
           The second cell of our 3-set should be 32, so the above line
           writes 32 to the 3rd cell from the beginning of the tape (0-indexed)
       ]
    ]
    >>>
    [
       <<<[ The second cell of our 3-set should be 10, and we must reset the line counter ] 
       <<++++++++[->>++<<<+>]>>-<<<++>>
    ]

    [ At this point, the delimiting cell we need is two cells to the left. ]
    <<[>>>>>>[>>>]>+<<<<<[<<<]<<-]

    >>>>>>[>>>]++++[-<++++++++>]
    [ Debug Mode: In the previous loop, add a + in the string of 8 +'s to get visible spaces in the grid ($-signs) ]
    >[-<+>]<<[<<<]>>
]

[ Go back to the beginning of the tape and clear up the residual '15' ]
<[-]~

<<,

[
    [->+>+<<],[-]++++[->>--------<<]

    [
        Take input such that the state of the tape now looks like this:
        [0 0 0 0 0 c c-32 0 32 32 0 32 32 0 32 32 0 ...]
                 ^
        Where 'c' was the entered character.
        We now set up 1's in the buffer zones of the first c-32
        3-sets and clear the character that is currently there.
        All that is left, then, is to copy c to that location.
    ]

    [ Set up the row of 1's. ]
    >>[>>>>[>>>]+[<<<]<-]

    [ Clear the current character. ]
    >>>>[>>>]<<[-]~<[<<<]

    [ Copy the new character. ]
    <<[>>>>>[>>>]<<+<[<<<]<<-]

    [ Clean up the 1's. ]
    >>>>>[>>>]~<<<[[-]<<<]

    [ Print the grid. ]
    >[.>.>>]~

    [ Print a bunch of newlines ]
    ++++++++++[->+>++<<]>>[-<.>]<[-]

    [ Take a new input. ]
    <<<<[<<<]<,
]

Mathematica, 108 bytes

a=" "~Table~16~Table~6;Dynamic@Grid@a
((a[[⌊#/16⌋-1,#~Mod~16+1]]=i)&@ToCharacterCode[i=Input[]];#0[])&[]

Try it online at https://sandbox.open.wolframcloud.com/

When you paste code and press Shift+Enter, a dialog box will pop up, you enter "a" for example for character a. The program runs forever.

Note: On Wolfram sandbox, the font is formatted differently from that in Mathematica in my computer. So the line/column spacing may looks weird.

Python 2, 115 bytes

s='\n'.join([' '*31]*6)
while 1:
 c=input();i=ord(c)
 if 31<i<128:i-=32;i=i%16*2+i//16*32;s=s[:i]+c+s[i+1:];print s

Try it online!

Requires quotation marks (single or double) around the inputted characters (the TIO version does not).

str, noncompeting, 18 bytes

Presenting my new semi-esoteric language.

#C;dby16#/~2-~u#pq

#C;dby16#/~2-~u#pq
..;                   preamble
#C                    clear screen
   ...............    main program; each character is pushed to the stack before
   d                  duplicate
    b                 buffer the character
     y                convert to character code
      16#/            divmod by 16 (a / b, a % 6)
          ~2-~        subtract a / b by 2
              u       unbuffer the character
               #p     place that character in the given position
                 q    "quiet"; disable auto-printing

Haskell, 133 bytes

p=putStr.("\27["++)
g l=do c<-getChar;p"2J";mapM h(c:l);g(c:l)
h c|(y,x)<-divMod(fromEnum c)16=p$show y++';':show(2*x+1)++'H':[c]
g[]

Requires a terminal that understands ANSI escape sequences.

It's shorter to keep a list of all keys pressed so far and clearing the screen before printing all of them each round than turning off the echo in the terminal session. The latter needs import System.IO and hSetEcho stdin(2<1) which costs too many bytes.

C, 101 bytes

c,y,x;f(){while(~(c=getchar()))printf("\e[1;20H"),y=c/16,x=c-y*16,printf("\e[%d;%dH%c",y+1,x*2+1,c);}

This was the program I used to make the graphics. Output is as shown in the GIF. ;)

QBasic, 62 58 bytes

a=ASC(INPUT$(1))
LOCATE a\16-1,1+2*(a MOD 16)
?CHR$(a)
RUN

Tested with QB64. Should work fine on regular QBasic, too, although you may want to modify it to do a CLS on the first run.

Similar to steenbergh's answer, but uses INPUT$(1) to read characters one at a time. This approach is shorter and also displays no prompt. It also uses RUN for the infinite loop, since we don't have to store any state between iterations except the state of the screen.

Pascal, 112 chars

Uses crt;var c:char;Begin ClrScr;repeat c:=ReadKey;GotoXY(ord(c)and$F*2+1,ord(c)shr 4-1);write(c);until 1<0;End.

As my Mathematica solution takes many bytes in div, mod and ToCharacterCode[Input[]], I try making another answer with Pascal. But without ClrScr my compiler (FPC) left some compile information on the screen. ClrScr; takes 7 bytes.

The *2 used for proper spacing takes another 2 bytes.

LOGO, 90 bytes

cs
rt 90
keyboardon[invoke[setxy 30*modulo ? 16 -30*int ?/16 label char ?]keyboardvalue]pu

Try it on FMSLogo.

After all, my Logo solution is the shortest, compared with my Mathematica and Pascal answer.

Add 3 bytes if the turtle is required to be hidden.

6502 machine code + Apple //e ROM, 31 bytes

Hex dump:

8000- 20 58 FC 20 0C FD 48 38
8008- E9 A0 48 29 0F 0A 85 24
8010- 68 4A 4A 4A 4A 20 5B FB
8018- 68 20 ED FD 4C 03 80

Commented assembly:

 1 HTAB     =     $24        ; HORIZONTAL POSITION OF CURSOR
 2 SETVTAB  =     $FB5B      ; SETS VERTICAL POSITION OF CURSOR FROM ACC
 3 COUT     =     $FDED      ; OUTPUTS CHARACTER IN ACC
 4 HOME     =     $FC58      ; CLEARS SCREEN
 5 RDKEY    =     $FD0C      ; GETS CHARACTER FROM KEYBOARD, STORES IN ACC
 6          ORG   $8000
 7          JSR   HOME
 8 GETINP   JSR   RDKEY
 9 * POSITION CURSOR
10          PHA              ; PRESERVE ACC
11          SEC              ; MAKE SURE CARRY IS SET TO SUBTRACT
12          SBC   #" "       ; SUBTRACT CHAR CODE OF SPACE
13          PHA              ; SAVE ACC
14          AND   #$0F       ; GET LOWER 4 BITS TO GET CURSOR X POSITION
15          ASL              ; SHIFT LEFT TO MAKE SPACES BETWEEN CHARS
16          STA   HTAB
17          PLA              ; GET OLD ACC
18          LSR              ; SHIFT HIGH NIBBLE
19          LSR              ; INTO LOW NIBBLE
20          LSR              ; TO GET CURSOR Y POSITION
21          LSR
22          JSR   SETVTAB
23          PLA              ; RESTORE ACC
24 *
25          JSR   COUT
26          JMP   GETINP

If the cursor invalidates it, here's a 36-byte version without a cursor:

8000- 20 58 FC AD 00 C0 10 FB
8008- 8D 10 C0 48 38 E9 A0 48
8010- 29 0F 0A 85 24 68 4A 4A
8018- 4A 4A 20 5B FB 68 20 ED
8020- FD 4C 03 80

Ruby, 79 75 71 + 13 = 84 bytes

+13 bytes for -rio/console flag.

loop{$/+=STDIN.getch
97.times{|n|print$/[(n+31).chr]||" ",["
"][n%16]}}

Ungolfed

loop {
  $/ += STDIN.getch
  97.times {|n|
    print $/[(n+31).chr] || " ", ["
"][n%16]
  }
}

SmileBASIC 3, 82 bytes

CLS
@L
C$=INKEY$()IF""!=C$THEN V=ASC(C$)-32LOCATE V MOD 16*2,V DIV 16*2?C$;
GOTO@L

In the SmileBASIC character set, ¥ is located where \ normally would be; hopefully this doesn't invalidate this answer completely.

Applesoft BASIC, 134 bytes

0TEXT:HOME:PR#0
1C=PEEK(49152):POKE49168,0:HTAB1:VTAB20:NORMAL:IFC>=128THENC=C-128:INVERSE
4Y=INT(C/16):X=C-Y*16:HTABX*2+1:VTABY+1:IFC>=32THEN PRINTCHR$(C):IFC<32THEN PRINTCHR$(127)
9GOTO1

This is a golfed version of the Apple ][ keyboard test, the program that inspired the challenge.