Сестина это формат стихотворения , который следует интересный образец , который мы можем генерировать. Он имеет шесть строф по шесть строк в каждой, где последние слова каждой строки в первой строфе составляют окончания строк в каждой последующей строфе, повернутые по заданному шаблону. (В конце также есть строфа из трех строк, но мы не будем об этом беспокоиться.) Взгляните на первые три строфы творчески названной Сестиной Элизабет Бишоп :

Сентябрьский дождь падает на дом.
В тусклом свете старая бабушка
сидит на кухне с ребенком
рядом с печью Little Marvel,
читая анекдоты из альманаха,
смеясь и разговаривая, чтобы скрыть слезы.

Она думает, что ее слезы равноденствия
и дождь, который бьется на крыше дома,
были предсказаны альманахом,
но известны только бабушке.
Железный чайник поет на плите.
Она нарезает хлеб и говорит ребенку:

Время для чая сейчас; но ребенок
наблюдает, как маленькие
горячие слезы чайника танцуют, как сумасшедшие, на горячей черной плите,
как дождь должен танцевать в доме.
Приводя в порядок, старая бабушка
вешает умный альманах

...

Обратите внимание, как каждая строка заканчивается одним из шести слов «дом», «бабушка», «ребенок», «плита», «альманах» или «слезы». Мало того, но слова упорядочены по схеме 6–1–5–2—4–3 относительно предыдущей строфы. Это выглядит как спираль:

У нас еще несколько лет до программной генерации полной сестины, но мы можем создать шаблон, содержащий конечные слова каждой строфы в правильном порядке. Напишите программу или функцию, которая, учитывая шесть слов в конце строки, выводит план для сестины, следуя этим правилам. Вот ожидаемый результат для ввода 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!

Как?

Yey, использование одного из моих дополнений к желе! ( œ?)

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 в формате, описанном в посте, с дополнительным завершающим переводом строки.

Попробуйте онлайн! (Ideone)

Кроме того, я не уверен, что это нормально, но вот более короткий ответ в виде анонимной лямбда-функции с 59 байтами, которая принимает входные данные в том же формате, что и ответ выше, и выводит программу, необходимую для генерации правильный вывод:

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

Поэтому он должен называться в формате exec(<Function Name>(<Array>)). Опять же, я не уверен, что это нормально, так что я добавляю это как дополнительный, отдельный, неконкурентный ответ, пока кто-то (возможно, даже ОП) не сможет, надеюсь, уточнить, хорошо это или нет, что я был бы очень признателен ,

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Заставляет его петлю вокруг, накапливая .с в первоначально опустошить 7 параметра. Это .связано с тем, ifчто не работает с пустыми строками.

Рубин, 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 без чтобы это не мешало перестановкам.

Рубин, 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)))

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

Тестирование:

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