15

Le défi:

Pour une entrée d'une lettre X (majuscule ou minuscule de A à Z) et d'un chiffre N (0-9), imprimez la lettre X correspondante en N * X.

La lettre doit provenir de cette liste:

 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

Exemples:

entrée: a 1

production:

 AAA
A   A
AAAAA
A   A
A   A

entrée: A 0

production: A

entrée: A 2

production:

      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

entrée: A -1

sortie: quoi que ce soit: peu importe

Règles supplémentaires:

Les paramètres d'entrée peuvent être séparés par le caractère que vous souhaitez.
Chaque lettre doit utiliser le capital d'elle-même comme caractère ascii pour la dessiner.
Les espaces de fin, les nouvelles lignes, etc. sont autorisés
Au lieu d'un programme, vous pouvez écrire une fonction qui prend la chaîne de chiffres comme argument. La sortie doit être imprimée normalement.
Stdout / Stderr n'a pas d'importance, choisissez-en un. Si des trucs imprimés sur l'autre n'ont pas d'importance non plus.
Les formats de sortie possibles peuvent être imprimés sur STDOUT, retournés sous forme de liste de chaînes, renvoyés sous forme de matrice de caractères, etc. tant que le résultat peut simplement être imprimé en utilisant la méthode d'impression par défaut des langues. *

*: comme la fonction f (a, 1) retourne la chaîne et on peut simplement dire print (f (a, 1)) ne fait pas appeler print () une partie de la réponse. (Cela a été souligné par Kevin Cruijssen et Arnauld).

Gagnant:

Il s'agit du code-golf, le plus petit nombre de victoires d'octets. S'amuser!

Edit : cette question semble très identique à celle-ci mais je dirais que ce n'est pas le cas, car elle devrait fonctionner non seulement pour H mais pour chaque lettre de l'alphabet .. Je suppose que vous décidez plutôt ou non qu'il s'agit d'un doublon.

code-golf ascii-art

— Nicolas Brauer
source

3

Très étroitement liés .

— AdmBorkBork

3

@ElPedro Merci! Je ne connaissais pas encore le bac à sable, merci beaucoup je vais y regarder de plus près!

— Nicolas Brauer

2

Joli premier défi! Cependant, votre question suggère actuellement que nous pouvons uniquement imprimer le résultat. La règle par défaut est que les fonctions sont autorisées à le renvoyer. De manière générale, les formats d'E / S sont très flexibles. Vous voudrez peut-être jeter un œil à ce post dans la méta qui explique pourquoi.

— Arnauld

2

@Arnauld car il s'agit de l'art ASCII, je dirais que l' impression du résultat est quelque peu crucial pour la tâche, mais je suppose que si votre code retourne le résultat et que la chaîne retournée pourrait simplement être imprimée en utilisant la méthode d'impression par défaut des langues (comme votre fonction f (a, 1) renvoie la chaîne et je peux simplement dire print (f (a, 1)) l'appel print () ne doit pas faire partie du code de réponse. Si cela est quelque peu compréhensible et que vous êtes d'accord, je peux l'ajouter à la description du défi

— Nicolas Brauer

2

@KevinCruijssen J'ai légèrement mis à jour la question, dites-moi si c'est compréhensible de la façon dont je l'ai écrite :)

— Nicolas Brauer

6

JavaScript (ES8), 281 octets

Prend l'entrée comme (letter)(N). Renvoie une chaîne.

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)

Essayez-le en ligne!

Comment?

Encodage des polices

$5\times5$ $0$ $31$

Le motif stocké est mis en miroir horizontalement et verticalement.

Exemple pour «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

Algorithme principal

$n$ $w=5^n$

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

(⌊ \frac{X}{5^{k}} ⌋ mod 5, ⌊ \frac{y}{5^{k}} ⌋ mod 5)

$\left(\left\lfloor\frac{x}{5^k}\right\rfloor\bmod 5,\left\lfloor\frac{y}{5^k}\right\rfloor\bmod 5\right)$

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

La fonction renvoie un espace dès qu'un pixel vierge est détecté à une certaine profondeur, ou le caractère correspondant à la lettre d'entrée si toutes les itérations sont réussies.

— Arnauld
source

Cela fonctionne vraiment bien, félicitations! Pouvez-vous essayer d'expliquer un peu le code s'il vous plaît?

— Nicolas Brauer

Pourquoi le motif stocké doit-il être mis en miroir horizontalement et verticalement? faudrait-il plus d'octets pour ne pas le refléter du tout pour le stockage? Et tyvm pour l'explication *. *

— Nicolas Brauer

1

y

$y$

w - 1

$w-1$

0

$0$

1

(Bien que je pense que nous pourrions laisser tomber le miroir vertical sans frais.)

— Arnauld

6

R , 348 octets

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

Essayez-le en ligne!

Utilise un encodage presque identique à celui d' Ouros ; cependant, il n'inverse pas les bits, choisissant plutôt de les utiliser directement.

Il crée ensuite une matrice 5x5 de bits et construit la matrice Kronecker Power pour générer le modèle nécessaire, en écrivant les résultats sur stdout.

— Giuseppe
source

C'est une excellente utilisation de Kronecker!

— digEmAll

1

272 utilisant une autre méthode de compression

— digEmAll

@digEmAll le cœur de ce défi est la méthode de compression (du point de vue code-golf de toute façon). Pourquoi ne le postez-vous pas comme réponse pour que vous puissiez aussi l'expliquer?

— Giuseppe

D'accord, merci!

— digEmAll

5

Propre , 436 372 octets

Beaucoup plus court avec le nouveau format 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]]

Essayez-le en ligne!

Compresse les modèles de lettres en bits de littéraux entiers pour économiser environ 700 octets. Par exemple A:

Aplatir [[' AAA '],['A A'],['AAAAA'],['A A'],['A A']]
Sens inverse [' AAA A AAAAAAA AA A']
Transformez ['A AA AAAAAAA A AAA ']en binaire ( 'A' = 1, ' ' = 0)
Transformer 0b1000110001111111000101110en décimal
Avoir 18415150

— Οurous
source

4

R , 259 octets

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

Essayez-le en ligne!

Avertissement:
cette solution a été obtenue en prenant la réponse de @ Giuseppe et en remplaçant la compression de la matrice par une autre approche très similaire à celle utilisée dans la réponse de @ Arnauld , alors tout d'abord, allez les voter :)

L'idée est la suivante:

Étant donné cette 5 x 26*5matrice 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

chaque colonne est considérée comme un nombre binaire et convertie en entier. Ces nombres entiers sont ensuite convertis en ASCII non imprimable dans la plage 1 ... 31:

par exemple pour les colonnes de "B"la chaîne finale sera "\017\021\017\021\017"(caractères non imprimables écrits en représentation octale):

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

          (transposed                  bin to int   int to ASCII
         for reability)

Par conséquent, étant donné la chaîne de 5*26 = 130caractères finale , nous reconvertissons cette chaîne en matrice d' 0/1utilisation:

sapply(utf8ToInt(STRING),intToBits)

puis nous sous-sectionnons simplement la matrice en sélectionnant uniquement les 5 premières lignes (intToBits renvoie 32 bits) et uniquement les colonnes correspondant à la lettre passée en entrée et enfin nous appliquons kronecker comme expliqué dans la réponse de @ Giuseppe .

— 4 tours
source

vous pouvez également utiliser des non imprimables pour raser la -48pièce, et utiliser !à la place de U: essayer en ligne

— Giuseppe

@Giuseppe: super! J'ai fait la réponse sur un wiki communautaire car c'est le résultat d'une collaboration :) N'hésitez pas à éditer mon pauvre anglais: D

— digEmAll

Code Golf: Lettre-Ception

JavaScript (ES8), 281 octets

Comment?

Encodage des polices

Algorithme principal

R , 348 octets

Propre , 436 372 octets

R , 259 octets