一个sestina是诗的格式遵循一个有趣的模式，我们可以生成。它有六个节，每个节有六行，其中第一个节中每行的最后一个单词组成每个相继节中以设置模式旋转的行结尾。（最后还有一个三行节，但我们不必担心。）看一下Elizabeth Bishop创造性地命名为Sestina的前三个节：

九月的雨落在房子上。
在失败的曙光中，老祖母
和孩子
坐在小奇迹炉子旁边，坐在厨房里，
读着历书中的笑话，
笑着说着掩饰眼泪。

她认为，历经的泪水
和房屋屋顶上刮起的大雨
都是历书所预言的，
但只有祖母才知道。
铁水壶在炉子上唱歌。
她切了一些面包，对孩子说，

现在该喝茶了；但是孩子
却看着茶壶的细小的硬泪
在疯狂的黑火炉上疯狂地跳舞，就像
雨在房子上跳舞一样。
整理时，老祖母
挂上了聪明的年历

...

请注意，每一行的结尾是六个单词“房子”，“祖母”，“孩子”，“火炉”，“年鉴”或“眼泪”之一。不仅如此，相对于先前的节，单词的排列方式为6–1–5–2–4–3。最终看起来像螺旋形：

距离以编程方式生成完整的sestina尚有几年的时间，但是我们可以创建一个模板，以适当的顺序包含每个节的结尾词。编写一个程序或函数，给定六个行结束词，并遵循以下规则输出sestina的设计图。这是输入的预期结果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

第一个节是原始顺序的单词，第二个节是第一个节的6-1-5-2-4-3顺序。第三个节是相对于第二个节的顺序，依此类推，一直到第6节。

假设输入单词将始终仅是字母，大写或小写。您可以将它们视为字符串数组或由非字母字符（空格，换行符等）分隔的单个字符串。在输出中，行用换行符（0x0A）分隔，节用两条换行符分隔。尾随换行符是可以接受的。

这是代码高尔夫球，因此以字节为单位的最短代码获胜。话虽如此，压缩整首诗的结构可能要短一些，但我希望看到一些将每个节都基于前一句的解决方案。

果冻，15 14 字节

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

TryItOnline！

怎么样？

是的，使用我添加的果冻之一！（œ?）

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字节

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

通过STDIN将输入作为6个字符串的逗号分隔数组，并以帖子中所述的格式输出到STDOUT，并带有附加的尾随换行符。

在线尝试！（爱迪生）

另外，我不确定是否可以这样做，但这是一个简短的答案，形式为59字节的匿名lambda函数，它以与上述答案相同的格式接受输入，并输出生成所需的程序正确的输出：

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

因此，必须以格式调用它exec(<Function Name>(<Array>))。同样，我不确定是否可以这样做，所以我将其添加为一个额外的，独立的，非竞争性的答案，直到有人（甚至甚至是OP）可以希望澄清这是否可行，对此我将不胜感激。

MATL，18 17字节

0ch5:"t[6l5H4I7])

输入是字符串的单元格数组，格式为

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

在线尝试！

说明

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个字节

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

此未命名函数的核心是NestList[RotateRight,#,5]，它接受长度为6的输入列表，并创建6个列表的列表，每个列表以sestina方式旋转。确实，如果可以接受字符串列表列表，则NestList[RotateRight,#,5]&该作业以26个字节为单位。

然后，r[...,""]在6个列表中的每一个之间插入一个空字符串；Flatten将整个事情变成一个字符串列表；~r~"\n"然后在每个字符串之间插入换行符；并将""<>整个内容连接成一个字符串。因此，其他33个字节仅用于将结构化输出转换为单个字符串。

批处理，99字节

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

说明：将输入作为命令行参数。在%0它会导致环路周围，积累.在原本空第七参数s。多余的.是因为if它不适用于空字符串。

Ruby，51个字节

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

除了遍历0..5下面的数字外，我们还遍历的元素重复6次z。在正常用法中，例如 (0..5).map{|i|puts i}代码{}读取迭代的元素。在这种情况下，内部代码由代码完成的置换{}不会读取迭代的元素，因此我们可以迭代的元素，z而不会干扰置换。

Ruby，56个字节

将6元素数组作为参数

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

具有6个参数的备用版本

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

每次迭代map我们都会置换z。原始版本加上""表示节之间的分隔符的a成为的输出map（赋值不需要此第七数组元素，因此将被忽略）。*$/将数组转换为字符串，将所有内容与换行符连接在一起。

拍子115字节

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

取消高尔夫：

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

测试：

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

输出：

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