El reto:

Para una entrada de una letra X (mayúsculas o minúsculas de la A a la Z) y un dígito N (0-9) imprima la letra X correspondiente hecha de N * X.

La carta tiene que ser de esta lista:

 AAA      BBBB       CCCC     DDDD      EEEEE     FFFFF      GGG      H   H
A   A     B   B     C         D   D     E         F         G         H   H
AAAAA     BBBB      C         D   D     EEEE      FFFF      G  GG     HHHHH
A   A     B   B     C         D   D     E         F         G   G     H   H
A   A     BBBB       CCCC     DDDD      EEEEE     F          GGG      H   H


IIIII         J     K   K     L         M   M     N   N      OOO 
  I           J     K  K      L         MM MM     NN  N     O   O
  I           J     KKK       L         M M M     N N N     O   O
  I       J   J     K  K      L         M   M     N  NN     O   O
IIIII      JJJ      K   K     LLLLL     M   M     N   N      OOO 


PPPP       QQQ      RRRR       SSSS     TTTTT     U   U     V   V     W   W
P   P     Q   Q     R   R     S           T       U   U     V   V     W   W
PPPP      Q   Q     RRRR       SSS        T       U   U     V   V     W   W
P         Q  QQ     R  R          S       T       U   U      V V      W W W
P          QQQQ     R   R     SSSS        T        UUU        V        W W 


X   X     Y   Y     ZZZZZ
 X X       Y Y         Z 
  X         Y         Z  
 X X        Y        Z   
X   X       Y       ZZZZZ

Ejemplos:

entrada: un 1

salida:

 AAA
A   A
AAAAA
A   A
A   A

entrada: A 0

salida: A

entrada: A 2

salida:

      AAA  AAA  AAA
     A   AA   AA   A
     AAAAAAAAAAAAAAA
     A   AA   AA   A
     A   AA   AA   A
 AAA                 AAA
A   A               A   A
AAAAA               AAAAA
A   A               A   A
A   A               A   A
 AAA  AAA  AAA  AAA  AAA
A   AA   AA   AA   AA   A
AAAAAAAAAAAAAAAAAAAAAAAAA
A   AA   AA   AA   AA   A
A   AA   AA   AA   AA   A
 AAA                 AAA
A   A               A   A
AAAAA               AAAAA
A   A               A   A
A   A               A   A
 AAA                 AAA
A   A               A   A
AAAAA               AAAAA
A   A               A   A
A   A               A   A

entrada: A -1

salida: lo que sea: no importa

Reglas Adicionales:

• Los parámetros de entrada se pueden separar por el carácter que desee.
• Cada letra debe usar la capital de sí misma como carácter ascii para dibujarla.
• Se permiten espacios finales, nuevas líneas, etc.
• En lugar de un programa, puede escribir una función que tome la cadena de dígitos como argumento. La salida debe imprimirse normalmente.
• Stdout / Stderr no importa, solo elige uno. Si las cosas impresas en el otro tampoco importan.
• Los posibles formatos de salida pueden imprimirse en STDOUT, devolverse como una lista de cadenas, devolverse como una matriz de caracteres, etc. siempre que el resultado pueda imprimirse simplemente utilizando el método de impresión predeterminado de los idiomas. *

*: al igual que la función f (a, 1) devuelve la cadena y uno simplemente puede decir que print (f (a, 1)) no hace que la llamada print () forme parte de la respuesta. (Esto fue señalado por Kevin Cruijssen y Arnauld).

Victorioso:

Este es el código de golf, el menor recuento de bytes gana. ¡Que te diviertas!

Editar : esta pregunta parece muy idéntica a esta, sin embargo, diría que no lo es, ya que no solo debería funcionar para H sino para cada letra del alfabeto ... Supongo que decides más bien o no es un duplicado.

JavaScript (ES8), 281 bytes

Toma entrada como (letter)(N). Devuelve una cadena.

c=>n=>(g=y=>y--?''.padEnd(w).replace(/./g,(_,x)=>(h=d=>~~(d/=5)?(P=parseInt)('hhvhefhfhfu111ufhhhfv1f1v11f1vehp1ehhvhhv444vehgggh979hv1111hhlrhhpljhehhhe11fhfuphheh9fhffge1u4444vehhhh4ahhhalhhhha4ah444ahv248v'[y/d%5+5*P(c,36)-50|0],36)>>x/d%5&1?h(d):' ':c)(w))+`
`+g(y):'')(w=5**n)

Pruébalo en línea!

¿Cómo?

Codificación de fuente

$5\times5$$0$$31$

El patrón que se almacena se refleja tanto horizontal como verticalmente.

Ejemplo para 'F':

#####     ....#     00001      1     '1'
#....     ....#     00001      1     '1'
####. --> .#### --> 01111 --> 15 --> 'f' --> '11f1v'
#....     ....#     00001      1     '1'
#....     #####     11111     31     'v'

$26\times5 = 130$

$(x,y)$$n^{\text{th}}$

parseInt('hhvhefhfh...'[y + 5 * n], 36) >> x & 1

Algoritmo principal

$n$$w=5^n$

$0\le x<w$$0\le y<w$$(x,y)$$h$

$k$$[0 \dots n-1]$

La función devuelve un espacio tan pronto como se detecta un píxel en blanco a cierta profundidad, o el carácter correspondiente a la letra de entrada si todas las iteraciones son exitosas.

R , 348 bytes

function(K,N){if(N)for(i in 1:N)T=T%x%matrix(c(15269425,32045630,16269839,32032318,33061407,33061392,15224366,18415153,32641183,1082926,18444881,17318431,18732593,18667121,15255086,32045584,15255151,32045649,16267326,32641156,18400814,18400580,18400938,18157905,18157700,32575775)[utf8ToInt(K)-64]%/%2^(24:0)%%2,5,5)
write(c(" ",K)[T+1],1,5^N,,"")}

Pruébalo en línea!

Utiliza una codificación casi idéntica a la de Ouros ; sin embargo, no invierte los bits, sino que opta por usarlos directamente.

Luego crea una matriz de bits 5x5 y construye la matriz de Kronecker Power para generar el patrón necesario, escribiendo los resultados en stdout.

limpia , 436 372 bytes

Significativamente más corto con el nuevo formato IO.

import StdEnv,StdLib
t=transpose
f=flatten
$0c=[[c]]
$n c=f[t(f[t($(n-1)if(isOdd({#18415150,16301615,31491134,16303663,32554047,1096767,15262766,18415153,32641183,15254032,18128177,32539681,18405233,18667121,15255086,1097263,32294446,18136623,16267326,4329631,15255089,4539953,11191857,18157905,4329809,32575775}.[toInt(max'A'c)-65]>>p))c' ')\\p<-[i..i+4]])\\i<-[0,5..20]]

Pruébalo en línea!

Comprime los patrones de letras en los bits de literales enteros para guardar ~ 700 bytes. Por ejemplo,A :

1. Aplanar [[' AAA '],['A A'],['AAAAA'],['A A'],['A A']]
2. Marcha atrás [' AAA A AAAAAAA AA A']
3. Giro ['A AA AAAAAAA A AAA '] en binario ( 'A' = 1, ' ' = 0)
4. Giro 0b1000110001111111000101110 en decimal
5. Obtener 18415150

R , 259 bytes

function(K,N,`!`=utf8ToInt){if(N)for(i in 1:N)T=T%x%(sapply(!"			




",intToBits)[1:5,5*(-64+!K)-4:0]>0)
write(c(" ",K)[T+1],1,5^N,,"")}

Pruébalo en línea!

Descargo de responsabilidad:
esta solución se ha obtenido tomando la respuesta de @ Giuseppe y reemplazando la compresión matricial con otro enfoque muy similar al utilizado en la respuesta de @ Arnauld , así que antes que nada, vótelos :)

La idea es la siguiente :

Dada esta 5 x 26*5matriz de 0/1:

(1 replaced by '#', 0 replaced by '.' and '|' added for readability)

.####|#####|.###.|#####|#####|#####|.###.|#####|#...#|...#.|#####|#####|#####|
#.#..|#.#.#|#...#|#...#|#.#.#|#.#..|#...#|..#..|#...#|....#|..#..|....#|.#...|
#.#..|#.#.#|#...#|#...#|#.#.#|#.#..|#...#|..#..|#####|....#|..#..|....#|..#..|
#.#..|#.#.#|#...#|#...#|#.#.#|#.#..|#.#.#|..#..|#...#|....#|.#.#.|....#|.#...|
.####|.#.#.|#...#|.###.|#...#|#....|..##.|#####|#...#|####.|#...#|....#|#####| ...
  ^     ^     ^     ^     ^     ^     ^     ^     ^     ^     ^     ^     ^   
  |     |     |     |     |     |     |     |     |     |     |     |     |   
  A     B     C     D     E     F     G     H     I     J     K     L     M   

cada columna se considera como un número binario y se convierte en un número entero. Estos enteros se convierten en ASCII no imprimible en el rango 1 ... 31:

por ejemplo, las columnas de "B"la cadena final serán "\017\021\017\021\017"(caracteres no imprimibles escritos en representación octal):

#####                   ####.     11110          15            '\017'
#.#.#                   #...#     10001          17            '\021'
#.#.#      ------->     ####. --> 11110  ------> 15   ------>  '\017'
#.#.#                   #...#     10001          17            '\021'
.#.#.                   ####.     11110          15            '\017'

          (transposed                  bin to int   int to ASCII
         for reability)    

Por lo tanto, dada la cadena final de 5*26 = 130caracteres, convertimos esa cadena de nuevo a la matriz de 0/1uso:

sapply(utf8ToInt(STRING),intToBits)

luego simplemente subdividimos la matriz seleccionando solo las primeras 5 filas (intToBits devuelve 32 bits) y solo las columnas correspondientes a la letra pasada como entrada y finalmente aplicamos kronecker como se explica en la respuesta de @ Giuseppe .