Я створив новий шрифт, який я називаю PrettyFont. Я вкладав багато часу на вдосконалення, але, оскільки я працююча людина, я не встигаю закінчити це. Тому він містить лише 4 символи. Одного разу, коли я розбагатів, це стане моєю довічною метою закінчити це, але поки що ...

Це PrettyFont: (0, 1, 2, 3)

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

Кожен символ шириною 4 пікселів та висотою 5 пікселів. Зараз! Я хочу, щоб ви написали мені програму, яка виводить число в PrettyFont, щоб я міг почати надсилати конструкції для друку.

Правила:

Вхід - це рядок у базі 4 (лише символи 0-3), наприклад "01321". Програма повинна мати можливість обробляти принаймні 10 символів у рядку. BONUS балів надається програмі, яка приймає фактичне базове ціле число замість рядка. Роз'яснення EDIT : цілий бонус означає, що можна ввести будь-яке базове число 10, наприклад 54321, і програма перетворить його на базу 4 і виведе його (у цьому випадку 31100301).

Виходом буде номер, надрукований за допомогою PrettyFont. Приклад введення та виведення:

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

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

 ## 
  # 
  # 
  # 
 ###

Величезний бонус програмі, яка може виводити її в один рядок так:

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

Символ "#" не є вимогою, і його можна замінити будь-яким символом.

При вертикальному виведенні потрібен порожній рядок між кожним символом PrettyFont. Якщо хтось робить горизонтальний вихід, між кожним символом PrettyFont потрібен один символ пробілу '' або символ вкладки.

Це код гольфу, найкоротший виграш коду! (Мені він потрібний короткий, оскільки мій офісний комп'ютер має обмежене сховище.)

k ( 118 117 72 71 69 66 символів)

Я ще не доклав великих зусиль для того, щоб пограти в гольф, але він домагається бажаного горизонтального результату не надто багато символів:

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

Здійснює введення з stdin, друкує вихід у stdout.

редагувати: Реалізуючи форму стиснення на вихідній "растровій карті", я зменшив її до 72. Растрова карта тепер будується за допомогою перетворення 64-бітових ints у бінарні та відображення 0s та 1s у "#" або "". Я міг би зробити це з шестигранної, як і деякі інші рішення, але я думаю, що це закінчиться довше . Виходить шістнадцятковий краще.

Вибірка зразка для 012301:

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

// редагувати: -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)]

Вибачте, вертикаль мені не була цікава.

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

J, 84 82 81 80 75 69 символів

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

Вводиться з клавіатури:

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

Чарівні числа FTW (або за друге місце в даному випадку) :-)

C - 164 151 символ по горизонталі

Про IDEone: http://ideone.com/gljc3

Код (164 байти):

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 байт

Я додав пропозиції з коментарів, а потім і деякі. Це не зовсім безпечно (0-довжина масив, який я 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)));}

Зауважте, i=puts("")це невизначена поведінка, оскільки я поводжусь voidяк int! Він послідовно повертається 0до моєї версії MinGW, але повертається 1на використання компілятора IDEOne.

Приймає десяткові, виводи базу 4 (167 байт)

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 символів + бонус ([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}

Приклад:

% 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 символів

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

Рубін

По вертикалі: 116 символів

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}

Проба зразка:

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

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

 ## 
  # 
  # 
  # 
 ###

Горизонтальний: 150 148 символів

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

Проба зразка:

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 знаків

Тепер працює з введенням в базу 10 (Integer bonus). Більш ранні версії можна знайти в редакціях.

Використання ArrayPlot :

З ArrayPlotми можемо безпосередньо перетворити 1 і 0 в чорних і білих квадратів, заощадивши кілька символів в процесі. Наприклад, при n = 58021, що становить 32022211 в базі 4:

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

Пояснення

Введення є параметром програми n.

Нуль може бути представлений {{1,1,1,1},{1,0,0,1},{1,0,0,1},{1,0,0,1},{1,1,1,1} шестигранним аналогом або його допомогою f999f.

Вираз f999f62227f924ff171f,, містить інформацію для відображення всіх чисел {0,1,2,3}. (Примітка. Починається з того f999f, що, як ми зазначали, маскується нуль.) Оскільки Mathematica не розпізнає це як число, я використовував 89998622278924881718(у чотирьох цілих рядках) натомість, розбив це число на цілі цифри, а потім використав 15 у кожному місці з'явилося 8. (Це дозволило мені використовувати цифри замість рядків.)

Математика , 112 107 103

Моє перейняти метод Девіда.

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

105 за допомогою БОНУСУ:

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

Вихід:

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

Python 2.7

По вертикалі 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'

Горизонтальний 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])

Обидва приймають введення як рядки, котирувані на stdin

приклад:
$. / досить
"0123"