¡Asegúrate de ver el otro desafío, el mapa de caracteres ASCII inverso !

El juego de caracteres ASCII (American Standard Code for Information Interchange) es el estándar de codificación de caracteres más utilizado. Los códigos ASCII representan texto en computadoras, equipos de telecomunicaciones y otros dispositivos.

Reto

Su desafío es imprimir un mapeo del juego de caracteres ASCII a medida que el usuario los ingresa. GIF:

Después de que el usuario ingresa todos los caracteres ASCII, la salida debería verse así:

Cartografía

Cada carácter tiene una posición asignada en una cuadrícula lógica de 16x6, comenzando con el carácter de espacio en la posición superior izquierda y ajustando de manera tal que el dígito 0 aparezca debajo de él.

Cuando se recibe una entrada ASCII imprimible, imprima ese carácter ASCII en su ubicación de pantalla asignada sin eliminar ninguno de los caracteres actualmente en pantalla.

Reglas

• Su programa solo necesita mapear los caracteres ASCII imprimibles, 0x20a 0x7E.
• Su programa no debe finalizar y continuar asignando caracteres a la pantalla hasta que se hayan ingresado todos los caracteres ASCII imprimibles. Desde aquí, su programa puede terminar o ejecutarse en Neverland.
• Su programa puede asignar caracteres de la forma que desee, por ejemplo, a una hoja de cálculo, una tabla, una ventana de consola o una ventana gráfica.
• No importa cómo visualice la asignación, debe actualizarse en tiempo real (tan pronto como reciba la entrada del usuario).
• Si su programa no lee la entrada en silencio, debe poner el cursor fuera del camino, para que el texto no se interponga en el mapa.

Ayuda

Aquí está el algoritmo de pseudocódigo que utilicé para generar el 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

Puede haber otra forma de lograr el resultado requerido. Puede elegir usar mi algoritmo o el suyo, pero la salida debe ser la misma independientemente.

Aquí hay una referencia de tabla ASCII útil.

Tanteo

La respuesta con la menor cantidad de bytes en cada idioma gana. ¡Que te diviertas!

QBIC , 53 57 bytes

Se agregaron 4 bytes para el espaciado.

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

QBIC comenzó el desarrollo como una abreviatura de QBasic, por lo que pensé que traducir mi respuesta QBasic demostraría esto muy bien. Hemos ahorrado un 40% en el byte de conteo para un programa funcionalmente idénticos - y eso es incluso cuando LOCATE, ASCy CHRno tienen QBIC-funciones todavía. Afortunadamente, QBIC puede pasar el código directamente a QBasic para compensar esto. Un lado a lado:

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

Guardado 16 bytes gracias a @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>

Es tan increíblemente satisfactorio simplemente apretar el teclado ...

QBasic 4.5, 81 85 bytes

Se agregaron 4 bytes para cumplir con la regla de espaciado.

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

Y la salida se verá así (NOTA: captura de pantalla anterior, ahora cada carácter está separado por un espacio):

QBasic tiene el LOCATEcomando, que es útil aquí. Un desglose de este código:

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));}}

Utiliza el código de control ANSI CSI n ; m f para establecer la posición del cursor y Console.readPassword()leer la entrada del usuario en silencio. Salida de algunos caracteres:

BrainFuck , 355 bytes

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

Las opciones de BrainFuck son bastante limitadas, por lo que la salida está en el terminal y la pantalla se "borra" con 20 líneas nuevas. La entrada debe ser los caracteres ASCII, separados por nuevas líneas.

Pruébalo en línea!

Formateado y Documentado

Estas son las notas de depuración que usé para escribir el programa. Utilicé mi intérprete que opcionalmente puede imprimir el estado de la cinta en cada carácter '~' para la depuración.

[
    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[])&[]

Pruébelo en línea en https://sandbox.open.wolframcloud.com/

Cuando pegue el código y presione Shift+Enter, aparecerá un cuadro de diálogo emergente, ingrese, "a"por ejemplo, el carácter a. El programa se ejecuta para siempre.

Nota: En el sandbox de Wolfram, la fuente tiene un formato diferente al de Mathematica en mi computadora. Por lo tanto, el espacio entre líneas / columnas puede parecer extraño.

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

Pruébalo en línea!

Requiere comillas (simples o dobles) alrededor de los caracteres ingresados ​​(la versión TIO no).

str , sin competencia, 18 bytes

Presentando mi nuevo lenguaje semi-esotérico.

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

Requiere un terminal que entienda las secuencias de escape ANSI.

Es más corto mantener una lista de todas las teclas presionadas hasta ahora y borrar la pantalla antes de imprimirlas todas en cada ronda que apagar el eco en la sesión de terminal. Este último necesita import System.IOy hSetEcho stdin(2<1)que cuesta demasiados 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);}

Este fue el programa que usé para hacer los gráficos. La salida es como se muestra en el GIF. ;)

QBasic, 62 58 bytes

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

Probado con QB64 . También debería funcionar bien en QBasic regular, aunque es posible que desee modificarlo para hacer un CLSen la primera ejecución.

Similar a la respuesta de steenbergh , pero se usa INPUT$(1)para leer los caracteres uno a la vez. Este enfoque es más corto y tampoco muestra ningún aviso. También se utiliza RUNpara el bucle infinito, ya que no tenemos que almacenar ningún estado entre iteraciones, excepto el estado de la pantalla.

Pascal, 112 caracteres

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.

Como mi solución Mathematica toma muchas Bytes div, mody ToCharacterCode[Input[]], intento hacer otra respuesta con Pascal. Pero sin ClrScrmi compilador (FPC) dejó algo de información de compilación en la pantalla. ClrScr;toma 7 bytes.

El *2utilizado para el espaciado adecuado toma otros 2 bytes.

LOGOTIPO, 90 bytes

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

Pruébalo en FMSLogo.

Después de todo, mi solución de Logo es la más corta, en comparación con mi respuesta de Mathematica y Pascal.

Agregue 3 bytes si se requiere que la tortuga esté oculta.

6502 código máquina + Apple // e ROM, 31 bytes

Volcado hexadecimal:

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

Asamblea comentada:

 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

Si el cursor lo invalida, aquí hay una versión de 36 bytes sin 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 para -rio/consolebandera.

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

Sin golf

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

En el conjunto de caracteres SmileBASIC, ¥se encuentra donde \normalmente estaría; Esperemos que esto no invalide esta respuesta por completo.

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

Esta es una versión de golf de Apple] [prueba de teclado, el programa que inspiró el desafío.