शब्द ग्राफ का व्यास ज्ञात कीजिए

Question

परिचय

एक लोकप्रिय शब्द पहेली एक शब्द को दूसरे चरण में बदलना है जो केवल एक अक्षर को प्रतिस्थापित करता है और जिसके परिणामस्वरूप हमेशा एक वैध शब्द होता है। उदाहरण के लिए, BAG को पांच चरणों के माध्यम से DOG में परिवर्तित किया जा सकता है:

BAG -> BAT -> CAT -> COT -> COG -> DOG

इस मामले में छोटे रास्ते भी मौजूद हैं; उदाहरण के लिए:

BAG -> BOG -> DOG

यदि कोई एक ऐसा ग्राफ़ खींचता है, जिसके सिरों को शब्दों द्वारा लेबल किया जाता है, किसी भी शब्द के बीच एक किनारे के साथ जो एक अक्षर से भिन्न होता है, तो "बीएजी" से "डीओजी" तक का सबसे छोटा रास्ता दो किनारों से मिलकर बनेगा।

चुनौती

आपको एक प्रोग्राम लिखना है जो इनपुट के रूप में प्राप्त होता है शब्दों का एक "शब्दकोश" जो सभी की लंबाई समान है, सभी स्वीकार्य शब्दों का प्रतिनिधित्व करता है जो एक पथ के साथ कदम के रूप में प्रकट हो सकते हैं। इसे कम से कम एक "सबसे लंबा सबसे छोटा रास्ता" आउटपुट करना चाहिए, जो कि दो शब्दों के बीच का एक रास्ता है:

• उन दो शब्दों के बीच किसी अन्य पथ से अधिक नहीं;

• कम से कम जब तक सूची में शब्दों के किसी भी अन्य जोड़ी के बीच कम से कम संभव पथ।

ऊपर वर्णित ग्राफ के संदर्भ में, इस तरह के पथ की लंबाई ग्राफ का व्यास है।

पतित मामले में जहां कोई भी इनपुट शब्द दूसरों में से किसी में भी तब्दील नहीं हो सकता, कम से कम एक पथ की लंबाई शून्य, यानी एक ही शब्द का आउटपुट।

उदाहरण

• इनपुट ["बैग", "बैट", "कैट", "कॉट", "डॉट", "डॉग"] को उस क्रम में (या रिवर्स ऑर्डर) सभी छह शब्दों को पीछे छोड़ते हुए एक रास्ता निकालना चाहिए, क्योंकि सबसे छोटा रास्ता " इस शब्दकोश के भीतर "टू" डॉग "पांच चरणों में सबसे लंबे समय तक प्राप्त करने योग्य है।

• इनपुट ["बैग", "बैट", "बॉट", "कैट", "कॉट", "डॉट", "डॉग"] पथ "बैग, बैट, बॉट, डॉट, डॉग" और / या इसके रास्ते का उत्पादन करना चाहिए उलट।

• इनपुट ["कोड", "गोल्फ", "पुरुष", "बज़", "मोल", "भूमिका", "मोल्ड", "ठंडा", "गोल्ड", "मोड"] को "कोड" के बीच एक रास्ता बनाना चाहिए और "गोल्फ"।

• इनपुट ["एक", "दो", "छह", "दस"] बिना किनारों वाले ग्राफ से मेल खाता है, इसलिए एक या अधिक एकल-शब्द (शून्य-लंबाई) पथ का उत्पादन करता है।

• यदि इनपुट में असमान लंबाई के दो शब्द हैं, तो आउटपुट अपरिभाषित है।

नियम

• मानक कोड गोल्फ नियम लागू होते हैं
• कई "सबसे छोटे" रास्ते होंगे। आपको कम से कम एक आउटपुट करना होगा, लेकिन आप जितनी चाहें उतने आउटपुट के लिए स्वतंत्र हैं।
• आप यह तय करने के लिए स्वतंत्र हैं कि आपके प्रोग्राम में इनपुट डिक्शनरी कैसे पास की जाती है।
• बाइट्स में सबसे छोटा कोड जीतता है।

Comments

कुछ और परीक्षण मामलों को जोड़ने का मन?

— योना

किया हुआ। उस मामले की भी चर्चा की जहां ग्राफ में कोई किनारा नहीं है।

— jnfnt

दृढ़ता से संबंधित, संभव डुप्लिकेट

— Emigna

क्या हमें एक खाली इनपुट स्वीकार करना चाहिए (उत्तर होगा []या [[]])?

— आउटगोल्फर

मैं खाली इनपुट पर अपरिभाषित व्यवहार के लिए खुश हूं।

— jnfnt

Answer 1

जेली , 20 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 2

APL (Dyalog Classic) , 84 80 77 76 74 66 61 बाइट्स

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

इसे ऑनलाइन आज़माएं!

इनपुट और आउटपुट कैरेक्टर मैट्रिसेस हैं

⍵+.≠⍉⍵ शब्दों के बीच हैमिंग-जैसी दूरियों का मैट्रिक्स

9*⍨2⌊0s और 1s को छोड़ दें, 2+ को कुछ बड़ी संख्या में बदल दें (512 = 2 ⁹ , "∞" के रूप में उपयोग किया जाता है)

⌊.+⍨⍣≡ फ्लोयड और वॉरहॉल का सबसे छोटा पथ एल्गोरिथम

• ⌊.+मैट्रिक्स गुणा की तरह लेकिन min( ⌊और) के +बजाय +और ×क्रमशः का उपयोग करना

• ⍨ बाईं और दाईं ओर समान मैट्रिक्स का उपयोग करें

• ⍣≡ अभिसरण तक दोहराएं

d←⌈/512|, सबसे लंबा ("" "नहीं") पथ, को सौंपा गया d

⊃⍸a=जो दो नोड्स कनेक्ट करता है, चलो उन्हें i और j कहते हैं

{⍵,⍨⊃⍋(1≠a⌷⍨⊃⍵),⍪⍺⌷a}⍣d/ पथ का पुनर्निर्माण करें

• { }⍣d/{ }फ़ंक्शन dसमय का मूल्यांकन करें । बायाँ arg ⍺हमेशा i होता है । दाएँ arg j के⍵ रूप में शुरू होता है और धीरे-धीरे पथ के आंतरिक नोड्स को जमा करता है

• (1≠a⌷⍨⊃⍵),⍪⍺⌷a इन दो वैक्टरों का 2-स्तंभ मैट्रिक्स बनाएँ:

  • 1≠a⌷⍨⊃⍵ बूलियन (0 या 1) जो इंगित करता है कि पहली से 1 की दूरी पर कौन से नोड हैं ⍵

  • ⍺⌷a सभी ग्राफ नोड्स की दूरी ⍺

• ⊃⍋ लेक्सिकोग्राफिक रूप से सबसे छोटी पंक्ति का सूचकांक

• ⍵,⍨ के लिए प्रस्तुत करना ⍵

⍵⌷⍨ पथ के साथ मूल शब्दों को अनुक्रमित करें

Answer 3

पायथन 3 , 225 बाइट्स

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]

इसे ऑनलाइन आज़माएं!

मूल रूप से, सभी संभव पथ लें, केवल उन लोगों को रखें जो वैध हैं, फिर प्रत्येक प्रारंभ-अंत संयोजन के माध्यम से जाएं, न्यूनतम पथ दूरी ढूंढें, और उस का अधिकतम पता लगाएं।

Answer 4

वोल्फ्राम भाषा (गणितज्ञ) , 105 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 5

जावास्क्रिप्ट (ईएस 6),  195  194 बाइट्स

लौटता है [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]

इसे ऑनलाइन आज़माएं!

कैसे?

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

(यह कोड प्रत्येक पुनरावृत्ति गहराई पर निष्पादित किया जाता है, लेकिन केवल मूल स्तर वास्तव में मायने रखता है)

$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
)                     //

Answer 6

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 92 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 7

पायथन 3, 228 बाइट्स।

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)

सभी जोड़े सबसे छोटे रास्तों के लिए फ़्लॉइड-वारशॉल एल्गोरिथ्म को लागू करता है, फिर पाए गए रास्तों पर अधिकतम ले जाता है।

इस कार्यान्वयन में 16 अक्षर टैब हैं, जो दुर्भाग्यपूर्ण है :(

Comments

यह तब टूटता है जब कोई घटना किनारों के साथ एक शीर्ष मौजूद होता है, उदाहरण के लिए, "प्रिंट जी (['बैग', 'बैट', 'खाट'])"

— jnfnt

पायथन इंडेंटेशन के लिए गोल्फ टिप: पहले स्तर के लिए एक स्थान, दूसरे के लिए एक टैब, तीसरे के लिए एक टैब और चौथे के लिए एक स्थान, आदि का उपयोग करें

— पीटर टेलर

@PeterTaylor अच्छा टिप, लेकिन केवल पायथन 2 के लिए काम करता है। पायथन 3 रिक्त स्थान के साथ टैब मिश्रण करने की अनुमति नहीं देता है।

— OOBalance

आह, अच्छा पकड़ @jnfnt। अब जब मैं इसके बारे में सोचता हूं, यह तभी काम करता है जब ग्राफ जुड़ा होता है।

— रिक्शाशाह