सबसे लंबा हाइपरक्यूब पथ

18

चुनौती

आपको एक ही लंबाई के दो अलग-अलग स्ट्रिंग्स दिए गए हैं। (उदाहरण के लिए, 000और 111।) आपका लक्ष्य एक से दूसरे तक का रास्ता खोजना है:

  • प्रत्येक चरण पर, आप केवल एक बिट बदलते हैं (आप से जा सकते हैं 000 में से किसी को 001, 010, 100)।
  • आप एक ही बिट स्ट्रिंग पर दो बार नहीं जा सकते।
  • इन बाधाओं के तहत, मार्ग यथासंभव लंबा है।

उदाहरण के लिए, से जा रहा 000है 111, हम पथ ले सकते हैं

000, 001, 011, 010, 110, 100, 101, 111

जो लंबाई 3 के सभी 8 बिट तारों का दौरा करता है, इसलिए इसे सबसे लंबा संभव होना चाहिए।

नियम

  • मानक खामियां लागू होती हैं।
  • आप इनपुट को जीरो के दो स्ट्रिंग्स और लोगों के रूप में, या जीरो के दो सरणियों और लोगों के रूप में, या बूलियन मूल्यों के दो सरणियों के रूप में ले सकते हैं।
  • आप सही बाइनरी प्रतिनिधित्व के साथ दो पूर्णांकों के रूप में इनपुट नहीं ले सकते हैं (लेखन 000और के 111रूप में 0और 7मान्य नहीं है)।
  • यदि आप चाहें, तो आप इनपुट के रूप में बिट स्ट्रिंग्स की लंबाई ले सकते हैं।
  • आपके प्रोग्राम को एक बार में आए बिट स्ट्रिंग्स को प्रिंट करके, या विज़िट किए गए बिट स्ट्रिंग्स की एक सरणी को वापस करके (इनपुट के रूप में एक ही प्रारूप में) पथ को आउटपुट करने की अनुमति है।
  • आपके आउटपुट में पथ का प्रारंभ और अंत शामिल होना चाहिए (जो आपके इनपुट हैं)।
  • यह कोड-गोल्फ है , बाइट्स जीत में सबसे छोटा कोड।

उदाहरण

0 1 -> 0, 1
10 01 -> 10, 00, 01 or 10, 11, 01
000 111 -> any of the following:

   000, 100, 110, 010, 011, 001, 101, 111

   000, 100, 101, 001, 011, 010, 110, 111

   000, 010, 110, 100, 101, 001, 011, 111

   000, 010, 011, 001, 101, 100, 110, 111

   000, 001, 101, 100, 110, 010, 011, 111

   000, 001, 011, 010, 110, 100, 101, 111

1001 1100 -> 1001, 0001, 0000, 0010, 0011, 0111, 0101, 0100, 0110, 1110, 1010, 1011, 1111, 1101, 1100 (other paths exist)
code-golf  binary  graph-theory 
— मिशा लावरोव
स्रोत
1
क्या हम लोगों और शून्य के बजाय बूलियन मान भी ले सकते हैं?
— 19
@flawr ज़रूर, यह ठीक है।
— मिशा लावरोव
क्या हम यह मान सकते हैं कि हमें दो समान बिट-स्ट्रिंग्स नहीं मिलेंगे (या यदि हम ऐसा कुछ भी कर सकते हैं तो)?
— जोनाथन एलन
1
@JonathanAllan हाँ, मान लेते हैं कि बिट-स्ट्रिंग समान नहीं हैं।
— मिशा लावरोव
— लीक नून

जवाबों:

6

हस्क , 27 26 24 बाइट्स

→foΛεẊδṁ≠ÖLm↓≠⁰←ġ→PΠmṠe¬

जानवर बल, बहुत धीमी गति से। इसे ऑनलाइन आज़माएं!

व्याख्या

हस्क स्वाभाविक रूप से दाएं से बाएं पढ़ता है।

←ġ→PΠmṠe¬  Hypercube sequences ending in second input, say y=[1,1,0]
     mṠe¬  Pair each element with its negation: [[0,1],[0,1],[1,0]]
    Π      Cartesian product: [[0,0,1],[1,0,1],..,[1,1,0]]
   P       Permutations.
 ġ→        Group by last element
←          and take first group.
           The permutations are ordered so that those with last element y come first,
           so they are grouped together and returned here.

ÖLm↓≠⁰  Find first input.
  m     For each permutation,
   ↓≠⁰  drop all elements before the first input.
ÖL      Sort by length.

foΛεẊδṁ≠  Check path condition.
fo        Keep those lists that satisfy:
    Ẋ      For each adjacent pair (e.g. [0,1,0] and [1,1,0]),
      ṁ    take sum of
       ≠   absolute differences
     δ     of corresponding elements: 1+0+0 gives 1.
  Λε       Each value is at most 1.

→  Finally, return last element (which has greatest length).
— Zgarb
स्रोत
4

गणितज्ञ, 108 बाइट्स

a=#~FromDigits~2+1&;Last@PadLeft[IntegerDigits[#-1,2]&/@FindPath[HypercubeGraph@Length@#,a@#,a@#2,∞,All]]&

इनपुट:

[{0, 0, 0, 0}, {1, 1, 1, 1}]

आउटपुट:

{{0, 0, 0, 0}, {0, 0, 0, 1}, {0, 0, 1, 1}, {0, 0, 1, 0}, {0, 1, 1, 0},
 {0, 1, 0, 0}, {0, 1, 0, 1}, {1, 1, 0, 1}, {1, 0, 0, 1}, {1, 0, 0, 0},
 {1, 1, 0, 0}, {1, 1, 1, 0}, {1, 0, 1, 0}, {1, 0, 1, 1}, {1, 1, 1, 1}}
— बेन
स्रोत
3

गणितज्ञ, 175 बाइट्स

अच्छा पहला सवाल! 

(m=#;n=#2;Last@SortBy[(S=Select)[S[Rest@Flatten[Permutations/@Subsets[Tuples[{0,1},(L=Length)@m]],1],First@#==m&&Last@#==n&],Union[EditDistance@@@Partition[#,2,1]]=={1}&],L])&


इनपुट

[{0, 0, 0}, {1, 1, 1}]

— J42161217
स्रोत
3

हास्केल , 212 207 बाइट्स

यह शायद बहुत लंबा रास्ता है, लेकिन यह अब काम करता है। ( कार्टेशियन उत्पाद ट्रिक के लिए @Lynn को धन्यवाद !) -5 बाइट्स के लिए थान्सिक @ नमि!

import Data.List
b%l=[l++[x|b/=last l,x`notElem`l,1==sum[1|(u,v)<-x`zip`last l,u/=v]]|x<-mapM id$[0>1..]<$b]
b!a|f<-nub.concat.((b%)<$>)=snd$maximum$map(length>>=(,))$filter((==b).last)$until(f>>=(==))f[[a]]

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

स्पष्टीकरण:

b%l -- helper function:
    -- given a path l (that should end in b) this generates all possible extensions
    -- of l (if not possible also l itself) 
            x<-mapM id$[0>1..]<$b -- generate all possible vertices of the hypercube
             -- and check the criteria
           b/=last l,x`notElem`l,1==sum[1|(u,v)<-x`zip`last l,u/=v] 
             -- extend if possible
    [l++[x|  ...                                                   ]| ... ]
b!a| -- actual function: 
     -- first define a helper function:
    f<-nub.concat.((b%)<$>)
     -- begin with the vertex a and apply the function from above repeatedly
     -- until you cannot make the path any longer without violating the
     -- criteria 
                                                                             until(f>>=(==))f[[a]]
     -- only take the paths that actually end in b          
                                                          filter((==b).last)$
     -- and find the one with the maximum length    
                           =snd$maximum$map(length>>=(,))$
— flawr
स्रोत
x<-mapM id$[1>0,1<0]<$b
— nimi
... क्या आपको जरूरत है [True,False]? यदि [False,True]यह भी काम करता है, तो आप उपयोग कर सकते हैं [0>1..]।
— nimi
ओह महान, धन्यवाद, मुझे नहीं पता था कि यह Boolहै Enum, और मैं भूल गया कि <$उपलब्ध है (पहले की कोशिश की *>जो प्रस्तावना में नहीं है)!
— 15
3

मेथेमेटिका ११६ 114 बाइट्स

कई बाइट्स के साथ मिशा लावरोव को धन्यवाद दिया।

Last@FindPath[Graph[Rule@@@Cases[Tuples[Tuples[{0,1},{l=Length@#}],{2}],x_/;Count[Plus@@x,1]==1]],##,{1,2^l},Alll]&

इनपुट (8 आयाम)

[{1,0,0,1,0,0,0,1},{1,1,0,0,0,0,1,1}]//AbsoluteTiming

आउटपुट (लंबाई = 254, 1.82 सेकंड के बाद)

{1.82393, {{1, 0, 0, 1, 0, 0, 0, 1}, {0, 0, 0, 1, 0, 0, 0, 1}, {0, 0, 0, 0, 0, 0, 0, 1}, {0, 0, 0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0, 1, 0}, {0, 0,0, 0, 0, 0, 1, 1}, {0, 0, 0, 0, 0, 1, 1, 1}, {0, 0, 0, 0, 0, 1, 0, 1}, {0, 0, 0, 0, 0, 1, 0, 0}, {0, 0, 0, 0, 0, 1, 1, 0}, {0, 0, 0, 0,1, 1, 1,0}, {0, 0, 0, 0, 1, 0, 1, 0}, {0, 0, 0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 1}, {0, 0, 0, 0, 1, 0, 1, 1}, {0, 0, 0, 0,1, 1, 1, 1}, {0, 0, 0, 0, 1, 1, 0, 1}, {0, 0, 0, 0, 1, 1, 0, 0}, {0, 0, 0, 1, 1, 1, 0, 0}, {0, 0, 0, 1, 0, 1, 0, 0}, {0, 0, 0, 1,0, 0, 0, 0}, {0, 0, 0, 1, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0, 1, 1}, {0, 0, 0, 1, 0, 1, 1, 1}, {0, 0, 0, 1, 0, 1, 0, 1}, {0, 0, 0, 1, 1, 1, 0, 1}, {0, 0, 0, 1, 1, 0, 0, 1}, {0, 0, 0, 1, 1, 0, 0, 0}, {0, 0, 0, 1, 1, 0, 1, 0}, {0, 0, 0, 1, 1, 0, 1, 1}, {0, 0, 0, 1,1, 1, 1, 1}, {0, 0, 0, 1, 1, 1, 1, 0}, {0, 0, 0, 1, 0, 1, 1, 0}, {0, 0, 1, 1, 0, 1, 1, 0}, {0, 0, 1, 0, 0, 1, 1, 0}, {0, 0, 1, 0,0, 0, 1, 0}, {0, 0, 1, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0, 0, 1}, {0, 0, 1, 0, 0, 0, 1, 1}, {0, 0, 1, 0, 0, 1, 1, 1}, {0, 0, 1, 0,0, 1, 0, 1}, {0, 0, 1, 0, 0, 1, 0, 0}, {0, 0, 1, 0, 1, 1, 0, 0}, {0, 0, 1, 0, 1, 0, 0, 0}, {0, 0, 1, 0, 1, 0, 0, 1}, {0, 0, 1, 0,1, 0, 1, 1}, {0, 0, 1, 0, 1, 0, 1, 0}, {0, 0, 1, 0, 1, 1, 1, 0}, {0, 0, 1, 0, 1, 1, 1, 1}, {0, 0, 1, 0, 1, 1, 0, 1}, {0, 0, 1, 1,1, 1, 0, 1}, {0, 0, 1, 1, 0, 1, 0, 1}, {0, 0, 1, 1, 0, 0, 0, 1}, {0, 0, 1, 1, 0, 0, 0, 0}, {0, 0, 1, 1, 0, 0, 1, 0}, {0, 0, 1, 1,0, 0, 1, 1}, {0, 0, 1, 1, 0, 1, 1,1}, {0, 0, 1, 1, 1, 1, 1, 1}, {0, 0, 1, 1, 1, 0, 1, 1}, {0, 0, 1, 1, 1, 0, 0, 1}, {0, 0, 1, 1,1, 0, 0, 0}, {0, 0, 1, 1, 1, 0, 1, 0}, {0, 0, 1, 1, 1, 1, 1, 0}, {0, 0, 1, 1, 1, 1, 0, 0}, {0, 0, 1, 1, 0, 1, 0, 0}, {0, 1, 1, 1,0, 1, 0, 0}, {0, 1, 0, 1, 0, 1, 0, 0}, {0, 1, 0, 0, 0, 1, 0, 0}, {0, 1, 0, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0, 0, 1}, {0, 1, 0, 0,0, 0, 1, 1}, {0, 1, 0, 0, 0, 0, 1, 0}, {0, 1, 0, 0, 0, 1, 1, 0}, {0, 1, 0, 0, 0, 1, 1, 1}, {0, 1, 0, 0, 0, 1, 0, 1}, {0, 1, 0, 0,1, 1, 0, 1}, {0, 1, 0, 0, 1, 0, 0, 1}, {0, 1, 0, 0, 1, 0, 0, 0}, {0, 1, 0, 0, 1, 0, 1, 0}, {0, 1, 0, 0, 1, 0, 1, 1}, {0, 1, 0, 0,1, 1, 1, 1}, {0, 1, 0, 0, 1, 1, 1, 0}, {0, 1, 0, 0, 1, 1, 0,0}, {0, 1, 0, 1, 1, 1, 0, 0}, {0, 1, 0, 1, 1, 0, 0, 0}, {0, 1, 0, 1,0, 0, 0, 0}, {0, 1, 0, 1, 0, 0, 0, 1}, {0, 1, 0, 1, 0, 0, 1, 1}, {0, 1, 0, 1, 0, 0, 1, 0}, {0, 1, 0, 1, 0, 1, 1, 0}, {0, 1, 0, 1,0, 1, 1, 1}, {0, 1, 0, 1, 0, 1, 0, 1}, {0, 1, 0, 1, 1, 1, 0, 1}, {0, 1, 0, 1, 1, 0, 0, 1}, {0, 1, 0, 1, 1, 0, 1, 1}, {0, 1, 0, 1,1, 0, 1, 0}, {0, 1, 0, 1, 1, 1, 1, 0}, {0, 1, 0, 1, 1, 1, 1, 1}, {0, 1, 1, 1, 1, 1, 1, 1}, {0, 1, 1, 0, 1, 1, 1, 1}, {0, 1, 1, 0,0, 1, 1, 1}, {0, 1, 1, 0, 0, 0, 1, 1}, {0, 1, 1, 0, 0, 0, 0, 1}, {0, 1, 1, 0, 0, 0, 0, 0}, {0, 1, 1, 0, 0, 0, 1, 0}, {0, 1, 1, 0,0, 1, 1, 0}, {0, 1, 1, 0, 0, 1, 0, 0}, {0, 1, 1, 0, 0, 1, 0, 1}, {0, 1, 1, 0, 1, 1, 0, 1}, {0, 1, 1, 0, 1, 0, 0, 1}, {0, 1, 1, 0,1, 0, 0, 0}, {0, 1, 1, 0, 1, 0, 1, 0}, {0, 1, 1, 0, 1, 0, 1, 1}, {0, 1, 1, 1, 1, 0, 1, 1}, {0, 1, 1, 1, 0, 0, 1, 1}, {0, 1, 1, 1,0, 0, 0, 1}, {0, 1, 1, 1, 0, 0, 0, 0}, {0, 1, 1, 1, 0, 0, 1, 0}, {0, 1, 1, 1, 0, 1, 1, 0}, {0, 1, 1, 1, 0, 1, 1, 1}, {0, 1, 1, 1,0, 1, 0, 1}, {0, 1, 1, 1, 1, 1, 0, 1}, {0, 1, 1, 1, 1, 0, 0, 1}, {0, 1, 1, 1, 1, 0, 0, 0}, {0, 1, 1, 1, 1, 0, 1, 0}, {0, 1, 1, 1,1, 1, 1, 0}, {0, 1, 1, 0, 1, 1, 1, 0}, {0, 1, 1, 0, 1, 1, 0, 0}, {0, 1, 1, 1, 1, 1, 0, 0}, {1, 1, 1, 1, 1, 1, 0, 0}, {1, 0, 1, 1,1, 1, 0, 0}, {1, 0, 0, 1, 1, 1, 0, 0}, {1, 0, 0, 0, 1, 1, 0, 0}, {1, 0, 0, 0, 0, 1, 0, 0}, {1, 0, 0, 0, 0, 0, 0, 0}, {1, 0, 0, 0,0, 0, 0, 1}, {1, 0, 0, 0, 0, 0, 1, 1}, {1, 0, 0, 0, 0, 0, 1, 0}, {1, 0, 0, 0, 0, 1, 1, 0}, {1, 0, 0, 0, 0, 1, 1, 1}, {1, 0, 0, 0,0, 1, 0, 1}, {1, 0, 0, 0, 1, 1, 0, 1}, {1, 0, 0, 0, 1, 0, 0, 1}, {1, 0, 0, 0, 1, 0, 0, 0}, {1, 0, 0, 0, 1, 0, 1, 0}, {1, 0, 0, 0,1, 0, 1, 1}, {1, 0, 0, 0, 1, 1, 1, 1}, {1, 0, 0, 0, 1, 1, 1, 0}, {1, 0, 0, 1, 1, 1, 1, 0}, {1, 0, 0, 1, 0, 1, 1, 0}, {1, 0, 0, 1,0, 0, 1, 0}, {1, 0, 0, 1, 0, 0, 0, 0}, {1, 0, 0, 1, 0, 1, 0, 0}, {1, 0, 0, 1, 0, 1, 0, 1}, {1, 0, 0, 1, 0, 1, 1, 1}, {1, 0, 0, 1,0, 0, 1, 1}, {1, 0, 0, 1, 1, 0, 1, 1}, {1, 0, 0, 1, 1, 0, 0, 1}, {1, 0, 0, 1, 1, 0, 0, 0}, {1, 0, 0, 1, 1, 0, 1, 0}, {1, 0, 1, 1,1, 0, 1, 0}, {1, 0, 1, 0, 1, 0, 1, 0}, {1, 0, 1, 0, 0, 0, 1, 0}, {1, 0, 1, 0, 0, 0, 0, 0}, {1, 0, 1, 0, 0, 0, 0, 1}, {1, 0, 1, 0,0, 0, 1, 1}, {1, 0, 1, 0, 0, 1, 1, 1}, {1, 0, 1, 0, 0, 1, 0, 1}, {1, 0, 1, 0, 0, 1, 0, 0}, {1, 0, 1, 0, 0, 1, 1, 0}, {1, 0, 1, 0,1, 1, 1, 0}, {1, 0, 1, 0, 1, 1, 0, 0}, {1, 0, 1, 0, 1, 0, 0, 0}, {1, 0, 1, 0, 1, 0, 0, 1}, {1, 0, 1, 0, 1, 0, 1, 1}, {1, 0, 1, 0,1, 1, 1, 1}, {1, 0, 1, 0, 1, 1, 0, 1}, {1, 0, 1, 1, 1, 1, 0, 1}, {1, 0, 0, 1, 1, 1, 0, 1}, {1, 0, 0, 1, 1, 1, 1, 1}, {1, 0, 1, 1,1, 1, 1, 1}, {1, 0, 1, 1, 0, 1, 1, 1}, {1, 0, 1, 1, 0, 0, 1, 1}, {1, 0, 1, 1, 0, 0, 0, 1}, {1, 0, 1, 1, 0, 0, 0, 0}, {1, 0, 1, 1,0, 0, 1, 0}, {1, 0, 1, 1, 0, 1, 1, 0}, {1, 0, 1, 1, 0, 1, 0, 0}, {1, 0, 1, 1, 0, 1, 0, 1}, {1, 1, 1, 1, 0, 1, 0, 1}, {1, 1, 0, 1,0, 1, 0, 1}, {1, 1, 0, 0, 0, 1, 0,1}, {1, 1, 0, 0, 0, 0, 0, 1}, {1, 1, 0, 0, 0, 0, 0, 0}, {1, 1, 0, 0, 0, 0, 1, 0}, {1, 1, 0, 0,0, 1, 1, 0}, {1, 1, 0, 0, 0, 1, 0, 0}, {1, 1, 0, 0, 1, 1, 0, 0}, {1, 1, 0, 0, 1, 0, 0, 0}, {1, 1, 0, 0, 1, 0, 0, 1}, {1, 1, 0, 0,1, 0, 1, 1}, {1, 1, 0, 0, 1, 0, 1, 0}, {1, 1, 0, 0, 1, 1, 1, 0}, {1, 1, 0, 0, 1, 1, 1, 1}, {1, 1, 0, 0, 0, 1, 1, 1}, {1, 1, 0, 1,0, 1, 1, 1}, {1, 1, 0, 1, 0, 0, 1, 1}, {1, 1, 0, 1, 0, 0, 0, 1}, {1, 1, 0, 1, 0, 0, 0, 0}, {1, 1, 0, 1, 0, 0, 1, 0}, {1, 1, 0, 1,0, 1, 1, 0}, {1, 1, 0, 1, 0, 1, 0, 0}, {1, 1, 0, 1, 1, 1, 0, 0}, {1, 1, 0, 1, 1, 0, 0, 0}, {1, 1, 0, 1, 1, 0, 0, 1}, {1, 1, 0, 1,1, 0, 1, 1}, {1, 1, 0, 1, 1, 0, 1, 0}, {1, 1, 0, 1, 1, 1, 1, 0}, {1, 1, 0, 1, 1, 1, 1, 1}, {1, 1, 0, 1, 1, 1, 0, 1}, {1, 1, 0, 0,1, 1, 0, 1}, {1, 1, 1, 0, 1, 1, 0, 1}, {1, 1, 1, 0, 0, 1, 0, 1}, {1, 1, 1, 0, 0, 0, 0, 1}, {1, 1, 1, 0, 0, 0, 0, 0}, {1, 1, 1, 0,0, 0, 1, 0}, {1, 1, 1, 0, 0, 1, 1, 0}, {1, 1, 1, 0, 0, 1, 0, 0}, {1, 1, 1, 0, 1, 1, 0, 0}, {1, 1, 1, 0, 1, 0, 0, 0}, {1, 1, 1, 0,1, 0, 0, 1}, {1, 1, 1, 0, 1, 0, 1, 1}, {1, 1, 1, 0, 1, 0, 1, 0}, {1, 1, 1, 0, 1, 1, 1, 0}, {1, 1, 1, 0, 1, 1, 1, 1}, {1, 1, 1, 0,0, 1, 1, 1}, {1, 1, 1, 1, 0, 1, 1, 1}, {1, 1, 1, 1, 0, 1, 1, 0}, {1, 1, 1, 1, 0, 0, 1, 0}, {1, 1, 1, 1, 0, 0, 0, 0}, {1, 1, 1, 1,0, 0, 0, 1}, {1, 1, 1, 1, 1, 0, 0, 1}, {1, 1, 1, 1, 1, 1, 0, 1}, {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 0}, {1, 1, 1, 1,1, 0, 1, 0}, {1, 1, 1, 1, 1, 0, 0, 0}, {1, 0, 1, 1, 1, 0, 0, 0}, {1, 0, 1, 1, 1, 0, 0, 1}, {1, 0, 1, 1, 1, 0, 1, 1}, {1, 1, 1, 1,1, 0, 1, 1}, {1, 1, 1, 1, 0, 0, 1, 1}, {1, 1, 1, 0, 0, 0, 1, 1}, {1, 1, 0, 0, 0, 0, 1, 1}}}

Tuples[{0,1},{l=Length@#}],{2}]बाइनरी सूचियों के रूप में संख्या 0 ... 8 उत्पन्न करता है।

बाहरी Tuples...{2} उन बाइनरी नंबरों के सभी ऑर्डर किए गए जोड़े पैदा करता है।

Plus@@x जोड़े में से प्रत्येक, 0, 1 के ट्रिपल पैदा करता है।

Cases....Count[Plus@@x, 1]==1 उन सभी रकमों को लौटाता है जिनमें एक एकल होता है। ये तब उत्पन्न होते हैं जब दो मूल बाइनरी नंबर एक किनारे से जुड़े होते हैं।

Rules ग्राफ के कोने जोड़ता है, प्रत्येक शीर्ष पर एक द्विआधारी संख्या है।

Graph कहा कोने और किनारों के अनुरूप एक ग्राफ बनाता है।

FindPath दी गई संख्याओं के लिए शीर्ष 2 को एक शीर्ष पर ले जाने के लिए n ^ को मिल रहा है।

Last इन रास्तों में सबसे लंबा है।

तीन आयामों के लिए, ग्राफ को एक विमान में दिखाया जा सकता है जैसा कि यहाँ दिखाया गया है:

ग्राफ फ्लैट

इनपुट के लिए, {0,0,0}, {1,1,1}निम्नलिखित आउटपुट है:

{{{0, 0, 0}, {0, 0, 1}, {0, 1, 1}, {0, 1, 0}, {1, 1, 0}, {1, 0, 0}, {1, 0, 1}, {1, 1, 1}}}

यह रास्ता उपरोक्त ग्राफ में पाया जा सकता है।

इसे 3-स्थान में निम्नलिखित पथ के रूप में भी कल्पना की जा सकती है, जहां प्रत्येक शीर्ष बिंदु से मेल खाती है {x,y,z} । {0,0,0} मूल का प्रतिनिधित्व करता है और {1,1,1} एक यूनिट क्यूब में "विपरीत" बिंदु का प्रतिनिधित्व करता है।

तो समाधान पथ इकाई घन के साथ किनारों के एक ट्रावेल से मेल खाती है। इस मामले में, पथ हैमिल्टनियन है: यह हर बार एक शीर्ष पर जाता है (यानी बिना किसी क्रॉसिंग और कोई कोने से छूटे)।

जी -4

— DavidC
स्रोत
क्या एक साधारण कारण है कि ए से बी तक 2 ^ एन पथ सबसे लंबे समय तक उनमें से सबसे लंबे समय तक चलने के लिए पर्याप्त मार्ग हैं?
— मीशा लावरोव
@ मीशा, एक बहुत अच्छा सवाल।
— डेविडऑक्ट
इसके बारे में सोचने का एक तरीका यह है। सबसे लंबा मार्ग, एक हैमिल्टन मार्ग, कोनों की संख्या से एक कम होगा। (हम पथ पर किनारों की संख्या गिन रहे हैं।) कोनों की संख्या 2 ^ n है। तो अधिकतम पथ की लंबाई 2 ^ n-1 होगी।
— डेविड
मैं मानता हूं कि अधिकतम पथ की लंबाई हमेशा 2 ^ n कोने (यदि यह हैमिल्टनियन है) या 2 ^ n-1 कोने (अगर हैमिल्टन की राह समता के कारण असंभव है) पर जाती है। यह मेरे प्रश्न से अलग है, जो है: क्यों 2 ^ (n + 2) उत्पन्न करता है (मुझे लगता है कि 2 ^ n गलत संख्या थी) विभिन्न पथ (जिनमें से कुछ बहुत कम हो सकते हैं) गारंटी देते हैं कि उनमें से सबसे लंबा होगा सभी विभिन्न रास्तों में से सबसे लंबा ।
— मीशा लावरोव
दूसरे शब्दों में, 2^(l+2)आपके कोड में क्यों ?
— मीशा लावरोव
3

हास्केल , 141 123 बाइट्स

c(a:b)=(1-a:b):map(a:)(c b)
c _=[]
q#z=[z]:[z:s|w<-c z,notElem w q,s<-(w:q)#w]
x!y=snd$maximum[(p*>x,p)|p<-[x]#x,last p==y]

पूर्णांकों की सूची का उपयोग करता है। इसे ऑनलाइन आज़माएं!

व्याख्या

मुख्य कार्य है !, और सहायक कार्य हैं #और c। बिट्स की सूची को देखते हुए, cउनमें से किसी एक को फ़्लिप करने के सभी संभावित तरीके दिए गए हैं, जैसे [0,1,1] -> [[1,1,1],[0,0,1],[0,1,0]]।

c(a:b)=        -- c on nonempty list with head a and tail b is
 (1-a:b):      -- the list with negated a tacked to b, then
 map(a:)(c b)  -- c applied recursively to b, with a tacked to each of the results.
c _=[]         -- c on empty list gives an empty list.

फ़ंक्शन #सूची ("मेमोरी") और एक सूची ("प्रारंभिक बिटस्ट्रिंग") की एक सूची लेता है। यह सभी हाइपरक्यूब पथों का निर्माण करता है जो प्रारंभिक तत्व से शुरू होते हैं, केवल अलग-अलग बिटस्ट्रिंग होते हैं, और मेमोरी में तारों पर कदम नहीं रखते हैं।

q#z=            -- # on memory q and initial string z is
 [z]:           -- the singleton path [z], and
 [z:s|          -- z tacked to each path s, where
  w<-c z,       -- w is obtained by flipping a bit of z,
  notElem w q,  -- w is not in the memory, and
  s<-(w:q)#w]   -- s is a path starting from w that avoids w and all elements of q.

मुख्य कार्य !यह सब एक साथ जोड़ता है। एक ट्रिक जो मैं यहाँ इस्तेमाल करता हूँ p*>x( xबार- length pबार) इसके बजाय length p। चूंकि xसूचियों के प्राकृतिक क्रम में बाद में आने की पुनरावृत्ति , maximumकिसी भी मामले में सबसे लंबा रास्ता चुनती है, चूंकि जोड़े के पहले निर्देशांक की तुलना दूसरे लोगों से पहले की जाती है।

x!y=          -- ! on inputs x and y is
 snd$maximum  -- the second element of the maximal pair in
 [(p*>x,p)|   -- the list of pairs (p*>x,p), where
  p<-[x]#x,   -- p is a path starting from x that avoids stepping on x, and
  last p==y]  -- p ends in y.
— Zgarb
स्रोत
2

जेली ,  25  27 बाइट्स

+2 बाइट्स मेरे गोल्फ के साथ एक बग को ठीक करने के लिए :( उम्मीद है कि मैं हालांकि एक छोटा रास्ता मिल जाएगा।

ṫi¥³ḣi
L2ṗŒ!瀵ạ2\S€ỊẠ×LµÞṪ

एक पूर्ण कार्यक्रम का उपयोग करके बिट-स्ट्रिंग्स ले रहा है 12सूची के रूप में और * । तर्क हैं fromऔरto । कार्यक्रम उसी की सूचियों की सूची प्रिंट करता है।

* 0और1 एक बाइट की लागत के बजाय इस्तेमाल किया जा सकता है ( ’बीच में L2ṗऔर Œ!ç€...घटाना)।

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

कैसे?

अद्यतन करने ...

ṫi¥³ḣi - Link 1, getSlice: list of lists, bitstrings; list, toBitstring
   ³   - get 3rd command line argument (fromBitstring)
  ¥    - last two links as a dyad:
 i     -   index (of fromBitstring in bitstrings)
ṫ      -   tail (bitstrings) from (that) index
     i - index (of toBitstring in that result)
    ḣ  - head to (that) index

L2ṗŒ!瀵ạ2\S€ỊẠ×LµÞṪ - Main link: list, fromBitstring; list, toBitstring
L                    - length (of fromBitstring)
 2                   - literal two
  ṗ                  - Cartesian power (of implicit range(2)=[1,2] with L(fromBitstring))
                     - ...i.e. all unique bitstrings of the required length (using [1,2])
   Œ!                - all permutations (of that list)
     ç€              - call the last link (1) as a dyad (i.e. f(that, toBitstring))
       µ         µÞ  - sort by the monadic function:
         2\          -   2-wise reduce with:
        ạ            -     absolute difference
           S€        -   sum €ach
             Ị       -   insignificant (vectorises) (abs(z)<=1 - for our purposes it's really just used for z==1 since only positive integers are possible)
              Ạ      -   all truthy? (1 if so 0 otherwise)
                L    -   length
               ×     -   multiply
                   Ṫ - tail (the last one is one of the maximal results)
                     - implicit print
— जोनाथन एलन
स्रोत
जेली कैसे काम करती है यह मेरे लिए एक रहस्य है, लेकिन जब मैं इसे ऑनलाइन आज़माता हूं, तो इसका एक इनपुट [1,1]और [2,2]उत्पादन होता है [[1, 1], [2, 1], [1, 2], [2, 2]], जो कि एक वैध रास्ता नहीं है।
— मिशा लावरोव
हम्म मैंने कुछ गलत किया होगा - देख ...
— जोनाथन एलन
ठीक है 2 बाइट्स के लिए मेरे गोल्फ में से एक को बदलकर।
— जोनाथन एलन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.