Una sestina es un formato de poema que sigue un patrón interesante que podemos generar. Tiene seis estrofas de seis líneas cada una, donde las últimas palabras de cada línea en la primera estrofa forman las terminaciones de línea en cada estrofa sucesiva, rotadas en un patrón establecido. (También hay una estrofa de tres líneas al final, pero no nos preocuparemos por eso). Eche un vistazo a las primeras tres estrofas de Sestina llamada creativamente por Elizabeth Bishop :

La lluvia de septiembre cae sobre la casa.
A la débil luz, la vieja abuela se
sienta en la cocina con el niño
al lado de la Pequeña Estufa Marvel,
leyendo los chistes del almanaque,
riendo y hablando para ocultar sus lágrimas.

Ella piensa que sus lágrimas equinocciales
y la lluvia que azota el techo de la casa
fueron predichas por el almanaque,
pero solo las conoce una abuela.
La tetera de hierro canta en la estufa.
Ella corta un poco de pan y le dice al niño:

Es hora de tomar el té ahora; pero el niño
observa cómo las pequeñas lágrimas duras de la tetera
bailan como locas en la estufa negra y caliente,
como la lluvia debe bailar en la casa.
Poniendo en orden, la abuela
cuelga el inteligente almanaque

...

Observe cómo cada línea termina con una de las seis palabras "casa", "abuela", "niño", "estufa", "almanaque" o "lágrimas". No solo eso, sino que las palabras están ordenadas en el patrón 6–1—5–2—4–3, en relación con la estrofa anterior. Termina pareciendo una espiral:

Todavía estamos a unos pocos años de generar mediante programación una sestina completa, pero podemos crear una plantilla con las palabras finales de cada estrofa en el orden correcto. Escriba un programa o función que, dadas las seis palabras que terminan la línea, muestre el anteproyecto para una sestina, siguiendo estas reglas. Aquí está el resultado esperado para la entrada 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 primera estrofa son las palabras en orden original, la segunda estrofa está en el orden 6-1-5-2-4-3 de la primera. La tercera estrofa es ese orden relativo a la segunda, y así sucesivamente, hasta la estrofa 6.

Suponga que las palabras de entrada siempre serán solo letras, mayúsculas o minúsculas. Puede tomarlos como una matriz de cadenas o una sola cadena delimitada por un carácter que no sea letra (espacio, nueva línea, etc.). En la salida, las líneas están separadas por líneas nuevas ( 0x0A) y las estrofas separadas por dos líneas nuevas. Una nueva línea final es aceptable.

Este es el código de golf , por lo que gana el código más corto en bytes. Dicho esto, puede ser más corto comprimir toda la estructura del poema, pero me gustaría ver algunas soluciones que basen cada estrofa en la anterior.

Jalea , 15 14 bytes

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

TryItOnline!

¿Cómo?

¡Sí, un uso de una de mis adiciones 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 bytes

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

Toma entrada a través de STDIN como una matriz separada por comas de 6 cadenas y salidas a STDOUT en el formato descrito en la publicación con una nueva línea adicional.

¡Pruébelo en línea! (Ideone)

Además, no estoy seguro de si esto está bien, pero aquí hay una respuesta más corta en forma de una función lambda anónima de 59 bytes que toma la entrada en el mismo formato que la respuesta anterior y genera el programa necesario para generar la salida correcta:

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

Por lo tanto, debe llamarse en el formato exec(<Function Name>(<Array>)). Una vez más, no estoy seguro de si esto está bien, así que estoy agregando esto como una respuesta adicional, separada y no competitiva hasta que alguien (tal vez incluso OP) pueda aclarar si está bien o no, lo que realmente agradecería .

MATL , 18 17 bytes

0ch5:"t[6l5H4I7])

La entrada es una matriz de celdas de cadenas, en el formato

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

Pruébalo en línea!

Explicación

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 bytes

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

El núcleo de esta función sin nombre es NestList[RotateRight,#,5], que toma una lista de entrada de longitud 6 y crea una lista de 6 listas, cada una rotada de manera sestina. De hecho, si una lista de listas de cadenas es una salida aceptable, entonces NestList[RotateRight,#,5]&hace el trabajo en 26 bytes .

Luego, r[...,""]inserta una cadena vacía entre cada una de las 6 listas; Flattenconvierte todo en una sola lista de cadenas; ~r~"\n"luego inserta una nueva línea entre cada una de esas cadenas; y ""<>concatena todo en una sola cadena. Por lo tanto, los otros 33 bytes son solo para convertir la salida estructurada en una sola cadena.

Lote, 99 bytes

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

Explicación: Toma datos como parámetros de la línea de comandos. Esto %0hace que se repita, acumulando .s en el séptimo parámetro originalmente vacío. El extra .es porque ifno funciona en cadenas vacías.

Ruby, 51 bytes

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

En lugar de iterar sobre los números 0..5como se muestra a continuación, repetimos 6 veces iterando sobre los elementos de z. En el uso normal, como (0..5).map{|i|puts i}el código {}lee, los elementos se repiten. En este caso, las permutaciones realizadas por el código dentro de {}no leen los elementos repetidos, por lo que podemos iterar sobre los elementos zsin que esto interfiera con las permutaciones.

Ruby, 56 bytes

Toma una matriz de 6 elementos como parámetro

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

versión alternativa que toma 6 parámetros

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

Con cada iteración de mappermutamos z. La versión original más una ""para representar una ruptura entre estrofas se convierte en la salida de map(la asignación no necesita este séptimo elemento de matriz, por lo que se ignora). *$/convierte las matrices en una cadena, uniendo todo junto con nuevas líneas.

Raqueta 115 bytes

(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)))

Sin golf:

(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))))

Pruebas:

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

Salida:

'(("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"))