El desafío aquí es extender una implementación de palindrome dado lo siguiente como entradas:

• n > 1y una lista l.

Su programa debe palindrome la lista tanto vertical como horizontalmente, es decir, primero debe palindrome la lista misma, luego cada elemento de la lista; O al revés. Antes de la palindromización, se garantiza que todos los elementos tengan la misma longitud. La acción del palíndromo se realizará entonces nen secuencia hasta que se cumpla la salida deseada. La forma más fácil de mostrar los resultados esperados es simplemente ejecutar algunos ejemplos:

Una iteración realizada en [123,456,789]:

Primero palindromizas la lista [123,456,789,456,123].

• Si bien esto no es un palíndromo si se une, es un palíndromo en términos de la lista.
• [a,b,c]se convirtió [a,b,c,b,a], por lo que la LISTA fue palindromizada.

Luego, palindromizas cada elemento de la lista [12321,45654,78987,45654,12321].

Así es como se realiza cada iteración, es esencialmente un palíndromo omnidireccional.

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

12321
45654
78987
45654
12321

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

123212321
456545654
789878987
456545654
123212321
456545654
789878987
456545654
123212321

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

3
2
1
2
3

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=["---|---","__|","___|","____|"]:

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

Reglas

• n siempre será mayor que 1.
• l siempre tendrá más de 1 elemento.
• Todos los elementos lson de la misma longitud.
• Esta es la solución más corta de código de golf que se marcará como ganador.

05AB1E , 4 bytes

Tenga en cuenta que si solo se requiere una única iteración ( n=1), entonces el programa sería el palíndromo û€û.

Fû€û

Pruébalo en línea

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

Si el relleno de la entrada seguía siendo una parte requerida del programa (11 bytes):

€R.B€RIFû€û

No pude encontrar una forma más corta de justificar correctamente. La justificación hacia la izquierda y el centrado fueron fáciles, pero esto fue más largo por alguna razón. Usar Eo en ²lugar de Itambién funciona.

Python 2 , 71 63 bytes

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

Pruébalo en línea!

Asigne una función de palíndromo para fgenerar y evaluar el siguiente patrón (para n=4)
f(map(f,f(map(f,f(map(f,f(map(f,<input>))))))))

Jalea , 6 bytes

ŒḄŒB$¡

Enlace diádico, o programa completo tomando la lista y n.

Pruébalo en línea!

Usando ambas versiones del fantástico "rebote" incorporado 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

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

Pruébalo en línea!- pie de página imprime cada uno de los elementos de la lista resultante, uno por línea, una "impresión bonita".

h es la función de palindomización, se agrega a la entrada, todos los elementos de una lista desde el último excepto uno, índice -2, al inicio en pasos de tamaño -1.

fllama hcon el resultado de llamar ha cada elemento por turno, se reduce nen uno y se llama a sí mismo hasta nllegar a 0, momento en el que se aencuentra el producto terminado.

APL, 15 bytes

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

Explicación:

• (... )⍣⎕⊢⎕: lea la lista y Ncomo entrada, y los Ntiempos de ejecución :
  • ⊢,1↓⌽: la lista, seguida de la cola de la lista invertida
  • Z←: almacena esta función en Z
  • Z¨: y aplicarlo a cada elemento de la lista también

Prueba:

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

Groovy, 66 bytes

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

Haskell, 51 bytes

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

Ejemplo de uso: ["123","456","789"] ? 1-> ["12321","45654","78987","45654","12321"]. Pruébalo en línea! .

(++)<*>reverse.initcrea un palíndromo de una lista, iterate(...)xrepite esto una y otra vez y recopila los resultados intermedios en una lista, !!nselecciona el enésimo elemento de esta lista. (%n)<$>x%nhace un n-palíndromo de cada elemento del n-palíndromo de x.

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

Pip , 25 bytes

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

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

Toma la lista como argumentos de línea de comandos y el número n de stdin. Pruébalo en línea!

Explicación

                          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)