Koniecznie zobacz inne wyzwanie, odwróć mapę znaków ASCII !

Zestaw znaków ASCII (American Standard Code for Information Interchange) jest najczęściej stosowanym standardem kodowania znaków. Kody ASCII reprezentują tekst w komputerach, sprzęcie telekomunikacyjnym i innych urządzeniach.

Wyzwanie

Wyzwanie polega na wydrukowaniu odwzorowania zestawu znaków ASCII podczas wprowadzania ich przez użytkownika. GIF:

Po wprowadzeniu przez użytkownika każdego znaku ASCII dane wyjściowe powinny wyglądać następująco:

Mapowanie

Każdy znak ma przypisaną pozycję na siatce logicznej 16x6, zaczynając od znaku spacji w lewym górnym rogu i zawijając, tak aby cyfra 0 pojawiła się pod nim.

Po odebraniu wejściowego wydruku ASCII wydrukuj ten znak ASCII w przypisanej lokalizacji na ekranie, nie usuwając żadnych znaków aktualnie wyświetlanych na ekranie.

Zasady

• Twój program musi jedynie zmapować drukowalne znaki ASCII, 0x20na 0x7E.
• Twój program nie może zakończyć i kontynuować mapowania znaków na ekranie, dopóki nie zostaną wprowadzone wszystkie drukowalne znaki ASCII. Odtąd twój program może zakończyć się lub uruchomić w Nibylandii.
• Twój program może mapować znaki w dowolny sposób, np. W arkuszu kalkulacyjnym, tabeli, oknie konsoli lub oknie graficznym.
• Bez względu na to, jak wyświetlasz odwzorowanie, musi ono zostać zaktualizowane w czasie rzeczywistym (jak tylko otrzyma dane wejściowe od użytkownika).
• Jeśli twój program nie odczytuje danych po cichu, musi odsunąć kursor, aby tekst nie przeszkadzał na mapie.

Wsparcie

Oto algorytm pseudokodu, którego użyłem do wygenerowania 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

Może być inny sposób na osiągnięcie wymaganej wydajności. Możesz wybrać użycie mojego algorytmu lub własnego, ale wynik musi być taki sam, niezależnie od tego.

Oto przydatne odniesienie do tabeli ASCII.

Punktacja

Odpowiedź z najmniej bajtami w każdym języku wygrywa. Baw się dobrze!

QBIC , 53 57 bajtów

Dodano 4 bajty dla odstępów.

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

QBIC zaczął opracowywać jako skrót dla QBasic, więc pomyślałem, że przetłumaczenie mojej odpowiedzi QBasic dobrze to zademonstruje. Mamy zapisane jakieś 40% w bajcie-count dla funkcjonalnie identyczny program - i to nawet kiedy LOCATE, ASCi CHRmieć jeszcze QBic-funkcje. Na szczęście QBIC może przekazać kod bezpośrednio do QBasic, aby to zrekompensować. Obok siebie:

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 bajtów

Zaoszczędź 16 bajtów dzięki @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>

To niewiarygodnie satysfakcjonujące po prostu zacierać klawiaturę ...

QBasic 4.5, 81 85 bajtów

Dodano 4 bajty, aby zachować zgodność z regułą odstępu.

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

Wyjście będzie wyglądać tak (UWAGA: stary zrzut ekranu, teraz każda postać jest oddzielona spacją):

QBasic ma LOCATEpolecenie, które przydaje się tutaj. Podział tego kodu:

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 bajty

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

Używa kodu sterującego ANSI, CSI n ; m f aby ustawić pozycję kursora i Console.readPassword()odczytywać dane wejściowe użytkownika w ciszy. Wyjście niektórych znaków:

BrainFuck , 355 bajtów

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

Opcje BrainFuck są dość ograniczone, więc wyjście jest w terminalu, a ekran jest „wyczyszczony” z 20 nowymi liniami. Dane wejściowe powinny być znakami ASCII, oddzielonymi znakami nowej linii.

Wypróbuj online!

Sformatowane i udokumentowane

Są to notatki debugowania, których użyłem do napisania programu. Użyłem mojego interpretera, który może opcjonalnie wydrukować stan taśmy przy każdym znaku ~ do debugowania.

[
    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 bajtów

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

Wypróbuj online na https://sandbox.open.wolframcloud.com/

Kiedy wkleisz kod i naciśniesz Shift+Enter, pojawi się okno dialogowe, w którym wpisz "a"np a. Znak . Program działa wiecznie.

Uwaga: W piaskownicy Wolfram czcionka jest sformatowana inaczej niż w Mathematica na moim komputerze. Tak więc odstępy między wierszami / kolumnami mogą wyglądać dziwnie.

Python 2 , 115 bajtów

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

Wypróbuj online!

Wymaga cudzysłowu (pojedynczego lub podwójnego) wokół wprowadzanych znaków (wersja TIO nie).

str , niekonkurujące, 18 bajtów

Przedstawiam mój nowy, na wpół ezoteryczny język.

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

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

Wymaga terminala, który rozumie sekwencje specjalne ANSI.

Krótsze jest trzymanie listy wszystkich wciśniętych do tej pory klawiszy i czyszczenie ekranu przed wydrukowaniem ich w każdej rundzie, niż wyłączenie echa w sesji terminalu. Ten ostatni potrzebuje import System.IOi hSetEcho stdin(2<1)kosztuje zbyt wiele bajtów.

C, 101 bajtów

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

To był program, którego użyłem do stworzenia grafiki. Dane wyjściowe są pokazane w pliku GIF. ;)

QBasic, 62 58 bajtów

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

Testowane z QB64 . Powinien również działać dobrze na zwykłym QBasic, chociaż możesz chcieć go zmodyfikować, aby wykonać CLSprzy pierwszym uruchomieniu.

Podobna do odpowiedzi Steenbergha , ale używa INPUT$(1)do odczytywania znaków pojedynczo. To podejście jest krótsze i nie wyświetla monitu. Wykorzystuje również RUNpętlę nieskończoną, ponieważ nie musimy przechowywać żadnego stanu między iteracjami oprócz stanu ekranu.

Pascal, 112 znaków

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.

Ponieważ moje rozwiązanie Mathematica zajmuje wiele bajtów div, modi ToCharacterCode[Input[]]próbuję udzielić innej odpowiedzi z Pascalem. Ale bez ClrScrmojego kompilatora (FPC) pozostawiłem pewne informacje o kompilacji na ekranie. ClrScr;zajmuje 7 bajtów.

Zastosowane *2do właściwego odstępu zajmuje kolejne 2 bajty.

LOGO, 90 bajtów

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

Wypróbuj na FMSLogo.

W końcu moje logo jest najkrótsze w porównaniu z moją odpowiedzią Mathematica i Pascal.

Dodaj 3 bajty, jeśli żółw musi być ukryty.

Kod maszynowy 6502 + ROM // e ROM, 31 bajtów

Zrzut szesnastkowy:

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

Skomentowany montaż:

 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

Jeśli kursor je unieważnia, oto 36-bajtowa wersja bez kursora:

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

Rubin, 79 75 71 + 13 = 84 bajtów

+13 bajtów dla -rio/console flagi.

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

Bez golfa

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

SmileBASIC 3, 82 bajty

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

W zestawie znaków SmileBASIC ¥znajduje się tam, gdzie \normalnie by się znajdowało; mam nadzieję, że nie unieważnia to całkowicie tej odpowiedzi.

Applesoft BASIC , 134 bajty

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

To jest wersja gry w golfa w Apple] [test klawiatury, program, który zainspirował to wyzwanie.