13

O desafio aqui é estender uma implementação do palíndromo considerando o seguinte como entradas:

n > 1e uma lista l.

Seu programa deve palindrome a lista vertical e horizontalmente, ou seja, primeiro palindrome a lista em si, depois cada elemento da lista depois; ou o contrário. Antes da palindromização, todos os elementos têm o mesmo comprimento. A ação do palíndromo deve então ser executada nvezes em sequência até que a saída desejada seja alcançada. A maneira mais fácil de mostrar os resultados esperados é apenas executar alguns exemplos:

Uma iteração realizada em [123,456,789]:

Primeiro você palindromize a lista para [123,456,789,456,123].

Embora este não seja um palíndromo se reunido, é um palíndromo em termos da lista.
[a,b,c]tornou-se [a,b,c,b,a], então a LIST foi palindromizada.

Em seguida, você palindromize cada elemento da lista [12321,45654,78987,45654,12321].

É assim que cada iteração é executada, é essencialmente um palíndromo omnidirecional.

Dado n=1 and l=[123,456,789]:

Dado n=2 and l=[123,456,789]

Dado n=1 and l=[3,2,1]:

Dado n=2 and l=["hat","mad"," a "]:

hatahatah
madamadam
 a a a a 
madamadam
hatahatah
madamadam
 a a a a 
madamadam
hatahatah

Dado n=2 and l=[" 3 ","2000"," 100"]:

 3   3 3   3 
2000002000002
100 00100 001
2000002000002
 3   3 3   3 
2000002000002
100 00100 001
2000002000002
 3   3 3   3

Dado n=4 and l=["3 ","20","1 "]:

3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3
20202020202020202
1 1 1 1 1 1 1 1 1
20202020202020202
3 3 3 3 3 3 3 3 3

Dado n=3 and l=["_|__","__|_","___|"]:

_|___|_|___|_|___|_|___|_
__|_|___|_|___|_|___|_|__
___|_____|_____|_____|___
__|_|___|_|___|_|___|_|__
_|___|_|___|_|___|_|___|_
__|_|___|_|___|_|___|_|__
___|_____|_____|_____|___
__|_|___|_|___|_|___|_|__
_|___|_|___|_|___|_|___|_
__|_|___|_|___|_|___|_|__
___|_____|_____|_____|___
__|_|___|_|___|_|___|_|__
_|___|_|___|_|___|_|___|_
__|_|___|_|___|_|___|_|__
___|_____|_____|_____|___
__|_|___|_|___|_|___|_|__
_|___|_|___|_|___|_|___|_

Dado n=2 and l=["---|---","__|","___|","____|"]:

---|-----|-----|-----|---
  __|   |__   __|   |__  
 ___|   |___ ___|   |___ 
 ____| |____ ____| |____ 
 ___|   |___ ___|   |___ 
  __|   |__   __|   |__  
---|-----|-----|-----|---
  __|   |__   __|   |__  
 ___|   |___ ___|   |___ 
 ____| |____ ____| |____ 
 ___|   |___ ___|   |___ 
  __|   |__   __|   |__  
---|-----|-----|-----|---

Regras

n sempre será maior que 1.
l sempre terá mais de 1 elemento.
Todos os elementos ltêm o mesmo comprimento.
Esta é a solução mais curta do code-golf será marcada como vencedora.

code-golf

— Urna de polvo mágico
fonte

9

Este seria um desafio melhor se não tivéssemos que preencher elementos.

— mbomb007

2

@ JonathanAllan é um palíndromo omnidirecional, ou palíndromo 2D, você poderia dizer. Eu atualizei a descrição; Além disso, o preenchimento evita alguns casos de franja ímpares em que uma corda menor já é um palíndromo.

— Urna de polvo mágico

1

@ JonathanAllan está nos termos da lista, se você estiver vendo a LIST como o item a ser palindromizado. Assim como [@ 1, @ 2, @ 1] também é um palíndromo quando olhar para ele como uma lista, não pelos elementos ...

— Magia Octopus Urna

1

@ JonathanAllan Sim, essencialmente, você pode olhar assim se quiser.

— Urna de polvo mágico

1

O último exemplo requer preenchimento.

— Jonathan Allan

9

05AB1E , 4 bytes

Observe que se apenas uma iteração fosse necessária ( n=1), o programa seria o palíndromo û€û.

Fû€û

Experimente online

F       Do n times
 û      Palindromize the list
  €û    Palindromize each element in the list

Se o preenchimento da entrada ainda era uma parte necessária do programa (11 bytes):

€R.B€RIFû€û

Não consegui encontrar uma maneira mais curta de justificar direito. A justificação à esquerda e a centralização eram fáceis, mas isso era mais demorado por algum motivo. Usar Eou em ²vez de Itambém funciona.

— mbomb007
fonte

7

Python 2 , 71 63 bytes

lambda x,n,f=lambda x:x+x[-2::-1]:eval('f(map(f,'*n+`x`+'))'*n)

Experimente online!

Designe uma função palíndromo para f, gere e avalie o seguinte padrão (para n=4)
f(map(f,f(map(f,f(map(f,f(map(f,<input>))))))))

— Cajado
fonte

1

Eu acho que você quer dizer atribuir . Eu não acho que assing é um verbo, lol.

— mbomb007

@ mbomb007 welp, é hora de tomar mais café ~ #

— Rod Rod

6

Gelatina , 6 bytes

ŒḄŒB$¡

Link diádico ou programa completo, levando a lista e n.

Experimente online!

Usando as duas versões do fantástico "salto" interno de Lynn.

ŒḄŒB$¡ - Main link: l, n
     ¡ - repeat n times
    $  -     last two links as a monad (firstly with l then the result...)
ŒḄ     -         bounce ("palindromise") the list
  ŒB   -         bounce the elements

— Jonathan Allan
fonte

5

Python 2 , 64 bytes

h=lambda a:a+a[-2::-1]
f=lambda a,n:n and f(h(map(h,a)),n-1)or a

Experimente online! - rodapé imprime cada um dos elementos da lista resultante, um por linha, uma "impressão bonita".

h é a função de palindomização, ela anexa à entrada todos os elementos de uma lista desde o último, exceto o índice -2, até o início em etapas de tamanho -1.

fchama hcom o resultado de chamar hcada elemento, por sua vez, reduz nem um e chama a si próprio até natingir 0, quando aé o produto final.

— Jonathan Allan
fonte

... e ainda estou esquecendo as f=funções recursivas, um dia lembrarei.

— Jonathan Allan

2

APL, 15 bytes

(Z¨Z←⊢,1↓⌽)⍣⎕⊢⎕

Explicação:

(... )⍣⎕⊢⎕: leia a lista e Ncomo entrada e os Ntempos de execução :
- ⊢,1↓⌽: a lista, seguida pelo final da lista invertida
- Z←: armazene esta função em Z
- Z¨: e aplique-o a cada elemento da lista também

Teste:

          (ZëZ ← ⊢, 1 ↓ ⌽) ⍣⎕⊢⎕ 
    ⎕:
          'hat' 'mad' 'a'
    ⎕:
          2
    ┌───────────────────────────┬────────────────────────── ┬───────────────────────────┬────────┐
    │hatahatah│madamadam│ aaaa │madamadam│hatahatah│madamadam│ aaaa │madamadam│hatahatah│
    └───────────────────────────┴────────────────────────── ┴───────────────────────────┴────────┘

— marinus
fonte

1

Groovy, 66 bytes

{x,n->f={z->z+z[z.size()-2..0]};n.times{x=f(x).collect{f(it)}};x}

— Urna de polvo mágico
fonte

1

Haskell, 51 bytes

x%n=iterate((++)<*>reverse.init)x!!n
x?n=(%n)<$>x%n

Exemplo de uso: ["123","456","789"] ? 1-> ["12321","45654","78987","45654","12321"]. Experimente online! .

(++)<*>reverse.initcria um palíndromo de uma lista, iterate(...)xrepete isso várias vezes e coleta os resultados intermediários em uma lista, !!nescolhe o enésimo elemento dessa lista. (%n)<$>x%nfaz um n-palíndromo de cada elemento do n-palíndromo de x.

— nimi
fonte

1

JavaScript (ES6), 87 bytes

f=(n,l,r=l=>[...a].reverse().slice(1))=>n--?f(l.concat(r(l)).map(s=>s+r(s).join``),n):l

— Neil
fonte

1

Pip , 25 bytes

24 bytes de código, +1 para -lsinalizador.

Lq{gM:_.@>RV_gAL:@>RVg}g

Leva a lista como argumentos de linha de comando e o número n de stdin. Experimente online!

Explicação

                          g is list of cmdline args (implicit)
Lq{                   }   Read a line of input and loop that many times:
      _.@>RV_             Lambda function: take all but the first character (@>) of the
                           reverse (RV) of the argument (_), and concatenate that (.) to
                           the argument (_)
   gM:                    Map this function to g and assign the result back to g
                 @>RVg    Take all but the first element of the reverse of g
             gAL:         Append that list to g and assign the result back to g
                       g  After the loop, print g (each item on its own line due to -l)

— DLosc
fonte

Pali-n-drome esta lista