La sfida:

Per un input di una lettera X (maiuscola o minuscola dalla A alla Z) e una cifra N (0-9) stampare la lettera X corrispondente fatta di N * X.

La lettera deve essere da questo elenco:

 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

Esempi:

input: a 1

produzione:

 AAA
A   A
AAAAA
A   A
A   A

input: A 0

produzione: A

input: A 2

produzione:

      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

input: A -1

output: qualunque cosa: non importa

Regole aggiuntive:

• I parametri di input possono essere separati da qualsiasi carattere tu voglia.
• Ogni lettera deve usare la capitale di se stessa come carattere ASCII per disegnarla.
• Sono consentiti spazi finali, nuove linee, ecc
• Invece di un programma, è possibile scrivere una funzione che accetta la stringa di cifre come argomento. L'output deve essere stampato normalmente.
• Stdout / Stderr non importa, basta sceglierne uno. Se le cose stampate sull'altro non contano neanche.
• I possibili formati di output possono essere stampati su STDOUT, restituiti come un elenco di stringhe, restituiti come matrice di caratteri, ecc. Purché il risultato possa essere semplicemente stampato utilizzando il metodo di stampa predefinito delle lingue. *

*: come la funzione f (a, 1) restituisce la stringa e si può semplicemente dire print (f (a, 1)) non rendere la chiamata print () parte della risposta. (Questo è stato sottolineato da Kevin Cruijssen e Arnauld).

Vincente:

Questo è code-golf, vince il conteggio di byte più basso. Divertiti!

Modifica : questa domanda sembra molto identica a questa, tuttavia direi che non lo è, poiché non dovrebbe funzionare solo per H ma per ogni lettera dell'alfabeto .. Immagino che tu decida piuttosto o no che sia un duplicato.

JavaScript (ES8), 281 byte

Accetta input come (letter)(N). Restituisce una stringa.

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)

Provalo online!

Come?

Codifica dei caratteri

$5\times5$$0$$31$

Il modello memorizzato viene specchiato sia in orizzontale che in verticale.

Esempio per '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 principale

$n$$w=5^n$

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

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

La funzione restituisce uno spazio non appena viene rilevato un pixel vuoto a una certa profondità o il carattere corrispondente alla lettera di input se tutte le iterazioni hanno esito positivo.

R , 348 byte

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,,"")}

Provalo online!

Utilizza una codifica quasi identica a quella di Ouros ; tuttavia, non inverte i bit, optando invece per usarli direttamente.

Crea quindi una matrice 5x5 di bit e crea la matrice Kronecker Power per generare lo schema necessario, scrivendo i risultati su stdout.

Pulito , 436 372 byte

Significativamente più breve con il nuovo 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]]

Provalo online!

Comprime i motivi delle lettere nei bit dei letterali interi per salvare ~ 700 byte. Ad esempio A:

1. Appiattire [[' AAA '],['A A'],['AAAAA'],['A A'],['A A']]
2. Inverso [' AAA A AAAAAAA AA A']
3. Trasforma ['A AA AAAAAAA A AAA ']in binario ( 'A' = 1, ' ' = 0)
4. Trasforma 0b1000110001111111000101110in decimale
5. Ottenere 18415150

R , 259 byte

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,,"")}

Provalo online!

Dichiarazione di non responsabilità:
questa soluzione è stata ottenuta prendendo la risposta di @ Giuseppe e sostituendo la compressione matrice con un altro approccio molto simile a quello usato nella risposta di @ Arnauld , quindi prima di tutto va votato :)

L'idea è la seguente:

Data questa 5 x 26*5matrice di 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   

ogni colonna è considerata come numero binario e convertita in un numero intero. Questi numeri interi vengono quindi convertiti in ASCII non stampabile nell'intervallo 1 ... 31:

ad es. per le colonne della "B"stringa finale saranno "\017\021\017\021\017"(caratteri non stampabili scritti in rappresentazione ottale):

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

          (transposed                  bin to int   int to ASCII
         for reability)    

Quindi, data la stringa finale di 5*26 = 130caratteri, riconvertiamo quella stringa nella matrice 0/1dell'uso di:

sapply(utf8ToInt(STRING),intToBits)

quindi sottostiamo semplicemente la matrice selezionando solo le prime 5 righe (intToBits restituisce 32 bit) e solo le colonne corrispondenti alla lettera passano come input e infine applichiamo kronecker come spiegato nella risposta di @ Giuseppe .