Eu projetei uma nova fonte que chamo de PrettyFont. Eu dediquei muito tempo a aperfeiçoá-lo, mas, como sou um trabalhador, não tenho tempo para terminá-lo. Portanto, ele contém apenas 4 caracteres no momento. Um dia, quando eu ficar rico, será meu objetivo ao longo da vida terminá-lo, mas por enquanto ...

Isto é PrettyFont: (0, 1, 2, 3)

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

Cada caractere tem 4 pixels de largura e 5 pixels de altura. Agora! Quero que você me escreva um programa que produza um número no PrettyFont para que eu possa começar a enviar desenhos para impressão.

Regras:

A entrada é um número de sequência na base 4 (apenas caracteres 0-3), por exemplo "01321". O programa deve poder manipular pelo menos 10 caracteres na sequência. Pontos de bônus são dados ao programa que usa um número inteiro base 10 real em vez de uma sequência. Esclarecimento sobre EDIT : o bônus inteiro significa que é possível inserir qualquer número da base 10, como 54321, e o programa o converterá na base 4 e a produzirá (neste caso, 31100301).

A saída será o número impresso com o PrettyFont. Exemplo de entrada e saída:

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

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

 ## 
  # 
  # 
  # 
 ###

Bônus enorme para o programa que pode produzi-lo em uma única linha como esta:

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

O caractere '#' não é um requisito e pode ser substituído por qualquer caractere.

Na saída vertical, é necessária uma linha vazia entre cada caractere PrettyFont. Se alguém fizer a saída horizontal, é necessário um caractere de espaço em branco '' ou um caractere de tabulação entre cada caractere PrettyFont.

Este é o código de golfe, o código mais curto vence! (Preciso disso porque o computador do meu escritório tem armazenamento limitado.)

k ( 118 117 72 71 69 66 caracteres)

Ainda não fiz muito esforço para jogar golfe, mas ele alcança a saída horizontal desejada em poucos caracteres:

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

Pega a entrada de stdin, imprime a saída em stdout.

edit: Ao implementar uma forma de compactação no "bitmap" de saída, reduzi-o para 72. O bitmap agora é construído convertendo ints de 64 bits em binários e mapeando os 0s e 1s para "#" ou "". Eu poderia fazer isso de hex como algumas das outras soluções, mas acho que isso acabaria por mais tempo . Acontece que hex é melhor.

Saída de amostra para 012301:

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

// editar: -6 char

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

Desculpe, vertical não foi interessante para mim.

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

J, 84 82 81 80 75 69 caracteres

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

Recebe entrada do teclado:

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

Números mágicos FTW (ou para o segundo lugar neste caso) :-)

C - 164 151 caracteres na horizontal

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

O 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("");}}

EDIT - 151 bytes

Eu adicionei as sugestões dos comentários e mais algumas. Não é exatamente seguro (matriz de comprimento 0 em que eu entro gets()...).

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

Observe, i=puts("")é um comportamento indefinido, pois estou tratando voidcomo int! Ele sempre retorna 0na minha versão do MinGW, mas 1no compilador que o IDEOne usa.

Aceita decimal, gera saída 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 + um bônus ([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}

Exemplo:

% 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 

EDIT: Ruby, 87 caracteres

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

Rubi

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}

Exemplo de execução:

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*$/

Exemplo de execução:

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 119 123 caracteres

Agora funciona com entrada na base 10 (bônus inteiro). Versões anteriores podem ser encontradas em edições.

Usando o ArrayPlot :

Com ArrayPlotisso, podemos converter diretamente o 1 e o 0 em quadrados em preto e branco, economizando alguns caracteres no processo. Por exemplo, com n = 58021, que é 32022211 na base 4:

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

Explicação

Entrada é o parâmetro do programa n,.

Zero pode ser representado por {{1,1,1,1},{1,0,0,1},{1,0,0,1},{1,0,0,1},{1,1,1,1} ou pelo equivalente hexadecimal f999f.

A expressão, f999f62227f924ff171fcontém as informações para exibir todos os números {0,1,2,3}. (Nota: começa com f999f, que conforme observamos, é zero disfarçado.) Como o Mathematica não reconhece isso como um número, eu usei 89998622278924881718(em quatro seqüências de caracteres inteiras), dividi o número em seus dígitos inteiros e depois usei 15 em todos os lugares um 8 apareceu. (Isso me permitiu usar dígitos em vez de strings por toda parte.)

Mathematica , 112 107 103

Minha opinião sobre o 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 com o bônus:

(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]}¨⍞

Resultado:

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 recebem a entrada como uma string citada no stdin

exemplo:
$. / pretty
"0123"