Tôi đã thiết kế một phông chữ mới mà tôi gọi là PrettyFont. Tôi đã dành nhiều thời gian để hoàn thiện nó, nhưng vì tôi là một người đàn ông làm việc nên tôi không có thời gian để hoàn thành nó. Do đó, nó chỉ chứa 4 ký tự ngay bây giờ. Một ngày nào đó khi tôi trở nên giàu có, nó sẽ trở thành mục tiêu cả đời của tôi để hoàn thành nó, nhưng bây giờ ...

Đây là PrettyFont: (0, 1, 2, 3)

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

Mỗi ký tự rộng 4 pixel và cao 5 pixel. Hiện nay! Tôi muốn bạn viết cho tôi một chương trình xuất ra một số trong PrettyFont để tôi có thể bắt đầu gửi các thiết kế để in.

Quy tắc:

Đầu vào là số chuỗi trong cơ sở 4 (chỉ các ký tự 0-3), ví dụ "01321". Chương trình sẽ có thể xử lý ít nhất 10 ký tự trong chuỗi. Điểm THƯỞNG được trao cho chương trình lấy số nguyên cơ bản 10 thay vì chuỗi. Làm rõ EDIT : phần thưởng số nguyên có nghĩa là người ta có thể nhập bất kỳ số 10 cơ sở nào, như 54321, và chương trình sẽ chuyển đổi nó thành cơ sở 4 và xuất nó (trong trường hợp này là 31100301).

Đầu ra sẽ là số được in bằng PrettyFont. Ví dụ đầu vào và đầu ra:

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

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

 ## 
  # 
  # 
  # 
 ###

Phần thưởng lớn cho chương trình có thể xuất nó theo một hàng duy nhất như thế này:

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

Ký tự '#' không phải là một yêu cầu và có thể được thay thế bằng bất kỳ ký tự nào.

Trong đầu ra dọc, một hàng trống được yêu cầu giữa mỗi ký tự PrettyFont. Nếu bất cứ ai tạo đầu ra theo chiều ngang, một ký tự khoảng trắng '' hoặc ký tự tab được yêu cầu giữa mỗi ký tự PrettyFont.

Đây là mã golf, mã ngắn nhất thắng! (Tôi cần nó ngắn vì máy tính văn phòng của tôi có dung lượng lưu trữ hạn chế.)

k ( 118 117 72 71 69 66 ký tự)

Tôi đã không nỗ lực nhiều để chơi golf này nhưng nó đạt được kết quả ngang mong muốn trong không quá nhiều ký tự:

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

Đưa đầu vào từ stdin, in đầu ra sang thiết bị xuất chuẩn.

chỉnh sửa: Bằng cách thực hiện một hình thức nén trên "bitmap" đầu ra, tôi đã giảm nó xuống 72. Hiện tại bitmap được xây dựng bằng cách chuyển đổi int 64bit thành nhị phân và ánh xạ 0 và 1 thành "#" hoặc "". Tôi có thể làm điều đó từ hex như một vài giải pháp khác nhưng tôi nghĩ việc này sẽ kết thúc lâu hơn . Hóa ra hex là tốt hơn.

Đầu ra mẫu cho 012301:

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

// chỉnh sửa: -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)]

Xin lỗi, dọc không thú vị đối với tôi.

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

J, 84 82 81 80 75 69 ký tự

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

Lấy đầu vào từ bàn phím:

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

Số ma thuật FTW (hoặc cho vị trí thứ hai trong trường hợp này) :-)

C - 164 151 ký tự ngang

Trên IDEone: http://ideone.com/gljc3

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

EDIT - 151 byte

Tôi đã thêm các đề xuất từ ​​các ý kiến ​​và sau đó một số. Nó không chính xác an toàn (mảng 0 độ dài mà tôi gets()tham gia ...) mặc dù.

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

Lưu ý, i=puts("")là hành vi không xác định vì tôi đang đối xử voidnhư int! Nó liên tục trả 0về phiên bản MinGW của tôi, nhưng nó trả 1về trình biên dịch mà IDEOne sử dụng.

Chấp nhận thập phân, đầu ra cơ sở 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)));}

Ruby, 0123 ký tự + phần thưởng ([0123] so với '#')

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}

Thí dụ:

% 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 ký tự

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

Hồng ngọc

Dọc: 116 ký tự

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}

Chạy mẫu:

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

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

 ## 
  # 
  # 
  # 
 ###

Ngang: 150 148 ký tự

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

Chạy mẫu:

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

Toán học 174 145 139 118 119 123 chars

Bây giờ hoạt động với đầu vào trong cơ sở 10 (Phần thưởng số nguyên). Các phiên bản trước có thể được tìm thấy trong các chỉnh sửa.

Sử dụng ArrayPlot :

Với ArrayPlotchúng ta có thể trực tiếp chuyển đổi 1 và 0 thành hình vuông màu đen và trắng, tiết kiệm một vài ký tự trong quá trình. Ví dụ: với n = 58021, là 32022211 trong cơ sở 4:

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

Giải trình

Đầu vào là tham số chương trình , n.

Không có thể được đại diện bởi {{1,1,1,1},{1,0,0,1},{1,0,0,1},{1,0,0,1},{1,1,1,1} hoặc bởi các đối tác hex f999f.

Biểu thức ,, f999f62227f924ff171fgiữ thông tin để hiển thị tất cả các số {0,1,2,3}. (Lưu ý: nó bắt đầu bằng f999f, như chúng tôi đã lưu ý, là số 0 được ngụy trang.) Bởi vì Mathicala không nhận ra đây là một số, 89998622278924881718thay vào đó, tôi đã sử dụng (trong bốn chuỗi số nguyên), chia số thành các chữ số nguyên của nó, sau đó sử dụng 15 ở mỗi nơi 8 xuất hiện. (Điều đó cho phép tôi sử dụng các chữ số thay vì các chuỗi trong suốt.)

Toán học , 112 107 103

Tôi chấp nhận phương pháp của David.

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

105 với TIỀN THƯỞNG:

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

Đầu ra:

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

Python 2.7

Dọc 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'

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

Cả hai đều lấy đầu vào là một chuỗi trích dẫn trên stdin

ví dụ:
$. / khá
"0123"