Kelime değiştirici, tek bir adımda bir kelimeyi diğerine çevirmeye çalıştığınız ve her adımın kendi kelimesi olduğu bir oyundur. Bu sorun için düzenlemeler değişiklik, ekleme veya silme olabilir. Örneğin, WINNER → LOSER bu rota ile yapılabilir (başkaları da olabilir):

WINNER
DINNER
DINER
DINE
LINE
LONE
LOSE
LOSER

Başka bir şekilde ifade edildiğinde, her seferinde Levenshtein mesafesindeki diğer kelimelerle sadece bir kelimeye ulaşabilmelisiniz.

Kodlama

Size bir kelime listesi ve iki kelime verilecek ve bir rota varsa bir kelimeden diğerine geçerli bir rota ya da hiçbir rota yoksa farklı bir sabit değer veya tutarlı bir davranış vermelisiniz.

• Giriş kelimelerinin her ikisinin de kelime listesinde olduğunu varsayabilirsiniz.
• Kelime listesi, uygun herhangi bir düz formatta alınabilir.
  • Listeler, kümeler, denemeler, boşlukla ayrılmış dizeler ve satırla ayrılmış dosyaların hepsi geçerlidir (örneğin), ancak Levenshtein bitişikliğinin önceden hesaplanmış bir grafiği geçerli değildir.
• Çıktı yolu her iki giriş sözcüğünü içermelidir, ancak başlayan ve biten önemli değildir.
• Hiçbir rota bulunamazsa, belirli bir sabit, bir sahte değer, boş bir liste çıktısı verebilir, bir istisna atabilir, sıfır olmayan bir kodla çıkabilirsiniz veya sonlu zamanda gerçekleşen başka herhangi bir davranış.
• Güzergahın optimal olması gerekmez ve hangi güzergahın izlenmesi gerektiği konusunda bir gereklilik yoktur
• Hesaplama karmaşıklığı önemli değildir, ancak programınızın sınırlı bir süre içinde sonlandırılacağı garanti edilmelidir. (evrenin sıcak ölümünün ötesine geçse bile)
• Aynı kelimedeki tüm kelimelerin tamamen harflerden oluştuğunu varsayabilirsiniz.

Örnek Test Durumları

• CAT → KÖPEK; [KEDİ, KÖPEK, COG, COT, KURBAĞA, GROG, BOG]
  • KEDİ, COT, COG, KÖPEK
• BANYO → DUŞ; [BANYO, DUŞ, HATH, ŞAPKA, BAT, SAT, TESTERE, GÖNDER, GÖSTER, NASIL]
  • Güzergah Bulunamadı
• BREAK → DÜZELTME; [BREAK, FIX, BEAK, EKMEK, OKUMA, BONCUK, KIRMIZI, YATAK, KÖTÜ, TEKLİF, FAD, FAKS]
  • KIRMA, EKMEK, BONCUK, KÖTÜ, FAD, FAKS, DÜZELTME
• YAP → DESTROY; [İNŞA, DESTROY, İNŞAAT, GUILT, GUILD, GILD, GILL, BILL, DILL, FILL, DESTRUCT, STRUCTURE, CONSTRUCT]
  • Güzergah Bulunamadı
• KART → KURUL; [KART, KURUL, BARD]
  • KART, BARD, KURUL
• DEMON → ANGEL; [DEMON, ANGEL]
  • Güzergah Bulunamadı
• SON → GEÇMİŞ; [SON, GEÇMİŞ, PATLATICI, DÖKÜM, SİYAH, HAYALET, POST, BOAST]
  • SON, SON
• INSERT → SİL; Bu kelime listesi
  • INSERT, INVERT, INVENT, INBENT, UNBENT, UNBEND, UNBIND, UNKIND, UNKING, UNKING, INKING, IRKING, DIRKING, DARKING, DARLING, ARLING, YASTIK, SIRING, SERING, SERINE, NERINE, NERITE, CERITE, CERATE, TATE, DER, SİL

05AB1E , 23 21 20 bayt

Geçerli rotaların bir listesini yazdırır. Kevin Cruijssen
sayesinde 2 bayt kurtardı .

怜€`ʒü.LP}ʒ¬²Qsθ³Q*

Çevrimiçi deneyin!

JavaScript (V8) ,  177  176 bayt

Girişi alır (target)(source, list). Olası tüm rotaları yazdırır. Ya da çözüm yoksa hiçbir şey yazdırmaz.

t=>F=(s,l,p=[],d)=>s==t?print(p):l.map((S,i)=>(g=(m,n)=>m*n?1+Math.min(g(m-1,n),g(m,--n),g(--m,n)-(S[m]==s[n])):m+n)(S.length,s.length)^d||F(S,L=[...l],[...p,L.splice(i,1)],1))

Çevrimiçi deneyin!

Yorumlananlar

t =>                            // t = target string
F = (                           // F is a recursive function taking:
  s,                            //   s = source string
  l,                            //   l[] = list of words
  p = [],                       //   p[] = path
  d                             //   d = expected Levenshtein distance between s and the
) =>                            //       next word (initially undefined, so coerced to 0)
  s == t ?                      // if s is equal to t:
    print(p)                    //   stop recursion and print the path
  :                             // else:
    l.map((S, i) =>             //   for each word S at index i in l[]:
      ( g =                     //     g = recursive function computing the Levenshtein
        (m, n) =>               //         distance between S and s
        m * n ?                 //       if both m and n are not equal to 0:
          1 + Math.min(         //         add 1 to the result + the minimum of:
            g(m - 1, n),        //           g(m - 1, n)
            g(m, --n),          //           g(m, n - 1)
            g(--m, n) -         //           g(m - 1, n - 1), minus 1 if ...
            (S[m] == s[n])      //           ... S[m - 1] is equal to s[n - 1]
          )                     //         end of Math.min()
        :                       //       else:
          m + n                 //         return either m or n
      )(S.length, s.length)     //     initial call to g with m = S.length, n = s.length
      ^ d ||                    //     unless the distance is not equal to d,
      F(                        //     do a recursive call to F with:
        S,                      //       the new source string S
        L = [...l],             //       a copy L[] of l[]
        [...p, L.splice(i, 1)], //       the updated path (removes S from L[])
        1                       //       an expected distance of 1
      )                         //     end of recursive call
    )                           //   end of map()

Wolfram Dili (Mathematica) , 59 bayt

Select[Rule@@@#~Tuples~2,EditDistance@@#<2&]~FindPath~##2&;

Çevrimiçi deneyin!

Python 2 , 155 bayt

f=lambda a,b,W,r=[]:a==b and r+[a]or reduce(lambda q,w:q or any({a,a[:i]+a[i+1:]}&{w,w[:i]+w[i+1:]}for i in range(len(a+w)))and f(w,b,W-{a},r+[a]),W-{a},0)

Çevrimiçi deneyin!

Girdi olarak iki kelime ve bir dizi kelime alır; bir dize listesi olarak varsa (optimal olmayan) bir yol döndürür, aksi takdirde False değerini döndürür.

Bu parça:

any({a,a[:i]+a[i+1:]}&{w,w[:i]+w[i+1:]}for i in range(len(a+w)))

ise Trueancak ve ancak a==wya aait Levenshtein mesafe vardır 1den w.

Wolfram Dili (Mathematica) , 124 bayt

Join[#,Select[Flatten[Permutations/@Subsets@#3,1],s=#;t=#2;Union[EditDistance@@@Partition[Join[s,#,t],2,1]]=={1}&][[1]],#2]&

Çevrimiçi deneyin!

Python 2 , 163 bayt

Bir rota bulunursa, stderr'e gönderilir ve program çıkış kodu 1 ile çıkar.
Rota yoksa, çıkış yoktur ve program çıkış kodu 0 ile sona erer.

s,e,d=input();r=[[s]]
for x in r:t=x[-1];t==e>exit(x);r+=[x+[w]for w in d-set(x)for a,b in(t,w),(w,t)for i in range(len(b)*2)if a==b[:i/2]+a[i/2:][:i%2]+b[i/2+1:]]

Çevrimiçi deneyin!

Python 3 , 217 214 212 201 bayt

Xnor'dan bir ipucuna -11 bayt thanx

d=lambda a,b:min(d(a[1:],b[1:])+(a[0]!=b[0]),d(a[1:],b)+1,d(a,b[1:])+1)if b>""<a else len(a+b)
def g(a,b,l,p=[]):
	if a==b:yield[a]+p
	for c in(a!=b)*l:
		if(c in p)+d(a,c)==1:yield from g(c,b,l,[a]+p)

Çevrimiçi deneyin!

Jöle , 38 bayt

⁵ḟ,€0ị$ṭ¹-Ƥ$€e€/ẸƊƇḢ€
Wṭ@ⱮÇßƊe@⁴oṆƲ?€Ẏ

Çevrimiçi deneyin!

Üç argümanı kabul eden tam bir program. Birincisi başlangıç ​​kelimesidir ve olarak verilir [["START"]]. İkinci argüman olarak verilen son kelimedir "END". Üçüncü argüman tırnak işaretleri arasında, virgülle ayrılmış kelimeler olarak verilen kelime listesidir.

Program listelerin bir listesini döndürür ve her liste baştan sona geçerli bir yolu temsil eder. Geçerli bir rota yoksa, yanıt boş bir listedir.

TIO bağlantısında, sonucu boşlukla ayrılmış her kelime ve satırsonu ile ayrılmış her kelime listesi ile güzel bir şekilde görüntülemek için altbilgi metni vardır. Altta yatan liste temsili çıktısı tercih edilirse, bu şekilde yapılabilir ÇŒṘ.

05ABIE'den farklı olarak, Levenshtein mesafesi için yerleşik değildir, bu nedenle bu program , jöle bükülmesine rağmen, @ ChasBrown'un çözümüne benzeyen tek bir karakter eksik olan outfix'leri karşılaştırır .

açıklama

Yardımcı bağlantı: sözcük listesini alan ve olası genişletilmiş listelerin listesini döndüren monadik bağlantı veya başka uzantı mümkün değilse boş bir liste

⁵ḟ                      | Filter the word list to remove words already used
  ,€0ị$                 | Pair each word with the last word in the current path
                  ƊƇ    | Filter these pairs such that
              e€/Ẹ      |   there exists any
       ṭ¹-Ƥ$€           |   match between the original words or any outfix with a single character removed
                    Ḣ€  | Take the first word of each of these pairs (i.e. the possible extensions of the route)

Ana bağlantı

              €         | For each of the current paths
            Ʋ?          | If:
       e@⁴              |   The path contains the end word
          oṆ            |   Or the path is empty (i.e. could not be extended)
W                       | Return the path wrapped in a list (which will be stripped by the final Ẏ)
 ṭ@ⱮÇ                   | Otherwise, look for possible extensions using the helper link, and add onto the end of the path
     ßƊ                 | And then feed all of these paths back through this link
               Ẏ        | Strip back one layer of lists (needed because each recursion nests the path one list deeper)

Swift 4.2 / Xcode 10.2.1 , 387 bayt

func d(l:String,m:String)->Bool{return (0..<l.count).contains{var c=l;c.remove(at:c.index(c.startIndex,offsetBy:$0));return c==m}};func f(r:[String])->[String]{if b==r.last!{return r};return w.lazy.map{!r.contains($0)&&(d(l:r.last!,m:$0)||d(l:$0,m:r.last!)||(r.last!.count==$0.count&&zip(r.last!,$0).filter{$0 != $1}.count==1)) ? f(r:r+[$0]):[]}.first{!$0.isEmpty} ?? []};return f(r:[a])

Çevrimiçi deneyin!