দীর্ঘতম হাইপারকিউব পাথ

18

চ্যালেঞ্জ

আপনাকে একই দৈর্ঘ্যের দুটি স্বতন্ত্র বিট স্ট্রিং দেওয়া হচ্ছে। (উদাহরণস্বরূপ, 000এবং 111।) আপনার লক্ষ্যটি হ'ল এক থেকে অন্যের মতো কোনও পথ খুঁজে পাওয়া যে:

  • প্রতিটি ধাপ অনুযায়ী, আপনি যদি শুধুমাত্র একটি বিট পরিবর্তন (আপনি থেকে যেতে পারেন 000কোন 001, 010, 100)।
  • আপনি একই বিট স্ট্রিং দু'বার দেখতে পারবেন না।
  • এই বাঁধাগুলির মধ্যে দিয়ে পথটি যতটা সম্ভব দীর্ঘ is

উদাহরণস্বরূপ, থেকে 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
আমরা কি মান এবং শূন্যের পরিবর্তে বুলিয়ান মান গ্রহণ করতে পারি?
— flawr
@ ফ্লোয়ার অবশ্যই, ঠিক আছে।
— মিশা লাভরভ
আমরা কি ধরে নিতে পারি যে আমরা দুটি সমান বিট-স্ট্রিং পাবেন না (বা যদি আমরা কিছু করতে পারি তবে)?
— জোনাথন অ্যালান
1
@ জোনাথন অ্যালান হ্যাঁ, ধরে নেওয়া যাক বিট-স্ট্রিংগুলি সমান নয়।
— মিশা লাভরভ
— লিকি নুন

উত্তর:

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 বাইট

এটি সম্ভবত দীর্ঘ দীর্ঘ, তবে এটি এখন শেষ পর্যন্ত কার্যকর হয়। ( কার্টেসিয়ান প্রোডাক্ট ট্রিকের জন্য @ লিনকে ধন্যবাদ!) থানস্ক @ নিমিকে -৫ বাইটের জন্য!

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
— নিমি
... তোমার কি দরকার [True,False]? [False,True]এছাড়াও যদি কাজ করে তবে আপনি ব্যবহার করতে পারেন [0>1..]।
— নিমি
ওহ দুর্দান্ত, ধন্যবাদ, আমি জানতাম না যে Boolএটি Enum, এবং আমি ভুলে গিয়েছিলাম যে <$এটি উপলব্ধ (প্রথম চেষ্টা *>যা প্রিলিডে নেই)!
— flawr
3

ম্যাথামেটিকাল 116 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 ০, ১ এর ট্রিপল উত্পন্ন করে প্রতিটি জোড়ার যোগফল দেয়।

Cases....Count[Plus@@x, 1]==1 একক ১ টি সমন্বিত সমস্ত যোগফল প্রদান করে These দুটি মূল বাইনারি সংখ্যা একটি প্রান্ত দ্বারা সংযুক্ত হয়ে থাকে তখন এগুলি উত্থাপিত হয়।

Rules গ্রাফের শীর্ষকোষগুলি সংযুক্ত করে, প্রতিটি শীর্ষবিন্দু একটি বাইনারি সংখ্যা।

Graph উল্লম্ব এবং প্রান্তের সাথে সম্পর্কিত গ্রাফ তৈরি করে।

FindPath প্রদত্ত সংখ্যাগুলিতে a a

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 a একটি ইউনিট কিউবে "বিপরীত" বিন্দু উপস্থাপন করে।

সুতরাং সমাধানের পথটি ইউনিট কিউব বরাবর প্রান্তগুলির একটি ট্র্যাভারসাল সাথে সামঞ্জস্য করে। এই ক্ষেত্রে, পাথ হ্যামিলটোনিয়ান: এটি প্রতিটি শীর্ষ প্রান্তটি একবারে পরিদর্শন করে (অর্থাত্ কোনও ক্রসিং এবং কোনও উল্লম্ব বাদ দেওয়া হয় না)।

G4

— DavidC
সূত্র
একটি b থেকে বি পর্যন্ত দীর্ঘ to ^ n পথগুলি দীর্ঘায়িতভাবে সামগ্রিকভাবে দীর্ঘতম হওয়ার জন্য কি কোনও সাধারণ কারণ আছে?
— মিশা লাভরভ
@ মিশা, খুব ভাল প্রশ্ন।
— ডেভিডসি
এটি সম্পর্কে চিন্তা করার এক উপায় এখানে। দীর্ঘতম পথ, একটি হ্যামিল্টোনীয় পাথ কোণার সংখ্যার চেয়ে কম হবে। (আমরা পথে প্রান্তের সংখ্যা গণনা করছি)) কোণার সংখ্যা 2। N। সুতরাং সর্বোচ্চ পাথের দৈর্ঘ্য 2 ^ n-1 হবে।
— ডেভিডসি
আমি সম্মত হই যে সর্বাধিক পথের দৈর্ঘ্য সর্বদা 2 ^ n শীর্ষে (যদি এটি হ্যামিল্টোনিয়ান হয়) বা 2 ^ n-1 শীর্ষে (যদি হ্যামিল্টোনীয় পথটি সমতার কারণে অসম্ভব) থাকে তবে পরিদর্শন করে। এটি আমার প্রশ্নের থেকে পৃথক, যা হ'ল: কেন 2 ^ (এন + 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উভয় ক্ষেত্রেই দীর্ঘতম পথ বেছে নেয়, কারণ জোড়াগুলির প্রথম স্থানাঙ্কগুলি দ্বিতীয়টির আগে তুলনা করা হয় before

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µÞṪ

বিট-স্ট্রিংগুলি ব্যবহার করে একটি সম্পূর্ণ প্রোগ্রাম 1 এবং 2তালিকা হিসাবে * । যুক্তিগুলি হ'ল 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 বাইটের জন্য ফিরিয়ে দিয়ে ঠিক আছে।
— জোনাথন অ্যালান
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.