Điều này hơi giống với mục nhập phủ đầy bụi này nhưng tôi hy vọng guồng quay của tôi trên đó làm cho nó đủ độc đáo. Không thể tìm thấy bất cứ điều gì ngăn cản tôi đăng bài này nhưng có khá nhiều biển ngoài đó.

Dù sao! Các thách thức:

Mã của bạn nhận được một chuỗi các ký tự; Nó chuyển đổi nó thành một phiên bản theo phong cách nghệ thuật ASCII của cùng một chuỗi, nhưng với một nhược điểm.

Chuyển đổi đầu vào

• Các ký tự duy nhất được hỗ trợ là AZ và 0-9
• Chữ thường được chuyển thành chữ hoa
• Bất cứ điều gì khác được âm thầm loại bỏ

Vẽ nhân vật

• Mỗi "pixel" của phông chữ được phóng to được rút ra từ chuỗi đầu vào
• Pixel thứ n bằng ký tự thứ n trong chuỗi đầu vào. Nếu n lớn hơn độ dài của chuỗi đầu vào, hãy quấn quanh từ đầu
• Các chữ cái riêng lẻ được vẽ từ trái sang phải, từ trên xuống dưới
• Các chữ cái tiếp theo lấy chỉ mục "ký tự pixel" của chúng từ nơi chữ cái cuối cùng rời khỏi (ví dụ: với độ dài đầu vào là 10, nếu chữ cái đầu tiên có 9 pixel, pixel thứ nhất của chữ cái thứ hai sẽ được vẽ bằng ký tự đầu vào thứ 10, ký tự thứ hai pixel sẽ được vẽ với ký tự đầu vào thứ 1)
• Mỗi chữ cái được vẽ trong một lưới 5x5, được đệm đầy đủ các khoảng trắng. Bạn có thể tìm thấy phông chữ bạn sẽ sử dụng được kết xuất sẵn cho bạn trong pastebin này hoặc một chút nữa trong bài viết này
• Mỗi chữ cái được vẽ trên cùng một dòng, vì vậy tổng số lần ngắt dòng trong đầu ra của bạn sẽ là 4
• Mỗi chữ cái được ngăn cách bởi 2 cột khoảng trắng

Đằng trước

 000 
0  00
0 0 0
00  0
 000 

111  
  1  
  1  
  1  
11111

2222 
    2
 222 
2    
22222

3333 
    3
  333
    3
3333 

  44 
 4 4 
44444
   4 
   4 

55555
5    
5555 
    5
5555 

 6666
6    
6666 
6   6
 666 

77777
    7
   7 
  7  
 7   

 888 
8   8
 888 
8   8
 888 

 999 
9   9
 9999
    9
9999 

 AAA 
A   A
AAAAA
A   A
A   A

BBBB 
B   B
BBBB 
B   B
BBBB 

 CCCC
C    
C    
C    
 CCCC

DDDD 
D   D
D   D
D   D
DDDD 

EEEEE
E    
EEE  
E    
EEEEE

FFFFF
F    
FFF  
F    
F    

 GGGG
G    
G  GG
G   G
 GGGG

H   H
H   H
HHHHH
H   H
H   H

IIIII
  I  
  I  
  I  
IIIII

JJJJJ
  J  
  J  
  J  
JJ   

K   K
K  K 
KKK  
K  K 
K   K

L    
L    
L    
L    
LLLLL

M   M
MM MM
M M M
M   M
M   M

N   N
NN  N
N N N
N  NN
N   N

 OOO 
O   O
O   O
O   O
 OOO 

PPPP 
P   P
PPPP 
P    
P    

 QQ  
Q  Q 
Q QQ 
Q  Q 
 QQ Q

RRRR 
R   R
RRRR 
R  R 
R   R

 SSSS
S    
 SSS 
    S
SSSS 

TTTTT
  T  
  T  
  T  
  T  

U   U
U   U
U   U
U   U
 UUU 

V   V
V   V
 V V 
 V V 
  V  

W   W
W   W
W W W
WW WW
W   W

X   X
 X X 
  X  
 X X 
X   X

Y   Y
 Y Y 
  Y  
  Y  
  Y  

ZZZZZ
   Z 
  Z  
 Z   
ZZZZZ

_{^{Có tôi biết 4 và Q là xấu}}

Một ví dụ

Đầu vào

0123456789

Đầu ra

 012   567    6789   0123     34   45678   9012  34567   234    567 
3  45    8        0      4   5 6   9      3          8  5   6  8   9
6 7 8    9     123     567  78901  0123   4567      9    789    0123
90  1    0    4          8     2       4  8   9    0    0   1      4
 234   12345  56789  9012      3   5678    012    1      234   5678 

Một vi dụ khac

Đầu vào

a3 B'2

Đầu ra

 A3B   B2A3   2A3B   2A3B 
2   A      B  2   A      2
3B2A3    2A3  3B2A    A3B 
B   2      B  3   B  2    
A   3  2A3B   2A3B   A3B2A

Sơ hở tiêu chuẩn bị cấm. Mã golf để không có dấu xanh sẽ được đưa ra.

Python 2 , _{413 411 373 364 352} 345 byte

-1 byte nhờ Kevin Cruijssen .
-9 byte nhờ Jo King .
-1 byte nhờ Lynn .

_{Chuỗi dữ liệu chứa không thể in được, phiên bản thoát bên dưới.}

k=list(filter(str.isalnum,input()))
q=range(5);o=['']*5;r=k*25;d=0
for c in'uM<LxSe#ye>El4NpD@$	gh>I,m]aB>e,]?kFLyglxV!%w832wGj%uT{Hr*K,*[P\n6.&ED#T}^DLI&p7f\d`*lG!FacG\rz?!A':d*=126;d+=ord(c)-1
for c in k:
 for i in q:
	for y in q+[999]*2:o[i]+=d>>int(c,36)*25+i*5+y&1and r.pop(0)or' '
print'\n'.join(o).upper()

Hãy thử trực tuyến!

Vì mỗi ký tự có 25 pixel, nó có thể được mã hóa dễ dàng trong 25 bit. Số cơ sở 126 'uM\x04<L\x10x\x14Se#ye\x0f>El4NpD@$\tgh>\x1d\x10\x15I,\x0em]a\x0e\x03B>e\x15,\x0c]\x03?kFL\x01\x0byglxV!\x18\x16\x0c\x0b\x10\x0b%w832wGj%uT{Hr*K,*[P\n6.&ED#T\x0c}^\x1c\x0fD\x17LI&p7\x17f\\d`*\x01l\x1bG\x12!Fac\x05\x08\x0eG\rz?!\x1aA'mã hóa tất cả các ký tự, 0được mã hóa bởi 25 bit có ý nghĩa nhỏ nhất, 25 bit 1tiếp theo và Zđược mã hóa bởi 25 bit quan trọng nhất. Một ký tự đơn được mã hóa theo thứ tự sau:

00 01 02 03 04
05 06 07 08 09
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24

^{( 00là bit có ý nghĩa ít nhất, là bit 25quan trọng nhất)}

Các không gian được mã hóa bằng 0, không phải khoảng trắng bởi một. Ví dụ :

77777      11111
    7      00001
   7   =>  00010  => (0001000100010001000011111)
  7        00100
 7         01000

Bị đánh cắp

k = list(filter(str.isalnum,input()))  # keep only alphanumeric characters of the input
o = ['']*5   # this list contains the output, initially 5 empty lines
r = k * 25   # make a copy of the input 25-times the length, these chars will be used for the pixels
data = 0
#  data encoded in base 126
b92d = 'uM<LxSe#ye>El4NpD@$	gh>I,m]aB>e,]?kFLyglxV!%w832wGj%uT{Hr*K,*[P\n6.&ED#T}^DLI&p7f\d`*lG!FacG\rz?!A'
for c in b92d:          # convert base 92 to base 10
  d*=126;d+=ord(c)-1

for c in k:             # iterate over the filtered input
  a_index = int(c, 36)  # the index of the current char in '0..9A..Z' / '0..9a..z'
  for i in range(5):    # for each row of the output
    for y in range(5)+[999]*2:  # for each pixel in the row, th two 999's are used for spaces
      is_set = data >> (a_index*25 + i*5 + y) & 1  # We shift the to the right to have ...
                                                   # the current pixels value at the LSB:
                                                   # 25 bits for each char that came before
                                                   # 5 bits for each previous row and 1 bit
                                                   # for every pixel in the same row
      o[i] += is_set and r.pop(0) or ' '           # If the current pixel is set, append ...
                                                   # ... a character from the input to the current row
print '\n'.join(o).upper()  # print the output

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 228 225 224 214 byte

Chương trình đầy đủ. Nhắc stdin cho chuỗi. In ra thiết bị xuất chuẩn. Khoảng một nửa mã chỉ là giải mã bảng chữ cái được mã hóa.

⍉↓(⍴t)⍴r\i⍴⍨+/r←,t←(⊂a⍳i←(1(819⌶)⍞)∩a←⎕D,⎕A)⌷0(220⌶)¯1(219⌶)¯125+⎕AV⍳_________________________________________________________________________________________________________________________________________________

_... _đại diện cho 143-byte chuỗi LZ4 mã hóa sau đây trong dấu ngoặc kép:"⊥\u0004pæ€}€\\⊃⌿Æ€â<Å€∧€ÀÆ€Ð┬:Ëcü\u0000≥ðè⊤õ⍨¢∧·èý\u0005þÐÕ\u001EÐ :\u001Eè⌊×ßi[B⊂ɫoãà oéìÐ⍙⊃Ý∣à)≥èB⊃\u001B\u001F⊥ä{⌿⍨ G⍺\u001B⌿Æ\u001F∇x└îR`:└è→⊂\u0000ê∧⍒\u0003ɫqè$$ÛD⊥â∊\u001B\u001Eéu|\u001B@4A|⍪┌nàkááЀ€€€€€€"

Hãy thử trực tuyến!

_... _ 143-byte chuỗi LZ4 mã hóa trong dấu ngoặc kép

⎕AV⍳ ɩ ndices điều đó trong Một Tomic V ector (bộ ký tự)

¯125+ thêm -125 vào đó (để có được số nguyên 8 bit đã ký)

¯1(219⌶) Giải nén LZ4

0(220⌶) deserialise thành một mảng Boolean 36 lớp, 5 hàng, 5 cột

(... )⌷ chỉ số thành rằng việc sử dụng các chỉ số sau:

 ⎕A hoa Một lphabet

 ⎕D, chuẩn bị cho igits D

 a← lưu trữ trong a(cho một lph.us)

 (... )∩ ngã tư sau đây và đó (loại bỏ đầu vào không hợp lệ):

  ⍞ lời nhắc nhập văn bản từ stdin (bảng điều khiển)

  1(819⌶) gấp lại thành chữ hoa ( 819hình như Big, 1 là có lớn so với nhỏ)

 i← lưu trữ trong i(cho i nput)

 a⍳ thông tin về điều đó tronga

 ⊂ kèm theo (để lập chỉ mục với mỗi một đại diện cho tọa độ hàng đầu)

t← lưu trữ trong t(cho t ext)

, ravel (làm phẳng)

r← lưu trữ trong r(cho r avelling)

+/ tổng cộng (tức là số lượng ký tự cần thiết để vẽ tác phẩm nghệ thuật)

i⍴⍨tuần hoàn r eshape đầu vào với chiều dài đó

r\ mở rộng điều đó; chèn một khoảng trắng ở 0s, sử dụng các chữ cái trong 1 giây

(Von) ⍴` định hình lại hình dạng sau:

 ⍴t hình dạng của văn bản

↓ chia mảng N-by-5 ​​-5 thành một ma trận N-by-5 ​​của các dòng nghệ thuật

⍉ chuyển thành ma trận 5-by-N của các dòng nghệ thuật (điều này căn chỉnh các dòng tương ứng của các ký tự)

Theo mặc định, APL tách các phần tử đơn giản của một mảng lồng nhau với 2 khoảng trắng.

Python 2 , 428 byte

s=filter(str.isalnum,input().upper());x=s
R=['']*5
for c in s:
 i=0;exec"n=int('RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDRXDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66YYABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H0000DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N6044AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'[i*36+ord(c)%55%45],36);R[i]+=bin(n+36*(n<30)<<2)[3:].replace(*'0 ').replace(*'1.');i+=1;"*5
 while'.'in`R`:R=eval(`R`.replace('.',x[0],1));x=x[1:]+s
print'\n'.join(R)

Hãy thử trực tuyến!

Các chữ cái được mã hóa như sau:

Mỗi phần duy nhất (có 23) được chuyển đổi thành nhị phân và 1 được thêm vào phía trước. Sau đó, nó được chuyển đổi sang cơ sở 36.

  part      bin      1+bin     int     base36
'  ...' -> 00111 -> 100111 ->   39  ->   13

Các số cơ sở-36 kết quả là:

[10,12,13,14,16,18,19,1A,1B,1C,1D,1E,1F,1H,1I,1K,1L,1N,1O,1Q,1R,X,Y]

Chữ cái đầu 1bị xóa, vì vậy chúng ta có một ký tự duy nhất:

[0,2,3,4,6,8,9,A,B,C,D,E,F,H,I,K,L,N,O,Q,R,X,Y]

Mỗi chữ cái ( A-Z0-9) sau đó được mã hóa thành năm ký tự mới này.

0 = ' ... ','.  ..','. . .','..  .',' ... ' -> A,F,H,L,A
1 = '...  ','  .  ','  .  ','  .  ','.....' -> O,0,0,0,R
etc.

Trong năm danh sách:

'AOQQ2RBRAAAQBQRRBDRRDCDDAQ8QBRDDDDDR'
'F0XX6CCXDDDDCDCCCD00ECNLDDEDC0DDD66Y'
'H0A3RQQYABRQCDOOFR00OCHHDQIQA0D6H000'
'L0CXYXD0DXDDCDCCDD00ECDFDCEEX0D6N604'
'ARRQYQA4AQDQBQRCBDRKDRDDAC9DQ0A0DD0R'

Để ánh xạ đầu vào tới một chỉ mục trong các danh sách này, thứ tự được sửa đổi:

'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
ord(c) = [48-57, 65-90]
ord(c)%55%45 = [3-9, 0-2, 10-35]

Bởi vì các thứ tự không phải là 0-35, nhưng hơi hỗn hợp, 5 danh sách được sắp xếp lại và nối liền nhau:

'RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDR'
'XDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66Y'
'YABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H000'
'0DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N604'
'4AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'
->
'RAAAOQQ2RBAQBQRRBDRRDCDDAQ8QBRDDDDDRXDDF0XX6CCDDCDCCCD00ECNLDDEDC0DDD66YYABH0A3RQQRQCDOOFR00OCHHDQIQA0D6H0000DXL0CXYXDDDCDCCDD00ECDFDCEEX0D6N6044AQARRQYQADQBQRCBDRKDRDDAC9DQ0A0DD0R'

Đối với mỗi char trong đầu vào, có 5 chữ cái được tìm thấy và được chuyển đổi thành ints (base36):

n=int('RAAA...D0R'[i*36+ord(c)%55%45],36)
                   i*36                    #get row i
                        ord(c)%55%45       #n -> 0..35
  int(                               ,36)  #convert to int

Nếu số ở dưới 30, 36được thêm vào (phần còn thiếu 1chúng tôi đã xóa trước đó)

n+36*(n<30)

Sau đó, số được chuyển đổi trở lại thành nhị phân, và 0s và 1s được chuyển đổi thành và .. Hai khoảng trắng được thêm vào cuối trong quá trình chuyển đổi.

bin(n+36*(n<30)<<2)[3:].replace(*'0 ').replace(*'1.')

    n+36*(n<30)                                       #add leading base36 '1'
               <<2                                    #add 2 0's to end
bin(              )                                   #convert to binary string
                   [3:]                               #remove '0b1' from front
                       .replace(*'0 ').replace(*'1.') #replace 0 and 1

Ví dụ.

C    base36    int     <<2       bin-str        str
3 ->   13   ->  39  ->  156 -> 0b10011100 -> '  ...  '

Đối với mỗi .kết quả, nó được thay thế bằng ký tự tiếp theo từ đầu vào (lặp lại bởi x)

while'.'in`R`:R=eval(`R`.replace('.',x[0],1));x=x[1:]+s

Java 8, 917 907 byte

int i,l;String[]S;s->{String q=" ",t="",r[]={t,t,t,t,t};S=s.toUpperCase().replaceAll("[^A-Z0-9]",t).split(t);i=-1;l=S.length;for(String c:S){r[0]+=s("12357BDEFHIJKLMNPRTUVWXYZ",c)+s("012356789ABCDEFGIJOPQRSTZ",c)+s("0123456789ABCDEFGIJOPQRSTZ",c)+s("023456789ABCDEFGIJOPRSTZ",c)+s("567CEFGHIJKMNSTUVWXYZ",c)+q;r[1]+=s("05689ABCDEFGHKLMNOPQRSUVW",c)+s("4MNXY",c)+s("1IJT",c)+s("04KMQXYZ",c)+s("023789ABDHMNOPRUVW",c)+q;r[2]+=s("0456ABCDEFGHKLMNOPQRUW",c)+s("245689ABEFHKPRSV",c)+s("012345689ABEFHIJKMNPQRSTWXYZ",c)+s("23456789ABGHPQRSV",c)+s("0349ADGHMNOUW",c)+q;r[3]+=s("0268ABCDEFGHKLMNOPQRUW",c)+s("0VWXZ",c)+s("17IJTY",c)+s("4KNQRVWX",c)+s("035689ABDGHMNOSUW",c)+q;r[4]+=s("12359ABDEFHIJKLMNPRSWXZ",c)+s("012356789BCDEGIJLOQSUZ",c)+s("01235689BCDEGILOQSTUVYZ",c)+s("012345689BCDEGILOSUZ",c)+s("12ACEGHIKLMNQRWXZ",c)+q;}return"".join("\n",r);}String s(String...s){return s[0].contains(s[1])?S[++i%l]:" ";}

Sẽ đánh gôn từ đây xuống ít nhất một nửa số byte hiện tại hy vọng ..

Hãy thử trực tuyến.

Giải trình:

int i,                         // Index-integer on class-level
    l;                         // Length-integer on class-level
String[]S;                     // String-array of characters on class-level

s->{                           // Method with String as both parameter and return-type
  String q="  ",               //  Temp String containing two spaces to reduce bytes
         t="",                 //  Temp Empty String to reduce bytes
         r[]={t,t,t,t,t};      //  Start with five empty rows
  S=s.toUpperCase()            //  Transform the input-String to uppercase
     .replaceAll("[^A-Z0-9]",t)//  Remove all non alphanumeric characters
     .split(t);                //  And transform it into a String-array of characters
  i=-1;                        //  Set the index-integer on -1 to start with
  l=S.length;                  //  Set the length of the modified input
  for(String c:S){             //  Loop over the characters of the modified input:
    r[0]+=                     //   Append to the first row:
          s("12357BDEFHIJKLMNPRTUVWXYZ",c)      // The first pixel
          +s("012356789ABCDEFGIJOPQRSTZ",c)     // The second pixel
          +s("0123456789ABCDEFGIJOPQRSTZ",c)    // The third pixel
          +s("023456789ABCDEFGIJOPRSTZ",c)      // The fourth pixel
          +s("567CEFGHIJKMNSTUVWXYZ",c)         // The fifth pixel
          +q;                                   // Two trailing spaces
    r[1]+=                     //   Append to the second row:
          s("05689ABCDEFGHKLMNOPQRSUVW",c)      // The first pixel
          +s("4MNXY",c)                         // The second pixel
          +s("1IJT",c)                          // The third pixel
          +s("04KMQXYZ",c)                      // The fourth pixel
          +s("023789ABDHMNOPRUVW",c)            // The fifth pixel
          +q;                                   // Two trailing spaces
    r[2]+=                     //   Append to the third row:
          s("0456ABCDEFGHKLMNOPQRUW",c)         // The first pixel
          +s("245689ABEFHKPRSV",c)              // The second pixel
          +s("012345689ABEFHIJKMNPQRSTWXYZ",c)  // The third pixel
          +s("23456789ABGHPQRSV",c)             // The fourth pixel
          +s("0349ADGHMNOUW",c)                 // The fifth pixel
          +q;                                   // Two trailing spaces
    r[3]+=                     //   Append to the fourth row:
          s("0268ABCDEFGHKLMNOPQRUW",c)         // The first pixel
          +s("0VWXZ",c)                         // The second pixel
          +s("17IJTY",c)                        // The third pixel
          +s("4KNQRVWX",c)                      // The fourth pixel
          +s("035689ABDGHMNOSUW",c)             // The fifth pixel
          +q;                                   // Two trailing spaces
    r[4]+=                     //   Append to the fifth row:
          s("12359ABDEFHIJKLMNPRSWXZ",c)        // The first pixel
          +s("012356789BCDEGIJLOQSUZ",c)        // The second pixel
          +s("01235689BCDEGILOQSTUVYZ",c)       // The third pixel
          +s("012345689BCDEGILOSUZ",c)          // The fourth pixel
          +s("12ACEGHIKLMNQRWXZ",c)             // The fifth pixel
          +q;}                                  // Two trailing spaces
  return"".join("\n",r);}      //  Return the rows joined with new-lines

//  Separated method with String-varargs parameter and String return-type
String s(String...s){          
  return s[0].contains(s[1])?  //  If the String contains the character-String:
                               //   Increase `i` by 1 first with `++i`
    S[++i%l]                   //   Then return the i'th character of the modified input
                               //   with wraparound by using modulo-`l`
   :                           //  Else:
    " ";}                      //   Return a space

Japt v2.0a0 -R, 213 211 210 209 206 193 191 190 byte

Bao gồm một không gian hàng đầu trên mỗi dòng.

uf \ w
£ `...` ò4 gXn36) nLõd) ¤r0S r1 @ gT ° Ãò5n) ù6Ãy m¸

Hãy thử hoặc kiểm tra tất cả các ký tự (các byte bổ sung là do TIO chưa hỗ trợ Japt v2)

Giải trình

Bảng tra cứu

Mỗi nhóm 4 ký tự trong chuỗi (được đại diện ...ở đây để tiết kiệm không gian và vì nó chứa một loạt các dấu vết không thể in được) là biểu diễn nhị phân của mỗi ký tự ( 0đối với khoảng trắng, 1đối với ký tự) với các dòng mới được xóa và chuyển đổi thành cơ sở 100.

Thí dụ

ZZZZZ -> 11111
   Z  -> 00010
  Z   -> 00100 -> 1111100010001000100011111 -> 32575775 -> !::L
 Z    -> 01000
ZZZZZ -> 11111

Mật mã

                                                :Implicit input of string U
u                                               :Uppercase
  f                                             :Get the array of characters matching
   \w                                           : /[a-z0-9]/gi
\n                                              :Reassign to U
£                                               :Map each character as X
 `...`                                          :  The string described above
      ò4                                        :  Split into strings of length 4
          Xn36                                  :  Convert X from base-36 to decimal
         g    )                                 :  Get the element in the array at that index
                Lõ                              :  Range [1,100]
                  d                             :  Get characters at those codepoints
               n   )                            :  Convert from that base to decimal
                    ¤                           :  Convert to binary
                     r0S                        :  Replace all 0s with spaces
                         r1                     :  Replace all 1s
                           @                    :  By passing each match through a function
                             T°                 :    Postfix increment T (initially 0)
                            g                   :    Get the character in U at that index (Yay, index wrapping!)
                               Ã                :  End replacement
                                ò5n)            :  Split into strings of length 5, weighted towards the end
                                    ù6          :  Left pad each with spaces to length 6
                                      Ã         :End mapping
                                       y        :Transpose
                                         m      :Map
                                          ¸     :  Join with spaces
                                                :Implicitly join with newlines and output

Ruby , 366 byte

->s{s.tr!('^0-9A-Za-z','');b=([s]*s.size).map(&:chars);%w(esuu6vfveeeufuvvfhvvhghheucufvhhhhhv j411agg1hhhhghgggh44igrphhihg4hhhaa2 l4e7vuu2efvughssjv44sgllhumue4hal444 p4g121h4h1hhghgghh44ighjhgii14hara48 evvu2ue8euhufuvgfhvohvhhegdhu4e4hh4v).map{|x|w=t='';s.chars{|c|c=~/\w/&&w+="%5b  "%x[c.to_i 36].to_i(36)};w.size.times{|i|t+=w[i]>?0?b[i/7].rotate![-1]:' '};t}}

Hãy thử trực tuyến!

Điều này có thể được chơi golf rất nhiều, nhưng bây giờ tôi đã hết thời gian và ý tưởng. Nó khó hơn tôi nghĩ ban đầu chỉ để nó hoạt động.

Làm thế nào nó hoạt động:

Điều đó không quá khó hiểu, tôi sẽ chỉ giải thích cách bảng chữ cái được mã hóa bằng một ví dụ. Mỗi dòng của mỗi ký tự được chuyển đổi thành nhị phân và sau đó thành cơ sở-36.

 AAA   -> 01110 -> E
A   A  -> 10001 -> H
AAAAA  -> 11111 -> V
A   A  -> 10001 -> H
A   A  -> 10001 -> H

Bước đầu tiên là tước tất cả các ký tự không chữ và số từ chuỗi đầu vào.

Sau đó, tôi tạo một bảng tra cứu cho kết xuất cuối cùng, vì tôi muốn in dòng cho dòng.

Sau đó, lặp đi lặp lại trên dòng bảng chữ cái, tôi tạo ra mẫu nhị phân của các chữ cái.

Cuối cùng tôi thay 0 bằng dấu cách và 1 bằng ký tự từ bảng tra cứu.

Vui lòng chơi gôn hơn nữa, tôi biết điều này có thể ngắn hơn 20-30 byte (sử dụng gsub thay vì tr, v.v.), nhưng bây giờ tôi không quan tâm, trừ khi tôi có thể làm cho bảng chữ cái nhỏ hơn đáng kể.

Than , 172 164 byte

≔⁺⭆χιαα≔Φ↥Ｓ№αιθＦθ«Ｅ⁵⭆§⪪”)∧%"<⁰ＥＴV´el⟧2[◧À&η²p.±‹§Ｋ×GＲ←∨�X¶⌈hＦ)ξυ9ＤUuqε↘Ｚ)s⎚H⊙←<¿.＆]～b≧✂⪪XïＪ61%ZWm/ειK⮌λ﹪▷(σΠＮc←º✳Ｆb⌕⊘¹ÞＥpＭ＆➙δl◨α↑j≕ςL¡ρG⁰/y”⁵⁺κ×⁵⌕αι⎇Ｉμ§θ⊖Ｌ⊞Ｏυω Ｍ⁷±⁵

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

≔⁺⭆χιαα

Tiền tố các chữ số cho bảng chữ cái viết hoa được xác định trước.

≔Φ↥Ｓ№αιθ

Viết hoa đầu vào và lọc ra tất cả các ký tự không được hỗ trợ.

Ｆθ«

Lặp lại các ký tự còn lại.

Ｅ⁵

Lặp lại trên mỗi hàng, in ngầm từng kết quả trên dòng riêng của nó.

⭆§⪪”...”⁵⁺κ×⁵⌕αι

Chuỗi nén là hằng số nguyên lớn của @ ovs, được chuyển đổi thành nhị phân và đảo ngược. Sau đó, nó được cắt thành 180 chuỗi con gồm 5 ký tự và chuỗi con có liên quan cho ký tự và hàng hiện tại sau đó được lặp lại.

⎇Ｉμ§θ⊖Ｌ⊞Ｏυω 

Nếu bit được đặt thì in theo chu kỳ ký tự tiếp theo của đầu vào được lọc nếu không sẽ in một khoảng trắng.

Ｍ⁷±⁵

Định vị con trỏ sẵn sàng để in ký tự tiếp theo.

Perl 5 với -nlaF/[^A-Za-z0-9]+|/, 247 byte

@l{0..9,A..Z}=unpack("b*",q&....!.?.......G...../.......\....c|...C......'..N.>..c.1~B......I1..~.5.8k....^|!...}.......BH.1..."1..."*FE.....&)=~/.{25}/g;eval'$;[$j%5].=($l{+uc}=~/.{5}/g)[$j++%5]=~s/./$&?uc$F[$i++%@F]:$"/ger.$"x2;'x5for@F;say for@

Hãy thử trực tuyến!

Giải trình

Đầu tiên một bảng tra cứu được tạo %lbằng cách sử dụng packdữ liệu ed. Dữ liệu này là một chuỗi nhị phân 900 bit của mỗi char được đóng gói dưới dạng chuỗi nhị phân 25 bit (được lưu dưới dạng 113 byte - chỉ hơn 1 byte so với than!), Tương tự như một số câu trả lời khác, vì vậy A:

 AAA 
A   A
AAAAA
A   A
A   A

trong đó, sử dụng 0cho không gian và 1cho Alà:

01110
10001
11111
10001
10001

và không có ngắt dòng là:

0111010001111111000110001

Khi quá trình tra cứu được khởi tạo, chúng tôi lặp lại từng char hợp lệ @F(được điền bằng -atùy chọn utosplit của Perl ) nối vào mỗi trong số 5 phần tử của danh sách @;cho mỗi hàng trong mảng từ tra cứu, thay thế tất cả 1các phần tử uc$F[$i++%@F]đó là $ithứ ký tự (modulo @Fcó độ dài @F) được chuyển đổi thành upper case và tất cả các 0s $"mặc định là không gian. Khi mỗi chỉ mục @;được điền cho mỗi ký tự @F, hãy sayin từng dòng bằng một dòng mới.

Lưu ý : chuỗi sau unpackchứa không thể in được thoát bằng cách sử dụng \xXXký hiệu. Xác minh cho điểm số 247 .

SOGL V0.12 , 165 164 163 byte

⁰CīøDs8↓3‛⁸⁷ω8<t↑\≈⅓dPb¦l═│ƹč<⁷i3ζ°@Ο≠ΖηKπ⁴Φd←⅔Ωī$∞ΧΗf▼xƧqWƨ∑ģpc!ƨ@┐Γ<§5ΛMn«Ιq;⁾№╔1xdψBN≤⁴ζ8□\b╗³╤>↔²Μ±}H}≤╬bφIæ7“2─{rƧ- W}⁰∑M¼nEU{SUZ+;W:?ew;cF+C}X}⁰┌cŗā;{√┼@L*┼

Hãy thử nó ở đây!

Giải trình:

...“                 big long number of the character data
    2─               convert to a base 2 string
      {r    }        for each number in it
        Ƨ- W           get it's index in "- ": space for 0, dash for 1
             ⁰∑      join up the results
               M¼n   split into groups of 25 - the letters
                  E  save that in variable E

U{                 }⁰ map over the input uppercased
  SUZ+                  push 1234567890 + the alphabet
      ;W                get the current characters index in that string
        :?       }      duplicate, if not 0 (aka if found)
          e               push the variable E
           w              get in it the duplicated number'th item
                            this leavesleaving the array below the item
            ;             get the array ontop
             cF+C         append the character to the array C
                  X     and remove the top item - either the duplicate or the array

┌             push "-"
 c            load the variable C
  ŗ           cycically replace "-" in maps result with the characters of C
   ā          push an empty array - the output
    ;{        for each item in the result of the replacement
      √         squareify it
       ┼        and append that to the output array
        @L*┼    top-to-bottom, left-to-right add 10 spaces to the array

JavaScript (Node.js) , 365 347 byte

Đã lưu 1 byte nhờ @Scoots

Trả về một mảng gồm 5 chuỗi. Bao gồm một không gian hàng đầu trên mỗi hàng.

37 36 byte bị mất khi chuyển đổi mọi thứ thành chữ hoa và khớp [A-Z0-9]: - /

a=>(a=a.toUpperCase(s=[...'     ']).match(/[A-Z\d]/g)).map(x=c=>(g=n=>n<35&&g(n+1,s[n<25?n/5|0:n%5]+=Buffer("mJ*Z?<^#?.&+o@V+`L7ho=Jkm?`:Tm)Km?ZZo@p*#MmjoCZ[=('ZoC#;?-g[RZW[>.cJ#Mmm?<^;Vp5[#p*]?,iM#KAm$$:Mm?0*R[#;-46B#qC;o==*X$(km?0-XDc=$.Mm#%]=X$*-?1M[".slice(parseInt(c,36)*(i=v=4))).map(c=>v+=c%80*80**--i)|v>>n&n<25?a[++x]||a[x=0]:' '))(0))&&s

Hãy thử trực tuyến!

Mã hóa ký tự

Các ký tự được mã hóa lộn ngược và được chuyển đổi thành cơ sở 80 tùy chỉnh với độ lệch là 4 , sử dụng phạm vi ASCII [35..114] .

Các giá trị 35 đến 79 được ánh xạ trực tiếp vào ký tự ASCII tương ứng, trong khi các giá trị từ 0 đến 34 được ánh xạ tới các ký tự 80 đến 114 . Điều này cho phép giải mã bằng cách lấy mã ASCII modulo 80 .

Chẳng hạn, 'F' được mã hóa thành "RZW[":

....#     00001
....#     00001
..### --> 00111 --> 0000100001001110000111111 --[decimal]--> 1088575 --[-4]--> 1088571
....#     00001
#####     11111

floor(1088571 / 80**3)        = 2    --> (( 2 + 45) mod 80) + 35 = 82  --> 'R'
floor(1088571 / 80**2) mod 80 = 10   --> ((10 + 45) mod 80) + 35 = 90  --> 'Z'
floor(1088571 / 80)    mod 80 = 7    --> (( 7 + 45) mod 80) + 35 = 87  --> 'W'
1088571                mod 80 = 11   --> ((11 + 45) mod 80) + 35 = 91  --> '['

Bắt đầu với i = v = 4 , nó được giải mã trở lại số nguyên 25 bit bằng cách thực hiện:

Buffer("RZW[").map(c => v += c % 80 * 80 ** --i)

Trong mã đầy đủ, chúng tôi thực sự xử lý một lát cắt không giới hạn () của luồng được mã hóa, điều đó có nghĩa là chúng tôi có khả năng lặp lại đáng kể hơn 4 lần. Đây không phải là vấn đề vì tất cả các lần lặp với i <0 sẽ chỉ ảnh hưởng đến phần thập phân của kết quả, dù sao cũng bị bỏ qua bởi các thao tác bitwise ngay lập tức.

Hãy thử trực tuyến!

C (gcc) , 792 690 byte

#define S strlen
#define V v[1][i]
#define A putchar(32);
#define F(x)(((G(x,0)*92+G(x,1))*92+G(x,2))*92+G(x,3))*92+G(x,4))
#define G(x,y)(f[(x-(x<58?48:55))*5+y]-35)
i,j,l;main(c,v)char**v;{l=S(v[c=1]);char*x[l],t[l+1],*p=t,*f="$dKqK&>%Q3&R`ms&RYXg#gAB/&b_R/$n>Pw&]?vO$cbu+$ccG#$csC+&X7sS$n0w[&X+={&b^%s&b^$W$n3qS%(4\\_&^Bjg&^Bj/%(Pec$xx%S%+L`/%*jjw$cel7&X7oS$NWLO&X7u3$n.U+&^BhG%(')k%'|*/%(+:'%%UO;%%U=K&]`{+";*x=t;for(;i<l;i++){V>96?V-=32:V;(V>47)&(V<58)|(V>64)&(V<91)?*(p++)=V:V;}*p=0;for(;c<S(t);)x[c++]=((__builtin_popcount(F(t[c-1])+x[c-1]-t)%S(t))+t;for(c=6;--c;){for(i=0;i<S(t);i++){for(j=5,l=1<<c*5+3;j--;)if((l>>=1)&F(t[i]){putchar(*x[i]++);!*x[i]?x[i]=t:x;}else A A A}puts(p);}}

Hãy thử trực tuyến!

Quản lý để siết chặt điều này dưới 800 với một số tái sử dụng biến. Đã chọn lưu trữ phông chữ dưới dạng một mảng int, vì mặc dù lưu trữ nó dưới dạng một chuỗi dài trông giống như một ý tưởng hấp dẫn, vì vậy nhiều đoạn 8 bit của phông chữ không phải là một ký tự ASCII tiện lợi mà các mã thoát đang chiếm nhiều ký tự hơn intmảng đã làm.

Chỉnh sửa: Rốt cuộc, dưới 700 bằng cách chuyển sang mã hóa chuỗi - phần nào lấy cảm hứng từ nhiều phản hồi khác ở đây, tôi đã ghép lại một đại diện cơ sở 92 bằng cách sử dụng (hầu hết) các ký tự ASCII có thể in được. Đại diện không bao gồm dấu gạch chéo ngược cần thêm phần thoát nhưng điều đó chỉ xảy ra một lần trong phông chữ.

Khác với điều đó không có gì quá hào nhoáng đang diễn ra - đầu vào (bao gồm đối số dòng lệnh đầu tiên) được sao chép vào một mảng ngăn xếp, trừ đi bất kỳ ký tự nào không có trong phông chữ và chữ cái viết thường được thay thế bằng chữ cái phiên bản chữ hoa, ký tự "pixel" mà mỗi chữ cái đầy đủ bắt đầu được tính toán (sử dụng __builtin_popcount có một tên dài nhưng vẫn tốt hơn bất kỳ phương pháp đếm bit nào tôi có thể nghĩ ra), và sau đó in ấn theo từng dòng. Trình biên dịch của khóa học xuất ra nhiều lần độ dài chương trình trong các cảnh báo.

Một số suy giảm dưới đây cho niềm vui xem của bạn:

//The defines are listed here for reference. Some are replaced in the below code but I still use F() because it's long.
#define S strlen
#define V v[1][i]
#define A putchar(32);
#define F(x)(((G(x,0)*92+G(x,1))*92+G(x,2))*92+G(x,3))*92+G(x,4))  //How to lookup a font character given an input char x
#define G(x,y)(f[(x-(x<58?48:55))*5+y]-35)                         //Used for looking up the individual parts of a character font
i, j, l;                                           // Declaring some int variables for later use.
main(c,v) char**v; {                               // Declaring afterwards lets us have the int arg default without declaring it
  l = strlen(v[c=1]);                              // Using l as a local variable to shorten S(v[1]) and also giving c an initial value here where there was a spare 1, saving a character over writing the full c=1 init in a later for loop.
  char t[l+1], *p=t, *x[l];                        // Declaring char arrays and char*s and char* arrays. t is oversized if there are any invalid characters in the input, but that's not important for golfing.
  char *f="$dKqK&>%Q3&R`ms&RYXg#gAB/&b_R/$n>Pw&]?vO$cbu+$ccG#$csC+&X7sS$n0w[&X+={&b^%s&b^$W$n3qS%(4\\_&^Bjg&^Bj/%(Pec$xx%S%+L`/%*jjw$cel7&X7oS$NWLO&X7u3$n.U+&^BhG%(')k%'|*/%(+:'%%UO;%%U=K&]`{+";      // The font, encoded base-92 with 5 characters to a letter in the order 0123456789ABCDEF... etc.
  *x=t;                                            // The first character's "pixels" will start at the beginning of the valid input.
  for(; i<strlen(l); i++){                         // Speaking of which, now validate the input.
    v[1][i] > 96 ? v[1][i] -= 32 : v[1][i];        // Change lowercase characters to uppercase. If they aren't actually lowercase characters but have ascii value >96, they won't end up valid after this either and will be edited out on the next line. The false case does nothing, but since with the macro it is one character using the ternary operator saves a character over an if statement even though that case ends up redundant.
    (v[1][i]>47)&(v[1][i]<58)|(v[1][i]>64)&(v[1][i]<91)?*(p++)=v[1][i]:v[1][i];        // If the character is now either a numeral or an uppercase letter, set the next spot in the t array by way of the pointer p and then increment said pointer. 
  }
  *p=0;                                            // Add the null terminator to the t array, our validated input string.
  for(;c<strlen(t);) {                             // Now find out at what index each letter should start getting "pixels" from.
    x[c++] = ((__builtin_popcount(F(t[c-1])+x[c-1]-t)%strlen(t))+t;          // Use the builtin to get the number of on bits/pixels in the previous letter, then add that to the previous letter's starting pixel and take the modulus strlen() of the valid string.
  }
  for(c=6; --c;){                                  // Now start the actual printing. For each line...
    for(i=0; i<strlen(t); i++){                    // For each letter...
      for(j=5, l=1<<c*5+3; j--;) {                 // For each pixel of the 5 on this line...
        if((l>>=1) & F(t[i]) {                     // If it is on...
          putchar(*x[i]++);                        // Print it and increment the pixel-fetching pointer for this letter.
          !*x[i]?x[i]=t:x;                         // If said pointer hit the end of the valid input go back to the beginning.
        } else {
          putchar(32);                             // If it is an off pixel, print a space.
        }
      }
      putchar(32);                                 // After a letter, print two spaces.
      putchar(32);
    }
    puts(p);                                       // This is the cheapest way in character count I could come up with to output a newline. p currently points to the end of t, so it is an empty string and puts just adds a newline.
  }
}

VBA Excel, 816 byte

Một chức năng cửa sổ ngay lập tức VBE ẩn danh nhận đầu vào từ phạm vi [A1]và đầu ra đến bàn điều khiển.

Theo như tôi biết, đây là câu trả lời VBA đầu tiên sử dụng base64nén.

For i=1To[Len(A1)]:c=Mid(UCase([A1]),i,1):y=y &IIf(c Like"[0-9A-Z]",c,""):Next:l=Len(y):Set d=New MSXML2.DOMDocument:Set d=d.createElement("b64"):d.DataType="bin.base64":d.Text="HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=":b=d.nodeTypedValue:For i=0To 112:k=Right("00000" &Evaluate("=Dec2Bin("&b(i)&")"),8)&k:Next:For i=1To 5:For j=1To l:c=UCase(Mid(y,j,1)):Z=c Like"[0-9]":s=s &IIf(c Like"[A-Z]",Mid(k,IIf(Z,1,25*(Asc(c)-55)+5*i),5)&" ",IIf(Z,Mid(k,25*(Asc(c)-48)+5*i,5)&" ","")):Next:s=Replace(Replace(s,0," "),1,"#") &vbLf:Next:Do:i=InStr(1+(g*l+h)*6+g,s,"#"):p=(p-e)Mod l:e=i<(g*l+h+1)*6+g:s=IIf(e,Left(s,i-1)&Replace(s,"#",Mid(y,p+1,1),i,1),s):g=g-(0=e):h=h-(g>4):g=g Mod 5:Loop While InStr(1,s,"#"):?s

Lưu ý: Câu trả lời này phụ thuộc vào Microsoft XML, v3.0tài liệu tham khảo VBA

Ví dụ I / O

[A1]="'0123456789"
For i=1To[Len(A1)]:c=Mid(UCase([A1]),i,1):y=y &IIf(c Like"[0-9A-Z]",c,""):Next:l=Len(y):Set d=New MSXML2.DOMDocument:Set d=d.createElement("b64"):d.DataType="bin.base64":d.Text="HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=":b=d.nodeTypedValue:For i=0To 112:k=Right("00000" &Evaluate("=Dec2Bin("&b(i)&")"),8)&k:Next:For i=1To 5:For j=1To l:c=UCase(Mid(y,j,1)):Z=c Like"[0-9]":s=s &IIf(c Like"[A-Z]",Mid(k,IIf(Z,1,25*(Asc(c)-55)+5*i),5)&" ",IIf(Z,Mid(k,25*(Asc(c)-48)+5*i,5)&" ","")):Next:s=Replace(Replace(s,0," "),1,"#") &vbLf:Next:Do:i=InStr(1+(g*l+h)*6+g,s,"#"):p=(p-e)Mod l:e=i<(g*l+h+1)*6+g:s=IIf(e,Left(s,i-1)&Replace(s,"#",Mid(y,p+1,1),i,1),s):g=g-(0=e):h=h-(g>4):g=g Mod 5:Loop While i<InStrRev(s,"#"):?s
 012  567   6789  0123    34  45678  9012 34567  234   567  
3  45   8       0     4  5 6  9     3         8 5   6 8   9 
6 7 8   9    123    567 78901 0123  4567     9   789   0123 
90  1   0   4         8    2      4 8   9   0   0   1     4 
 234  12345 56789 9012     3  5678   012   1     234  5678

Ungolfed và giải thích

Phần chính của giải pháp này lưu trữ phông chữ lớn dưới dạng chuỗi 64 cơ sở. Điều này được thực hiện bằng cách trước tiên chuyển đổi phông chữ thành nhị phân, trong đó 1đại diện cho một pixel và 0đại diện cho một pixel tắt. Ví dụ, cho 0, điều này được thể hiện dưới dạng

      ###     01110
     #  ##    10011
0 -> # # # -> 10101 --> 0111010011101011100101110
     ##  #    11001
      ###     01110

Với cách tiếp cận này, chữ số có thể được biểu diễn dưới dạng

0: 0111010011101011100101110    1: 1110000100001000010011111
2: 1111000001011101000011111    3: 1111000001001110000111110
4: 0011001010111110001000010    5: 1111110000111100000111110
6: 0111110000111101000101110    7: 1111100001000100010001000
8: 0111010001011101000101110    9: 0111010001011110000111110
A: 0111010001111111000110001    B: 1111010001111101000111110
C: 0111110000100001000001111    D: 1111010001100011000111110
E: 1111110000111001000011111    F: 1111110000111001000010000
G: 0111110000100111000101111    H: 1000110001111111000110001
I: 1111100100001000010011111    J: 1111100100001000010011000
K: 1000110010111001001010001    L: 1000010000100001000011111
M: 1000111011101011000110001    N: 1000111001101011001110001
O: 0111010001100011000101110    P: 1111010001111101000010000
Q: 0110010010101101001001101    R: 1111010001111101001010001
S: 0111110000011100000111110    T: 1111100100001000010000100
U: 1000110001100011000101110    V: 1000110001010100101000100
W: 1000110001101011101110001    X: 1000101010001000101010001
Y: 1000101010001000010000100    Z: 1111100010001000100011111

Các phân đoạn này được nối và chuyển đổi thành MSXML cơ sở 64, kết xuất

HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnzTHGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc=

Chương trình con bên dưới lấy cái này, chuyển đổi thành nhị phân và sử dụng tham chiếu này để xây dựng chuỗi đầu ra, từng dòng, lấy 5 pixel trên cùng của mỗi ký tự, sau đó là hàng thứ hai và cứ thế cho đến khi chuỗi được xây dựng .

Chương trình con sau đó lặp lại chuỗi đầu ra và thay thế các pixel 'trên' bằng các ký tự từ chuỗi đầu vào.

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''
''  Embiggen Function
''
''  @Title  :   Embiggen
''  @Author :   Taylor Scott
''  @Date   :   15 June 2018
''  @Desc   :   Function that takes input, value, and outputs a string in which
''              value has been filtered to alphnumerics only, each char is then
''              scaled up to a 5x5 ASCII art, and each 'pixel' is replaced with
''              a char from value. Replacement occurs letter by letter, line by
''              line
''
''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
Function EMBIGGEN(ByVal value As String) As String

    Dim DOM         As New MSXML2.DOMDocument, _
        bytes()     As Byte

    Dim isNum       As Boolean, _
        found       As Boolean, _
        index       As Integer, _
        length      As Integer, _
        line        As Integer, _
        letter      As Integer, _
        pos         As Integer, _
        alphanum    As String, _
        char        As String, _
        filValue    As String, _
        outValue    As String

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Filter input
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For letter = 1 To Len(value) Step 1             ''  Iterate Accross `Value`
        Let char = Mid$(UCase(value), letter, 1)    ''  Take the nth char
        ''  If the char is alphnumeric, append it to a filtered input string
        Let filValue = filValue & IIf(char Like "[0-9A-Z]", char, "")
    Next letter
    Let length = Len(filValue)                      ''  store length of filValue

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Convert Constant from Base 64 to Byte Array
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    With DOM.createElement("b64")           ''  Construct b64 DOM object
        Let .DataType = "bin.base64"        ''  define type of object`
        ''  Input constructed constant string shown above
        Let .Text = "HxHxCSEqRkVUjLvGSJSK0cUYIyGEfB8cfFH66Ju0kkHoo3cxRhdnz" & _
                     "THGuuOHEMIouYyYEPI/IeTH+GN8ccIHIYf/Qw6/jzH6ByF8PvroY/" & _
                     "zR+fCic9FFh4gI30UPnw8efiG+Mj6c4D90wX9CCHe5Tgc="
        Let bytes = .nodeTypedValue         ''  Pass resulting bytes to array
    End With

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Convert Byte Array to Byte String
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For index = 0 To 112 Step 1
        '' convert each byte to binary, fill left with `0`s and prepend
        Let alphanum = _
            Right("00000" & Evaluate("=Dec2Bin(" & bytes(index) & ")"), 8) & _
            alphanum
    Next index

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Construct Embiggened Binary String of Input Value
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    For line = 1 To 5 Step 1                ''  iterate across lines
        For letter = 1 To length Step 1     ''  iterate across letters
            ''  take the corresponding letter from
            Let char = UCase(Mid(filValue, letter, 1))
            If char Like "[0-9]" Then       '' if it is a number,
                ''  Add the 5 bit corresponding to number at line
                Let outValue = outValue & _
                    Mid$(alphanum, 25 * Val(char) + 5 * line, 5) & " "
            ElseIf char Like "[A-Z]" Then   '' if it is a letter,
                ''  Add the 5 bits corresponding to letter at line
                Let outValue = outValue & _
                    Mid$(alphanum, 25 * (Asc(char) - 55) + 5 * line, 5) & " "
            End If
            Next letter
        Let outValue = outValue & IIf(line < 5, vbLf, "")
    Next line
    Let outValue = Replace(Replace(outValue, 0, " "), 1, "#")

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Replace #s with Input Value
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Let pos = 0                             ''  Reset position in filValue
    Let line = 0                            ''  Reset line index
    Let letter = 0                          ''  Reset letter index
    Do
        ''  Find the index of the first `#` starting at line and letter
        Let index = _
            InStr(1 + (line * length + letter) * 6 + line, outValue, "#")
        ''  Iterate position in filValue if a `#` is found in that letter & line
        Let pos = (pos - found) Mod length
        ''  check to see if found index is in the correct letter
        Let found = index < (line * length + letter + 1) * 6 + line
        ''  iff so, replace that # with letter in filValue corresponding to pos
        Let outValue = IIf(found, _
            Left(outValue, index - 1) & _
                Replace(outValue, "#", Mid(filValue, pos + 1, 1), index, 1), _
            outValue)
        ''  if not found, them iterate line
        Let line = line - (found = False)
        ''  iterate letter every five iterations of line
        Let letter = letter - (line > 4)
        ''  Ensure that line between 0 and 4 (inc)
        Let line = line Mod 5
    ''  Loop while there are '#'s in outValue
    Loop While InStr(1, outValue, "#")

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Output
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Let EMBIGGEN = outValue

    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    ''
    ''  Clean Up
    ''
    ''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
    Set DOM = Nothoing
End Function

K (ngn / k) , 230 231 byte

(+1 byte sau khi thay đổi ngôn ngữ impl)

f:{{x,'"  ",/:y}/(#s;5;5)#@[(#c)#"";i;:;(#i:&c:,/(36 25#4_,/+2\a)s)#`c$b s:((b:(48+!10),65+!26)?x-32*(96<x)&x<123)^0N]}

Hãy thử trực tuyến!

Ở đâu a một chuỗi ký tự được trích dẫn mã hóa phông chữ. K xem các chuỗi là chuỗi byte, do đó, một chương trình chứa một chữ như vậy là hợp lệ, nhưng nó không thể chạy trên TIO, vì dạng HTML của nó cố gắng diễn giải nó thành UTF-8 và làm rối tung nó.

Số lượng byte được tính như sau:

• 119 được báo cáo bởi TIO

• -2 để đặt tên hàm f:

• -1 cho trình giữ chỗ a

• 2 cho một cặp trích dẫn ""

• 113 cho độ dài của chuỗi ký tự akhông chứa bất kỳ ký tự nào yêu cầu thoát