Esto es un poco similar a esta entrada cubierta de polvo, pero espero que mi giro lo haga lo suficientemente único. No he podido encontrar nada que me disuade de publicar esto, pero hay bastante mar por ahí.

¡De todas formas! El reto:

Su código recibe una cadena de caracteres; Convierte esto en una versión de estilo ASCII-art de la misma cadena, pero con una captura.

Transformación de entrada

• Los únicos caracteres que se admiten son AZ y 0-9.
• Las letras minúsculas se transforman en mayúsculas
• Todo lo demás se elimina silenciosamente.

Dibujo de personajes

• Cada "píxel" de la fuente ampliada se dibuja desde la cadena de entrada
• El enésimo píxel es igual al enésimo carácter en la cadena de entrada. Si n es mayor que la longitud de la cadena de entrada, regrese al principio
• Las letras individuales se dibujan de izquierda a derecha, de arriba a abajo
• Las letras posteriores recogen su índice de "carácter de píxel" de donde quedó la última letra (por ejemplo, con una longitud de entrada de 10, si la primera letra tenía 9 píxeles, el primer píxel de la segunda letra se dibujará con el décimo carácter de entrada, el segundo el píxel se dibujará con el primer carácter de entrada)
• Cada letra se dibuja en una cuadrícula de 5x5, completamente rellenada con espacios. Puedes encontrar la fuente que vas a usar pre-renderizada para ti en este pastebin o un poco más abajo en esta publicación
• Cada letra se dibuja en la misma línea, por lo que el número total de saltos de línea en su salida será 4
• Cada letra está separada por 2 columnas de espacios

La fuente

 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

_{^{Sí, sé que 4 y Q son feos}}

Un ejemplo

Entrada

0123456789

Salida

 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 

Otro ejemplo

Entrada

a3 B'2

Salida

 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

Las lagunas estándar están prohibidas. Codifique el golf para que no se dé la marca verde.

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

-1 byte gracias a Kevin Cruijssen .
-9 bytes gracias a Jo King .
-1 byte gracias a Lynn .

_{La cadena de datos contiene versiones no imprimibles, escapadas a continuación}

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

Pruébalo en línea!

Como cada personaje tiene 25 píxeles, puede codificarse fácilmente en 25 bits. El número base 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'codifica todos los caracteres, 0está codificado por los 25 bits menos significativos, 1por los siguientes 25 bits y Zestá codificado por los 25 bits más significativos. Se codifica un solo carácter en el siguiente orden:

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

^{( 00es el bit menos significativo, 25el más significativo)}

Los espacios están codificados por un cero, no espacios por uno. Ejemplo :

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

Sin golf

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

Pruébalo en línea!

APL (Dyalog Unicode) , 228 225 224 214 bytes

Programa completo Solicita stdin para cadena. Imprime en stdout. Aproximadamente la mitad del código solo decodifica el alfabeto codificado.

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

_... _representa la siguiente cadena codificada LZ4 de 143 bytes entre comillas:"⊥\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ááЀ€€€€€€"

Pruébalo en línea!

_… _ Cadena de 143 bytes con codificación LZ4 entre comillas

⎕AV⍳ ɩ ndices de que en el A tomic V ector (el juego de caracteres)

¯125+ agregue -125 a eso (para obtener enteros de 8 bits firmados)

¯1(219⌶) Descompresión LZ4

0(220⌶) deserializar a una matriz booleana de 36 capas, 5 filas y 5 columnas

(... )⌷ indexe eso usando los siguientes índices:

 ⎕Aalfabeto  mayúscula A

 ⎕D, anteponer los D igits

 a← almacenar en a(para un alfabeto)

 (... )∩ intersección de lo siguiente y eso (elimina la entrada no válida):

  ⍞ solicitud de entrada de texto desde stdin (consola)

  1(819⌶) doblar a mayúsculas ( 819parece que Big1 es para sí grande en lugar de pequeño)

 i← tienda en i(para i Nput)

 a⍳ d nices de eso ena

 ⊂ adjuntar (para indexar con cada uno representando la coordenada principal)

t← almacenar en t(por t ext)

, ravel (aplanar)

r← almacenar en r(para r avelled)

+/ suma que (es decir, la cantidad de caracteres necesarios para pintar la obra de arte)

i⍴⍨cíclicamente r eshape la entrada a la longitud

r\ expandir eso; inserte espacios en 0s, consuma letras en 1s

(…) ⍴` remodelar a la siguiente forma:

 ⍴t la forma del texto

↓ dividir la matriz N por 5 por 5 en una matriz N por 5 de líneas artísticas

⍉ transponer en una matriz de 5 por N de líneas de arte (esto alinea las líneas correspondientes de los caracteres)

Por defecto, APL separa elementos simples de una matriz anidada con 2 espacios.

Python 2 , 428 bytes

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)

Pruébalo en línea!

Las letras están codificadas de la siguiente manera:

Cada parte única (hay 23) se convierte en binario y se agrega un 1 al frente. Luego se convierte a la base 36.

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

Los números de base 36 resultantes son:

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

La inicial 1se elimina, por lo que tenemos un solo carácter:

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

Cada letra ( A-Z0-9) se codifica a cinco de estos nuevos caracteres.

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

En cinco listas:

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

Para asignar la entrada a un índice en estas listas, se modifica el ordinal:

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

Debido a que los ordinales no son 0-35, sino que están ligeramente mezclados, las 5 listas se reorganizan y se concatenan:

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

Para cada carácter en la entrada, se encuentran 5 letras y se convierten en 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

Si el número está debajo 30, 36se agrega (los que faltamos 1eliminamos anteriormente)

n+36*(n<30)

Luego, el número se convierte de nuevo a binario, y 0sy 1s se convierten en y .. Se agregan dos espacios al final durante la conversión.

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

P.ej.

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

Para cada uno .en el resultado, se reemplaza por el siguiente carácter de la entrada (iterado por x)

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

Java 8, 917 907 bytes

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

Lo jugará golf desde aquí para reducir al menos a la mitad el conteo de bytes actual con suerte.

Pruébalo en línea.

Explicación:

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 bytes

Incluye un espacio inicial en cada línea.

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

Pruébelo o pruebe todos los caracteres (los bytes adicionales se deben a que TIO aún no admite Japt v2)

Explicación

Tabla de búsqueda

Cada grupo de 4 caracteres en la cadena (representada ...aquí para ahorrar espacio y porque contiene un montón de no imprimibles) es la representación binaria de cada carácter ( 0para espacios, 1para caracteres) con las nuevas líneas eliminadas y convertidas a base-100.

Ejemplo

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

El código

                                                :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

Rubí , 366 bytes

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

Pruébalo en línea!

Esto se puede jugar mucho, pero ahora me he quedado sin tiempo e ideas. Fue más difícil de lo que pensé solo para que funcionara.

Cómo funciona:

No es tan difícil de entender, solo explicaré cómo se codifica el alfabeto con un ejemplo. Cada línea de cada personaje se convierte en binario y luego en base-36.

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

El primer paso es quitar todos los caracteres no alfanuméricos de la cadena de entrada.

Luego genero una tabla de búsqueda para el renderizado final, porque quiero imprimir línea por línea.

Después de eso, iterando en la línea del alfabeto, creo el patrón binario de las letras.

Finalmente, reemplazo 0 con espacios y 1 con caracteres de la tabla de búsqueda.

Siéntase libre de jugar más golf, sé que esto podría ser 20-30 bytes más corto (usando gsub en lugar de tr, etc.), pero ahora no estoy interesado, a menos que pueda hacer que la tabla del alfabeto sea drásticamente más pequeña.

Carbón de leña , 172 164 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

≔⁺⭆χιαα

Prefije los dígitos al alfabeto en mayúsculas predefinido.

≔Φ↥Ｓ№αιθ

Ponga en mayúscula la entrada y filtre todos los caracteres no compatibles.

Ｆθ«

Recorre los personajes restantes.

Ｅ⁵

Pase sobre cada fila, imprimiendo implícitamente cada resultado en su propia línea.

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

La cadena comprimida es la constante entera grande de @ ovs, convertida a binaria e invertida. Luego se divide en 180 subcadenas de 5 caracteres, y la subcadena relevante para el carácter y la fila actual se repite.

⎇Ｉμ§θ⊖Ｌ⊞Ｏυω 

Si se configuró el bit, imprima cíclicamente el siguiente carácter de la entrada filtrada; de lo contrario, imprima un espacio.

Ｍ⁷±⁵

Coloque el cursor listo para imprimir el siguiente carácter.

Perl 5 con -nlaF/[^A-Za-z0-9]+|/247 bytes

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

Pruébalo en línea!

Explicación

Primero se crea una tabla de búsqueda al %lusar los packdatos ed. Estos datos son una cadena binaria de 900 bits de cada char empaquetada como una cadena binaria de 25 bits (almacenada como 113 bytes, ¡solo 1 byte más que el carbón!), Similar a algunas otras respuestas, así Aes:

 AAA 
A   A
AAAAA
A   A
A   A

que, usando 0para espacio y 1para Aes:

01110
10001
11111
10001
10001

y sin los saltos de línea es:

0111010001111111000110001

Una vez que se inicializa la búsqueda, iteramos sobre cada char válido @F(que se completa utilizando la -aopción utosplit de Perl ) añadiendo a cada uno de los 5 elementos de la lista @;para cada fila en la matriz de la búsqueda, reemplazando todos los 1s con los uc$F[$i++%@F]cuales es el $ith carácter (módulo @Fque es la longitud de @F) convertido a upper case, y todos los 0s con los $"valores predeterminados al espacio. Una vez que @;se rellena cada índice para cada carácter @F, sayimprime cada línea con una nueva línea final.

Nota : la cadena posterior unpackcontiene elementos no imprimibles que se escapan utilizando la \xXXnotación. Verificación de puntaje de 247 .

SOGL V0.12 , 165 164 163 bytes

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

Pruébalo aquí!

Explicación:

...“                 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 bytes

Guardado 1 byte gracias a @Scoots

Devuelve una matriz de 5 cadenas. Incluye un espacio inicial en cada fila.

37 36 bytes se pierden al convertir todo a mayúsculas y hacer coincidir [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

Pruébalo en línea!

Codificación de caracteres

Los caracteres se codifican al revés y se convierten en una base 80 personalizada con un desplazamiento de 4 , utilizando el rango ASCII [35..114] .

Los valores 35 a 79 se asignan directamente al carácter ASCII correspondiente, mientras que los valores 0 a 34 se asignan a los caracteres 80 a 114 . Esto permite decodificar simplemente tomando el código ASCII módulo 80 .

Por ejemplo, 'F' se codifica como "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  --> '['

Comenzando con i = v = 4 , se decodifica de nuevo a un entero de 25 bits haciendo:

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

En el código completo, en realidad procesamos un segmento sin límites () de la secuencia codificada, lo que significa que es probable que iteremos significativamente más de 4 veces. Esto no es un problema porque todas las iteraciones con i <0 solo afectarán la parte decimal del resultado, lo cual es ignorado de todos modos por las operaciones bit a bit que siguen inmediatamente.

Pruébalo en línea!

C (gcc) , 792 690 bytes

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

Pruébalo en línea!

Se las arregló para exprimir esto por debajo de 800 con alguna reutilización variable. Optaron por almacenar la fuente como una matriz de ints, ya que aunque almacenarla como una cadena larga parecía una idea atractiva, muchos de los fragmentos de 8 bits de la fuente no eran un carácter ASCII conveniente y agradable que los códigos de escape estaban tomando más personajes que la intmatriz.

Editar: obtuve menos de 700 al cambiar a una codificación de cadena después de todo, algo inspirado por muchas de las otras respuestas aquí, improvisé una representación de base 92 usando (la mayoría de) los caracteres ASCII imprimibles. La representación incluye barras invertidas que necesitan un extra para escapar pero eso solo ocurre una vez en la fuente.

Aparte de eso, no hay mucho que sea demasiado llamativo: la entrada (que consiste en el primer argumento de la línea de comandos) se copia en una matriz de pila, menos los caracteres que no están en la fuente y con letras minúsculas reemplazadas por sus en mayúsculas, se calcula qué carácter de "píxel" comienza cada letra completa (el uso __builtin_popcounttiene un nombre dolorosamente largo pero aún mejor que cualquier método de contar con bits que se me ocurra), y luego la impresión se realiza línea por línea. El compilador, por supuesto, genera varias veces la duración del programa en advertencias.

Debajo de un poco de desnivel para su placer visual:

//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 bytes

Una función de ventana inmediata anónima VBE que toma la entrada del rango [A1]y las salidas a la consola.

Hasta donde yo sé, esta es la primera respuesta de VBA para usar la base64compresió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

Nota: esta respuesta depende de la Microsoft XML, v3.0referencia de VBA

Ejemplo de E / S

[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

No golfista y explicado

La mayor parte de esta solución almacena la fuente grande como una cadena base 64. Esto se realiza convirtiendo primero la fuente a binario, donde 1representa un píxel 0activado y representa un píxel inactivo. Por ejemplo, para 0, esto se representa como

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

Con este enfoque, los alfanuméricos se pueden representar como

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

Estos segmentos se concatenaron y se convirtieron a MSXML base 64, lo que representa

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

La subrutina a continuación toma esto, convierte de nuevo a binario, y usa esto como referencia a partir de la cual se construye una cadena de salida, línea por línea, tomando primero los 5 píxeles superiores de cada carácter, luego la segunda fila y así sucesivamente hasta que se construya la cadena .

La subrutina luego itera sobre la cadena de salida y reemplaza los píxeles 'on' con caracteres de la cadena de entrada.

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

(+1 byte después de un cambio en el idioma 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]}

Pruébalo en línea!

donde aes un literal de cadena citado que codifica la fuente. K ve las cadenas como secuencias de bytes, por lo que un programa que contiene dicho literal es válido, pero no se puede ejecutar en TIO, ya que su forma HTML intenta interpretarlo como UTF-8 y lo estropea.

El recuento de bytes se calcula como:

• 119 reportados por TIO

• -2 para nombrar la función f:

• -1 para el marcador de posición a

• 2 para un par de citas ""

• 113 para la longitud del literal de cadena aque no contiene ningún carácter que requiera escapar