Soyez sûr de voir l'autre défi, inverser la carte de caractères ASCII !

Le jeu de caractères ASCII (American Standard Code for Information Interchange) est la norme de codage de caractères la plus utilisée. Les codes ASCII représentent le texte des ordinateurs, des équipements de télécommunications et d'autres appareils.

Défi

Votre défi consiste à imprimer un mappage du jeu de caractères ASCII lorsque l'utilisateur les saisit. GIF:

Une fois que l'utilisateur a saisi chaque caractère ASCII, la sortie doit ressembler à ceci:

Cartographie

Chaque caractère a une position assignée sur une grille logique 16x6, en commençant par le caractère espace en haut à gauche et en encapsulant de sorte que le chiffre 0 apparaisse en dessous.

Lorsqu'une entrée ASCII imprimable est reçue, imprimez ce caractère ASCII à son emplacement d'écran attribué sans supprimer aucun des caractères actuellement à l'écran.

Règles

• Votre programme n'a besoin que de mapper les caractères ASCII imprimables 0x20vers 0x7E.
• Votre programme ne doit pas se terminer et continuer de mapper des caractères à l'écran tant que tous les caractères ASCII imprimables n'ont pas été saisis. À partir de là, votre programme peut se terminer ou s’exécuter dans Neverland.
• Votre programme peut mapper des caractères comme vous le souhaitez, par exemple sur une feuille de calcul, un tableau, une fenêtre de console ou une fenêtre graphique.
• Quelle que soit la façon dont vous affichez le mappage, il doit être mis à jour en temps réel (dès qu'il reçoit une entrée utilisateur).
• Si votre programme ne lit pas l'entrée silencieusement, il doit mettre le curseur hors du chemin, afin que le texte ne gêne pas la carte.

Aidez-moi

Voici l'algorithme de pseudocode que j'ai utilisé pour générer le 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

Il peut exister un autre moyen d'obtenir la sortie requise. Vous pouvez choisir d'utiliser mon algorithme ou le vôtre, mais la sortie doit être la même indépendamment.

Voici une référence de table ASCII utile.

Notation

La réponse avec le moins d'octets dans chaque langue l'emporte. S'amuser!

QBIC , 53 57 octets

Ajout de 4 octets pour l'espacement.

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

QBIC a commencé le développement comme raccourci pour QBasic, donc j'ai pensé que traduire ma réponse QBasic le démontrerait bien. Nous avons économisé environ 40% dans l'octet de comptage pour un programme fonctionnellement identique - et c'est quand même LOCATE, ASCet CHRn'a pas encore SPEQ-fonctions. Heureusement, QBIC peut transmettre du code directement à QBasic pour compenser cela. Un côte à côte:

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 octets

16 octets enregistrés grâce à @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>

C'est tellement incroyablement satisfaisant de simplement écraser le clavier ...

QBasic 4.5, 81 85 octets

Ajout de 4 octets pour se conformer à la règle d'espacement.

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

Et la sortie ressemblera à ceci (REMARQUE: ancienne capture d'écran, maintenant chaque caractère est séparé par un espace):

QBasic a la LOCATEcommande, qui est utile ici. Une ventilation de ce 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 octets

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

Utilise le code de contrôle ANSI CSI n ; m f pour définir la position du curseur et Console.readPassword()lire silencieusement l'entrée utilisateur. Sortie de certains caractères:

BrainFuck , 355 octets

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

Les options de BrainFuck sont assez limitées, donc la sortie est dans le terminal et l'écran est "effacé" avec 20 nouvelles lignes. L'entrée doit être les caractères ASCII, séparés par des retours à la ligne.

Essayez-le en ligne!

Formaté et documenté

Ce sont les notes de débogage que j'ai utilisées pour écrire le programme. J'ai utilisé mon interpréteur qui peut éventuellement imprimer l'état de la bande à chaque caractère «~» pour le débogage.

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

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

Essayez-le en ligne sur https://sandbox.open.wolframcloud.com/

Lorsque vous collez du code et appuyez sur Shift+Enter, une boîte de dialogue apparaîtra, vous entrez "a"par exemple pour le caractère a. Le programme fonctionne pour toujours.

Remarque: Sur Wolfram sandbox, la police est formatée différemment de celle de Mathematica sur mon ordinateur. L'espacement des lignes / colonnes peut donc sembler étrange.

Python 2 , 115 octets

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

Essayez-le en ligne!

Nécessite des guillemets (simples ou doubles) autour des caractères saisis (la version TIO ne le fait pas).

str , non compétitif, 18 octets

Présentation de mon nouveau langage semi-ésotérique.

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

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

Nécessite un terminal qui comprend les séquences d'échappement ANSI.

Il est plus court de conserver une liste de toutes les touches enfoncées jusqu'à présent et d'effacer l'écran avant de les imprimer toutes à chaque tour que de désactiver l'écho dans la session de terminal. Ce dernier a besoin import System.IOet hSetEcho stdin(2<1)coûte trop d'octets.

C, 101 octets

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

C'était le programme que j'ai utilisé pour faire les graphiques. La sortie est comme indiqué dans le GIF. ;)

QBasic, 62 58 octets

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

Testé avec QB64 . Devrait également fonctionner correctement sur QBasic, bien que vous souhaitiez peut-être le modifier pour faire unCLS lors de la première exécution.

Similaire à la réponse de steenbergh , mais utilise INPUT$(1)pour lire les caractères un à la fois. Cette approche est plus courte et n'affiche également aucune invite. Il utilise également RUNpour la boucle infinie, car nous n'avons pas à stocker d'état entre les itérations à l'exception de l'état de l'écran.

Pascal, 112 caractères

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.

Comme ma solution Mathematica prend de nombreux octets div, modetToCharacterCode[Input[]] j'essaie de faire une autre réponse avec Pascal. Mais sans ClrScrmon compilateur (FPC), j'ai laissé quelques informations de compilation à l'écran. ClrScr;prend 7 octets.

Le *2utilisé pour l'espacement correct prend encore 2 octets.

LOGO, 90 octets

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

Essayez-le sur FMSLogo.

Après tout, ma solution Logo est la plus courte, par rapport à ma réponse Mathematica et Pascal.

Ajoutez 3 octets si la tortue doit être cachée.

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

Vidage hexadécimal:

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

Assemblée commentée:

 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 le curseur l'invalide, voici une version à 36 octets sans curseur:

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

Rubis, 79 75 71 + 13 = 84 octets

+13 octets pour l' -rio/consoleindicateur.

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 octets

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

Dans le jeu de caractères SmileBASIC, ¥se trouve là où \se trouverait normalement; j'espère que cela n'invalide pas complètement cette réponse.

Applesoft BASIC , 134 octets

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

Il s'agit d'une version golfée du test de clavier Apple] [, le programme qui a inspiré le défi.