Когда я был моложе, я играл в словесную игру под названием цепочка слов . Это было очень просто. Первый игрок выбирает слово; следующий игрок произносит другое слово, начинающееся с той же буквы, что и предыдущее слово. Это продолжается вечно, пока кто-нибудь не сдастся! Трюк в том, что вы не можете использовать одно и то же слово дважды (если все не забыли, что это слово использовалось даже!). Обычно мы играем с определенной темой, чтобы сделать ее сложнее. Но теперь я хочу, чтобы вы сделали программу, которая сделает это для меня.

Вызов

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

Это код-гольф , поэтому выигрывает самый короткий код!

вход

Есть два входа: список и начальное слово. Начальное слово не будет в списке. Все входные данные являются строчными ASCII, и список не будет содержать повторяющихся слов.

Выход

Все последовательности слов из списка такие, что:

• Начальное слово - это первое слово в последовательности.

• Каждое последующее слово начинается с той же буквы, что и последняя буква предыдущего слова.

• Длина последовательности самая длинная .

Если имеется несколько самых длинных последовательностей, выведите их все.

Последовательность не обязательно должна содержать все слова списка. Иногда это невозможно (см. Контрольные примеры). Опять же, ни одно слово не может быть использовано дважды!

Testcases

In: [hello, turtle, eat, cat, people] artistic
Out:  [artistic, cat, turtle, eat]
In: [lemonade, meatball, egg, grape] ham 
Out: [ham, meatball, lemonade, egg, grape]
In: [cat, cute, ewok] attic
Out: [attic, cute, ewok]
In:[cat, cute, ewok, kilo, to, otter] attic
Out: [attic, cute, ewok, kilo, otter]
In:[cat, today, yoda, attic] ferret
Out: [ferret, today, yoda, attic, cat]
In: [cancel, loitering, gnocchi, improv, vivic, child, despair, rat, tragic, chimney, rex, xylophone] attic
Out: [[attic, child, despair, rat, tragic, cancel, loitering, gnocchi, improv, vivic, chimney], [attic, cancel, loitering, gnocchi, improv, vivic, child, despair, ra', tragic, chimney]]
In: [cat, today, yoda, artistic, cute, ewok, kilo, to, otter] attic
Out: [attic, cat, today, yoda, artistic, cute, ewok, kilo, otter]

Pyth, 25 23 байта

.MlZfqhMtTeMPT+Lzs.pMyQ

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

Решение грубой силы. Слишком медленно для некоторых крупных тестовых случаев.

Ввод в форме:

attic
["cat", "today", "yoda", "to", "otter"] 

Вывод в виде:

[['attic', 'cat', 'today', 'yoda'], ['attic', 'cat', 'to', 'otter']]

Объяснение:

.MlZfqhMtTeMPT+Lzs.pMyQ
                           Q = eval(input()) (The list of words)
                           z = input()       (The starting word)
                     yQ    All subsets of the input.
                  .pM      All permutations of the subsets.
                 s         Flatten.
              +Lz          Add the starting word to the front of each list.
                           This is all possible sequences.
    f                      Filter on
     q                     The equality of
      hMtT                 The first character of each word but the first
          eMPT             The last character of each word but the last
.MlZ                       Take only the lists of maximal length.

JavaScript (ES6), 164 байта

f=(l,s,r=[[]])=>l.map((w,i)=>w[0]==s.slice(-1)&&(x=l.slice(),x.splice(i,1),o=f(x,w),a=o[0].length,b=r[0].length,r=a>b?o:a<b?r:r.concat(o)))&&r.map(q=>[s].concat(q))

объяснение

Рекурсивная функция, которая проверяет, как долго будет выходной список для всех возможных вариантов.

Возвращает массив массивов слов.

f=(l,s,r=[[]])=>            // l = list, s = starting word, r is not passed (it is
                            //     here so that it is not defined globally)
  l.map((w,i)=>             // for each word w at index i
    w[0]==s.slice(-1)&&(    // if the first letter is the same as the last letter:
      x=l.slice(),          // x = clone of the list of words
      x.splice(i,1),        // remove the current word
      o=f(x,w),             // get the list of words starting from the current word
      a=o[0].length,
      b=r[0].length,
      r=a>b?o:              // if o is longer, set r to o
        a<b?r:              // if o is shorter, keep r
        r.concat(o)         // if o is same, add it to r
    )
  )
  &&r.map(q=>[s].concat(q)) // return a list of longest lists with the starting word

Тестовое задание

Параметр по умолчанию не используется в тесте, чтобы сделать его более совместимым с браузерами.

f=(l,s,r)=>l.map((w,i)=>w[0]==s.slice(-1)&&(x=l.slice(),x.splice(i,1),o=f(x,w),a=o[0].length,b=r[0].length,r=a>b?o:a<b?r:r.concat(o)),r=[[]])&&r.map(q=>[s].concat(q))

Word list (space separated) = <input type="text" id="list" value="cancel loitering gnocchi improv vivic child despair rat tragic chimney rex xylophone" /><br />
Starting word = <input type="text" id="word" value="attic" /><br />
<button onclick="result.textContent=f(list.value.split(' '),word.value).join('\n')">Go</button>
<pre id="result"></pre>

Python, 104

def f(d,w):
 a=[[w]]
 while a:b=a;a=[x+[y]for x in a for y in set(d)-set(x)if x[-1][-1]==y[0]]
 return b

Я думаю, что это должно работать сейчас ...

Попробуйте онлайн .

Perl 5, 275 байт

Возможно, не так много в гольфе, как это возможно, но, в любом случае, это не выигрыш, верно?

use List::Util max;use List::MoreUtils uniq,before;use Algorithm::Permute permute;$i=pop;permute{push@c,[@ARGV]}@ARGV;for$c(@c){unshift@$c,$i;push @{$d{before{(substr$c->[$_],-1)ne(substr$c->[1+$_],0,1)}keys$c}},$c}for$m(max keys%d){say for uniq map{"@$_[0..$m+1]"}@{$d{$m}}}

Используйте это так:

$ perl -M5.010 chain.pl cat tin cot arc
arc cat tin
arc cot tin

Предупреждение! Использование этого скрипта в длинном списке требует много памяти! Он отлично работал для меня семь (шесть плюс один дополнительный), но не тринадцать (двенадцать плюс один).

Он удаляет последний ввод, генерирует массив arrayrefs, где arrayrefs - все перестановки, и добавляет начальное слово обратно в начале. Затем он помещает каждую такую ​​перестановку в другой массивref, который является значением хэша с ключом, равным количеству массива, у которого есть желаемое свойство сцепления. Затем он находит максимум такого ключа и распечатывает все массивы.

C 373 байта

g(char*y){printf("%s, ",y);}z(char*w){int i,k=-1,v=0,j=sizeof(c)/sizeof(c[0]);int m[j],b=0;for(i=0;i<j;i++){m[v++]=c[i][0]==w[strlen(w)-1]?2:1;if(u[i]==6)m[v-1]=1;if(strcmp(w,c[i]))k=i;}printf("%s",w);for(i=0;i<j;i++){if(m[i]!=1){if(v+i!=j){g(s);for(;b<j;b++){if(u[b]==6)g(c[b]);}}else printf(", ");u[i]=6;z(c[i]);u[i]=1;}else v+=-1;}if(k!=-1)u[k]=1;if(v==0)printf(" ; ");}

Я полагаю, что, возможно, здесь гораздо больше возможностей для игры в гольф, поэтому я, вероятно, обновлю его.

Де-гольф

char *c[9]={"cat","today","yoda","artistic","cute","ewok","kilo","to","otter"};
u[9]={-1};
char *s="attic";

g(char*y){printf("%s, ",y);}
z(char*w){
   int i,k=-1,v=0,j=sizeof(c)/sizeof(c[0]);
   int m[j],b=0;
   for(i=0;i<j;i++){
      m[v++]=c[i][0]==w[strlen(w)-1]?i:-1;
      if(u[i]==6)m[v-1]=-1;
      if(strcmp(w,c[i]))k=i;
   }
   printf("%s",w);
   for(i=0;i<j;i++){
      if(m[i]!=-1){
         if(v+i!=j){
            g(s);
            for(;b<j;b++){
                if(u[b]==6)g(c[b]);
             }
         }else printf(", ");
         u[i]=6;
         z(c[i]);
         u[i]=-1;
      } else v+=-1;
   }
   if(k!=-1)u[k]=-1;
   if(v==0)printf(" ; ");
}

main(){
   z(s);
   printf("\n");
   return 0;
}

Идеальная ссылка - Если я не сделал это правильно, просто дайте мне знать: D