Questa è una variante di Gioca la catena di parole e Costruisci una lunga catena di parole .

L'input è un elenco non vuoto di parole univoche di almeno 2 caratteri costituiti da caratteri in [az]. È necessario generare la lunghezza della catena più lunga possibile, in cui ogni parola successiva inizia con l'ultima lettera della parola precedente. Puoi iniziare con qualsiasi parola nell'elenco.

Un altro colpo di scena è che ti è permesso ripetere ogni singola parola nell'elenco. Tuttavia, non è possibile ripetere nessun blocco di due parole. Ad esempio, cat->tac->catè consentito, ma cat->tac->cat->tacnon lo è, perché è stato ripetuto un blocco di due parole ( cat->tac). Inoltre, non è possibile utilizzare la stessa parola due volte di seguito (ad es eye->eye.).

Esempi:

• cat dog tree egg => 3 (gatto-> albero-> uovo)
• new men ten whim => 5 (dieci-> nuovo-> capriccio-> uomini-> nuovo)
• truth fret heart his => 5 (tasto-> verità-> cuore-> verità-> sua)
• we were stew early yew easy => 9 (spezzatino-> erano-> inizio-> tasso-> erano-> facile-> tasso-> noi-> facile)
• tac cat tac cot tac can => 6 (tac-> cat-> tac-> cot-> tac-> can)

(Fammi sapere se ho commesso un errore in uno di questi esempi o se ne pensi di più.)

Python 3 , 150 149 145 byte

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)

Provalo online!

L'idea per la costruzione di percorsi di successione più lunghe (o in questo caso sentieri) fino a quando nessuno poteva più essere creato è stato direttamente ispirato dalla risposta di GRC sul gioco della catena di parola domanda.

Haskell , 131 141 byte

Fondamentalmente l'approccio della forza bruta .. L'idea è di generare tutti i possibili pezzi di domino , permutarli, verificare se è una combinazione valida e massimizzare il tutto. La complessità temporale è ridicola, il quarto caso di test richiede già ~ 4 secondi sul mio PC e sul TIO non sembra funzionare!

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

Provalo online!

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

Modifica : cambiato da Lambdabot per scoprire Haskell ma salvato alcuni byte giocando a golf, in modo che sia ancora meno di 145byte :)