Compila il mio foglio di bolle

18

Oggi è stato il giorno della registrazione all'esame AP nella mia scuola e mentre stavo meticolosamente gorgogliando le pagine e le pagine di informazioni richieste, l'idea per questa sfida mi ha colpito. Quindi, data una serie di lettere e numeri, genera un grafico a bolle opportunamente compilato.

Regole:

  • Per ogni carattere nella stringa di input, sostituisci quel carattere nella colonna corrispondente con uno #o @qualsiasi altro simbolo ragionevole (se la tua lingua può gestirlo, il carattere Unicode 'full_block': █ sembra davvero buono)
  • Uno spazio è rappresentato da una colonna vuota (vedi esempi)
  • L'input valido sarà una stringa composta solo da lettere maiuscole, cifre numeriche e spazi.
  • L'input avrà una lunghezza con un minimo di 1 e un massimo di 32 caratteri.
  • L'output deve essere MAIUSCOLO
  • Se la lunghezza di input è inferiore alla lunghezza massima di 32, il programma deve comunque generare le colonne vuote rimanenti
  • Il tuo programma non deve gestire l'input in minuscolo come se fosse in maiuscolo, ma se lo può fare punti bonus.

Formato scheda:

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

Esempi:

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

E, naturalmente, si tratta di code-golf , quindi vince la risposta più breve

code-golf  ascii-art 
— X1M4L
fonte
7
La convalida dell'input è generalmente sconsigliata, quindi potresti semplicemente avere la corrispondenza dell'input [A-Z0-9]{1,32}e consentire qualsiasi comportamento per gli input che non corrispondono.
— Giuseppe,
1
Quanto è ridicolmente fastidioso il fatto che '0'
— preceda
"L'input valido sarà una stringa composta dai caratteri che compaiono sul foglio a bolle e dagli spazi" ma si indica anche "Qualsiasi carattere diverso dalle lettere maiuscole, dagli spazi e dalle cifre numeriche o oltre il limite di 32 caratteri dovrebbe essere ignorato " , quindi quale è?
— Kritixi Lithos,
1
Ma secondo la prima affermazione, dici che $non apparirà negli input
— Kritixi Lithos
1
Ora che hai rimosso cifre e caratteri non analitici dalle specifiche, potresti anche rimuoverli dagli esempi.
— Tito

Risposte:

4

Buccia , 23 byte

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

Provalo online o provalo con il personaggio di fantasia ((ma un numero di byte non valido)!

Sfortunatamente non sono stato in grado di unire le due maps in una (tranne con l'uso di parentesi, che costano 24 byte) ..

Spiegazione

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"]
— ბიმო
fonte
4

Rubino , 62 byte

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

Provalo online!

Restituisce una matrice di stringhe. Potrebbe essere ulteriormente migliorato scartando i join di stringhe e restituendo una matrice 2D di caratteri come di solito è la norma, ma non sono sicuro che sia consentito qui.

— Kirill L.
fonte
3

C (gcc) , 132 126 byte

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

Provalo online!

Grazie a Jonathan Frech per aver salvato 6 byte.

— LambdaBeta
fonte
puts("")è equivalente a putchar(10).
— Jonathan Frech,
++a)putchar((x[a-s]-*_)?*_:64);-> )putchar(x[a++-s]-*_?*_:64);.
— Jonathan Frech,
Se sei disposto a piegare un po 'le regole, puoi anche giocare 64a golf 1.
— Jonathan Frech,
In tal caso, è putcharpossibile eseguire il golf della chiamata putchar(*_*(*_!=a[x-s]));.
— Jonathan Frech,
Normalmente starei bene a piegare le regole per quello ... ma 1 è una bestia molto diversa da un rettangolo pieno o un segno @. Le altre modifiche sono comunque utili: verranno aggiornate.
— LambdaBeta,
3

Rosso , 177 byte

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]

Provalo online!

Più leggibile:

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
fonte
3

Carbone , 21 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

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

Versione precedente con convalida dell'input, 34 32 byte. Modifica: salvato 2 byte grazie solo a @ ASCII.

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

Provalo online! Il collegamento è alla versione dettagliata del codice.

— Neil
fonte
: / sembra che manchi un paren vicino alla fine
— solo ASCII il
Questo appare come funziona. (Wolfram StringReplace) In una nota a margine, un built-in sostitutivo sarebbe davvero utile a destra
— solo ASCII
Non importa, non so cosa stavo facendo. 27 byte - non è necessarioCast
— solo ASCII il
Inoltre, ri: il pad con carattere arbitrario di cui ti stavi chiedendo prima: pensi che sarebbe abbastanza utile da aggiungere come incorporato? o forse come un built-in a due caratteri?
— ASCII il
23
— ASCII il
3

R , 104 byte

function(S,o=""){for(i in 1:32)o=paste0(o,`[<-`(x<-c(LETTERS,1:9),x==substr(S,i,i),"@"))
cat(o,sep="
")}

Provalo online!

— Giuseppe
fonte
3

Gelatina ,  18  17 byte

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

Usa un personaggio spaziale. Per utilizzare una #sostituzione ⁶con ”#per un costo di un byte.

Provalo online!

Come?

Ø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
fonte
Posso salvare un byte.
— Erik the Outgolfer,
Welp, ho anche avuto ³Ḣ,⁶yØA;ØD¤µ32СZY18 anni, che ritengo possa essere anche migliorabile! Uscire però ...
— Jonathan Allan il
Quindi, ovviamente, non è questo il byte a cui mi riferisco. :) Prova di più ...
— Erik the Outgolfer,
Incredibile sono riuscito a giocare a golf su 17 byte
— Jonathan Allan,
Il mio era in realtà questo , ma complimenti!
— Erik the Outgolfer,
2

C ++ 14, 319 byte 237

Questa è la prima volta che lo faccio, nel peggior linguaggio possibile CodeGolf: 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';}}

Provalo online!

— NL628
fonte
Domanda: devo includere l'intestazione?
— NL628,
Se è necessario per eseguire il codice, deve essere nella tua risposta. Detto questo, puoi rimuovere praticamente tutto lo spazio bianco e avere questa risposta ancora funzionante.
Potrei riscriverlo come una funzione con parametri, anziché come main ()?
— NL628,
@ NL628 sì, puoi. Consulta i suggerimenti per giocare a golf in C ++ per ulteriori informazioni. EDIT: collegamento commutato a C ++
— Giuseppe
1
COBOL qualcuno? Non ho mai scritto una riga di codice, ma usare COBOL per il golf del codice potrebbe essere una sfida interessante.
— Hans-Martin Mosner,
2

Node.js, 85 byte

Porta su Node.js suggerito da @DanielIndie

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

Provalo 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):''

Provalo online!

— Arnauld
fonte
90 byte che ne dici di questo?
— DanielIndie,
@DanielIndie Grazie! Aggiunto. (Non ne abbiamo davvero bisogno +"", vero?)
— Arnauld
Non so mai se dobbiamo convertirci o no, quindi non ci penso: P, ma sì, in realtà non ne hai bisogno :)
— DanielIndie
@DanielIndie Ah, ora possiamo semplicemente usare x/32per salvare altri 2 byte, dato che Bufferè forzato a numeri interi.
— Arnauld,
f=(s,x=561,c=Buffer([48+x/33%43]))=>x<1749?(s[x++%33]==c?'@':x%33?c:`\n`)+f(s,x):''
— l4m2
2

Haskell , 86 byte

Per un approccio molto più piacevole (e meno byte), vedi la soluzione di Laikoni !

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

Provalo online!

In alternativa per lo stesso numero di byte potremmo usare:

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

Provalo online!

Spiegazione / Non golf

L'operatore (#) è molto simile, zipWithtuttavia la funzione è hardcoded, st. usa #se due caratteri sono uguali e altrimenti mantiene il secondo, non golfato:

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

Se il primo elenco è esaurito, aggiunge solo gli elementi rimanenti del secondo:

_ # w = w

Con quell'helper abbiamo solo bisogno di generare la stringa "A..Z0..9", replicare ogni elemento 32 volte e comprimere l'input con ogni stringa, non convertito:

f x = map ((x#) . replicate 32) (['A'..'Z'] ++ ['0'..'9'])
— ბიმო
fonte
1
— Laikoni,
@Laikoni: Peccato che sia solo 1 byte in meno, questo è un uso davvero intelligente di max. Penso che dovresti pubblicarlo come soluzione personale poiché è molto diverso dalla mia soluzione.
— ბიმო
Ho pubblicato una versione da 74 byte .
— Laikoni,
2

Haskell , 74 byte

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

Provalo online! Una stringa di input xè riempita con spazi per una lunghezza di 32 con take 32$x++cycle" ". Per ogni carattere cda Aa Ze 0a 9, osserviamo i caratteri adalla stringa di input imbottita e li sostituiamo con ~quando ae csono uguali e caltrimenti. Ciò si ottiene max[c]['~'|a==c], ad esempio max "A" "~" = "~"quando a = c = 'A', max "A" "" = "A"quando c = 'A'e quando a = 'B'. Poiché ciò produce una stringa singleton anziché un carattere, doviene utilizzata la notazione che concatena le stringhe singleton in una stringa.

Basato sulla soluzione Haskell di BMO .

— Laikoni
fonte
2

Python 2, 138 byte

Supporta caratteri maiuscoli e minuscoli e lascia una colonna vuota per gli spazi.

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

Se il bonus non ne vale la pena, allora vado per 125 byte e supporterò solo input maiuscoli:

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
fonte
2

Stax , 15 byte

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

Esegui ed esegui il debug

Usa '#'per indicare una bolla piena.

Disimballato, non golfato e commentato, sembra così.

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

Esegui questo

— ricorsivo
fonte
1

Pyth, 23 20 byte

j.Tm:s+r1GUTdN.[Qd32

Provalo qui

Spiegazione

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 byte

Richiede la stringa di input e utilizza il carattere # come identificatore:

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

Spiegazione:

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
fonte
1

C (gcc) , 124 byte

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

Provalo online!

Invece di un array hardcoded, l'ho sostituito con una funzione di ricerca. Fortunatamente il set di caratteri ASCII ha intervalli alfabetici e numerici contigui (ti sto guardando, EBCDIC!) Inoltre, mi sono assicurato di mantenere l'output a esattamente 32 caratteri usando sprintf(): se questo non era un requisito dell'attività, il la funzione sarebbe 97 byte:

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

Provalo online!

— ErikF
fonte
— ceilingcat il
1

CJam , 31 byte

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

Provalo online! Utilizza gli spazi come carattere "buco".

Se è consentito lo spazio bianco finale, questo funziona per 29 byte :

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

Provalo online!

Ecco una variazione di 34 byte che utilizza invece il blocco completo Unicode ( █):

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

Provalo online!

Spiegazione

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
fonte
1

05AB1E , 19 byte

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

Provalo online!

Spiegazione

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
fonte
a[b]non funziona come lo vuoi qui, fa: P?
— Magic Octopus Urn
@MagicOctopusUrn: Sfortunatamente no. Anche questo è stato il mio primo pensiero, ma l'indicizzazione modulare non è nostra amica in questo caso: P
— Emigna,
1

MATL , 21 byte

1Y24Y2vjO33(32:)y=~*c

Utilizza uno spazio come carattere marcatore.

Provalo online!

Spiegazione

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
fonte
1

Lisp comune , 150 byte

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

Provalo online!

Spiegazione

;; 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")
— ASCII-only
fonte
1

Java 10, 120 118 117 byte

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

Provalo online (per TIO ho usato '█' ( 9608invece di35 ) per una migliore visibilità).

Spiegazione:

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
fonte
1

Retina , 64 byte

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

Provalo online!

$
36* 
L`.{36}

Riempie la stringa di input a destra con spazi di 36 caratteri

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

Quindi, metti ogni personaggio sulla sua linea e aggiungi ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789prima di esso.

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

Abbina una coppia dello stesso personaggio sulla stessa linea, di cui esiste uno se e solo se il carattere per quella linea corrisponde a uno dei ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789. Sostituisci il primo con @e rimuovi il secondo.

N$`\S
$.%`

Le uniche linee senza eguali sono quelle con spazi, quindi i caratteri non spaziali sono un blocco quadrato 36 × 36. Trasponilo.

L`.{32}

Mantieni solo i primi 32 caratteri in ogni riga

— TwiNight
fonte
1

Tcl , 153 145 byte

Grazie @sergiol per -8 byte

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

Provalo online!

Spiegazione

# 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}}
        ]
        ""
    ]
}
— ASCII-only
fonte
152
— sergiol,
@sergiol: | sì. 146 ?
— ASCII
1
145
— ASCII
1

SNOBOL4 (CSNOBOL4) , 155 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

Provalo online!

Spiegazione:

	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
fonte
1

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

-6 byte grazie al ciarlatano di @Cows , -6 byte grazie a @ 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`.

Provalo online!

Spiegazione

% 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`.
— ASCII-only
fonte
0

Ottava , 61 byte

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

Provalo online!

La funzione funziona come segue:

@(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
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.