Ich habe eine neue Schriftart entworfen, die ich PrettyFont nenne. Ich habe viel Zeit investiert, um es zu perfektionieren, aber da ich ein Arbeiter bin, habe ich keine Zeit, es zu beenden. Daher enthält es derzeit nur 4 Zeichen. Eines Tages, wenn ich reich geworden bin, wird es mein lebenslanges Ziel sein, es zu beenden, aber fürs Erste ...

Dies ist PrettyFont: (0, 1, 2, 3)

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

Jedes Zeichen ist 4 Pixel breit und 5 Pixel hoch. Jetzt! Ich möchte, dass Sie mir ein Programm schreiben, das eine Zahl in PrettyFont ausgibt, damit ich anfangen kann, Entwürfe zum Drucken zu senden.

Regeln:

Die Eingabe ist eine Zeichenfolgennummer in Basis 4 (nur Zeichen 0-3), zum Beispiel "01321". Das Programm sollte mindestens 10 Zeichen in der Zeichenfolge verarbeiten können. BONUS-Punkte werden an das Programm vergeben, das anstelle einer Zeichenfolge eine tatsächliche Ganzzahl zur Basis 10 verwendet. EDIT- Erklärung: Der Ganzzahlbonus bedeutet, dass man eine beliebige Zahl zur Basis 10 wie 54321 eingeben kann. Das Programm konvertiert sie zur Basis 4 und gibt sie aus (in diesem Fall 31100301).

Die Ausgabe ist die mit PrettyFont gedruckte Nummer. Beispiel Ein- und Ausgabe:

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

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

 ## 
  # 
  # 
  # 
 ###

Ein riesiger Bonus für das Programm, das es in einer einzigen Zeile wie folgt ausgeben kann:

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

Das Zeichen '#' ist keine Voraussetzung und kann durch ein beliebiges Zeichen ersetzt werden.

Bei der vertikalen Ausgabe ist zwischen jedem PrettyFont-Zeichen eine leere Zeile erforderlich. Wenn jemand die horizontale Ausgabe vornimmt, ist zwischen jedem PrettyFont-Zeichen ein Leerzeichen '' oder ein Tabulatorzeichen erforderlich.

Das ist Code Golf, der kürzeste Code gewinnt! (Ich brauche es kurz, weil mein Bürocomputer nur über begrenzten Speicherplatz verfügt.)

k ( 118 117 72 71 69 66 Zeichen)

Ich habe mir noch nicht viel Mühe gegeben, um Golf zu spielen, aber es erreicht die gewünschte horizontale Ausgabe in nicht zu vielen Zeichen:

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

Übernimmt die Eingabe von stdin und druckt die Ausgabe auf stdout.

edit: Durch das Implementieren einer Form der Komprimierung für die Ausgabe "Bitmap" habe ich sie auf 72 reduziert. Die Bitmap wird jetzt erstellt, indem 64-Bit-Ints in Binärdaten konvertiert und die Nullen und Einsen in "#" oder "" abgebildet werden. Ich könnte es wie bei einigen anderen Lösungen aus dem Hex machen, aber ich denke, das würde länger dauern . Es stellt sich heraus, dass Hex besser ist.

Beispielausgabe für 012301:

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

// edit: -6 Zeichen

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

Sorry, vertical war für mich nicht interessant.

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

J, 84 82 81 80 75 69 Zeichen

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

Nimmt Eingaben über die Tastatur entgegen:

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

Magic Numbers FTW (oder für den zweiten Platz in diesem Fall) :-)

C - 164 151 Zeichen horizontal

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

Der Code (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

Ich habe die Vorschläge aus den Kommentaren hinzugefügt und dann einige. Es ist jedoch nicht ganz sicher (Array mit der Länge 0, in dem ich mich befinde 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)));}

Beachten Sie, i=puts("")ist undefiniertes Verhalten, da ich voidals behandle int! Es kehrt konsistent 0zu meiner Version von MinGW zurück, aber es kehrt 1zu dem Compiler zurück, den IDEOne verwendet.

Akzeptiert Dezimalzahlen, gibt Basis 4 aus (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 Zeichen + ein 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}

Beispiel:

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

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

Rubin

Vertikal: 116 Zeichen

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}

Probelauf:

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 bis 148 Zeichen

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

Probelauf:

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 Zeichen

Funktioniert jetzt mit Eingaben in Basis 10 (Ganzzahlbonus). Frühere Versionen finden Sie in den Bearbeitungen.

Verwenden von ArrayPlot :

Mit können ArrayPlotwir die Einsen und Nullen direkt in schwarze und weiße Quadrate umwandeln und dabei ein paar Zeichen sparen. Zum Beispiel mit n = 58021, was 32022211 in Basis 4 ist:

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

Erläuterung

Eingang Programmparameter n.

Null kann durch {{1,1,1,1},{1,0,0,1},{1,0,0,1},{1,0,0,1},{1,1,1,1} oder durch das hexadezimale Gegenstück dargestellt werden f999f.

Der Ausdruck f999f62227f924ff171fenthält die Informationen zur Anzeige aller Zahlen {0,1,2,3}. (Anmerkung: Es beginnt mit f999f, was, wie wir festgestellt haben, in Verkleidung Null ist.) Da Mathematica dies nicht als Zahl erkennt, habe ich 89998622278924881718stattdessen (in vier Ganzzahlzeichenfolgen) die Zahl in ihre ganzzahligen Ziffern zerlegt und dann verwendet 15 an jeder Stelle erschien eine 8. (Dadurch konnte ich durchgehend Ziffern anstelle von Zeichenfolgen verwenden.)

Mathematica , 112 107 103

Ich übernehme Davids Methode.

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

105 mit dem BONUS:

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

Ausgabe:

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

Python 2.7

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

Beide nehmen die Eingabe als String in Anführungszeichen auf stdin

Beispiel:
$. / pretty
"0123"