introduzione

Un popolare puzzle di parole è quello di convertire una parola in un'altra tramite una serie di passaggi che sostituiscono solo una lettera e che risultano sempre in una parola valida. Ad esempio, BAG può essere convertito in DOG tramite un percorso di cinque passaggi:

BORSA -> BAT -> CAT -> COT -> COG -> CANE

In questo caso esistono anche percorsi più brevi; per esempio:

BORSA -> BOG -> CANE

Se uno disegnasse un grafico i cui vertici erano etichettati da parole, con un bordo tra una coppia di parole che differiscono di una lettera, allora il percorso più breve da "BORSA" a "CANE" sarebbe costituito da due bordi.

Sfida

Devi scrivere un programma che riceve come input un "dizionario" di parole che hanno tutte la stessa lunghezza, che rappresentano tutte le parole consentite che possono apparire come passi lungo un percorso. Dovrebbe generare almeno un "percorso più lungo più breve", ovvero un percorso tra due delle parole che è:

• non più di qualsiasi altro percorso tra quelle due parole;

• almeno fino a quando il percorso più breve possibile tra qualsiasi altra coppia di parole nell'elenco.

Nel contesto del grafico sopra descritto, la lunghezza di tale percorso è il diametro del grafico.

Nel caso degenerato in cui nessuna delle parole di input può essere trasformata in nessuna delle altre, emettere almeno un percorso di lunghezza zero, cioè una singola parola.

Esempi

• L'input ["bag", "bat", "cat", "cot", "dot", "dog"] dovrebbe generare un percorso che attraversa tutte e sei le parole in quell'ordine (o ordine inverso), poiché il percorso più breve da " borsa "a" cane "all'interno di questo dizionario è il più lungo possibile, cinque passaggi.

• L'input ["bag", "bat", "bot", "cat", "cot", "dot", "dog"] dovrebbe fornire il percorso "bag, bat, bot, dot, dog" e / o il suo inversione.

• L'ingresso ["codice", "golf", "maschio", "ronzio", "talpa", "ruolo", "muffa", "freddo", "oro", "modalità"] dovrebbe generare un percorso tra "codice e "golf".

• L'ingresso ["uno", "due", "sei", "dieci"] corrisponde a un grafico senza spigoli, quindi emette uno o più percorsi a parola singola (lunghezza zero).

• Se l'input contiene due parole di lunghezza diversa, l'output non è definito.

Regole

• Si applicano le regole standard per il golf
• Ci saranno più percorsi "più brevi". Devi produrne almeno uno, ma sei libero di produrne quanti ne desideri.
• Sei libero di decidere come passare il dizionario di input nel tuo programma.
• Vince il codice più breve in byte.

Gelatina , 20 byte

ŒPŒ!€ẎnƝ§ỊẠƲƇ.ịⱮḢƙƊṪ

Provalo online!

APL (Dyalog Classic) , 84 80 77 76 74 66 61 byte

{⍵⌷⍨{⍵,⍨⊃⍋(1≠a⌷⍨⊃⍵),⍪⍺⌷a}⍣d/⊃⍸a=d←⌈/512|,a←⌊.+⍨⍣≡9*⍨2⌊⍵+.≠⍉⍵}

Provalo online!

input e output sono matrici di caratteri

⍵+.≠⍉⍵ matrice di distanze martellanti tra le parole

9*⍨2⌊lascia intatti 0 e 1, trasforma 2+ in un numero grande (512 = 2 ⁹ , usato come "∞")

⌊.+⍨⍣≡ L' algoritmo del percorso più breve di floyd & warshall

• ⌊.+come la moltiplicazione di matrici ma usando min( ⌊) e +invece di +e ×rispettivamente

• ⍨ usa la stessa matrice a sinistra e a destra

• ⍣≡ ripetere fino alla convergenza

d←⌈/512|, lunghezza del percorso più lungo (non "∞"), assegnato a d

⊃⍸a=che due nodi non si connette, chiamiamoli i e j

{⍵,⍨⊃⍋(1≠a⌷⍨⊃⍵),⍪⍺⌷a}⍣d/ ricostruire il percorso

• { }⍣d/valutare i tempi di { }funzione d. l'arg sinistra ⍺è sempre io . l'arg destro ⍵inizia come j e accumula gradualmente i nodi interni del percorso

• (1≠a⌷⍨⊃⍵),⍪⍺⌷a costruire una matrice a 2 colonne di questi due vettori:

  • 1≠a⌷⍨⊃⍵ booleani (0 o 1) che indicano quali nodi sono a distanza 1 dal primo di ⍵

  • ⍺⌷a distanze di tutti i nodi del grafico a ⍺

• ⊃⍋ indice della riga lessicograficamente più piccola

• ⍵,⍨ anteporre a ⍵

⍵⌷⍨ indicizza le parole originali con il percorso

Python 3 , 225 byte

from itertools import*
def f(a):b=[((p[0],p[-1]),(len(p),p))for i in range(len(a))for p in permutations(a,i+1)if all(sum(q!=r for q,r in zip(*x))<2for x in zip(p,p[1:]))];return max(min(r for q,r in b if x==q)for x,y in b)[1]

Provalo online!

Fondamentalmente, prendi tutti i percorsi possibili, mantieni solo quelli validi, quindi passa attraverso ogni combinazione inizio-fine, trova la distanza minima del percorso e trova il massimo.

Wolfram Language (Mathematica) , 105 byte

f@x_:=MaximalBy[AdjacencyGraph[x,UnitStep[1-DistanceMatrix@x]]~FindShortestPath~##&@@@Tuples[x,2],Length]

Provalo online!

JavaScript (ES6),  195  194 byte

Ritorni [optimal_length, [optimal_path]].

f=(a,p=[],w=o=[],l=0)=>Object.values(o,o[k=[w,p[0]]]=(o[k]||0)[0]<l?o[k]:[l,p],a.map((v,i)=>w+w&&[...v].map((c,i)=>s-=c!=w[i],s=1)|s||f(a.filter(_=>i--),[...p,v],v,l+1))).sort(([a],[b])=>b-a)[0]

Provalo online!

Come?

$f$$o$$w_0$$w_1$$[l, p]$$p$$w_0$$w_1$$l$

$p$$l$$w$$p$$o$

o[k = [w, p[0]]] = (o[k] || 0)[0] < l ? o[k] : [l, p]

$o$

Object.values(o).sort(([a], [b]) => b - a)[0]

(questo codice viene eseguito ad ogni profondità di ricorsione, ma conta solo il livello principale)

$v$$w$

[...v].map((c, i) => s -= c != w[i], s = 1) | s

$v$

f(                    //
  a.filter(_ => i--), // remove the i-th word from a[]
  [...p, v],          // append v to p[]
  v,                  // pass v as the last word
  l + 1               // increment the length of the path
)                     //

Wolfram Language (Mathematica) , 92 byte

MaximalBy[Select[Rule@@@a,EditDistance@@#<2&]~FindShortestPath~##&@@@(a=#~Tuples~2),Length]&

Provalo online!

Python 3, 228 byte.

def G(w):
    D={A+B:[A,B]if sum(a!=b for a,b in zip(A,B))<2else[0,0]*len(w)for A in w for B in w}
    for k in w:
        for i in w:
            for j in w:
                p=D[i+k]+D[k+j][1:]
                if len(p)<len(D[i+j]):D[i+j]=p
    return max(D.values(),key=len)

Implementa l'algoritmo Floyd-Warshall per i percorsi più brevi di tutte le coppie, quindi prende il massimo sui percorsi trovati.

16 dei personaggi in questa implementazione sono schede, il che è sfortunato :(