Assicurati di vedere l'altra sfida, Reverse ASCII character map !

Il set di caratteri ASCII (American Standard Code for Information Interchange) è lo standard di codifica dei caratteri più utilizzato. I codici ASCII rappresentano il testo nei computer, nelle apparecchiature di telecomunicazione e in altri dispositivi.

Sfida

La tua sfida è stampare una mappatura del set di caratteri ASCII mentre l'utente li inserisce. GIF:

Dopo che l'utente ha inserito tutti i caratteri ASCII, l'output dovrebbe essere simile al seguente:

Mappatura

A ciascun personaggio è assegnata una posizione su una griglia logica 16x6, a partire dal carattere spazio nella posizione in alto a sinistra e avvolgendo in modo tale che la cifra 0 appaia sotto di essa.

Quando si riceve un input ASCII stampabile, stampare quel carattere ASCII nella posizione dello schermo assegnata senza eliminare nessuno dei caratteri attualmente visualizzati sullo schermo.

Regole

• Il tuo programma deve solo mappare i caratteri ASCII stampabili 0x20a 0x7E.
• Il programma non deve terminare e continuare a mappare i caratteri sullo schermo fino a quando non sono stati immessi tutti i caratteri ASCII stampabili. Da qui, il tuo programma può terminare o eseguire in Neverland.
• Il tuo programma può mappare i caratteri come preferisci, ad esempio su un foglio di calcolo, una tabella, una finestra della console o una finestra grafica.
• Indipendentemente da come si visualizza la mappatura, deve essere aggiornata in tempo reale (non appena riceve l'input dell'utente).
• Se il tuo programma non legge l'input in silenzio, deve spostare il cursore in modo che il testo non si frapponga alla mappa.

Aiuto

Ecco l'algoritmo pseudocodice che ho usato per generare la 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

Potrebbe esserci un altro modo per ottenere l'output richiesto. Puoi scegliere di usare il mio algoritmo o il tuo, ma l'output deve essere lo stesso indipendentemente.

Ecco un utile riferimento alla tabella ASCII.

punteggio

Vince la risposta con il minor numero di byte in ciascuna lingua. Divertiti!

QBIC , 53 57 byte

Aggiunti 4 byte per la spaziatura.

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

QBIC ha iniziato lo sviluppo come una scorciatoia per QBasic, quindi ho pensato che tradurre la mia risposta QBasic lo avrebbe dimostrato bene. Abbiamo salvato circa il 40% nel byte-count per un programma funzionalmente identici - e questo è anche quando LOCATE, ASCe CHRhanno ancora Qbic-funzioni. Fortunatamente, QBIC può passare il codice direttamente a QBasic per compensare questo. Un fianco a fianco:

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 byte

Risparmiato 16 byte grazie 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>

È così incredibilmente soddisfacente schiacciare semplicemente la tastiera ...

QBasic 4.5, 81 85 byte

Aggiunti 4 byte per rispettare la regola di spaziatura.

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

E l'output sarà simile al seguente (NOTA: vecchio screenshot, ora ogni personaggio è separato da uno spazio):

QBasic ha il LOCATEcomando, che è utile qui. Una ripartizione di questo codice:

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 byte

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

Utilizza il codice di controllo ANSI CSI n ; m f per impostare la posizione del cursore e Console.readPassword()leggere silenziosamente l'input dell'utente. Uscita di alcuni personaggi:

BrainFuck , 355 byte

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

Le opzioni di BrainFuck sono piuttosto limitate, quindi l'output è nel terminale e lo schermo viene "cancellato" con 20 nuove righe. L'input dovrebbe essere i caratteri ASCII, separati da nuove righe.

Provalo online!

Formattato e documentato

Queste sono le note di debug che ho usato per scrivere il programma. Ho usato il mio interprete che può opzionalmente stampare lo stato del nastro su ogni carattere '~' per il debug.

[
    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 byte

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

Provalo online su https://sandbox.open.wolframcloud.com/

Quando si incolla il codice e si preme Shift+Enter, viene visualizzata una finestra di dialogo, immettere "a"ad esempio per il caratterea . Il programma funziona per sempre.

Nota: sulla sandbox Wolfram, il carattere è formattato in modo diverso da quello di Mathematica sul mio computer. Quindi la spaziatura di linea / colonna può sembrare strana.

Python 2 , 115 byte

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

Provalo online!

Richiede virgolette (singole o doppie) attorno ai caratteri immessi (la versione TIO no).

str , non competitivo, 18 byte

Presentando il mio nuovo linguaggio semi-esoterico.

#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 byte

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

Richiede un terminale che comprenda le sequenze di escape ANSI.

È più breve tenere un elenco di tutti i tasti premuti finora e cancellare lo schermo prima di stamparli tutti in ogni round piuttosto che disattivare l'eco nella sessione del terminale. Quest'ultimo ha bisogno import System.IOe hSetEcho stdin(2<1)che costa troppi byte.

C, 101 byte

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

Questo era il programma che ho usato per realizzare la grafica. L'output è come mostrato nella GIF. ;)

QBasic, 62 58 byte

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

Testato con QB64 . Dovrebbe funzionare bene anche su QBasic normale, anche se potresti volerlo modificare per eseguire una CLSprima esecuzione.

Simile alla risposta di Steenbergh , ma utilizza INPUT$(1)per leggere i caratteri uno alla volta. Questo approccio è più breve e non visualizza alcun prompt. Utilizza anche RUNper il ciclo infinito, poiché non è necessario memorizzare alcuno stato tra le iterazioni tranne lo stato dello schermo.

Pascal, 112 caratteri

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.

Poiché la mia soluzione Mathematica occupa molti byte in div, modeToCharacterCode[Input[]] , provo facendo un'altra risposta con Pascal. Ma senzaClrScr mio compilatore (FPC) ho lasciato alcune informazioni di compilazione sullo schermo. ClrScr;richiede 7 byte.

La *2spaziatura corretta utilizzata richiede altri 2 byte.

LOGO, 90 byte

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

Provalo su FMSLogo.

Dopotutto, la mia soluzione Logo è la più breve, rispetto alla mia risposta Mathematica e Pascal.

Aggiungi 3 byte se la tartaruga deve essere nascosta.

6502 codice macchina + Apple // e ROM, 31 byte

Discarica esadecimale:

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

Assemblaggio commentato:

 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

Se il cursore lo invalida, ecco una versione a 36 byte senza cursore:

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

Rubino, 79 75 71 + 13 = 84 byte

+13 byte per la -rio/consolebandiera.

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 byte

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

Nel set di caratteri SmileBASIC, ¥si trova dove \normalmente si troverebbe; speriamo che questo non invalidi completamente questa risposta.

Applesoft BASIC , 134 byte

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

Questa è una versione da golf dell'Apple] [test della tastiera, il programma che ha ispirato la sfida.