이것은 먼지로 덮인이 항목 과 약간 비슷 하지만 스핀이 충분히 독창적이기를 바랍니다. 내가 이것을 게시하지 못하게하는 것을 찾을 수 없었지만 거기에는 꽤 바다가 있습니다.

어쨌든! 도전 과제 :

코드는 문자열을받습니다. 이를 동일한 문자열의 ASCII 아트 스타일 버전으로 변환하지만 캐치가 있습니다.

입력 변환

• 지원되는 유일한 문자는 AZ와 0-9입니다.
• 소문자는 대문자로 변환됩니다
• 다른 것은 자동으로 제거됩니다

캐릭터 그리기

• 확대 된 글꼴의 각 "픽셀"은 입력 문자열에서 가져옵니다.
• n 번째 픽셀은 입력 문자열에서 n 번째 문자와 같습니다. n이 입력 문자열의 길이보다 큰 경우 처음으로 다시 둘러 쌉니다.
• 개별 문자는 왼쪽에서 오른쪽으로, 위에서 아래로 그려집니다.
• 후속 문자는 마지막 문자가 남은 위치에서 "픽셀 문자"인덱스를 가져옵니다 (예 : 입력 길이가 10 인 경우 첫 번째 문자에 9 개의 픽셀이있는 경우 두 번째 문자의 첫 번째 픽셀은 두 번째 문자의 두 번째 문자로 그려 짐) 첫 번째 입력 문자로 픽셀이 그려집니다)
• 각 문자는 공백으로 채워진 5x5 격자로 그려집니다. 이 페이스트 빈 에서 미리 렌더링 된 글꼴을 찾거 나이 게시물에서 조금 더 찾을 수 있습니다.
• 모든 문자는 같은 줄에 그려 지므로 출력에서 ​​줄 바꿈의 총 개수는 4가됩니다.
• 모든 문자는 2 열의 공백으로 구분됩니다.

폰트

 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

_{^{네, 4와 Q가 못 생겼다는 걸 압니다}}

예

입력

0123456789

산출

 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 

또 다른 예

입력

a3 B'2

산출

 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

표준 허점 은 금지되어 있습니다. 코드 골프이므로 녹색 체크 표시가 없습니다.

파이썬 (2) , _{413 (411) 373 364 352} 345 바이트

Kevin Cruijssen 덕분에 -1 바이트 . Jo King
덕분에 -9 바이트 . Lynn 덕분에 -1 바이트 .

_{데이터 문자열에는 인쇄 할 수없는 이스케이프 된 버전이 포함되어 있습니다.}

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

온라인으로 사용해보십시오!

각 문자는 25 픽셀이므로 25 비트로 쉽게 인코딩 할 수 있습니다. 기수 (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'는 모든 문자 0를 인코딩하고, 최하위 25 비트에 의해 인코딩 1되고, 다음 25 비트에 Z의해 인코딩되고, 25 개의 최상위 비트에 의해 인코딩된다. 단일 문자는 다음 순서로 인코딩됩니다.

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

^{( 가장 중요한 00비트, 25가장 중요한 비트 )}

공백은 0이 아닌 공백으로 1이 인코딩됩니다. 예 :

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

언 골프

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

온라인으로 사용해보십시오!

APL (Dyalog Unicode) , 228 (225) 224 214 바이트

전체 프로그램. 문자열을 stdin 프롬프트합니다. 표준 출력으로 인쇄합니다. 코드의 약 절반은 인코딩 된 알파벳을 해독하는 것입니다.

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

_… _다음 143 바이트 LZ4 인코딩 문자열을 따옴표로 나타냅니다."⊥\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ááЀ€€€€€€"

온라인으로 사용해보십시오!

_…_  143 바이트 LZ4 인코딩 문자열 (따옴표)

⎕AV⍳ ɩ 에서 그 ndices 토믹 V의 엑터 (문자 세트)

¯125+ 그것에 -125를 더하십시오 (부호있는 8 비트 정수를 얻으려면)

¯1(219⌶) LZ4 압축 해제

0(220⌶) 36 계층, 5 행, 5 열 부울 배열로 역 직렬화

(… )⌷ 다음 지수를 사용하여 색인을 작성하십시오.

 ⎕A 대문자 A lphabet

 ⎕D, 앞에 추가 D의 igits을

 a← 에 저장 a(위한 lphabet)

 (… )∩ 다음과의 교차점 (유효하지 않은 입력 제거) :

  ⍞ stdin에서 텍스트 입력 프롬프트 (콘솔)

  1(819⌶) 대문자로 접습니다 ( 819예 Big: 1은 작은 것이 아니라 큰 것입니다)

 i← 저장소에 i(대해 내가 nput)

 a⍳ ndi의 ndicesa

 ⊂ 동봉 (선행 좌표를 나타내는 각각의 색인으로)

t← 의 저장 t을 위해 ( t EXT)

, 라벨 (평평하게)

r← 의 저장 r을 위해 ( R avelled)

+/ 합계 (즉, 아트웍을 그리는 데 필요한 문자 수)

i⍴⍨주기적으로 r 그 길이로 입력 eshape

r\ 그것을 확장; 0에 공백을 삽입하고 1에 문자를 소비

(…) ⍴`는 다음과 같은 형태로 변형됩니다 :

 ⍴t 텍스트의 모양

↓ Nx5x5 배열을 Nx5 행렬의 아트 라인으로 분할

⍉ 아트 라인의 5xN 행렬로 전치 (문자의 해당 라인을 정렬)

기본적으로 APL은 중첩 배열의 간단한 요소를 2 개의 공백으로 구분합니다.

파이썬 2 , 428 바이트

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)

온라인으로 사용해보십시오!

문자는 다음과 같이 인코딩됩니다.

각각의 고유 한 부분 (23 개가 있음)은 이진수로 변환되고 1이 앞에 추가됩니다. 그런 다음베이스 36으로 변환됩니다.

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

결과 base-36 숫자는 다음과 같습니다.

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

이니셜 1은 제거되므로 단일 문자가 있습니다.

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

A-Z0-9그런 다음 각 문자 ( )는이 새로운 문자 5 개로 인코딩됩니다.

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

다섯 가지 목록으로 :

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

입력을이 목록의 색인에 맵핑하기 위해 서 수가 수정됩니다.

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

서 수가 0-35가 아니라 약간 혼합되어 있으므로 5 개의 목록이 재정렬되고 연결됩니다.

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

입력의 각 문자에 대해 5 글자가 발견되고 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

숫자가 아래 30에 36있으면가 추가됩니다 ( 1이전에 누락 된 부분 없음)

n+36*(n<30)

그런 다음 숫자는 다시 이진수로 변환되고 0s와 1s는 및. . 변환하는 동안 끝에 두 개의 공백이 추가됩니다.

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

예 :

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

.결과에서 각각 에 대해 입력에서 다음 문자로 대체됩니다 (로 x표시됨).

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

Java 8, 917 907 바이트

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]:" ";}

적어도 현재 바이트 수를 절반으로 줄이려면 여기에서 골프를 타십시오 ..

온라인으로 사용해보십시오.

설명:

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

apt v2.0a0 -R , 213 211 210 209 206 193 191 190 바이트

각 줄에 선행 공간을 포함합니다.

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

시도 하거나 모든 문자를 테스트하십시오 (추가 바이트는 TIO가 Japt v2를 아직 지원하지 않기 때문에 발생합니다)

설명

조회 테이블

문자열에서 ...공간을 절약하기 위해 여기에 표시되고 인쇄 할 수없는 많은 문자가 포함되어 있기 때문에 4 개의 문자로 구성된 각 그룹은 줄 바꿈이 제거되고 base-100으로 변환 된 각 문자 ( 0공백, 1문자) 의 이진 표현입니다 .

예

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

코드

                                                :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

루비 , 366 바이트

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

온라인으로 사용해보십시오!

이것은 골프를 많이 할 수 있지만 지금은 시간과 아이디어가 부족합니다. 처음에 생각했던 것보다 더 힘들었습니다.

작동 방식 :

이해하기가 어렵지 않습니다. 알파벳이 예제로 어떻게 코딩되는지 설명하겠습니다. 모든 문자의 모든 줄은 이진수로 변환 된 다음 base-36으로 변환됩니다.

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

첫 번째 단계는 입력 문자열에서 모든 영숫자가 아닌 문자를 제거하는 것입니다.

그런 다음 줄마다 줄을 인쇄하기 때문에 최종 렌더링을위한 조회 테이블을 생성합니다.

그런 다음 알파벳 줄을 반복하여 문자의 이진 패턴을 만듭니다.

마지막으로 0을 공백으로 바꾸고 1을 조회 테이블의 문자로 바꿉니다.

더 자유롭게 골프를 타십시오. 이것은 20-30 바이트 더 짧을 수 있다는 것을 알고 있습니다 (tr 대신 gsub 사용 등). 그러나 알파벳 테이블을 크게 작게 만들 수 없다면 관심이 없습니다.

숯 , 172 164 바이트

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

온라인으로 사용해보십시오! 링크는 자세한 버전의 코드입니다. 설명:

≔⁺⭆χιαα

숫자를 사전 정의 된 대문자 알파벳으로 시작하십시오.

≔Φ↥Ｓ№αιθ

입력을 대문자로하고 지원되지 않는 모든 문자를 필터링하십시오.

Ｆθ«

나머지 문자를 반복합니다.

Ｅ⁵

각 행을 반복하여 각 결과를 자체 행에 내재적으로 인쇄합니다.

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

압축 된 문자열은 @ovs의 큰 정수 상수이며 이진수로 변환되고 반대로 변환됩니다. 그런 다음 5 개의 문자로 구성된 180 개의 하위 문자열로 분할 된 다음 현재 문자 및 행의 관련 하위 문자열이 반복됩니다.

⎇Ｉμ§θ⊖Ｌ⊞Ｏυω 

비트가 설정된 경우 필터링 된 입력의 다음 문자를 주기적으로 인쇄하고 그렇지 않으면 공백을 인쇄합니다.

Ｍ⁷±⁵

다음 문자를 인쇄 할 수 있도록 커서를 놓습니다.

펄 5 와 -nlaF/[^A-Za-z0-9]+|/247 바이트,

@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@

온라인으로 사용해보십시오!

설명

먼저 ed 데이터 를 %l사용하여 검색 테이블을 pack만듭니다. 이 데이터는 다른 응답과 마찬가지로 25 비트 이진 문자열 (113 바이트로 저장 됨-숯보다 1 바이트 더 큼!)로 압축 된 각 문자의 900 비트 이진 문자열입니다 A.

 AAA 
A   A
AAAAA
A   A
A   A

사용하는 0공간과 1에 대한 A있습니다 :

01110
10001
11111
10001
10001

줄 바꿈이 없으면 다음과 같습니다.

0111010001111111000110001

조회는 각 유효 문자 위에 우리 반복 처리를 초기화되면 @F(이는 펄 사용 채워진 -a목록의 5 개 각 요소에 추가 utosplit 옵션)를 @;모두 대체하는 룩업부터 배열의 각 행 1에 (S) uc$F[$i++%@F]는 IS되는 $i토륨 문자 (모듈 @F의 길이 @F)로 변환 upper의 cASE, 그리고 모두가 0함께 s의 $"공간에있는 기본 설정됩니다. 각 인덱스되면 @;각 문자를 채워집니다 @F, say뒤에 줄 바꿈 각 행을 인쇄합니다.

참고 : 뒤에 문자열 unpack에는 \xXX표기법을 사용하여 이스케이프 할 수없는 인쇄 할 수없는 항목이 포함되어 있습니다 . 247 점의 검증 .

SOGL V0.12 , 165 (164) 163 바이트

⁰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*┼

여기 사용해보십시오!

설명:

...“                 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 바이트

@Scoots 덕분에 1 바이트 절약

5 개의 문자열 배열을 반환합니다. 각 행에 선행 공간을 포함합니다.

모든 것을 대문자로 변환하고 일치 시키면 37 36 바이트가 손실됩니다 [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

온라인으로 사용해보십시오!

문자 인코딩

ASCII 범위를 사용하여 문자가 거꾸로 인코딩되고 오프셋이 4 인 사용자 정의 base-80으로 변환됩니다 [35..114] .

값 35 행 79 값하면서 직접 대응 ASCII 문자로 매핑되는, 0 행 34 문자로 매핑되는 80 행 114 . 이것은 ASCII 코드 modulo 80을 취함으로써 해독 할 수 있습니다 .

예를 들어 'F' 는 다음과 같이 인코딩됩니다 "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  --> '['

i = v = 4로 시작하여 다음 을 수행하여 25 비트 정수로 다시 디코딩됩니다.

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

전체 코드에서 우리 는 인코딩 된 스트림의 무한 슬라이스 () 를 실제로 처리 합니다. 이는 4 배 이상 크게 반복 될 가능성이 있음을 의미합니다 . i <0의 모든 반복 은 결과의 소수 부분에만 영향을 미치므로 즉시 따르는 비트 단위 연산에 의해 무시 되므로 문제가되지 않습니다 .

온라인으로 사용해보십시오!

C (gcc) , 792690 바이트

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

온라인으로 사용해보십시오!

가변적 인 재사용으로 800 미만으로 이것을 압축했습니다. int하나의 긴 문자열로 저장하면 매력적인 아이디어처럼 보이지만 글꼴의 8 비트 청크 중 많은 수가 이스케이프 코드가 차지하는 편리한 ASCII 문자가 아니기 때문에 글꼴 을 s 배열로 저장하도록 선택했습니다. 보다 많은 문자int 배열 .

편집 : 결국 문자열 인코딩으로 전환하여 700 이하가되었습니다. 여기의 많은 다른 응답에서 다소 영감을 얻었습니다. 인쇄 가능한 ASCII 문자 (대부분)를 사용하여 base-92 표현을 함께 모았습니다. 이스케이프에는 백 슬래시가 포함되어 있으며 이스케이프 처리를 위해 여분의 문자가 필요하지만 글꼴에서 한 번만 발생합니다.

그 외에는 너무 화려하지는 않습니다. 첫 번째 명령 줄 인수로 구성된 입력은 글꼴에없는 문자와 소문자로 대체 된 문자를 제외한 스택 배열로 복사됩니다. 대문자 버전에서 각 전체 문자가 시작하는 "픽셀"문자가 계산됩니다 ( __builtin_popcount 고통 적으로 긴 이름을 사용하지만 생각할 수있는 비트 수를 계산하는 방법보다 여전히 낫습니다). 그러면 인쇄가 한 줄씩 진행됩니다. 물론 컴파일러는 프로그램 길이의 여러 배를 경고로 출력합니다.

시청의 즐거움을 위해 아래에서 다소 디 고프했습니다.

//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.
  }
}

Excel VBA, 816 바이트

범위에서 입력 [A1]을 받아 콘솔로 출력 하는 익명의 VBE 즉시 창 기능 .

내가 아는 한, 이것은 base64압축 을 사용하는 첫 번째 VBA 답변 입니다.

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

참고 :이 답변은 Microsoft XML, v3.0VBA 참조 에 따라 다릅니다.

예제 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

언 골프 및 설명

이 솔루션의 주요 부분은 큰 글꼴을 기본 64 문자열로 저장합니다. 이것은 먼저 글꼴을 이진으로 변환하여 수행됩니다. 여기서 1on 픽셀을 0나타내고 off 픽셀을 나타냅니다. 예를 들어,에 대해서는 다음 0과 같이 표시됩니다.

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

이 방법을 사용하면 영숫자를 다음과 같이 나타낼 수 있습니다.

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

이 세그먼트는 연결되어 MSXML base 64로 변환되어 렌더링됩니다.

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

아래의 서브 루틴은 이것을 다시 이진수로 변환하고, 출력 문자열을 한 줄씩 작성하고, 각 문자의 맨 위 5 픽셀을 잡고, 두 번째 행을 잡고 문자열이 생성 될 때까지 참조를 사용합니다. .

그런 다음 서브 루틴은 출력 문자열을 반복하고 'on'픽셀을 입력 문자열의 문자로 바꿉니다.

''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''
''
''  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) 바이트

(언어 impl 변경 후 +1 바이트)

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

온라인으로 사용해보십시오!

어디 a 글꼴을 인코딩하는 인용 된 문자열 리터럴입니다. K는 문자열을 바이트 시퀀스로 인식하므로 이러한 리터럴을 포함하는 프로그램은 유효하지만 HTML 양식이 UTF-8로 해석하여 엉망으로 만들므로 TIO에서 실행할 수 없습니다.

바이트 수는 다음과 같이 계산됩니다.

• TIO가보고 한 119

• 함수의 이름을 지정하는 경우 -2 f:

• 자리 표시 자의 경우 -1 a

• 한 쌍의 따옴표에 2 ""

• a이스케이프가 필요한 문자를 포함하지 않는 문자열 리터럴의 길이는 113