Il s'agit d'une variante de Jouer la chaîne de mots et Construire une longue chaîne de mots .

L'entrée est une liste non vide de mots uniques d'au moins 2 caractères composés de caractères en [az]. Vous devez afficher la longueur de la chaîne la plus longue possible, où chaque mot suivant commence par la dernière lettre du mot précédent. Vous pouvez commencer par n'importe quel mot de la liste.

Une autre tournure est que vous êtes autorisé à répéter n'importe quel mot de la liste. Cependant, vous ne pouvez pas répéter un bloc de deux mots. Par exemple, cat->tac->catest autorisé, mais cat->tac->cat->tacne l'est pas, car vous avez répété un bloc de deux mots ( cat->tac). De plus, vous ne pouvez pas utiliser le même mot deux fois de suite (par exemple eye->eye).

Exemples:

• cat dog tree egg => 3 (chat-> arbre-> œuf)
• new men ten whim => 5 (dix-> nouveau-> caprice-> hommes-> nouveau)
• truth fret heart his => 5 (frette-> vérité-> cœur-> vérité-> son)
• we were stew early yew easy => 9 (ragoût-> étaient-> tôt-> if-> étaient-> facile-> if-> nous-> facile)
• tac cat tac cot tac can => 6 (tac-> cat-> tac-> cot-> tac-> can)

(Faites-moi savoir si j'ai fait une erreur sur l'un de ces exemples ou si vous en trouvez plus.)

Python 3 , 150 149 145 octets

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)

Essayez-le en ligne!

L'idée de construire des chemins plus en plus longues (ou dans ce cas de sentiers) jusqu'à ce qu'il ne pouvait plus être créé directement inspiré par la réponse de la RRB sur la lecture de la chaîne de mot de question.

Haskell , 131 141 octets

Fondamentalement, l'approche par force brute. L'idée est de générer toutes les pièces de dominos possibles , de les permuter, de vérifier si c'est un combo valide et de maximiser le tout. La complexité temporelle est ridicule, le 4ème cas de test prend déjà ~ 4s sur mon PC et sur le TIO ça ne semble pas fonctionner!

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

Essayez-le en ligne!

Non golfé

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

Edit : changé de Lambdabot en Haskell nu mais économisé quelques octets en le jouant au golf, de sorte qu'il est toujours inférieur à 145octets :)