Preencha minha folha de bolhas

18

Hoje era o dia de inscrição para o exame de AP na minha escola e, enquanto eu estava meticulosamente borbulhando nas páginas e nas informações necessárias, a idéia para esse desafio me atingiu. Assim, dada uma sequência de letras e números, produza um gráfico de bolhas devidamente preenchido.

Regras:

  • Para cada caractere na sequência de entrada, substitua esse caractere na coluna correspondente por um #ou @outro símbolo razoável (se o seu idioma puder lidar com isso, o caractere Unicode 'full_block': █ parece realmente bom)
  • Um espaço é representado por uma coluna em branco (veja exemplos)
  • A entrada válida será uma string composta apenas de letras maiúsculas, dígitos numéricos e espaços.
  • A entrada terá um comprimento mínimo de 1 e máximo de 32 caracteres.
  • A saída deve estar em MAIÚSCULAS
  • Se o comprimento da entrada for menor que o comprimento máximo de 32, seu programa ainda deverá gerar as colunas em branco restantes
  • Seu programa não precisa manipular as entradas em minúsculas da mesma forma que as maiúsculas, mas pontos de bônus, se puder.

Formato da placa:

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

Exemplos:

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, claro, isso é código-golfe , então a resposta mais curta ganha

code-golf  ascii-art 
— X1M4L
fonte
7
A validação de entrada geralmente é desencorajada, portanto, você pode apenas ter a correspondência de entrada [A-Z0-9]{1,32}e permitir qualquer comportamento para entradas que não correspondam a isso.
— Giuseppe
1
Quão ridiculamente irritante é o fato de que '0' vem antes de 'A' no código ASCII> :( lol
— NL628
"A entrada válida será uma string composta pelos caracteres que aparecem na folha de bolhas e também pelos espaços", mas você também declara "Qualquer caractere que não seja as letras maiúsculas, espaços e dígitos numéricos ou acima do limite de 32 caracteres deve ser ignorado " , então qual é?
— Kritixi Lithos
1
Mas de acordo com a primeira afirmação, você diz que $não aparecerá em entradas
— Kritixi Lithos
1
Agora que você removeu dígitos e caracteres inválidos das especificações, também poderá removê-los dos exemplos.
— Titus

Respostas:

4

Casca , 23 bytes

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

Experimente on-line ou tente com o caractere chique (mas um número inválido de conta)!

Infelizmente não consegui mesclar os dois maps em um (exceto com o uso de parênteses, custando 24 bytes) ..

Explicação

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

Ruby , 62 bytes

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

Experimente online!

Retorna uma matriz de strings. Poderia ser jogado mais longe descartando junções de string e retornando uma matriz 2D de caracteres, como geralmente é a norma, mas não tenho certeza se é permitido aqui.

— Kirill L.
fonte
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);}

Experimente online!

Agradecimentos a Jonathan Frech por salvar 6 bytes.

— LambdaBeta
fonte
puts("")é equivalente a putchar(10).
— 22818 Jonathan Frech
++a)putchar((x[a-s]-*_)?*_:64);-> )putchar(x[a++-s]-*_?*_:64);.
— 22818 Jonathan Frech
Se você está disposto a dobrar as regras um pouco, você também poderia golf 64para 1.
— Jonathan Frech
Se o fizer, a putcharchamada pode ser direcionada para putchar(*_*(*_!=a[x-s]));.
— 22818 Jonathan Frech
Normalmente, eu aceitaria flexionar as regras para isso ... mas 1 é uma fera muito diferente de um retângulo preenchido ou um sinal @. As outras alterações são úteis - serão atualizadas.
— LambdaBeta
3

Vermelho , 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]

Experimente online!

Mais legível:

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

Carvão , 21 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

Versão anterior com validação de entrada, 34 32 bytes. Editar: salvou 2 bytes graças a @ ASCII-only.

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

Experimente online! Link é a versão detalhada do código.

— Neil
fonte
: / Você parece estar faltando um parêntese fechar no final
— ASCII-only
Este parece que funciona. (Wolfram StringReplace) Em uma nota lateral, a substituir builtin seria realmente útil para a direita
— ASCII-only
Não importa, eu não sei o que estava fazendo. 27 bytes - você não precisa doCast
— ASCII-only
Além disso, re: o bloco com caráter arbitrário sobre o qual você estava perguntando antes: você acha que isso seria útil o suficiente para adicionar como um builtin? ou talvez como um builtin de dois caracteres?
— somente ASCII
23
— somente ASCII
3

Geléia ,  18  17 bytes

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

Usa um caractere de espaço. Para usar um #substituir ⁶com ”#um custo de um byte.

Experimente online!

Quão?

Ø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
Eu posso salvar um byte.
— Erik the Outgolfer
Welp, também cheguei ³Ḣ,⁶yØA;ØD¤µ32СZYaos 18 anos e acho que também pode ser improvável! Sair embora ...
— Jonathan Allan #
Então, obviamente, não é esse o byte ao qual estou me referindo. :) Tente mais ...
— Erik the Outgolfer
Incrível eu consegui golfe no celular 17 bytes
— Jonathan Allan
O meu era realmente isso , mas parabéns!
— Erik the Outgolfer
2

C ++ 14, 319 bytes 237

Esta é a primeira vez que faço isso, na pior linguagem possível do 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';}}

Experimente Online!

— NL628
fonte
Pergunta: Preciso incluir o cabeçalho?
— NL628
Se for necessário executar o código, ele deverá estar na sua resposta. Dito isto, você pode remover praticamente todo o espaço em branco e ter essa resposta ainda funcionando.
Eu poderia reescrever isso como uma função com parâmetros, em vez de um main ()?
— NL628 20/0418
@ NL628 sim, você pode. Veja dicas para jogar golfe em C ++ para obter mais ajuda. Edição: link comutado para C ++
— Giuseppe
1
COBOL alguém? Eu nunca escrevi uma linha de código nela, mas usar COBOL para código de golfe pode ser um desafio interessante.
— Hans-Martin Mosner
2

Node.js, 85 bytes

Port to Node.js sugerida por @DanielIndie

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

Experimente online!

JavaScript (ES6), 103 98 bytes

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

Experimente online!

— Arnauld
fonte
90 bytes e quanto a isso?
— precisa saber é o seguinte
@DanielIndie Thanks! Adicionado. (Nós realmente não precisa disso +"", não é?)
— Arnauld
Eu nunca sei se precisamos converter ou não, então eu não penso sobre isso: P, mas sim, você não realmente precisa dele :)
— DanielIndie
@DanielIndie Ah, agora podemos usar apenas x/32para salvar mais 2 bytes, uma vez que Bufferé obrigatório para números inteiros.
— 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 bytes

Para uma abordagem muito mais agradável (e menos bytes), consulte a solução da Laikoni !

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

Experimente online!

Como alternativa, para a mesma contagem de bytes, poderíamos usar:

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

Experimente online!

Explicação / Ungolfed

O operador (#)é muito parecido com zipWitho de que a função está codificada permanentemente, st. ele usa #se dois caracteres são iguais e, caso contrário, mantém o segundo, não-destruído:

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

Se a primeira lista estiver esgotada, basta adicionar os elementos restantes da segunda:

_ # w = w

Com esse auxiliar, precisamos gerar apenas a string "A..Z0..9", replicar cada elemento 32 vezes e compactar a entrada com cada string, sem o uso de luvas:

f x = map ((x#) . replicate 32) (['A'..'Z'] ++ ['0'..'9'])
— ბიმო
fonte
1
— Laikoni
@Laikoni: Pena que seja apenas 1 byte a menos, este é um uso realmente inteligente de max. Eu acho que você deve postar isso como sua própria solução, pois é muito diferente da minha solução.
— ბიმო
Eu publiquei uma versão de 74 bytes .
— Laikoni
2

Haskell , 74 bytes

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

Experimente online! Uma cadeia de entrada xé preenchida com espaços com um comprimento de 32 com take 32$x++cycle" ". Para cada caractere cde Apara Ze 0para 9, examinamos os caracteres ada cadeia de entrada preenchida e os substituímos por ~quando ae csão iguais e por coutros. Isso é alcançado por max[c]['~'|a==c], que é, por exemplo , max "A" "~" = "~"quando a = c = 'A', e max "A" "" = "A"quando c = 'A'e a = 'B'. Como isso gera uma sequência singleton em vez de um caractere, doé usada a notação que concatena as seqüências singleton em uma sequência.

Baseado na solução Haskell da BMO .

— Laikoni
fonte
2

Python 2, 138 bytes

Suporta caracteres maiúsculos e minúsculos e deixa uma coluna não preenchida para espaços.

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 o bônus não valer a pena, eu irei para 125 bytes e suportarei apenas entradas em maiúsculas:

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 bytes

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

Execute e depure

Utilizado '#'para indicar uma bolha cheia.

Descompactado, não jogado e comentado, parece com isso.

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

Execute este

— recursivo
fonte
1

Pitão, 23 20 bytes

j.Tm:s+r1GUTdN.[Qd32

Experimente aqui

Explicação

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

Solicita a sequência de entrada e usa o caractere # como identificador:

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

Explicação:

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

Experimente online!

Em vez de uma matriz codificada, substituí-a por uma função de pesquisa. Felizmente, o conjunto de caracteres ASCII tem intervalos alfabéticos e numéricos contíguos (estou olhando para você, EBCDIC!) Além disso, certifiquei-me de manter a saída com exatamente 32 caracteres usando sprintf(): se isso não fosse um requisito da tarefa, o A função seria 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));}

Experimente online!

— ErikF
fonte
— ceilingcat
1

CJam , 31 bytes

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

Experimente online! Usa espaços como o caractere "buraco".

Se o espaço em branco à direita for permitido, isso funcionará para 29 bytes :

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

Experimente online!

Aqui está uma variação de 34 bytes que usa o bloco completo Unicode ( █):

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

Experimente online!

Explicação

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 bytes

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

Experimente online!

Explicação

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]não funciona como você deseja aqui, funciona: P?
— Urna Mágica do Polvo
@MagicOctopusUrn: Infelizmente não. Esse foi o meu primeiro pensamento também, mas indexação modular não é nosso amigo, neste caso: P
— Emigna
1

MATL , 21 bytes

1Y24Y2vjO33(32:)y=~*c

Usa um espaço como caractere marcador.

Experimente online!

Explicação

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 comum , 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")

Experimente online!

Explicação

;; 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")
— Somente ASCII
fonte
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;}

Experimente on-line (para o TIO, usei '█' (em 9608vez de 35) para obter melhor visibilidade).

Explicação:

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 bytes

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

Experimente online!

$
36* 
L`.{36}

Protege a sequência de entradas à direita com espaços para 36 caracteres

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

Em seguida, coloque cada caractere em sua própria linha e adicione ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789antes dele.

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

Combine um par do mesmo caractere na mesma linha, que existe se e somente se o caractere para essa linha corresponder a um dos ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789. Substitua o primeiro por @e remova o segundo.

N$`\S
$.%`

As únicas linhas não correspondentes são aquelas com espaços, portanto, os caracteres não espaciais são um bloco quadrado de 36 × 36. Transponha.

L`.{32}

Mantenha apenas os 32 primeiros caracteres em cada linha

— TwiNight
fonte
1

Tcl , 153 145 bytes

Obrigado @sergiol por -8 bytes

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

Experimente online!

Explicação

# 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}}
        ]
        ""
    ]
}
— Somente ASCII
fonte
152
— sergiol
@sergiol: | Sim, ele é. 146 ?
— somente ASCII
1
145
— somente ASCII
1

SNOBOL4 (CSNOBOL4) , 155 150 bytes

	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

Experimente online!

Explicação:

	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 bytes

-6 bytes graças a @Vaca quack , -6 bytes graças 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`.

Experimente online!

Explicação

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

Oitava , 61 bytes

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

Experimente online!

A função funciona da seguinte maneira:

@(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
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.