Una sestina è un formato di poesia che segue uno schema interessante che possiamo generare. Ha sei stanze di sei linee ciascuna, in cui le ultime parole di ogni linea nella prima stanza compongono le terminazioni di linea in ogni stanza successiva, ruotate secondo uno schema prestabilito. (C'è anche una strofa a tre righe alla fine, ma non ci preoccuperemo per questo.) Dai un'occhiata alle prime tre stanze della creativamente chiamata Elizabeth Sestina :

La pioggia di settembre cade sulla casa.
Nella luce fioca, la vecchia nonna è
seduta in cucina con il bambino
accanto alla Stufa della Piccola Marvel,
leggendo le battute dell'almanacco,
ridendo e parlando per nascondere le sue lacrime.

Pensa che le sue lacrime equinoziali
e la pioggia che batte sul tetto della casa siano
state entrambe predette dall'almanacco,
ma solo conosciute da una nonna.
Il bollitore di ferro canta sul fornello.
Taglia un po 'di pane e dice al bambino,

Adesso è il momento del tè; ma il bambino
sta guardando le piccole lacrime dure del teiera
danzare come matti sulla calda stufa nera,
come la pioggia deve danzare sulla casa.
Riordinando, la vecchia nonna
riattacca il sapiente almanacco

...

Nota come ogni riga termina con una delle sei parole "casa", "nonna", "bambino", "stufa", "almanacco" o "lacrime". Non solo, ma le parole sono ordinate nello schema 6–1—5–2—4–3, rispetto alla strofa precedente. Finisce per sembrare una spirale:

Mancano ancora pochi anni alla generazione programmatica di una sestina completa, ma possiamo creare un modello che mostri le parole finali di ogni strofa nell'ordine corretto. Scrivi un programma o una funzione che, date le parole che terminano con sei righe, genera il modello per una sestina, seguendo queste regole. Ecco il risultato atteso per l'input house grandmother child stove almanac tears:

house
grandmother
child
stove
almanac
tears

tears
house
almanac
grandmother
stove
child

child
tears
stove
house
grandmother
almanac

almanac
child
grandmother
tears
house
stove

stove
almanac
house
child
tears
grandmother

grandmother
stove
tears
almanac
child
house

La prima strofa sono le parole nell'ordine originale, la seconda strofa è nell'ordine 6-1-5-2-4-3 dalla prima. La terza strofa è quell'ordine relativo alla seconda, e così via, fino alla strofa 6.

Supponiamo che le parole di input siano sempre solo lettere, maiuscole o minuscole. Puoi prenderli come una matrice di stringhe o una singola stringa delimitata da un carattere non lettera (spazio, newline, ecc.). Nell'output, le linee sono separate da newline ( 0x0A) e le stanze sono separate da due newline. Una nuova riga finale è accettabile.

Questo è code-golf , quindi vince il codice più breve in byte. Detto questo, potrebbe essere più breve comprimere l'intera struttura della poesia, ma mi piacerebbe vedere alcune soluzioni che basano ciascuna strofa sulla precedente.

Gelatina , 15 14 byte

620œ?$ÐĿY€j⁷Ḥ¤

TryItOnline!

Come?

Sì, un uso di una delle mie aggiunte a Jelly! ( œ?)

620œ?$ÐĿY€j⁷Ḥ¤ - Main link: list of words L
      ÐĿ       - loop until no longer unique, collecting intermediate results
     $         -     last two links as a monad
   œ?          -         permutation of right argument (initially L) at index
620            -         620
        Y€     - join with line feeds for €each (the words of each stanza)
          j    - join (the stanzas) with
             ¤ - nilad followed by link(s) as a nilad
           ⁷   -     a line feed
            Ḥ  -     double (two line feeds)

Python, 72 64 byte

i,n=input(),'\n';exec"print n.join(i)+n;i=map(i.pop,[-1,0]*3);"*6

Prende l'input tramite STDIN come un array separato da virgole di 6 stringhe e l'output su STDOUT nel formato descritto nel post con una nuova riga finale aggiuntiva.

Provalo online! (Ideone)

Inoltre, non sono sicuro che vada bene, ma ecco una risposta più breve sotto forma di una funzione lambda anonima a 59 byte che accetta input nello stesso formato della risposta precedente e genera il programma necessario per generare l'uscita corretta:

lambda i,n='\n':"print n.join(i)+n;i=map(i.pop,[-1,0]*3);"*6

Pertanto deve essere chiamato nel formato exec(<Function Name>(<Array>)). Ancora una volta, non sono sicuro che vada bene, quindi sto aggiungendo questa come una risposta extra, separata e non competitiva fino a quando qualcuno (forse anche OP) potrà sperare di chiarire se va bene o no, cosa che apprezzerei davvero .

MATL , 18 17 byte

0ch5:"t[6l5H4I7])

L'input è un array di celle di stringhe, nel formato

{'house' 'grandmother' 'child' 'stove' 'almanac' 'tears'}

Provalo online!

Spiegazione

0c          % Push string with a single space, to be used as separator
h           % Input array of 6 strings implicitly and append the above string
5:"         % Repeat 5 times
  t         %   Duplicate the array of strings (previous stanza plus separator)
  [6l5H4I7] %   Push array [6 1 5 2 4 3 7]. The 7th string is the separator, and stays
            %   at the end. The other strings are shuffled as required
  )         %   Index into the array of strings
            % End implicitly
            % Display implicitly

Mathematica, 59 byte

r=Riffle;""<>Flatten@r[NestList[RotateRight,#,5],""]~r~"\n"&

Il nucleo di questa funzione senza nome è NestList[RotateRight,#,5], che prende un elenco di input di lunghezza 6 e crea un elenco di 6 elenchi, ciascuno ruotato in modo sestina. In effetti, se un elenco di elenchi di stringhe è un output accettabile, allora NestList[RotateRight,#,5]&esegue il lavoro in 26 byte .

Quindi, r[...,""]inserisce una stringa vuota tra ciascuna delle 6 liste; Flattentrasforma il tutto in un unico elenco di stringhe; ~r~"\n"quindi inserisce una nuova riga tra ciascuna di quelle stringhe; e ""<>concatena il tutto in un'unica stringa. Quindi gli altri 33 byte servono solo per convertire l'output strutturato in una singola stringa.

Lotto, 99 byte

@for %%w in (%*)do @if not .%%w==.%7 echo %%w
@echo(
@if not .%7==...... %0 %6 %1 %5 %2 %4 %3 .%7

Spiegazione: Accetta input come parametri della riga di comando. Ciò %0provoca il loop, accumulando .s nel settimo parametro originariamente vuoto. Il extra .è perché ifnon funziona su stringhe vuote.

Rubino, 51 byte

->z{z.map{z[1],z[3],z[5],z[4],z[2],z[0]=z+[""]}*$/}

Invece di 0..5ripetere i numeri come sotto, ripetiamo 6 volte ripetendo gli elementi di z. Nell'uso normale come (0..5).map{|i|puts i}il codice {}legge gli elementi ripetuti. In questo caso le permutazioni fatte dal codice all'interno {}non leggono gli elementi ripetuti, quindi possiamo iterare sugli elementi zsenza che questo interferisca con le permutazioni.

Rubino, 56 byte

Accetta un array di 6 elementi come parametro

->z{(0..5).map{z[1],z[3],z[5],z[4],z[2],z[0]=z+[""]}*$/}

versione alternativa prendendo 6 parametri

->a,b,c,d,e,f{(0..5).map{b,d,f,e,c,a=a,b,c,d,e,f,""}*$/}

Con ogni iterazione di mappermute z. La versione originale più a ""per rappresentare un'interruzione tra le stanze diventa l'output di map(questo settimo elemento dell'array non è necessario per l'assegnazione, quindi viene ignorato). *$/converte gli array in una stringa, unendo tutto insieme a newline.

Racchetta 115 byte

(let p((o(list l))(m 0))(if(> n m)(p(cons(map(λ(x)(list-ref(list-ref o 0)x))'(5 0 4 1 3 2))o)(+ 1 m))(reverse o)))

Ungolfed:

(define(f l n)
 (let loop ((ol (list l))
             (m 0))
    (if (> n m) 
        (loop
         (cons (map
                (λ (x) (list-ref (list-ref ol 0) x))
                '(5 0 4 1 3 2))
               ol)
         (add1 m))
        (reverse ol))))

test:

(f (list "house" "grandmother" "child" "stove" "almanac" "tears") 6)

Produzione:

'(("house" "grandmother" "child" "stove" "almanac" "tears")
  ("tears" "house" "almanac" "grandmother" "stove" "child")
  ("child" "tears" "stove" "house" "grandmother" "almanac")
  ("almanac" "child" "grandmother" "tears" "house" "stove")
  ("stove" "almanac" "house" "child" "tears" "grandmother")
  ("grandmother" "stove" "tears" "almanac" "child" "house")
  ("house" "grandmother" "child" "stove" "almanac" "tears"))