Diğer mücadeleyi, ASCII karakter haritasını tersine çevirmeyi unutmayın !

ASCII karakter seti (Bilgi Değişimi için Amerikan Standart Kodu) en yaygın kullanılan karakter kodlama standardıdır. ASCII kodları, bilgisayarlardaki, telekomünikasyon ekipmanındaki ve diğer cihazlardaki metni temsil eder.

Meydan okuma

Buradaki zorluk, kullanıcı tarafından girildiği sırada ayarlanan ASCII karakterinin bir eşlemesini yazdırmaktır. GIF:

Kullanıcı her ASCII karakterini girdikten sonra, çıkış şöyle görünmelidir:

haritalama

Her karakter 16x6 mantıksal bir ızgarada, üst soldaki boşluk karakteri ile başlayan ve 0 basamağının altında görünecek şekilde sarılı olarak atanmış bir konuma sahiptir.

Yazdırılabilir ASCII girişi alındığında, ekranda görüntülenen karakterlerden hiçbirini silmeden bu ASCII karakterini atanmış ekran konumuna yazdırın.

kurallar

• Programınızın yalnızca yazdırılabilir ASCII karakterlerini ile eşleştirmesi 0x20gerekir 0x7E.
• Programınız, yazdırılabilir tüm ASCII karakterleri girilene kadar karakterleri ekrana getirmemeli ve ekrana getirmemelidir. Buradan, programınız Neverland'da sonlandırabilir veya sonlandırabilir.
• Programınız karakterleri istediğiniz gibi, örneğin bir elektronik tablo, tablo, konsol penceresi veya grafiksel bir pencere ile eşleyebilir.
• Haritalamayı nasıl gösterdiğiniz önemli değil, gerçek zamanlı olarak güncellenmelidir (kullanıcı girdisini alır almaz).
• Programınız girişi sessizce okumazsa, imleci yoldan çıkarması gerekir, böylece metin haritaya girmez.

yardım et

GIF'yi oluşturmak için kullandığım sözde kod algoritması:

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

Gerekli çıktıyı elde etmenin başka bir yolu olabilir. Algoritmamı veya kendi algoritmamı kullanmayı seçebilirsiniz, ancak çıktı ne olursa olsun aynı olmalıdır.

İşte yararlı bir ASCII tablo referansı.

puanlama

Her dilde en az bayt olan cevap kazanır. İyi eğlenceler!

QBIC , 53 57 bayt

Boşluk için 4 bayt eklendi.

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

QBIC, gelişime QBasic için bir kısa yol olarak başladı, bu yüzden QBasic cevabını çevirmenin bunu güzelce göstereceğini düşündüm . Biz işlevsel olarak aynı program için bayt sayısında% 40 kadarını kurtardım - ve bu bile var LOCATE, ASCve CHRhenüz QBIC-işlevlere sahiptir. Neyse ki, QBIC bunu telafi etmek için kodu doğrudan QBasic'e iletebilir. Yan yana:

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 bayt

@Shaggy sayesinde 16 bayt kaydedildi

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>

Klavyeyi ezmek inanılmaz derecede tatmin edici.

QBasic 4.5, 81 85 bayt

Boşluk kuralına uyması için 4 bayt eklendi.

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

Çıktı şöyle görünecektir (NOT: Eski ekran görüntüsü, şimdi her karakter bir boşlukla ayrılmıştır):

QBasic, LOCATEburada kullanışlı olan bir komuta sahiptir . Bu kodun bir dökümü:

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 bayt

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

İmleç konumunu ayarlamak ve kullanıcı girişini sessizce okumak için ANSI kontrol kodunu kullanır . Bazı karakterlerin çıktısı:CSI n ; m fConsole.readPassword()

BrainFuck , 355 Bayt

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

BrainFuck'ın seçenekleri oldukça sınırlıdır, bu nedenle çıkış terminaldedir ve ekran 20 yeni satırla "temizlenir". Girdi, yeni satırlarla ayrılmış ASCII karakterleri olmalıdır.

Çevrimiçi deneyin!

Biçimlendirilmiş ve Belgelenmiş

Bunlar programı yazmak için kullandığım hata ayıklama notları. İsteğe bağlı olarak bandın durumunu her '~' karakterinde hata ayıklama amacıyla yazdırabilen tercümanımı kullandım .

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

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

Https://sandbox.open.wolframcloud.com/ adresinde çevrimiçi deneyin.

Kodu yapıştırdığınızda ve tuşuna bastığınızda Shift+Enter, bir iletişim kutusu açılır, "a"örneğin karakter için girersiniz a. Program sonsuza kadar çalışır.

Not: Wolfram sanal alanında, yazı tipi bilgisayarımdaki Mathematica'dakinden farklı olarak biçimlendirilmiş. Dolayısıyla çizgi / sütun aralığı tuhaf görünebilir.

Python 2 , 115 bayt

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

Çevrimiçi deneyin!

Girilen karakterlerin etrafına tırnak işaretleri (tek veya çift) gerekir (TIO sürümü gelmez).

str , rekabetçi olmayan, 18 bayt

Yeni yarı ezoterik dilimi sunuyorum.

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

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

ANSI kaçış dizilerini anlayan bir terminal gerektirir.

Terminal oturumunda yankıyı kapatmak yerine, her bir tura basmadan önce tüm tuşların bir listesini basılı tutmak ve ekranı temizlemek için daha kısadır. İkincisi ihtiyacı import System.IOve hSetEcho stdin(2<1)çok fazla bayt maliyeti.

C, 101 bayt

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

Bu grafik yapmak için kullandığım programdı. Çıkış GIF’te gösterildiği gibidir. ;)

QBasic, 62 58 bayt

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

QB64 ile test edilmiştir . İlk seferde bir değişiklik yapmak isteyebilirsiniz, ancak düzenli QBasic üzerinde de iyi çalışmalı CLS.

Steenbergh'in cevabına benzer , ancak INPUT$(1)karakterleri teker teker okumak için kullanır . Bu yaklaşım daha kısa ve aynı zamanda bir bilgi istemediğini de gösteriyor. RUNSonsuz döngü için de kullanır , çünkü ekranın durumu dışında yinelemeler arasında herhangi bir durum kaydetmemize gerek yoktur.

Pascal, 112 karakter

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.

Benim Mathematica çözüm birçok bayt alır gibi div, modve ToCharacterCode[Input[]]ben Pascal ile başka bir yanıt yapmayı deneyin. Ancak ClrScrderleyicim (FPC) olmadan ekranda bazı derleme bilgileri bıraktı. ClrScr;7 bayt alır.

*2Doğru aralanması için kullanılan başka bir 2 bayt alır.

Logo, 90 bayt

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

FMSLogo'da deneyin.

Sonuçta, Logo özümüm, Mathematica ve Pascal cevabımla karşılaştırıldığında en kısa sürdü.

Kaplumbağanın gizlenmesi gerekiyorsa 3 bayt ekleyin.

6502 makine kodu + Apple // e ROM, 31 bayt

Hex dökümü:

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

Yorum yapılan montaj:

 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

İmleç geçersiz kılarsa, işte imleçsiz 36 baytlık bir sürüm:

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 bayt

-rio/consoleBayrak için +13 bayt .

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 bayt

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

SmileBASIC karakter setinde normalde olacağı ¥yer \; umarım bu, bu cevabı tamamen geçersiz kılmaz.

Applesoft BASIC , 134 bayt

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

Bu Apple'ın golf versiyonudur] [klavye testi, mücadeleye ilham veren program.