Fülle mein Bubble Sheet aus

18

Heute war der Anmeldungstag für die AP-Prüfung an meiner Schule, und während ich akribisch in den erforderlichen Seiten und Informationsseiten blubberte, traf mich die Idee für diese Herausforderung. Ausgehend von einer Folge von Buchstaben und Zahlen geben Sie ein entsprechend ausgefülltes Blasendiagramm aus.

Regeln:

  • Ersetzen Sie für jedes Zeichen in der Eingabezeichenfolge dieses Zeichen in der entsprechenden Spalte durch ein #oder @ein anderes sinnvolles Symbol (wenn Ihre Sprache damit umgehen kann, sieht das Unicode-Zeichen 'full_block' aus: █ sieht wirklich gut aus).
  • Ein Leerzeichen wird durch eine leere Spalte dargestellt (siehe Beispiele)
  • Eine gültige Eingabe ist eine Zeichenfolge, die nur aus Großbuchstaben, Ziffern und Leerzeichen besteht.
  • Die Eingabe hat eine Länge von mindestens 1 und höchstens 32 Zeichen.
  • Die Ausgabe muss in GROSSBUCHSTABEN erfolgen
  • Wenn die Eingabelänge kleiner als die maximale Länge von 32 ist, muss Ihr Programm die verbleibenden leeren Spalten weiterhin ausgeben
  • Ihr Programm muss Eingaben in Kleinbuchstaben nicht so behandeln, als ob sie in Großbuchstaben geschrieben wären, sondern Bonuspunkte, wenn dies möglich ist.

Kartenformat:

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
LLLLLLLLLLLLLLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
00000000000000000000000000000000
11111111111111111111111111111111
22222222222222222222222222222222
33333333333333333333333333333333
44444444444444444444444444444444
55555555555555555555555555555555
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999

Beispiele:

CODE GOLF ->

AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
█CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DD█DDDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEE█EEEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFFFFF█FFFFFFFFFFFFFFFFFFFFFFF
GGGGG█GGGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHHHHHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK
LLLLLLL█LLLLLLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMMMMMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN
O█OOOO█OOOOOOOOOOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSSSSSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUUUUUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYYYYYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
00000000000000000000000000000000
11111111111111111111111111111111
22222222222222222222222222222222
33333333333333333333333333333333
44444444444444444444444444444444
55555555555555555555555555555555
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999


ABCDEFGHIJKLMNOPQRSTUVWXYZ012345 ->

@AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
B@BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB
CC@CCCCCCCCCCCCCCCCCCCCCCCCCCCCC
DDD@DDDDDDDDDDDDDDDDDDDDDDDDDDDD
EEEE@EEEEEEEEEEEEEEEEEEEEEEEEEEE
FFFFF@FFFFFFFFFFFFFFFFFFFFFFFFFF
GGGGGG@GGGGGGGGGGGGGGGGGGGGGGGGG
HHHHHHH@HHHHHHHHHHHHHHHHHHHHHHHH
IIIIIIII@IIIIIIIIIIIIIIIIIIIIIII
JJJJJJJJJ@JJJJJJJJJJJJJJJJJJJJJJ
KKKKKKKKKK@KKKKKKKKKKKKKKKKKKKKK
LLLLLLLLLLL@LLLLLLLLLLLLLLLLLLLL
MMMMMMMMMMMM@MMMMMMMMMMMMMMMMMMM
NNNNNNNNNNNNN@NNNNNNNNNNNNNNNNNN
OOOOOOOOOOOOOO@OOOOOOOOOOOOOOOOO
PPPPPPPPPPPPPPP@PPPPPPPPPPPPPPPP
QQQQQQQQQQQQQQQQ@QQQQQQQQQQQQQQQ
RRRRRRRRRRRRRRRRR@RRRRRRRRRRRRRR
SSSSSSSSSSSSSSSSSS@SSSSSSSSSSSSS
TTTTTTTTTTTTTTTTTTT@TTTTTTTTTTTT
UUUUUUUUUUUUUUUUUUUU@UUUUUUUUUUU
VVVVVVVVVVVVVVVVVVVVV@VVVVVVVVVV
WWWWWWWWWWWWWWWWWWWWWW@WWWWWWWWW
XXXXXXXXXXXXXXXXXXXXXXX@XXXXXXXX
YYYYYYYYYYYYYYYYYYYYYYYY@YYYYYYY
ZZZZZZZZZZZZZZZZZZZZZZZZZ@ZZZZZZ
00000000000000000000000000@00000
111111111111111111111111111@1111
2222222222222222222222222222@222
33333333333333333333333333333@33
444444444444444444444444444444@4
5555555555555555555555555555555@
66666666666666666666666666666666
77777777777777777777777777777777
88888888888888888888888888888888
99999999999999999999999999999999

ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ->^^^

Und das ist natürlich Code-Golf , also gewinnt die kürzeste Antwort

code-golf  ascii-art 
— X1M4L
quelle
7
Die Eingabevalidierung wird im Allgemeinen nicht empfohlen, sodass Sie nur die Eingabe als übereinstimmend einstufen [A-Z0-9]{1,32}und jedes Verhalten für Eingaben zulassen können, die nicht mit der Eingabe übereinstimmen.
— Giuseppe
1
Wie lächerlich ärgerlich ist die Tatsache, dass '0' vor 'A' im ASCII-Code steht> :( lol
— NL628
"Gültige Eingabe ist eine Zeichenfolge, die sich aus den Zeichen auf dem Bubble Sheet sowie aus Leerzeichen zusammensetzt". Sie können jedoch auch "Alle Zeichen außer Großbuchstaben, Leerzeichen und numerischen Ziffern oder mehr als 32 Zeichen" eingeben sollte ignoriert werden " , also welches ist es?
— Kritixi Lithos
1
Laut der ersten Aussage $wird dies jedoch nicht in den Eingaben erscheinen
— Kritixi Lithos,
1
Nachdem Sie Ziffern und ungültige Zeichen aus den Spezifikationen entfernt haben, möchten Sie diese möglicherweise auch aus den Beispielen entfernen.
— Titus

Antworten:

4

Schale , 23 Bytes

mż§?'#|=⁰mR32¤+…"AZ""09

Versuchen Sie es online oder versuchen Sie es mit der Phantasie █ Charakter (aber einen ungültigen bytecount)!

Leider konnte ich die beiden maps nicht zu einem verschmelzen (außer bei Verwendung von Klammern, die 24 Byte kosten).

Erläuterung

mż§?'#|=⁰mR32¤+…"AZ""09"  -- expects string as argument, eg. "FOO"
             ¤            -- with the two strings "AZ" "09" ..
               …          -- | fill ranges: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                          -- |              "0123456789"
              +           -- .. and concatenate: "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
          m               -- map the following (eg. with 'X')
                          -- | replicate 32 times: "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
                          -- : ["A…A","B…B",…,"Z…Z","0…0",…"9…9"]
m                         -- map the following (eg. with "F…")
 ż      ⁰                 -- | zipWith (keeping elements of longer list) argument ("FOO")
  §?   =                  -- | | if elements are equal
    '#                    -- | | | then use '#'
      |                   -- | | | else use the first character
                          -- | : ["#FF…F"]
                          -- : ["A…A",…,"#FF…F",…,"O##O…O",…,"9…9"]
— ბიმო
quelle
4

Ruby , 62 Bytes

->s{[*?A..?Z,*?0..?9].map{|c|(0..31).map{|i|c==s[i]??@:c}*''}}

Probieren Sie es online!

Gibt ein Array von Strings zurück. Könnte weiter golfen werden, indem man String-Joins verwirft und ein 2D-Array von Zeichen zurückgibt, wie es normalerweise der Fall ist, aber ich bin mir nicht sicher, ob es hier erlaubt ist.

— Kirill L.
quelle
3

C (GCC) , 132 126 Bytes

char*s="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",*_,*a;f(char*x){for(_=s;*_;++_,puts(""))for(a=s;*a;)putchar(x[a++-s]-*_?*_:64);}

Probieren Sie es online!

Vielen Dank an Jonathan Frech für das Speichern von 6 Bytes.

— LambdaBeta
quelle
puts("")ist äquivalent zu putchar(10).
— Jonathan Frech
++a)putchar((x[a-s]-*_)?*_:64);-> )putchar(x[a++-s]-*_?*_:64);.
— Jonathan Frech
Wenn Sie bereit sind , die Regeln ein wenig zu biegen, können Sie auch Golf 64zu 1.
— Jonathan Frech
Wenn Sie dies tun, könnte der putcharAnruf an Golf gespielt werden putchar(*_*(*_!=a[x-s]));.
— Jonathan Frech
Normalerweise würde ich die Regeln dafür in Ordnung bringen ... aber 1 ist ein ganz anderes Biest als ein gefülltes Rechteck oder ein @ -Zeichen. Die anderen Änderungen sind jedoch nützlich - werden aktualisiert.
— LambdaBeta
3

Rot , 177 Bytes

func[s][m: copy[]foreach c a:"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"[insert/dup r: copy"^/"c 32 append m r]j: 0
foreach c s[j: j + 1 if c <>#" "[m/(index? find a c)/(j): #"@"]]m]

Probieren Sie es online!

Besser lesbar:

f: func[s][
    m: copy[]
    a:"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
    foreach c a[
        insert/dup r: copy "^/" c 32
        append m r
    ]
    j: 0
    foreach c s[
        j: j + 1
        if c <>#" "[m/(index? find a c)/(j): #"@"]
    ]
    m
]
— Galen Ivanov
quelle
3

Holzkohle , 21 Bytes

Ｅ⁺α⭆…αχκ⭆…◨θφ³²⎇⁼ιλ#ι

Probieren Sie es online!Link ist eine ausführliche Version des Codes. Erläuterung:

  α  α                  Uppercase alphabet predefined variable
      χ                 Predefined variable 10
    …                   Chop to length
   ⭆                    Map over characters and join
       κ                Current index
 ⁺                      Concatenate
Ｅ                       Map over characters into array
           θ            Input string
            φ           Predefined variable 1000
          ◨             Right pad to length
             ³²         Literal 32
         …              Chop to length
        ⭆               Map over characters and join
                 ι  ι   Current outer character
                  λ     Current inner character
                ⁼       Equals
                   #    Literal `#`
               ⎇        Ternary
                        Implicitly print each result on its own line

Vorgängerversion mit Eingabevalidierung, 34 32 Bytes. Bearbeiten: 2 Bytes dank nur @ ASCII gespeichert.

≔⁺α⭆…αχκαＥα⭆…◨Φθ∨⁼ι №αιφ³²⎇⁼ιλ#ι

Probieren Sie es online! Link ist eine ausführliche Version des Codes.

— Neil
quelle
: / Sie scheinen am Ende eine enge Paren zu vermissen
— ASCII
Das sieht so aus, als ob es funktioniert. (Wolfram StringReplace) Nebenbei bemerkt, ein eingebauter Ersatz wäre wirklich praktisch
— ASCII
Egal, ich weiß nicht was ich tat. 27 Bytes - Sie brauchen das nichtCast
— Nur ASCII
Betrachten Sie auch das Pad mit einem beliebigen Zeichen, nach dem Sie zuvor gefragt haben: Glauben Sie, dass dies nützlich genug wäre, um es als eingebautes Pad hinzuzufügen? oder vielleicht als Zwei-Zeichen-Builtin?
— Nur ASCII
23
— Nur ASCII
3

Jelly ,  18  17 Bytes

ØA;ØDWẋ32ɓ,€⁶y"ZY

Verwendet ein Leerzeichen. So verwenden Sie einen #Ersatz ⁶mit ”#für einen Preis von einem Byte.

Probieren Sie es online!

Wie?

ØA;ØDWẋ32ɓ,€⁶y"ZY - Main Link: list of characters, S   e.g.  ['S','P','A','M']
ØA                - upper-case alphabet characters           ['A','B',...,'Z']
   ØD             - digit characters                         ['0','1',...,'9']
  ;               - concatenate                              ['A','B',...,'Z','0','1',...,'9']
     W            - wrap in a list                           [['A','B',...,'Z','0','1',...,'9']]
      ẋ32         - repeat 32 times                          [['A','B',...,'Z','0','1',...,'9'],...,['A','B',...,'Z','0','1',...,'9']]
         ɓ        - start a new dyadic chain with that on the right
            ⁶     - space character                          ' '
          ,€      - pair €ach of S with a space              [['S',' '],['P',' '],['A',' '],['M',' ']]
              "   - zip with:
             y    -   translate (replace 'S' with ' ' in 1st, 'P' with ' ' in 2nd, ...) -- Note: zip is a zip-longest, so trailing lists remain
                Z  - transpose
                 Y - join with line-feeds
                   - implicit print
— Jonathan Allan
quelle
Ich kann ein Byte speichern.
— Erik der Outgolfer
Welp, ich bin auch ³Ḣ,⁶yØA;ØD¤µ32СZYmit 18 gekommen, was ich für verbesserungsfähig halte! Ausgehen obwohl ...
— Jonathan Allan
Das ist natürlich nicht das Byte, auf das ich mich beziehe. :) Versuchen Sie es stärker ...
— Erik der Outgolfer
Erstaunlich, ich schaffte es, auf mobilen 17 Bytes
— Jonathan Allan
Meins war eigentlich das , aber herzlichen Glückwunsch!
— Erik der Outgolfer
2

C ++ 14, 319 Bytes 237

Dies mache ich zum ersten Mal in der schlechtesten CodeGolf-Sprache: P

char c;string k="ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",s;int main(){map<char,vc>g;g[' ']=vc(32,' ');for(char c:k)g[c]=vc(32,c);getline(cin,s);for(int i=0;i<s.length();i++)g[s[i]][i]='@';for(char d:k){for(char x:g[d])cout<<x;cout<<'\n';}}

Probieren Sie es online!

— NL628
quelle
Frage: Muss ich den Header einfügen?
— NL628,
Wenn der Code ausgeführt werden soll, muss er in Ihrer Antwort enthalten sein. Das heißt, Sie können so ziemlich das gesamte Leerzeichen entfernen, und diese Antwort funktioniert immer noch.
Könnte ich dies als eine Funktion mit Parametern anstelle von main () umschreiben?
— NL628,
@ NL628 ja das kannst du. SehenWeitere Hilfe finden Tipps zum Golfen in C ++ . BEARBEITEN: Link zu C ++ umgestellt
— Giuseppe
1
COBOL jemand? Ich habe noch nie eine Codezeile geschrieben, aber COBOL für Code Golf zu verwenden, könnte eine interessante Herausforderung sein.
— Hans-Martin Mosner
2

Node.js, 85 Bytes

Port auf Node.js, vorgeschlagen von @DanielIndie

f=(s,x=544,c=Buffer([48+x/32%43]))=>x<1696?(s[x&31]==c?'@':c)+[`
`[++x&31]]+f(s,x):''

Probieren Sie es online!

JavaScript (ES6), 103 98 Byte

f=(s,x=544,n=x>>5,c=String.fromCharCode(48+n%43))=>n<53?(s[x&31]==c?'@':c)+[`
`[++x&31]]+f(s,x):''

Probieren Sie es online!

— Arnauld
quelle
90 Bytes wie wäre es damit?
— DanielIndie
@ DanielIndie Danke! Hinzugefügt. (Wir brauchen das nicht wirklich +"", oder?)
— Arnauld
Ich weiß nie, ob wir konvertieren müssen oder nicht, also denke ich nicht darüber nach: P, aber ja, du brauchst es eigentlich nicht :)
— DanielIndie
@DanielIndie Ah, jetzt können wir nur noch x/322 Bytes speichern, da Bufferes sich um Ganzzahlen handelt.
— Arnauld
f=(s,x=561,c=Buffer([48+x/33%43]))=>x<1749?(s[x++%33]==c?'@':x%33?c:`\n`)+f(s,x):''
— 14 m²,
2

Haskell , 86 Bytes

Für einen viel schöneren Ansatz (und weniger Bytes) sehen Sie sich die Lösung von Laikoni an !

f x=(x#).(<$[1..32])<$>['A'..'Z']++['0'..'9']
(a:b)#(u:v)=last(u:['#'|a==u]):b#v
_#w=w

Probieren Sie es online!

Alternativ können wir für die gleiche Anzahl von Bytes Folgendes verwenden:

(a:b)#(u:v)|a==u='#':b#v|0<3=u:b#v

Probieren Sie es online!

Erklärung / Ungolfed

Der Operator (#)ist sehr ähnlich, zipWithjedoch ist die Funktion fest codiert, st. Es wird verwendet, #wenn zwei Zeichen gleich sind, andernfalls wird das zweite Zeichen ungolfed beibehalten:

(a:b) # (u:v)
   | a == u    = '#' : b # v
   | otherwise =  u  : b # v

Wenn die erste Liste erschöpft ist, werden nur die verbleibenden Elemente der zweiten angefügt:

_ # w = w

Mit diesem Helfer müssen wir nur den String generieren "A..Z0..9", jedes Element 32-mal replizieren und die Eingabe mit jedem String, ungolfed, komprimieren:

f x = map ((x#) . replicate 32) (['A'..'Z'] ++ ['0'..'9'])
— ბიმო
quelle
1
— Laikoni
@Laikoni: Schade, dass es nur 1 Byte weniger ist, das ist eine wirklich clevere Verwendung von max. Ich denke, Sie sollten das als Ihre eigene Lösung posten, da es sich sehr von meiner Lösung unterscheidet.
— ბიმო
Ich habe eine 74-Byte-Version gepostet .
— Laikoni
2

Haskell , 74 Bytes

f x=[do a<-take 32$x++cycle" ";max[c]['~'|a==c]|c<-['A'..'Z']++['0'..'9']]

Probieren Sie es online! Eine Eingabezeichenfolge xwird mit Leerzeichen bis zu einer Länge von 32 mit aufgefüllt take 32$x++cycle" ". Für jedes Zeichen causA bis Zund 0bis betrachten 9wir die Zeichen aaus der aufgefüllten Eingabezeichenfolge und ersetzen sie durch ~wann aund csind gleich und durch csonst. Dies wird erreicht, indem max[c]['~'|a==c]zB max "A" "~" = "~"wann a = c = 'A'und max "A" "" = "A"wann c = 'A'und a = 'B'. Da dies einen Singleton-String anstelle eines Zeichens ergibt, wird derdo Zeichens ergibt Anmerkung verwendet, die die Singleton-Zeichenfolgen zu einer Zeichenfolge verkettet.

Basierend auf der Haskell-Lösung von BMO .

— Laikoni
quelle
2

Python 2, 138 Bytes

Unterstützt sowohl Groß- als auch Kleinbuchstaben und lässt eine nicht ausgefüllte Spalte für Leerzeichen.

def f(s):
 s=s.upper()
 for j in"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":print"".join(j if(len(s)<=i)or(s[i]!=j)else'@'for i in range(32))

Wenn sich der Bonus nicht lohnt, werde ich 125 Bytes verwenden und nur Großbuchstaben unterstützen:

def f(s):
 for j in"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789":print"".join(j if(len(s)<=i)or(s[i]!=j)else'@'for i in range(32))
— sonrad10
quelle
2

Stax , 15 Bytes

╛dδÑ-═E↑\≈Fà±AG

Führen Sie es aus und debuggen Sie es

Es benutzt '#' zeigt eine gefüllte Blase an.

Ausgepackt, ungolfed und kommentiert sieht es so aus.

32(     right-pad or truncate to 32
{       begin block for mapping
  VAVd+ "A..Z0..9"
  s'#+  move input character to top of stack and append "#". e.g. "C#"
  |t    translate; replace the first character with the second in string
m       perform map using block
Mm      transpose array of arrays and output each line

Führen Sie dieses aus

— rekursiv
quelle
1

Pyth, 23 20 Bytes

j.Tm:s+r1GUTdN.[Qd32

Probieren Sie es hier aus

Erläuterung

j.Tm:s+r1GUTdN.[Qd32
              .[Qd32      Pad the input to 32 characters.
   m                      For each character...
     s+r1GUT              ... get the string "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"...
    :       dN            ... with the character replaced by a '"'.
j.T                       Transpose the lines and print them all.
1

APL + WIN, 56 Bytes

Fordert zur Eingabe einer Zeichenfolge auf und verwendet das Zeichen # als Bezeichner:

m←⍉32 36⍴⎕av[(65+⍳26),48+⍳10]⋄((,m[;1]∘.=32↑⎕)/,m)←'#'⋄m

Erläuterung:

m←⍉32 36⍴⎕av[(65+⍳26),48+⍳10] create the table

32↑⎕ pad the input string to 32 characters with spaces

(,m[;1]∘.=32↑⎕) use outer product with = to identify characters in table

((,m[;1]∘.=32↑⎕)/,m)←'#' replace characters with #

m display table

⋄ statement separator
— Graham
quelle
1

C (gcc) 124 Bytes

f(s,b,x,y)char*s,b[33];{sprintf(b,"%-32.32s",s);for(x=0;++x<36;puts(""))for(y=x+21+43*(x<27),s=b;*s;putchar(*s++==y?35:y));}

Probieren Sie es online!

Anstelle eines hartcodierten Arrays habe ich stattdessen eine Suchfunktion verwendet. Glücklicherweise ist die ASCII - Zeichensatz hat zusammenhängenden alphabetischen und numerischen Bereiche (Ich sehe dich an , EBCDIC!) Wie gut, stellte ich sicher , genau 32 Zeichen die Ausgabe zu halten mit sprintf(): wenn dies nicht eine Anforderung der Aufgabe war es , die Funktion wäre 97 Bytes:

f(s,i,x,y)char*s,*i;{for(x=0;++x<36;puts(""))for(y=x+21+43*(x<27),i=s;*i;putchar(*i++==y?35:y));}

Probieren Sie es online!

— ErikF
quelle
— Ceilingcat
1

CJam , 31 Bytes

q32Se]{'[,65>A,s+S+_@#St);}%zN*

Probieren Sie es online! Verwendet Leerzeichen als "Loch" -Zeichen.

Wenn nachfolgendes Leerzeichen zulässig ist, funktioniert dies für 29 Bytes :

q32Se]{'[,65>A,s+S+_@#St}%zN*

Probieren Sie es online!

Hier ist eine 34-Byte-Variante, die █stattdessen Unicode full block ( ) verwendet:

q32Se]{'[,65>A,s+S+_@#'█t);}%zN*

Probieren Sie es online!

Erläuterung

q                                Input.
    e]                           Pad to a length of
 32                                32
                                 with
   S                               spaces.
      {                   }%     For each character:
                                   Get the uppercase alphabet by
            >                        dropping the first
          65                           65
                                     elements of
         ,                             the range of characters below
       '[                                '['.
                +                  Append
               s                     the string version
              ,                        of the range of numbers below
             A                           10.
                  +                Append
                 S                   a space.
                     #             Find the index of
                    @                the character.
                       t           Set this index to
                      S              a space
                   _               in the original array.
                        );         Drop the space at the end.
                                   Yield this modified array.
                                 End for. The result is an array of arrays of characters.
                            z    Transpose this array, turning rows into columns.
                             N*  Join the result on newlines.
— Esolanging Fruit
quelle
1

05AB1E , 19 Bytes

RтúR32£vžKuÙyð:})ø»

Probieren Sie es online!

Erläuterung

R                     # reverse
 тú                   # prepend 100 zeroes
   R                  # reverse
    32£        }      # take the first 32 characters
       v              # for each character
        žK            # push a string of [a-zA-Z0-9]
          uÙ          # upper case and remove duplicates
            yð:       # replace current character with space
                )ø    # transpose
                  »   # join by newline
— Emigna
quelle
a[b]funktioniert hier nicht so wie du es willst, oder: P?
— Magic Octopus Urn
@MagicOctopusUrn: Leider nicht. Das war auch mein erster Gedanke, aber die modulare Indizierung ist in diesem Fall nicht unser Freund: P
— Emigna
1

MATL , 21 Bytes

1Y24Y2vjO33(32:)y=~*c

Verwendet ein Leerzeichen als Markierungszeichen.

Probieren Sie es online!

Erläuterung

1Y2     % Push 'AB...YZ'
4Y2     % Push '01...89'
v       % Concatenate into a 36×1 column vector of chars
j       % Push unevaluated input: string of length n, or equivalently 1×n
        % row vector of chars
O33(    % Write 0 at position 33. This automatically writes a 0 at postions
        % n+1, n+2, ..., 32 too
32:)    % Keep only the first 32 entries: gives a 1×32 row vector
y       % Duplicate from below: pushes a copy of the 36 ×1 column vector
=~      % Test for non-equal entries, with broadcast. Gives a 33×32 matrix
        % containing 0 for matching entries, and 1 otherwise
*       % Multiply this matrix by the 1×32 row vector, with broadcast. This
        % changes each 1 into the corresponding character in the input
c       % Convert to char. Implicitly display. Char 0 is displayed as space
— Luis Mendo
quelle
1

Common Lisp , 150 Bytes

(setq s(format nil"~32a"(read-line)))(map nil(lambda(i)(map nil(lambda(j)(princ(if(eq i j)#\# i)))s)(princ"
"))"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")

Probieren Sie es online!

Erläuterung

;; pad input to 32 spaces on the right
(setq s(format nil"~32a"(read-line)))
;; for each character in bubble sheet, for each character in input:
;; if characters are equal print "#"
;; else print bubble sheet character
(map nil(lambda(i)(map nil(lambda(j)(princ(if(eq i j)#\# i)))s)(princ"
"))"ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789")
— Nur ASCII
quelle
1

Java 10, 120 118 117 Bytes

s->{var r="";for(char c=65,i;c<91&c!=58;r+="\n",c+=c<90?1:-42)for(i=0;i<32;i++)r+=i<s.length&&s[i]==c?35:c;return r;}

Probieren Sie es online aus (für TIO habe ich '█' verwendet) ( 9608anstelle von35 ) für eine bessere Sichtbarkeit verwendet).

Erläuterung:

s->{                   // Method with character-array parameter and String return-type
  var r="";            //  Result-String, starting empty
  for(char c=65,i;     //  Start character `c` at 'A'
      c<91&c!=58       //  Loop as long as `c` is 'Z' or smaller, and is not '9'
      ;                //    After every iteration:
       r+="\n",        //     Append a new-line to the result-String
       c+=c<90?        //     If `c` is not 'Z' yet
           1           //      Go to the next character ASCII-value-wise
          :            //     Else:
           -42)        //      Change the 'Z' to '0'
    for(i=0;i<32;i++)  //    Inner loop `i` in the range [0,32)
      r+=i<s.length    //     If we're not at the end of the input array yet,
         &&s[i]==c?    //     and the characters in the column and array are the same
          35           //      Append the filler-character '#'
         :             //     Else:
          c;           //      Append the current character instead
  return r;}           //  Return the result-String
— Kevin Cruijssen
quelle
1

Netzhaut , 64 Bytes

$
36* 
L`.{36}
.
36*@$&¶
Y`@`Ld
(.)(.*)\1
@$2
N$`\S
$.%`
L`.{32}

Probieren Sie es online!

$
36* 
L`.{36}

Füllt die Eingabezeichenfolge rechts mit Leerzeichen zu 36 Zeichen auf

.
36*@$&¶
Y`@`Ld

Setzen Sie dann jedes Zeichen in eine eigene Zeile und fügen Sie es ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789davor hinzu.

(.)(.*)\1
@$2

Ordnen Sie ein Paar desselben Zeichens in derselben Zeile zu, das es genau dann gibt, wenn das Zeichen für diese Zeile mit einem von übereinstimmt ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789. Ersetzen Sie das erste durch @und entfernen Sie das zweite.

N$`\S
$.%`

Die einzigen nicht übereinstimmenden Zeilen sind solche mit Leerzeichen, daher ist das Nicht-Leerzeichen ein 36 × 36-Quadratblock. Transponiere es.

L`.{32}

Behalten Sie nur die ersten 32 Zeichen in jeder Zeile

— TwiNight
quelle
1

Tcl , 153 145 Bytes

Danke @sergiol für -8 Bytes

lmap i [split ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ""] {puts [join [lmap j [split [format %-32s [join $argv ""]] ""] {expr {$i==$j?"#":$i}}] ""]}

Probieren Sie es online!

Erläuterung

# for i in list of choices
lmap i [split ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ""] {
    # print string of
    puts [join
        # list of
        [lmap j
             # for each character in first argument padded to 32 characters
             [split [format %-32s [join $argv ""]] ""]
             # return "#" if current choice and current character are equal, else current choice
             {expr {$i==$j?"#":$i}}
        ]
        ""
    ]
}
— Nur ASCII
quelle
152
— Sergiol
@sergiol: | ja ist es. 146 ?
— Nur ASCII
1
145
— Nur ASCII
1

SNOBOL4 (CSNOBOL4) , 155 bis 150 Byte

	I =INPUT
	U =&UCASE '0123456789'
N	U LEN(1) . K REM . U	:F(END)
	O =DUPL(K,32)
	X =
S	I LEN(X) @X K	:F(O)
	O POS(X) K =' '	:S(S)
O	OUTPUT =O	:(N)
END

Probieren Sie es online!

Erläuterung:

	I =INPUT			;* read input
	U =&UCASE '0123456789'		;* U = uppercase concat digits
N	U LEN(1) . K REM . U	:F(END)	;* while U not empty, pop first letter as K
	O =DUPL(K,32)			;* dup K 32 times
	X =				;* set position to 0
S	I LEN(X) @X K	:F(O)		;* find the next occurrence of K and save (index - 1) as X
	O POS(X) K =' '	:S(S)		;* replace the X'th occurrence of K with space. If that's before character 32, goto S, else proceed to next line
O	OUTPUT =O	:(N)		;* output the string and goto N
END
— Giuseppe
quelle
1

Prolog (SWI) , 235 229 228 222 214 198 173 167 165 Bytes

-6 Bytes dank @Cows quack , -6 Bytes dank @ 0 ' 

X*[H|T]:-(H=X->write(#);writef("%n",[X])),X*T;nl.
_+[].
X+[H|T]:-H*X,X+T.
?-read(X),swritef(Y,"%32l",[X]),string_codes(Y,Z),Z+`ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`.

Probieren Sie es online!

Erläuterung

% if head = bubble char, write "#", else write bubble char, then while tail is non-empty, recurse.
% if tail is empty then print newline
X*[H|T]:-(H=X->write(#);writef("%n",[X])),X*T;nl.
% if list is empty, then do nothing. this prevents t from being called with invalid X
_+[].
% call t, then recurse for each char in list
X+[H|T]:-H*X,X+T.
% read, pad input to 32 chars, and convert input to list
?-read(X),swritef(Y,"%32l",[X]),string_codes(Y,Z),Z+`ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789`.
— Nur ASCII
quelle
0

Oktave , 61 Bytes

@(s)[((a=[30:55 13:22]'*~~(o=1:32)).*(a+35~=[s o](o)))+35 '']

Probieren Sie es online!

Die Funktion funktioniert wie folgt:

@(s)[                                                     ''] %Anonymous function, taking string, outputting character array   
         [30:55 13:22]'                                       %Creates the board alphabet ('A':'Z' '0':'9']) but minus 35 (value of '#')
                       *~~(o=1:32)                            %Matrix multiplication by an array of 32 1's to form the 2D board. Saves 1:32 for later.
      (a=                         )                           %Saves the board mimus 32 to a for use later.
                                            [s o](o)          %Ensures the input is 32 characters long. Missing chars replaced by 1:32 (not in board)
                                     (a+35~=        )         %Compares against board (a+35 as a=board-35). Makes 2D array where matches = 0, others = 1. 
     (                             .*                )+35     %Element=wise multiplication, forcing matches to 0. Then add 35 resulting in board with #'s
— Tom Carpenter
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.