He diseñado una nueva fuente que llamo PrettyFont. He dedicado mucho tiempo a perfeccionarlo, pero como soy un hombre trabajador no tengo tiempo para terminarlo. Por lo tanto, solo contiene 4 caracteres en este momento. Un día, cuando me haya hecho rico, se convertirá en mi objetivo de toda la vida terminarlo, pero por ahora ...

Esto es PrettyFont: (0, 1, 2, 3)

####  ##  #### ####
#  #   #  #  #    #
#  #   #    #   ###
#  #   #   #      #
####  ### #### ####

Cada personaje tiene 4 píxeles de ancho y 5 píxeles de alto. ¡Ahora! Quiero que me escriba un programa que genere un número en PrettyFont para que pueda comenzar a enviar diseños para imprimir.

Reglas:

La entrada es un número de cadena en la base 4 (solo caracteres 0-3), por ejemplo "01321". El programa debería poder manejar al menos 10 caracteres en la cadena. Se otorgan puntos de BONIFICACIÓN al programa que toma un entero de base 10 real en lugar de una cadena. EDITAR aclaración: la bonificación de enteros significa que uno puede ingresar cualquier número de base 10, como 54321, y el programa lo convertirá a base 4 y lo generará (en este caso 31100301).

La salida será el número impreso con PrettyFont. Ejemplo de entrada y salida:

> "321"
####
   #
 ###
   #
####

####
#  #
  # 
 #  
####

 ## 
  # 
  # 
  # 
 ###

Gran ventaja para el programa que puede generarlo en una sola fila de esta manera:

> "321"
#### ####  ## 
   # #  #   # 
 ###   #    # 
   #  #     # 
#### ####  ### 

El carácter '#' no es un requisito y puede reemplazarse por cualquier carácter.

En la salida vertical, se requiere una fila vacía entre cada personaje PrettyFont. Si alguien realiza la salida horizontal, se requiere un carácter de espacio en blanco '' o un carácter de tabulación entre cada carácter PrettyFont.

Este es el código de golf, ¡el código más corto gana! (Lo necesito corto porque la computadora de mi oficina tiene un almacenamiento limitado).

k ( 118117 72 71 69 66 caracteres)

Todavía no he hecho un gran esfuerzo para jugar al golf, pero logra el rendimiento horizontal deseado en no demasiados caracteres:

-1'" "/:'+(5 4#/:4 20#"# "@,/0b\:'0x066609ddd806db00e8e0)"I"$'0:0;

Toma la entrada de stdin, imprime la salida a stdout.

editar: Al implementar una forma de compresión en el "mapa de bits" de salida, lo reduje a 72. El mapa de bits ahora se construye convirtiendo ints de 64 bits en binario y asignando los 0 y 1 a "#" o "". Podría hacerlo desde hexadecimal como algunas de las otras soluciones, pero creo que esto terminaría por más tiempo . Resulta que el hex es mejor.

Salida de muestra para 012301:

####  ##  #### #### ####  ##
#  #   #  #  #    # #  #   #
#  #   #    #   ### #  #   #
#  #   #   #      # #  #   #
####  ### #### #### ####  ###

// editar: -6 caracteres

Python3 (124)

s=input();[print(*["".join(" #"[0xf171ff429f72226f999f>>(20*int(x)+4*y+i)&1]for i in(3,2,1,0))for x in s])for y in range(5)]

Lo siento, vertical no fue interesante para mí.

???/golf.py
1230012301203012030102301230
 ##  #### #### #### ####  ##  #### #### ####  ##  #### #### #### ####  ##  #### #### #### ####  ##  #### #### #### ####  ##  #### #### ####
  #  #  #    # #  # #  #   #  #  #    # #  #   #  #  # #  #    # #  #   #  #  # #  #    # #  #   #  #  # #  #    # #  #   #  #  #    # #  #
  #    #   ### #  # #  #   #    #   ### #  #   #    #  #  #  ### #  #   #    #  #  #  ### #  #   #  #  #   #   ### #  #   #    #   ### #  #
  #   #      # #  # #  #   #   #      # #  #   #   #   #  #    # #  #   #   #   #  #    # #  #   #  #  #  #      # #  #   #   #      # #  #
 ### #### #### #### ####  ### #### #### ####  ### #### #### #### ####  ### #### #### #### ####  ### #### #### #### ####  ### #### #### ####

J, 84 82 81 80 75 69 caracteres

' #'{~(,4,.(4*".,' ',.1!:1[1)+/i.4){"1#:63231 37521 37415 37441 63487

Toma entrada del teclado:

   ' #'{~(,4,.(4*".,' ',.1!:1[1)+/i.4){"1#:63231 37521 37415 37441 63487 63487
0123210
 ####  ##  #### #### ####  ##  ####
 #  #   #  #  #    # #  #   #  #  #
 #  #   #    #   ###   #    #  #  #
 #  #   #   #      #  #     #  #  #
 ####  ### #### #### ####  ### ####

Números mágicos FTW (o para el segundo lugar en este caso) :-)

C - 164151 caracteres horizontales

En IDEone: http://ideone.com/gljc3

El código (164 bytes):

i,j;main(){char n[99];gets(n);for(;j<5;++j){for(i=0;n[i];++i)printf("%.4s ","#####  # ##   #  ### #     #"+4*("01110233340135006460"[(n[i]-48)*5+j]-48));puts("");}}

EDITAR - 151 bytes

Agregué las sugerencias de los comentarios y algo más. Sin gets()embargo, no es exactamente seguro (matriz de longitud 0 en la que estoy ...).

char i,j=5,n[];main(){for(gets(n);j--;)for(i=puts("");n[i];printf("%.4s ","#####  # ##   #  ### #     #"+4*(0x1A600BA136E0248>>15*n[i++]-720+3*j&7)));}

Nota, i=puts("")es un comportamiento indefinido ya que estoy tratando voidcomo int! Siempre regresa 0en mi versión de MinGW, pero regresa 1en el compilador que IDEOne usa.

Acepta decimal, emite base 4 (167 bytes)

char i,j=5,n[];main(p){for(itoa(atoi(gets(n)),n,4);j--;)for(i=puts("");n[i];printf("%.4s ","#####  # ##   #  ### #     #"+4*(0x1A600BA136E0248>>15*n[i++]-720+3*j&7)));}

Ruby, 0123 caracteres + una bonificación ([0123] vs '#')

f=15
0.upto(4){|n|$*[0].chars{|x|$><<"%4s "%eval(:f6ff929192279241f7ff[x.to_i+4*n]).to_i.to_s(2).tr(?0,' ').tr(?1,x)}
puts}

Ejemplo:

% ruby ./font.rb 01231231
0000  11  2222 3333  11  2222 3333  11  
0  0   1  2  2    3   1  2  2    3   1  
0  0   1    2   333   1    2   333   1  
0  0   1   2      3   1   2      3   1  
0000  111 2222 3333  111 2222 3333  111
% ruby ./font.rb 01231231102020103201301203212302230
0000  11  2222 3333  11  2222 3333  11   11  0000 2222 0000 2222 0000  11  0000 3333 2222 0000  11  3333 0000  11  2222 0000 3333 2222  11  2222 3333 0000 2222 2222 3333 0000 
0  0   1  2  2    3   1  2  2    3   1    1  0  0 2  2 0  0 2  2 0  0   1  0  0    3 2  2 0  0   1     3 0  0   1  2  2 0  0    3 2  2   1  2  2    3 0  0 2  2 2  2    3 0  0 
0  0   1    2   333   1    2   333   1    1  0  0   2  0  0   2  0  0   1  0  0  333   2  0  0   1   333 0  0   1    2  0  0  333   2    1    2   333 0  0   2    2   333 0  0 
0  0   1   2      3   1   2      3   1    1  0  0  2   0  0  2   0  0   1  0  0    3  2   0  0   1     3 0  0   1   2   0  0    3  2     1   2      3 0  0  2    2      3 0  0 
0000  111 2222 3333  111 2222 3333  111  111 0000 2222 0000 2222 0000  111 0000 3333 2222 0000  111 3333 0000  111 2222 0000 3333 2222  111 2222 3333 0000 2222 2222 3333 0000 

EDITAR: Ruby, 87 caracteres

0.upto(4){|n|$*[0].bytes{|x|$><<"%04b0"%:f6ff929192279241f7ff[x-48+4*n].to_i(16)}
puts}

Rubí

Vertical: 116 caracteres

f="f999f62227f924ff171f".chars.map{|c|c.hex.to_s(2).rjust(4).tr"01"," #"}
$<.chars{|c|i=c.to_i*5;$><<f[i,5]*$/+$/*2}

Ejecución de muestra:

bash-4.2$ echo -n 321 | ruby -e 'f="f999f62227f924ff171f".chars.map{|c|c.hex.to_s(2).rjust(4).tr"01"," #"};$<.chars{|c|i=c.to_i*5;$><<f[i,5]*$/+$/*2}'
####
   #
 ###
   #
####

####
#  #
  # 
 #  
####

 ## 
  # 
  # 
  # 
 ###

Horizontal: 150 148 caracteres

f="f999f62227f924ff171f".chars.map{|c|c.hex.to_s(2).rjust(4).tr"01"," #"}
o=(0..4).map{""}
$<.chars{|c|5.times{|j|o[j]<<f[c.to_i*5+j]+" "}}
$><<o*$/

Ejecución de muestra:

bash-4.2$ echo -n 321 | ruby -e 'f="f999f62227f924ff171f".chars.map{|c|c.hex.to_s(2).rjust(4).tr "01"," #"};o=(0..4).map{""};$<.chars{|c|5.times{|j|o[j]<<f[c.to_i*5+j]+" "}};$><<o*$/'
#### ####  ##  
   # #  #   #  
 ###   #    #  
   #  #     #  
#### ####  ### 

Mathematica 174 145 139 118 119 123 caracteres

Ahora funciona con entrada en base 10 (bonificación de enteros). Las versiones anteriores se pueden encontrar en ediciones.

Usando ArrayPlot :

Con ArrayPlotpodemos convertir directamente los 1 y los 0 en cuadrados en blanco y negro, ahorrando algunos caracteres en el proceso. Por ejemplo, con n = 58021, que es 32022211 en la base 4:

i = IntegerDigits; i[n, 4] /. Thread@Rule[0~Range~3, ArrayPlot /@ ((PadLeft[#, 4] & /@ i[#, 2]) & /@ (i@{89998, 62227, 89248, 81718} /. {8 -> 15}))]

Explicación

Entrada es parámetro del programa, n.

El cero puede ser representado por {{1,1,1,1},{1,0,0,1},{1,0,0,1},{1,0,0,1},{1,1,1,1} o por la contraparte hexadecimal f999f.

La expresión, f999f62227f924ff171fcontiene la información para mostrar todos los números {0,1,2,3}. (Nota: comienza con f999f, lo que, como notamos, es cero disfrazado). Como Mathematica no reconoce esto como un número, usé 89998622278924881718(en cuatro cadenas enteras), dividí el número en sus dígitos enteros, y luego usé 15 en cada lugar aparecieron 8. (Eso me permitió usar dígitos en lugar de cadenas).

Mathematica , 112 107 103

Mi opinión sobre el método de David.

i=IntegerDigits;Grid/@i@n/.Thread[0~Range~3->("#"i[i@#/.8->15,2,4]&/@{89998,62227,89248,81718}/.0->"")]

105 con el BONO:

(para n = 54321)

i=IntegerDigits;Grid/@n~i~4/.Thread[0~Range~3->("#"i[i@#/.8->15,2,4]&/@{89998,62227,89248,81718}/.0->"")]

APL ( 58 57)

{' #'[1+5 4⍴1022367 401959 1020495 988959[1+⍎⍵]⊤⍨20⍴2]}¨⍞

Salida:

0123
 #### ## #### #### 
 # # # # # # 
 # # # # ### 
 # # # # # 
 #### ### #### #### 

Python 2.7

Vertical 160

for i in input():print['****\n*  *\n*  *\n*  *\n****',' ** \n  * \n  * \n  * \n***','****\n*  *\n  * \n *  \n****','****\n   *\n ***\n   *\n****'][int(i)]+'\n'

Horizontal 234 216

x=[['****\n*  *\n*  *\n*  *\n****',' ** \n  * \n  * \n  * \n ***','****\n*  *\n  * \n *  \n****','****\n   *\n ***\n   *\n****'][int(i)]for i in input()]
for i in range(5):print' '.join([y.split('\n')[i]for y in x])

Ambos toman la entrada como una cadena entre comillas en stdin

ejemplo:
$. / pretty
"0123"