13

La sfida qui è estendere un'implementazione del palindromo dato quanto segue come input:

n > 1e un elenco l.

Il tuo programma deve palindromo la lista sia in verticale che in orizzontale, vale a dire deve prima palindrare la lista stessa, quindi ogni elemento nella lista dopo; o viceversa. Prima della palindromizzazione, tutti gli elementi hanno la stessa lunghezza. L'azione palindromo deve quindi essere eseguita nin sequenza fino a quando non viene raggiunta la potenza desiderata. Il modo più semplice per mostrare gli output previsti è solo quello di esaminare alcuni esempi:

Una iterazione eseguita su [123,456,789]:

Per prima cosa palindromizza l'elenco a [123,456,789,456,123].

Sebbene questo non sia un palindromo se unito, è un palindromo in termini di elenco.
[a,b,c]divenne [a,b,c,b,a], quindi la LISTA fu palindromizzata.

Quindi, si palindromizza ogni elemento dell'elenco [12321,45654,78987,45654,12321].

Ecco come viene eseguita ogni iterazione, è essenzialmente un palindromo omnidirezionale.

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

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

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

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

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

Dato 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

Dato 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

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

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

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

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

Regole

n sarà sempre maggiore di 1.
l avrà sempre più di 1 elemento.
Tutti gli elementi di lhanno la stessa lunghezza.
Questa è la soluzione più corta per giocare a code-golf che verrà contrassegnata come vincente.

code-golf

— Urna di polpo magico
fonte

9

Questa sarebbe una sfida migliore se non dovessimo riempire gli elementi.

— mbomb007

2

@JonathanAllan è un palindromo omnidirezionale, o palindromo 2D che potresti dire. Ho aggiornato la descrizione; inoltre, l'imbottitura impedisce alcuni strani casi di frange in cui una corda più piccola è già un palindromo.

— Magic Octopus Urn

1

@JonathanAllan è in termini di elenco, se stai guardando la LISTA come l'elemento da palindromizzare. Proprio come [@ 1, @ 2, @ 1] è anche un palindromo quando lo si guarda come un elenco, non dagli elementi ...

— Magic Octopus Urn

1

@JonathanAllan sì, in sostanza, puoi guardarlo così se vuoi.

— Magic Octopus Urn

1

L'ultimo esempio richiede imbottitura.

— Jonathan Allan,

9

05AB1E , 4 byte

Si noti che se fosse necessaria una sola iterazione ( n=1), il programma sarebbe il palindromo û€û.

Fû€û

Provalo online

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

Se il riempimento dell'ingresso era ancora una parte richiesta del programma (11 byte):

€R.B€RIFû€û

Non sono riuscito a trovare un modo più breve per giustificare a destra. La giustificazione e la centratura a sinistra erano tutte facili, ma questo era più lungo per qualche motivo. Usare Eo ²invece di Ifunzionare anche.

— mbomb007
fonte

7

Python 2 , 71 63 byte

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

Provalo online!

Assegnare una funzione palindromo a f, generare e valutare il modello seguente (per n=4)
f(map(f,f(map(f,f(map(f,f(map(f,<input>))))))))

— asta
fonte

1

Penso che intendi assegnare . Non credo che il culo sia un verbo, lol.

— mbomb007,

@ mbomb007 welp, è ora di prendere più caffè ~

— Rod

6

Gelatina , 6 byte

ŒḄŒB$¡

Collegamento diadico o programma completo che prende l'elenco e n.

Provalo online!

Utilizzando entrambe le versioni del fantastico "rimbalzo" di 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 byte

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

Provalo online! - footer stampa ciascuno degli elementi dell'elenco risultante, uno per riga, una "stampa carina".

h è la funzione di palindomizzazione, aggiunge all'input, tutti gli elementi di un elenco dall'ultimo tranne uno, indice -2, all'inizio in passi di dimensione -1.

fchiama hcon il risultato di chiamare ha turno ciascun elemento, si riduce ndi uno e chiama se stesso fino a nraggiungere 0, a quel punto aè il prodotto finito.

— Jonathan Allan
fonte

... e sto ancora dimenticando le f=funzioni ricorsive, un giorno ricorderò.

— Jonathan Allan,

2

APL, 15 byte

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

Spiegazione:

(... )⍣⎕⊢⎕: leggi l'elenco e Ncome input e i Ntempi di esecuzione :
- ⊢,1↓⌽: l'elenco, seguito dalla coda dell'elenco invertito
- Z←: memorizza questa funzione in Z
- Z¨: e applicalo anche a ciascun elemento dell'elenco

Test:

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

— marinus
fonte

1

Groovy, 66 byte

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

— Urna di polpo magico
fonte

1

Haskell, 51 byte

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

Esempio di utilizzo: ["123","456","789"] ? 1-> ["12321","45654","78987","45654","12321"]. Provalo online! .

(++)<*>reverse.initcrea un palindromo da un elenco, lo iterate(...)xripete ancora e ancora e raccoglie i risultati intermedi in un elenco, !!nseleziona l'ennesimo elemento di questo elenco. (%n)<$>x%ncrea un n-palindrom di ogni elemento del n-palindrome di x.

— Nome del modello
fonte

1

JavaScript (ES6), 87 byte

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 byte

24 byte di codice, +1 per la -lbandiera.

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

Prende l'elenco come argomenti della riga di comando e il numero n da stdin. Provalo online!

Spiegazione

                          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 questo elenco

Regole

05AB1E , 4 byte

Python 2 , 71 63 byte

Gelatina , 6 byte

Python 2 , 64 byte

APL, 15 byte

Groovy, 66 byte

Haskell, 51 byte

JavaScript (ES6), 87 byte

Pip , 25 byte

Spiegazione