Completa mi hoja de burbujas

18

Hoy era el día de inscripción para el examen AP en mi escuela, y aunque estaba meticulosamente burbujeando en las páginas y páginas de información requeridas, la idea de este desafío me golpeó. Entonces, dada una cadena de letras y números, genera un gráfico de burbujas debidamente completado.

Reglas:

  • Para cada carácter en la cadena de entrada, reemplace ese carácter en la columna correspondiente con uno #o @cualquier otro símbolo razonable (si su idioma puede manejarlo, el carácter Unicode 'full_block': █ se ve muy bien)
  • Un espacio está representado por una columna en blanco (ver ejemplos)
  • La entrada válida será una cadena que se compone solo de letras mayúsculas, dígitos numéricos y espacios.
  • La entrada tendrá una longitud con un mínimo de 1 y un máximo de 32 caracteres.
  • La salida debe ser MAYÚSCULAS
  • Si la longitud de entrada es menor que la longitud máxima de 32, su programa aún debe generar las columnas en blanco restantes
  • Su programa no tiene que manejar la entrada en minúscula de la misma manera que si fuera mayúscula, sino puntos de bonificación si puede.

Formato de tablero:

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

Ejemplos:

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

Y, por supuesto, este es el código de golf , por lo que gana la respuesta más corta

code-golf ascii-art X1M4L
fuente
77
La validación de entrada generalmente se desaconseja, por lo que podría hacer que la entrada coincida [A-Z0-9]{1,32}y permitir cualquier comportamiento para las entradas que no coincidan.
Giuseppe
1
Qué ridículamente molesto es el hecho de que '0' viene antes que 'A' en el código ASCII> :( lol
NL628
"La entrada válida será una cadena que se compone de los caracteres que aparecen en la hoja de burbuja, así como los espacios", pero también debe indicar "Cualquier carácter que no sean las letras mayúsculas, espacios y dígitos numéricos, o más del límite de 32 caracteres debe ser ignorado " , ¿cuál es?
Kritixi Lithos
1
Pero de acuerdo con la primera declaración, usted dice que $no aparecerá en las entradas
Kritixi Lithos el
1
Ahora que eliminó los dígitos y los caracteres innalid de las especificaciones, es posible que también desee eliminarlos de los ejemplos.
Tito

Respuestas:

4

Casco , 23 bytes

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

¡Pruébelo en línea o inténtelo con el elegante personaje █ (pero un bytecount inválido)!

Lamentablemente, no pude fusionar los dos maps en uno (excepto con el uso de paréntesis, que cuesta 24 bytes).

Explicación

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

Ruby , 62 bytes

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

Pruébalo en línea!

Devuelve una matriz de cadenas. Podría jugar más golf descartando uniones de cadenas y devolviendo una matriz 2D de caracteres como suele ser la norma, pero no estoy seguro de si está permitido aquí.

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

Pruébalo en línea!

Gracias a Jonathan Frech por guardar 6 bytes.

LambdaBeta
fuente
puts("")es equivalente a putchar(10).
Jonathan Frech
++a)putchar((x[a-s]-*_)?*_:64);-> )putchar(x[a++-s]-*_?*_:64);.
Jonathan Frech
Si usted está dispuesto a doblar las reglas un poco, usted podría también campo 64a 1.
Jonathan Frech
Si lo hace, la putcharllamada podría ser respondida putchar(*_*(*_!=a[x-s]));.
Jonathan Frech
Normalmente estaría de acuerdo con doblar las reglas para eso ... pero 1 es una bestia muy diferente de un rectángulo relleno o un signo @. Sin embargo, los otros cambios son útiles: se actualizarán.
LambdaBeta
3

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

Pruébalo en línea!

Más legible:

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

Carbón , 21 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

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

Versión anterior con validación de entrada, 34 32 bytes. Editar: guardado 2 bytes gracias a @ ASCII-only.

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

Pruébalo en línea! El enlace es a la versión detallada del código.

Neil
fuente
: / parece que te falta un par cercano al final
solo ASCII
Esto parece que funciona. (Wolfram StringReplace) En una nota al margen, un reemplazo incorporado sería realmente útil
solo el
No importa, no sé lo que estaba haciendo. 27 bytes - no necesita elCast
solo ASCII
Además, re: el bloc con carácter arbitrario sobre el que preguntabas antes: ¿crees que sería lo suficientemente útil como para agregarlo como un builtin incorporado? o tal vez como una construcción de dos caracteres?
Solo ASCII
23
Solo ASCII
3

R , 104 bytes

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

Pruébalo en línea!

Giuseppe
fuente
3

Jalea ,  18  17 bytes

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

Utiliza un personaje espacial. Para usar un #reemplazo ⁶con ”#un costo de un byte.

Pruébalo en línea!

¿Cómo?

Ø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
fuente
Puedo guardar un byte.
Erik the Outgolfer
¡Bien, también obtuve ³Ḣ,⁶yØA;ØD¤µ32СZY18 años, lo que creo que también puede mejorarse! Sin embargo, salir ...
Jonathan Allan
Entonces, obviamente, ese no es el byte al que me refiero. :) Intenta más ...
Erik the Outgolfer
Increíble logré jugar golf en el móvil 17 bytes
Jonathan Allan
El mío fue en realidad esto , ¡pero felicidades!
Erik the Outgolfer
2

C ++ 14, 319 bytes 237

Esta es la primera vez que hago esto, en el peor lenguaje CodeGolf posible: 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';}}

Pruébalo en línea!

NL628
fuente
Pregunta: ¿Necesito incluir el encabezado?
NL628
Si es necesario para ejecutar el código, debe estar en su respuesta. Dicho esto, puedes eliminar casi todo el espacio en blanco y hacer que esta respuesta siga funcionando.
¿Podría reescribir esto como una función con parámetros, en lugar de main ()?
NL628
@ NL628 sí puedes. Consulte los consejos para jugar golf en C ++ para obtener más ayuda. EDITAR: enlace cambiado a C ++
Giuseppe
1
COBOL alguien? Nunca he escrito una línea de código en él, pero usar COBOL para golf de código podría ser un desafío interesante.
Hans-Martin Mosner
2

Nodo.js, 85 bytes

Port to Node.js sugerido por @DanielIndie

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

Pruébalo en línea!

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

Pruébalo en línea!

Arnauld
fuente
90 bytes ¿qué tal esto?
DanielIndie
@DanielIndie Gracias! Adicional. (Realmente no necesitamos esto +"", ¿ verdad ?)
Arnauld
Nunca sé si necesitamos convertir o no, así que no lo pienso: P pero sí, en realidad no lo necesitas :)
DanielIndie
@DanielIndie Ah, ahora solo podemos usar x/32para guardar 2 bytes más, ya que se Bufferestá convirtiendo en números enteros.
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 un enfoque mucho más agradable (y menos bytes), ¡vea la solución de Laikoni !

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

Pruébalo en línea!

Alternativamente para el mismo número de bytes, podríamos usar:

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

Pruébalo en línea!

Explicación / Ungolfed

El operador (#)es muy similar a, zipWithsin embargo, la función está codificada, st. usa #si dos caracteres son iguales y, de lo contrario, mantiene el segundo, sin golfizar:

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

Si la primera lista está agotada, solo agrega los elementos restantes de la segunda:

_ # w = w

Con ese ayudante solo necesitamos generar la cadena "A..Z0..9", replicar cada elemento 32 veces y comprimir la entrada con cada cadena, sin golf:

f x = map ((x#) . replicate 32) (['A'..'Z'] ++ ['0'..'9'])
ბიმო
fuente
1
85 bytes: ¡ Pruébelo en línea!
Laikoni
@Laikoni: Es una pena que sea solo 1 byte menos, este es un uso realmente inteligente de max. Creo que debe publicar eso como su propia solución, ya que es muy diferente de mi solución.
ბიმო
Publiqué una versión 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']]

Pruébalo en línea! Una cadena de entrada xse rellena con espacios hasta una longitud de 32 con take 32$x++cycle" ". Para cada carácter cde Aa Zy 0a 9, nos fijamos en los caracteres ade la cadena de entrada acolchado y reemplazarlas por ~cuando ay cson iguales y por clo contrario. Esto se logra mediante max[c]['~'|a==c], que es, por ejemplo , max "A" "~" = "~"cuándo a = c = 'A', y max "A" "" = "A"cuándo c = 'A'y a = 'B'. Como esto produce una cadena singleton en lugar de un carácter, dose utiliza la notación que concatena las cadenas singleton en una cadena.

Basado en la solución Haskell de BMO .

Laikoni
fuente
2

Python 2, 138 bytes

Admite caracteres en mayúsculas y minúsculas y deja una columna sin rellenar para espacios.

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

Si el bono no vale la pena, entonces usaré 125 bytes y solo admitiré entradas en mayú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
fuente
2

Stax , 15 bytes

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

Ejecutar y depurarlo

Se utiliza '#'para indicar una burbuja llena.

Desempaquetado, sin golf y comentado, se ve así.

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

Ejecute este

recursivo
fuente
1

Pyth, 23 20 bytes

j.Tm:s+r1GUTdN.[Qd32

Pruébalo aquí

Explicación

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.

fuente
1

APL + WIN, 56 bytes

Solicita una cadena de entrada y usa el carácter # como identificador:

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

Explicación:

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

Pruébalo en línea!

En lugar de una matriz codificada, la reemplacé con una función de búsqueda. Afortunadamente, el conjunto de caracteres ASCII tiene rangos contiguos alfabéticos y numéricos (¡te estoy mirando, EBCDIC!) Además, me aseguré de mantener la salida a exactamente 32 caracteres usando sprintf(): si este no era un requisito de la tarea, el la función sería de 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));}

Pruébalo en línea!

ErikF
fuente
106 bytes
ceilingcat
1

CJam , 31 bytes

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

Pruébalo en línea! Utiliza espacios como el carácter "agujero".

Si se permite el espacio en blanco al final, esto funciona para 29 bytes :

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

Pruébalo en línea!

Aquí hay una variación de 34 bytes que utiliza el bloque completo Unicode ( █) en su lugar:

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

Pruébalo en línea!

Explicación

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.
Fruta Esolanging
fuente
1

05AB1E , 19 bytes

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

Pruébalo en línea!

Explicación

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
fuente
a[b]no funciona como lo quieres aquí, ¿verdad: P?
Urna mágica de pulpo
@MagicOctopusUrn: Lamentablemente no. Ese fue mi primer pensamiento también, pero la indexación modular no es nuestra amiga en este caso: P
Emigna
1

MATL , 21 bytes

1Y24Y2vjO33(32:)y=~*c

Utiliza un espacio como marcador.

Pruébalo en línea!

Explicación

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

Lisp común , 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")

Pruébalo en línea!

Explicación

;; 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")
Solo ASCII
fuente
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;}

Pruébelo en línea (para TIO he usado '█' (en 9608lugar de 35) para una mejor visibilidad).

Explicación:

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

Retina , 64 bytes

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

Pruébalo en línea!

$
36* 
L`.{36}

Rellena la cadena de entrada a la derecha con espacios de 36 caracteres.

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

Luego, coloca cada carácter en su propia línea y agrega ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789antes.

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

Haga coincidir un par del mismo personaje en la misma línea, que hay uno si y solo si el personaje de esa línea coincide con uno de ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789. Reemplace el primero con @y retire el segundo.

N$`\S
$.%`

Las únicas líneas no coincidentes son las que tienen espacios, por lo que los caracteres no espaciales son un bloque cuadrado de 36 × 36. Transponerlo.

L`.{32}

Solo mantenga los primeros 32 caracteres en cada línea

TwiNight
fuente
1

Tcl , 153145 bytes

Gracias @sergiol por -8 bytes

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

Pruébalo en línea!

Explicación

# 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}}
        ]
        ""
    ]
}
Solo ASCII
fuente
152
sergiol
@sergiol: | sí lo es. 146 ?
Solo ASCII
1
145
Solo 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

Pruébalo en línea!

Explicación:

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

Prólogo (SWI) , 235 229 228 222 214 198 173 167 165 bytes

-6 bytes gracias a @Cows quack , -6 bytes gracias 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`.

Pruébalo en línea!

Explicación

% 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`.
Solo ASCII
fuente
0

Octava , 61 bytes

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

Pruébalo en línea!

La función funciona de la siguiente manera:

@(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
fuente