Ho progettato un nuovo carattere che chiamo PrettyFont. Ho dedicato molto tempo a perfezionarlo, ma dal momento che sono un lavoratore non ho tempo di finirlo. Pertanto al momento contiene solo 4 caratteri. Un giorno, quando sarò diventato ricco, diventerà il mio obiettivo per tutta la vita per finirlo, ma per ora ...

Questo è PrettyFont: (0, 1, 2, 3)

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

Ogni carattere è largo 4 pixel e alto 5 pixel. Adesso! Voglio che tu mi scriva un programma che genera un numero in PrettyFont in modo da poter iniziare a inviare disegni da stampare.

Regole:

L'input è un numero di stringa nella base 4 (solo caratteri 0-3), ad esempio "01321". Il programma dovrebbe essere in grado di gestire almeno 10 caratteri nella stringa. I punti BONUS vengono assegnati al programma che accetta un numero intero di base 10 effettivo anziché una stringa. Chiarimento EDIT : il bonus intero significa che si può inserire qualsiasi numero di base 10, come 54321, e il programma lo convertirà in base 4 e lo produrrà (in questo caso 31100301).

L'output sarà il numero stampato con PrettyFont. Esempio di input e output:

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

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

 ## 
  # 
  # 
  # 
 ###

Enorme bonus per il programma che può emetterlo in una sola riga come questa:

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

Il carattere '#' non è un requisito e può essere sostituito da qualsiasi carattere.

Nell'output verticale, è richiesta una riga vuota tra ciascun carattere PrettyFont. Se qualcuno crea l'output orizzontale, è richiesto un carattere di spazio bianco '' o un carattere di tabulazione tra ciascun carattere PrettyFont.

Questo è il codice golf, il codice più corto vince! (Ne ho bisogno perché il mio computer dell'ufficio ha una memoria limitata.)

k ( 118 117 72 71 69 66 caratteri)

Non ho ancora fatto molti sforzi per giocare a golf, ma raggiunge l'output orizzontale desiderato in non troppi caratteri:

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

Prende input da stdin, stampa l'output su stdout.

modifica: Implementando una forma di compressione sull'output "bitmap", l'ho ridotta a 72. La bitmap è ora costruita convertendo inte binari a 64 bit e mappando gli 0 e 1 su "#" o "". Potrei farlo da hex come alcune delle altre soluzioni, ma penso che questo finirebbe più a lungo . Si scopre che esadecimale è meglio.

Esempio di output per 012301:

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

// modifica: -6 caratteri

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

Spiacente, il verticale non è stato interessante per me.

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

J, 84 82 81 80 75 69 caratteri

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

Accetta input dalla tastiera:

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

Numeri magici FTW (o per il secondo posto in questo caso) :-)

C - 164 151 caratteri orizzontali

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

Il codice (164 byte):

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

MODIFICA - 151 byte

Ho aggiunto i suggerimenti dai commenti e poi alcuni. gets()Tuttavia, non è esattamente sicuro (array di lunghezza 0 in cui mi trovo ...).

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("")è un comportamento indefinito poiché sto trattando voidcome int! Ritorna costantemente 0sulla mia versione di MinGW, ma ritorna 1sul compilatore utilizzato da IDEOne.

Accetta decimale, output base 4 (167 byte)

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

Rubino, 0123 caratteri + un bonus ([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}

Esempio:

% 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 caratteri

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

Rubino

Verticale: 116 caratteri

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}

Esecuzione di esempio:

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}'
####
   #
 ###
   #
####

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

 ## 
  # 
  # 
  # 
 ###

Orizzontale: 150 148 caratteri

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

Esecuzione di esempio:

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 caratteri

Ora funziona con input in base 10 (bonus intero). Le versioni precedenti sono disponibili nelle modifiche.

Utilizzando ArrayPlot :

Con ArrayPlotpossiamo convertire direttamente 1 e 0 in quadrati bianchi e neri, risparmiando alcuni caratteri nel processo. Ad esempio, con n = 58021, che è 32022211 nella base 4:

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

Spiegazione

Ingresso è parametro di programma, n.

Lo zero può essere rappresentato dalla {{1,1,1,1},{1,0,0,1},{1,0,0,1},{1,0,0,1},{1,1,1,1} o dalla controparte esadecimale f999f.

L'espressione, f999f62227f924ff171fcontiene le informazioni per visualizzare tutti i numeri {0,1,2,3}. (Nota: inizia con f999f, che come abbiamo notato, è zero sotto mentite spoglie.) Poiché Mathematica non lo riconosce come un numero, ho usato 89998622278924881718(in quattro stringhe di numeri interi), invece, ho suddiviso il numero nelle sue cifre intere, e quindi usato 15 in ogni luogo apparve un 8. (Ciò mi ha permesso di utilizzare le cifre anziché le stringhe in tutto.)

Mathematica , 112 107 103

La mia opinione sul metodo di David.

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

105 con il BONUS:

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

Produzione:

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

Python 2.7

Verticale 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'

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

Entrambi accettano input come stringa tra virgolette su stdin

esempio:
$. / pretty
"0123"