Mappage des caractères ASCII entrés

32

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:

gif

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

table

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!

MD XF
la source
Avons-nous besoin d'espaces entre les personnages?
musicman523
@ musicman523 Oui, ceux-ci sont nécessaires. La sortie doit ressembler exactement à celle des captures d'écran.
MD XF
Sommes-nous autorisés à assumer la couleur d'arrière-plan du terminal?
2017 totalement humain
L'effacement du terminal, puis le redessinage de la table mise à jour pour chaque caractère est-il acceptable?
Digital Trauma
@DigitalTrauma - Redessiner à chaque fois est acceptable - j'ai demandé dans le post Sandbox
musicman523

Réponses:

3

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)
Steenbergh
la source
18

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 ...

ETHproductions
la source
9
"tellement incroyablement satisfaisant de simplement écraser le clavier" peut ou non avoir été ce que j'allais chercher. +1
MD XF
Et oui, vous pouvez supposer que seul l'ASCII imprimable est fourni. Je suis presque sûr que c'est la règle n ° 1.
MD XF
Ne pouvez-vous pas simplement l'utiliser prompt()dans une boucle? Il vous sauvera de toute la gestion des événements et du HTML. OP semble le permettre. Voir les commentaires du billet Mathematica.
Arjun
Ne gère que l'ASCII imprimable; soustrayez 7 octets si nous pouvons supposer que seul ASCII imprimable est donné. Cela ne semble pas avoir de sens. S'il ne gère que l'ASCII imprimable, comment l'hypothèse ASCII imprimable peut-elle sauver des octets?
Arjun
Vous devriez pouvoir l'utiliser onkeypressseul, ce qui vous permet de supprimer la bodybalise. En outre, la prebalise peut être raccourcie à juste <pre id=O. Cependant, vous devrez inclure la fermeture >pour qu'elle fonctionne dans un extrait.
Shaggy
15

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):entrez la description de l'image ici

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
Steenbergh
la source
QBasic bat tout le monde! Hou la la!
Arjun
5
@Arjun Vous les enfants et votre Java ...
steenbergh
8

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:

capture d'écran

Beluga timide
la source
1
La première fois que je vois que Java a aussi une chance dans le golf de code! Agréable !
LMD
1
+1, jamais vu readPassword()utilisé comme ça. Oh, et vous semblez manquer un point-virgule après l'impression. En outre, n'est-il pas possible d'utiliser d'une System.out.printfmanière ou d'une autre au lieu de System.out.println(String.format(? Et vous pouvez passer ()->à o->en utilisant un paramètre vide inutilisé .
Kevin Cruijssen
@KevinCruijssen Fixé, merci!
Bashful Beluga
6

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. ]
    <<<<[<<<]<,
]
BrainSteel
la source
6

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.

utilisateur202729
la source
Est-ce que cela cartographie continuellement chaque personnage? Ie devez-vous l'exécuter plus d'une fois pour voir la sortie souhaitée?
MD XF
Vous l'exécutez une fois, et chaque fois que vous appuyez OKsur une zone de saisie, une autre zone de saisie apparaît pour que vous puissiez entrer la saisie.
user202729
Cela semble valable alors, merci. Bon travail!
MD XF
Je pense que i = ToString @ Input []] serait plus pratique. Les utilisateurs devraient simplement taper a et non "a"
J42161217
ou mieux i = InputString []
J42161217
5

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

musicman523
la source
1
Vous pouvez passer raw_inputà inputcomme c'est le recensement de la communauté que vous pouvez supposer que l'entrée a des guillemets autour si nécessaire.
caird coinheringaahing
1
Ça m'a l'air bien! Lorsque je testais, je saisissais juste des clés, et c'était malheureux que j'entre {sans correspondance }.
musicman523
4

str , non compétitif, 18 octets

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

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

GIF animé

#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
Conor O'Brien
la source
Je ne vois pas d'espaces entre les personnages ...
MD XF
2
@MDXF La spécification ne dit rien sur les espaces entre les caractères. Sans oublier qu'il existe de nombreuses réponses qui n'utilisent pas d'espaces.
Conor O'Brien
3

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.

nimi
la source
3

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

MD XF
la source
3

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.

DLosc
la source
Wow, sympa. Je ne savais pas input$(). J'aime trop le sujet TIPS.
steenbergh
1

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.

utilisateur202729
la source
1

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.

utilisateur202729
la source
1

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

Démo GIF

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
nom_insertion_ici
la source
1

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]
  }
}
Jordan
la source
1

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.

escargot_
la source
0

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.

MD XF
la source
Il s'agit en fait de 134 octets, car Applesoft BASIC est symbolisé.
insert_name_here
@insert_name_here Ah, oui. Merci.
MD XF