15

O desafio:

Para uma entrada de uma letra X (maiúscula ou minúscula de A a Z) e um dígito N (0-9), imprima a letra correspondente X feita de N * X.

A carta deve ser desta 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

Exemplos:

entrada: a 1

resultado:

 AAA
A   A
AAAAA
A   A
A   A

entrada: A 0

resultado: A

entrada: A 2

resultado:

      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

saída: o que nunca: não importa

Regras adicionais:

Os parâmetros de entrada podem ser separados por qualquer caractere que você desejar.
Cada letra deve usar seu próprio capital como caractere ascii para desenhá-la.
Espaços à direita, novas linhas etc. são permitidos
Em vez de um programa, você pode escrever uma função que aceita a sequência de dígitos como argumento. A saída deve ser impressa normalmente.
Stdout / Stderr não importa, basta escolher uma. Se o material impresso no outro também não importa.
Os possíveis formatos de saída podem ser impressos em STDOUT, retornados como uma lista de seqüências de caracteres, retornados como uma matriz de caracteres etc., desde que o resultado possa ser simplesmente impresso usando o método de impressão padrão dos idiomas. *

*: como a função f (a, 1) retorna a string e pode-se simplesmente dizer print (f (a, 1)) não faça com que a chamada print () faça parte da resposta. (Isso foi apontado por Kevin Cruijssen e Arnauld).

Ganhando:

Isso é código-golfe, vitórias mais baixas na contagem de bytes. Diverta-se!

Edit : esta questão parece muito idêntica a esta, no entanto, eu diria que não, pois não deve funcionar apenas para H, mas para cada letra do alfabeto. Acho que você decide melhor ou não é uma duplicata.

code-golf ascii-art Nicolas Brauer
fonte

3

Muito intimamente relacionado .

AdmBorkBork

3

@ElPedro Obrigado! Ainda não sabia sobre a caixa de areia, muito obrigado. Vou dar uma olhada mais de perto!

Nicolas Brauer

2

Bom primeiro desafio! No entanto, sua pergunta atualmente sugere que apenas podemos imprimir o resultado. A regra padrão é que as funções têm permissão para devolvê-lo. De um modo geral, os formatos de E / S são muito flexíveis. Você pode dar uma olhada neste post na meta, que explica o porquê.

Arnauld 12/12

2

@Arnauld, pois é sobre a arte ASCII, eu diria que imprimir o resultado é um pouco crucial para a tarefa, mas acho que se o seu código retornar o resultado e a string retornada puder simplesmente ser impressa usando o método de impressão padrão dos idiomas (como sua função f (a, 1) retorna a string e posso apenas dizer print (f (a, 1)) a chamada print () não deve fazer parte do código de resposta.Se isso for um pouco compreensível e você concordar, posso adicioná-lo a a descrição do desafio.

Nicolas Brauer

2

@KevinCruijssen I levemente atualizada a pergunta, por favor me diga se o seu compreensível a maneira que eu escrevi :)

Nicolas Brauer

6

JavaScript (ES8), 281 bytes

Toma entrada como (letter)(N). Retorna uma string.

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)

Experimente online!

Quão?

Codificação de fontes

$5\times5$ $0$ $31$

O padrão armazenado é espelhado na horizontal e na vertical.

Exemplo 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$

(⌊ \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]$

A função retorna um espaço assim que um pixel em branco é detectado em alguma profundidade ou o caractere correspondente à letra de entrada, se todas as iterações forem bem-sucedidas.

Arnauld
fonte

Funciona muito bem, parabéns! Você pode tentar explicar um pouco o código, por favor?

Nicolas Brauer 12/12

Por que o padrão armazenado é espelhado horizontal e verticalmente? seria necessário mais bytes para não espelhá-lo para armazenar? E tyvm para a explicação * *.

Nicolas Brauer

1

y

$y$

w - 1

$w-1$

0

$0$

1

(Embora eu acho que nós poderíamos deixar cair o espelho vertical, sem nenhum custo.)

Arnauld

6

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

Experimente online!

Usa uma codificação quase idêntica à de Ouros ; no entanto, ele não reverte os bits, optando por usá-los diretamente.

Em seguida, cria uma matriz 5x5 de bits e constrói a matriz Kronecker Power para gerar o padrão necessário, escrevendo os resultados em stdout.

Giuseppe
fonte

Este é um ótimo uso do Kronecker!

digEmAll

1

272 usando outro método de compactação

digEmAll

@digEm Todo o coração desse desafio é o método de compactação (de qualquer maneira, do ponto de vista do código-golfe). Por que você não o publica como resposta, para que você também possa explicar?

Giuseppe

Ok, tudo bem, obrigado!

digEmAll

5

Limpo , 436 372 bytes

Significativamente mais curto com o novo formato de E / S.

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

Experimente online!

Compacta os padrões de letras nos bits de literais inteiros para economizar ~ 700 bytes. Por exemplo A:

Aplainar [[' AAA '],['A A'],['AAAAA'],['A A'],['A A']]
Marcha ré [' AAA A AAAAAAA AA A']
Transforme-se ['A AA AAAAAAA A AAA ']em binário ( 'A' = 1, ' ' = 0)
Transformar 0b1000110001111111000101110em decimal
Obter 18415150

Furioso
fonte

4

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

Experimente online!

Isenção de responsabilidade:
esta solução foi obtida pegando a resposta de @ Giuseppe e substituindo a compressão da matriz por outra abordagem muito semelhante à usada na resposta de @ Arnauld , então, antes de tudo, faça um voto positivo :)

A ideia é a seguinte :

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 coluna é considerada como número binário e convertida em um número inteiro. Esses números inteiros são então convertidos em ASCII não imprimíveis no intervalo de 1 a 31:

por exemplo, para as colunas da "B"sequência final será "\017\021\017\021\017"(caracteres não imprimíveis escritos em representação 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)

Portanto, dada a sequência final de 5*26 = 130caracteres, convertemos essa sequência novamente na matriz de 0/1uso:

sapply(utf8ToInt(STRING),intToBits)

então simplesmente subsecretamos a matriz selecionando apenas as 5 primeiras linhas (intToBits retorna 32 bits) e apenas as colunas correspondentes à letra passada como entrada e, finalmente, aplicamos o kronecker, conforme explicado na resposta de @ Giuseppe .

digEmAll
fonte

você também pode usar unprintables para raspar a -48peça, e uso !no lugar de U: experimentá-lo on-line

Giuseppe

@ Giuseppe: ótimo! Fiz a resposta em um wiki da comunidade, pois é o resultado de uma colaboração :) Sinta-se livre para editar meu inglês ruim: D

digEmAll

Código Golf: Letter-Ception

Respostas:

JavaScript (ES8), 281 bytes

Quão?

Codificação de fontes

Algoritmo principal

R , 348 bytes

Limpo , 436 372 bytes

R , 259 bytes