Zaprojektowałem nową czcionkę, którą nazywam PrettyFont. Wiele czasu poświęciłem na doskonalenie go, ale ponieważ jestem pracującym człowiekiem, nie mam czasu, aby go ukończyć. Dlatego obecnie zawiera tylko 4 znaki. Pewnego dnia, gdy stanę się bogaty, stanie się moim życiowym celem, aby go ukończyć, ale na razie ...

To jest PrettyFont: (0, 1, 2, 3)

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

Każda postać ma szerokość 4 pikseli i wysokość 5 pikseli. Teraz! Chcę, żebyś napisał mi program, który wyświetla liczbę w PrettyFont, abym mógł rozpocząć wysyłanie projektów do wydrukowania.

Zasady:

Dane wejściowe to liczba ciągów w bazie 4 (tylko znaki 0-3), na przykład „01321”. Program powinien być w stanie obsłużyć co najmniej 10 znaków w ciągu. Punkty BONUS są przyznawane programowi, który przyjmuje rzeczywistą liczbę całkowitą podstawową 10 zamiast ciągu. EDIT wyjaśnienie: premia do liczby całkowitej oznacza, że ​​można wprowadzić dowolną liczbę podstawową 10, np. 54321, a program przekonwertuje ją na bazę 4 i wyśle ​​ją (w tym przypadku 31100301).

Wynik będzie liczbą wydrukowaną za pomocą PrettyFont. Przykładowe dane wejściowe i wyjściowe:

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

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

 ## 
  # 
  # 
  # 
 ###

Ogromna premia dla programu, która może wyświetlać go w jednym rzędzie, tak jak to:

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

Znak „#” nie jest wymagany i można go zastąpić dowolnym znakiem.

W wyjściu pionowym wymagany jest pusty wiersz między każdym znakiem PrettyFont. Jeśli ktoś tworzy wynik w poziomie, między każdym znakiem PrettyFont wymagany jest jeden biały znak „” lub znak tabulacji.

To jest golf golfowy, wygrywa najkrótszy kod! (Potrzebuję go krótko, ponieważ mój komputer w biurze ma ograniczone miejsce).

k ( 118 117 72 71 69 66 znaków)

Nie poczyniłem wiele wysiłku, aby zagrać w golfa, ale osiąga on pożądany poziomy wynik w niezbyt wielu znakach:

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

Pobiera dane wejściowe ze standardowego wejścia, drukuje dane wyjściowe na standardowe wyjście.

edycja: Wdrażając formę kompresji na wyjściowej „bitmapie”, zredukowałem ją do 72. Bitmapa jest teraz budowana przez konwersję 64-bitowych int na binarne i mapowanie zer i 1 na „#” lub „”. Mógłbym to zrobić z hexa, jak kilka innych rozwiązań, ale myślę, że skończyłoby to dłużej . Okazuje się, że hex jest lepszy.

Przykładowe dane wyjściowe dla 012301:

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

// edycja: -6 znaków

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

Przepraszam, pionowe nie było dla mnie interesujące.

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

J, 84 82 81 80 75 69 znaków

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

Pobiera dane z klawiatury:

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

Liczby magiczne FTW (lub w tym przypadku na drugie miejsce) :-)

C - 164 151 znaków w poziomie

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

Kod (164 bajty):

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

EDYCJA - 151 bajtów

Dodałem sugestie z komentarzy, a następnie niektóre. Nie jest to jednak do końca bezpieczne (tablica o zerowej długości, gets()do której ...).

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

Uwaga, i=puts("")jest niezdefiniowanym zachowaniem, ponieważ traktuję voidjak int! Konsekwentnie zwraca 0moją wersję MinGW, ale zwraca 1kompilator, którego używa IDEOne.

Akceptuje dziesiętne, wyjściowe bazy 4 (167 bajtów)

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

Rubin, 0123 znaków + 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}

Przykład:

% 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 

EDYCJA: Ruby, 87 znaków

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

Rubin

Pionowo: 116 znaków

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}

Przykładowy przebieg:

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

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

 ## 
  # 
  # 
  # 
 ###

Poziomo: 150 148 znaków

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

Przykładowy przebieg:

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 znaki

Teraz działa z danymi wejściowymi w bazie 10 (premia całkowita). Wcześniejsze wersje można znaleźć w edycjach.

Za pomocą ArrayPlot :

Za pomocą ArrayPlotmożemy bezpośrednio przekonwertować jedynki i zera na czarne i białe kwadraty, oszczędzając przy tym kilka znaków. Na przykład n = 58021, czyli 32022211 w podstawie 4:

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

Wyjaśnienie

Wejście jest parametr programu n.

Zero może być reprezentowane przez {{1,1,1,1},{1,0,0,1},{1,0,0,1},{1,0,0,1},{1,1,1,1} lub przez odpowiednik heksadecymalny f999f.

Wyrażenie „ f999f62227f924ff171fzawiera informacje umożliwiające wyświetlenie wszystkich liczb {0,1,2,3}. (Uwaga: zaczyna się od f999f, który, jak zauważyliśmy, wynosi zero w przebraniu.) Ponieważ Mathematica nie rozpoznaje tego jako liczby, 89998622278924881718zamiast tego użyłem (w czterech ciągach liczb całkowitych), podzieliłem liczbę na liczby całkowite, a następnie użyłem 15 w każdym miejscu pojawiło się 8. (To pozwoliło mi używać cyfr zamiast ciągów znaków w całym tekście).

Mathematica , 112 107 103

Moje podejście do metody Davida.

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

105 z BONUSEM:

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

Wynik:

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

Python 2.7

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

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

Oba przyjmują dane wejściowe jako ciąg cytowany na stdin

przykład:
$. / pretty
„0123”