J'ai conçu une nouvelle police que j'appelle PrettyFont. J'ai mis beaucoup de temps à le perfectionner, mais comme je travaille, je n'ai pas le temps de le terminer. Par conséquent, il ne contient actuellement que 4 caractères. Un jour, quand je serai devenu riche, ce sera mon objectif de toute ma vie de le finir, mais pour l'instant ...

Voici PrettyFont: (0, 1, 2, 3)

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

Chaque caractère mesure 4 pixels de large et 5 pixels de haut. Maintenant! Je veux que vous m'écriviez un programme qui génère un nombre dans PrettyFont afin que je puisse commencer à envoyer des dessins à imprimer.

Règles:

L'entrée est un numéro de chaîne en base 4 (uniquement les caractères 0-3), par exemple "01321". Le programme doit être capable de gérer au moins 10 caractères dans la chaîne. Des points BONUS sont donnés au programme qui prend un entier de base 10 réel au lieu d'une chaîne. Clarification EDIT : le bonus entier signifie que l'on peut entrer n'importe quel nombre de base 10, comme 54321, et le programme le convertira en base 4 et le sortira (dans ce cas 31100301).

La sortie sera le nombre imprimé avec PrettyFont. Exemple d'entrée et de sortie:

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

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

 ## 
  # 
  # 
  # 
 ###

Un énorme bonus pour le programme qui peut le produire en une seule ligne comme ceci:

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

Le caractère «#» n'est pas obligatoire et peut être remplacé par n'importe quel caractère.

En sortie verticale, une ligne vide est requise entre chaque caractère PrettyFont. Si quelqu'un effectue la sortie horizontale, un caractère d'espace blanc '' ou un caractère de tabulation est requis entre chaque caractère PrettyFont.

C'est le golf de code, le code le plus court gagne! (J'en ai besoin parce que mon ordinateur de bureau a un stockage limité.)

k ( 118 117 72 71 69 66 car.)

Je n'ai pas encore fait beaucoup d'efforts pour jouer au golf, mais il atteint la sortie horizontale souhaitée en pas trop de caractères:

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

Prend l'entrée de stdin, imprime la sortie sur stdout.

edit: En implémentant une forme de compression sur la sortie "bitmap", je l'ai réduit à 72. Le bitmap est maintenant construit en convertissant les bits 64 bits en binaire et en mappant les 0 et les 1 sur "#" ou "". Je pourrais le faire à partir d'hexagone comme quelques-unes des autres solutions mais je pense que cela finirait plus longtemps . Il s'avère que l'hexagone est meilleur.

Exemple de sortie pour 012301:

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

// edit: -6 car

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

Désolé, la verticale n'était pas intéressante pour moi.

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

J, 84 82 81 80 75 69 caractères

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

Prend l'entrée du clavier:

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

Nombre magique FTW (ou pour la deuxième place dans ce cas) :-)

C - 164 151 caractères horizontaux

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

Le code (164 octets):

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 octets

J'ai ajouté les suggestions des commentaires et puis certaines. Ce n'est pas exactement sûr (tableau de longueur 0 que je veux 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)));}

Remarque, i=puts("")est un comportement indéfini puisque je traite voidcomme int! Il revient systématiquement 0sur ma version de MinGW, mais il revient 1sur le compilateur utilisé par IDEOne.

Accepte les décimales, produit la base 4 (167 octets)

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 caractères + 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}

Exemple:

% 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 caractères

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

Rubis

Vertical: 116 caractères

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}

Exemple d'exécution:

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 caractères

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

Exemple d'exécution:

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 caractères

Fonctionne maintenant avec une entrée en base 10 (bonus entier). Les versions antérieures peuvent être trouvées dans les modifications.

Utilisation d'ArrayPlot :

Avec, ArrayPlotnous pouvons convertir directement les 1 et les 0 en carrés noir et blanc, économisant ainsi quelques caractères. Par exemple, avec n = 58021, soit 32022211 en base 4:

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

Explication

L' entrée est paramètre du programme, n.

Zéro peut être représenté par {{1,1,1,1},{1,0,0,1},{1,0,0,1},{1,0,0,1},{1,1,1,1} ou par l'homologue hexadécimal f999f.

L'expression f999f62227f924ff171f,, contient les informations pour afficher tous les nombres {0,1,2,3}. (Remarque: il commence par f999f, qui, comme nous l'avons noté, est nul déguisé.) Parce que Mathematica ne reconnaît pas cela comme un nombre, j'ai utilisé 89998622278924881718(en quatre chaînes entières) à la place, j'ai divisé le nombre en ses chiffres entiers, puis utilisé 15 dans chaque endroit un 8 est apparu. (Cela m'a permis d'utiliser des chiffres au lieu de chaînes partout.)

Mathematica , 112 107 103

Mon point de vue sur la méthode de David.

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

105 avec le BONUS:

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

Production:

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'

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

Les deux prennent l'entrée comme une chaîne entre guillemets sur stdin

exemple:
$. / joli
"0123"