A sestina é um formato de poema que segue um padrão interessante que podemos gerar. Ele tem seis estrofes de seis linhas cada, onde as últimas palavras de cada linha na primeira estrofe compõem as terminações de cada estrofe sucessiva, giradas em um padrão definido. (Há também uma estrofe de três linhas no final, mas não vamos nos preocupar com isso.) Dê uma olhada nas três primeiras estrofes da criativamente chamada Sestina, de Elizabeth Bishop :

A chuva de setembro cai sobre a casa.
À luz fraca, a velha avó
senta-se na cozinha com a criança
ao lado do Fogão da Pequena Marvel,
lendo as piadas do almanaque,
rindo e conversando para esconder as lágrimas.

Ela acha que suas lágrimas equinociais
e a chuva que bate no telhado da casa
foram preditas pelo almanaque,
mas são conhecidas apenas por uma avó.
A chaleira de ferro canta no fogão.
Ela corta um pouco de pão e diz à criança:

Está na hora do chá agora; mas a criança
está assistindo as pequenas lágrimas duras da chaleira
dançarem como loucas no fogão quente e preto,
do jeito que a chuva deve dançar na casa.
Arrumando, a velha avó
desliga o almanaque inteligente

...

Observe como cada linha termina com uma das seis palavras "casa", "avó", "criança", "fogão", "almanaque" ou "lágrimas". Não apenas isso, mas as palavras são ordenadas no padrão 6–1—5–2–4–3, em relação à estrofe anterior. Acaba parecendo uma espiral:

Ainda estamos a alguns anos de gerar programaticamente uma sestina completa, mas podemos criar um modelo com as palavras finais de cada estrofe na ordem correta. Escreva um programa ou função que, dadas as seis palavras finais de linha, produza o plano para uma sestina, seguindo estas regras. Aqui está o resultado esperado para a 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

A primeira estrofe são as palavras na ordem original, a segunda estrofe está na ordem 6-1-5-2-4-3 da primeira. A terceira estrofe é a ordem em relação à segunda e assim por diante, até a estrofe 6.

Suponha que as palavras de entrada sempre sejam apenas letras, maiúsculas ou minúsculas. Você pode tomá-los como uma matriz de cadeias ou uma única cadeia delimitada por um caractere não-letra (espaço, nova linha etc.). Na saída, as linhas são separadas por novas linhas ( 0x0A) e as estrofes separadas por duas novas linhas. Uma nova linha à direita é aceitável.

Isso é código-golfe , então o código mais curto em bytes vence. Dito isto, pode ser mais curto compactar toda a estrutura do poema, mas eu gostaria de ver algumas soluções que baseiam cada estrofe na anterior.

Geléia , 15 14 bytes

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

TryItOnline!

Quão?

Sim, uso de uma das minhas adições ao 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

Leva a entrada através de STDIN como uma matriz de 6 seqüências de caracteres separada por vírgula e sai para STDOUT no formato descrito na postagem com uma nova linha à direita adicional.

Experimente Online! (Ideona)

Além disso, não tenho certeza se isso é adequado, mas aqui está uma resposta mais curta na forma de uma função lambda anônima de 59 bytes que recebe entrada no mesmo formato da resposta acima e gera o programa necessário para gerar a saída correta:

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

Portanto, ele deve ser chamado no formato exec(<Function Name>(<Array>)). Novamente, não tenho certeza se isso é bom, então estou adicionando isso como uma resposta extra, separada e não competitiva até que alguém (talvez até OP) possa esclarecer se isso está bem ou não, o que eu realmente aprecio .

MATL , 18 17 bytes

0ch5:"t[6l5H4I7])

Entrada é uma matriz de células de cadeias, no formato

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

Experimente online!

Explicação

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"&

O núcleo desta função sem nome é NestList[RotateRight,#,5], que pega uma lista de entrada com o comprimento 6 e cria uma lista com 6 listas, cada uma rotacionada da maneira sestina. De fato, se uma lista de listas de seqüências de caracteres for uma saída aceitável, NestList[RotateRight,#,5]&o trabalho será executado em 26 bytes .

Em seguida, r[...,""]insere uma string vazia entre cada uma das 6 listas; Flattentransforma a coisa toda em uma única lista de strings; ~r~"\n"depois insere uma nova linha entre cada uma dessas cadeias; e ""<>concatena a coisa toda em uma única sequência. Assim, os outros 33 bytes são apenas para converter a saída estruturada em uma única sequência.

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

Explicação: Recebe a entrada como parâmetros da linha de comandos. A %0faz com que ele laço em torno, acumulando .s no parâmetro originalmente esvaziar 7. O extra .é porque ifnão funciona em cadeias vazias.

Ruby, 51 bytes

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

Em vez de iterar sobre os números 0..5como abaixo, repetimos 6 vezes iterando sobre os elementos de z. Em uso normal, como (0..5).map{|i|puts i}o código, {}lê os elementos repetidos. Nesse caso, as permutações feitas pelo código dentro {}do não leem os elementos iterados, para que possamos iterar sobre os elementos zsem que isso interfira nas permutações.

Ruby, 56 bytes

Toma uma matriz de 6 elementos como parâmetro

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

versão alternativa com 6 parâmetros

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

Com cada iteração de mappermutamos z. A versão original mais a ""para representar uma quebra entre sub-rotinas torna-se a saída do map(este sétimo elemento da matriz não é necessário pela atribuição, por isso é ignorado). *$/converte as matrizes em uma string, unindo tudo com novas linhas.

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

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

Teste:

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

Resultado:

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