Dies ist eine Variante von Spielen Sie die Wortkette und bauen Sie eine lange Wortkette auf .

Die Eingabe ist eine nicht leere Liste eindeutiger Wörter, die mindestens 2 Zeichen lang sind und aus Zeichen in [az] bestehen. Sie müssen die Länge der längsten möglichen Kette ausgeben, wobei jedes nachfolgende Wort mit dem letzten Buchstaben des vorherigen Wortes beginnt. Sie können mit jedem Wort in der Liste beginnen.

Eine weitere Wendung ist, dass Sie jedes einzelne Wort auf der Liste wiederholen dürfen. Sie können jedoch keinen Zwei-Wort-Block wiederholen. Zum Beispiel cat->tac->catist erlaubt, aber cat->tac->cat->tacnicht, weil Sie einen Zwei-Wort-Block ( cat->tac) wiederholt haben . Sie können dasselbe Wort auch nicht zweimal hintereinander verwenden (z eye->eye. B. ).

Beispiele:

• cat dog tree egg => 3 (Katze-> Baum-> Ei)
• new men ten whim => 5 (zehn-> neu-> Laune-> Männer-> neu)
• truth fret heart his => 5 (Bund-> Wahrheit-> Herz-> Wahrheit-> sein)
• we were stew early yew easy => 9 (Eintopf-> waren-> früh-> Eibe-> waren-> leicht-> Eibe-> wir-> leicht)
• tac cat tac cot tac can => 6 (tac-> cat-> tac-> cot-> tac-> can)

(Lassen Sie mich wissen, ob ich bei einem dieser Beispiele einen Fehler gemacht habe oder ob Sie sich mehr einfallen lassen.)

Python 3 , 150 149 145 Bytes

def f(d):
 a=[[w]for w in d]
 while a:b=a[0];a=[f+[l,y]for*f,l in a for y in{*d}-{b for a,b in zip(f,f[1:])if a==l}if l[-1]==y[0]]
 return len(b)

Probieren Sie es online aus!

Die Idee für sukzessive längere Pfade konstruieren (oder in diesem Fall Trails) , bis keine mehr erstellt von direkt inspiriert werden könnten grc Antwort auf die Wiedergabe der Wortkette Frage.

Haskell , 131 141 Bytes

Grundsätzlich der Brute-Force-Ansatz. Die Idee ist, alle möglichen Dominostücke zu generieren , sie zu permutieren, zu überprüfen, ob es sich um eine gültige Kombination handelt, und das Ganze zu maximieren. Die zeitliche Komplexität ist lächerlich, der 4. Testfall dauert auf meinem PC bereits ~ 4s und auf dem TIO scheint es nicht zu funktionieren!

import Data.List
p w=2+maximum[length$takeWhile(\(x,y)->x!!1==y!!0)$zip p$tail p|p<-permutations[[a,b]|(a,b)<-(,)<$>w<*>w,a/=b,last a==b!!0]]

Probieren Sie es online aus!

Ungolfed

p w = maximum
  [ 2 + length c | p <- permutations [ [a,b] | (a,b) <- (,)<$>w<*>w
                                             , a /= b
                                             , last a == head b
                                     ]
                 , c <- [ takeWhile (\(x,y) -> x!!1 == y!!0) $ zip p (tail p) ]
  ]

Bearbeiten : Von Lambdabot zu Bare Haskell geändert, aber durch Golfen ein paar Bytes gespart, so dass es immer noch weniger als 145Bytes sind :)