सबसे लंबी डोमिनोज़ चेन

Question

चुनौती का वर्णन

डोमिनोज़ एक ऐसा खेल है जिसमें टाइल्स को दो मूल्यों के साथ खेला जाता है - एक बाईं ओर, एक दाईं ओर, उदाहरण के लिए [2|4]या [4|5]। दो टाइलों को एक साथ जोड़ा जा सकता है अगर उनमें एक सामान्य मूल्य होता है। ऊपर की दो टाइलें इस तरह से जुड़ सकती हैं:

[2|4][4|5]

हम nशामिल टाइलों के अनुक्रम को लंबाई n की एक श्रृंखला कहेंगे । बेशक, टाइल्स को घुमाया जा सकता है, इसलिए टाइल्स [1|2], [1|3]और लंबाई 3 की [5|3]श्रृंखला में फिर से व्यवस्थित किया जा सकता है [2|1][1|3][3|5]।

पूर्णांक के जोड़े की सूची को देखते हुए, इन टाइलों का उपयोग करके बनाई जाने वाली सबसे लंबी श्रृंखला की लंबाई निर्धारित करें। यदि सूची खाली है, तो सही उत्तर है 0(ध्यान दें कि आप हमेशा 1टाइल्स की गैर-खाली सूची से लंबाई की एक श्रृंखला बना सकते हैं )।

नमूना इनपुट / आउटपुट

[(0, -1), (1, -1), (0, 3), (3, 0), (3, 1), (-2, -1), (0, -1), (2, -2), (-1, 2), (3, -3)] -> 10
([-1|0][0|-1][-1|2][2|-2][-2|-1][-1|1][1|3][3|0][0|3][3|-3])

[(17, -7), (4, -9), (12, -3), (-17, -17), (14, -10), (-6, 17), (-16, 5), (-3, -16), (-16, 19), (12, -8)] -> 4
([5|-16][-16|-3][-3|12][12|-8])

[(1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1), (1, 1)] -> 7
([1|1][1|1][1|1][1|1][1|1][1|1][1|1])

[(0, 1), (2, 3), (4, 5), (6, 7), (8, 9), (10, 11)] -> 1
(any chain of length 1)

[] -> 0
(no chain can be formed)

Comments

रनिंग टाइम या मेमोरी पर कोई प्रतिबंध? सोचें कि सभी अनुज्ञाओं के लिए ब्रूट-फोर्सिंग करना

— लुइस मेंडो

@LuisMendo: बहुत यकीन है कि यह समस्या एनपी है, इसलिए अपनी O(n!)इच्छा के अनुसार आग

— लगाओ

I guess it's P

— l4m2

Answer 1

ब्रेकीलॉग , 23 बाइट्स

s:papcb~k~c:{#=l2}al|,0

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

व्याख्या

s:papcb~k~c:{#=l2}al|,0
s                         Check subsets of the input (longest first).
 :pa                      Check all permutations inside the input's elements
    p                     and all permutations /of/ the input's elements.
     c                    Flatten the result;
      b                   delete the first element;
       ~k                 find something that can be appended to the end so that
         ~c               the result can be unflattened into
           :{    }a       a list whose elements each have the property:
             #=             all the elements are equal
               l2           and the list has two elements.
                   l      If you can, return that list's length.
                    |,0   If all else fails, return 0.

तो दूसरे शब्दों में, जैसे इनपुट के लिए [[1:2]:[1:3]:[5:3]], हम इसे एक वैध श्रृंखला में पुनर्व्यवस्थित करने की कोशिश करते हैं [[2:1]:[1:3]:[3:5]], फिर उत्पादन करने के लिए समतल / बीहेड / अनकेनाइफ [1:1:3:3:5:_](जहां _एक अज्ञात का प्रतिनिधित्व करता है)। का संयोजन ~cऔर :{…l2}aप्रभावी ढंग से इसे 2 तत्वों के समूहों में विभाजित करता है, और हम यह सुनिश्चित करते हैं कि सभी समूह समान हैं। जैसा कि हमने चपटा किया (लंबाई दोगुनी), एक तत्व को शुरू से हटा दिया और एक को अंत में जोड़ा (कोई बदलाव नहीं), और जोड़े में बांटा गया (लंबाई को आधा करते हुए), इसमें डोमिनोज़ की मूल श्रृंखला के समान लंबाई होगी।

"बीहेड" निर्देश विफल हो जाएगा यदि इनपुट में कोई डोमिनोज़ नहीं हैं (वास्तव में, IIRC :paभी विफल हो जाएगा; aखाली सूचियों को नापसंद करता है), इसलिए हमें 0. के लिए एक विशेष मामले की आवश्यकता है (एक बड़ा कारण हमारे बीच विषमता है bऔर ~kऐसा है) कि हम भी 1. के लिए एक विशेष मामले की जरूरत नहीं है)

Comments

अच्छाई जो बहुत छोटी है ...

— घातक

Answer 2

ब्रेकीलॉग , 29 बाइट्स

v0|sp:{|r}aLcbk@b:{l:2%0}a,Ll

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

बहुत यकीन है कि यह बहुत लंबा है, लेकिन जो भी हो। यह भी भयानक धीमी है।

व्याख्या

v0                               Input = [], Output = 0
  |                              Or
   sp:{|r}aL                     L (a correct chain) must be a permutation of a subset of the
                                   Input with each tile being left as-is or reversed
           Lcbk                  Concatenate L into a single list and remove the first and
                                   last elements (the two end values don't matter)
               @b                Create a list of sublists which when concatenated results in
                                   L, and where each sublist's elements are identical
                 :{     }a,      Apply this to each sublist:
                   l:2%0           It has even length
                           Ll    Output = length(L)

इसका कारण यह होगा कि सबसे बड़ा एक है क्योंकि s - subsetसबसे बड़े से सबसे छोटे सबसेट के लिए पसंद अंक उत्पन्न करता है।

Answer 3

मैथमेटिका, 191 बाइट्स

If[#=={},0,Max[Length/@Select[Flatten[Rest@Permutations[#,∞]&/@Flatten[#,Depth[#]-4]&@Outer[List,##,1]&@@({#,Reverse@#}&/@#),1],MatchQ[Differences/@Partition[Rest@Flatten@#,2],{{0}...}]&]]]&

एक निष्पक्ष सा गोल्फ हो सकता है, मुझे यकीन है। लेकिन मूल रूप से वैसा ही एल्गोरिथ्म है जैसा कि फ़ेटलेट के ब्रेकीलॉग उत्तर में है , अंत में थोड़ा अलग परीक्षण के साथ।

Comments

-1 बाइट: Differences/@Rest@Flatten@#~Partition~2के बजाय Differences/@Partition[Rest@Flatten@#,2]( Infixकी तुलना में अधिक पूर्वता है Map)

— जंगम मिन

Answer 4

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 92 बाइट्स

(a,l)=>Math.max(0,...(for(d of a)for(n of d)if(!(l-n))1+f(a.filter(e=>e!=d),d[0]+d[1]-n)))

• lअंतिम मूल्य है, या undefinedप्रारंभिक आह्वान के लिए। l-nइसलिए एक मिथ्या मूल्य है अगर डोमिनोज़ को बजाया जा सकता है।
• d विचाराधीन डोमिनोज़ है।
• nपिछले डोमिनो के लिए चिन करने के लिए विचाराधीन डोमिनो का अंत है। दूसरे छोर को आसानी से गणना की जा सकती है d[0]+d[1]-n।
• 0, बस कोई खेलने योग्य डोमिनोज़ के आधार मामले को संभालता है।

Answer 5

हास्केल , 180 134 131 117 बाइट्स

p d=maximum$0:(f[]0d=<<d)
f u n[]c=[n]
f u n(e@(c,d):r)a@(_,b)=f(e:u)n r a++(f[](n+1)(r++u)=<<[e|b==c]++[(d,c)|b==d])

इसे ऑनलाइन आज़माएं! नया दृष्टिकोण छोटा और अधिक कुशल दोनों निकला। सभी संभावित क्रमपरिवर्तन के बजाय केवल सभी वैध श्रृंखलाएं निर्मित होती हैं।

संपादित करें: 117 बाइट संस्करण फिर से बहुत धीमा है, लेकिन अभी भी जानवर-बल से तेज है।

---

पुराने जानवर बल विधि:

p(t@(a,b):r)=[i[]t,i[](b,a)]>>=(=<<p r)
p e=[e]
i h x[]=[h++[x]]
i h x(y:t)=(h++x:y:t):i(h++[y])x t
c%[]=[0]
c%((_,a):r@((b,_):_))|a/=b=1%r|c<-c+1=c:c%r
c%e=[c]
maximum.(>>=(1%)).p

यह एक ब्रूट-फोर्स कार्यान्वयन है जो सभी संभावित क्रमपरिवर्तन की कोशिश करता है (संभावित क्रमपरिवर्तन की संख्या A000165 , " सम संख्याओं का दोहरा तथ्य ") द्वारा दी गई लगती है । इसे ऑनलाइन आज़माएं मुश्किल से लंबाई 7 तक इनपुट का प्रबंधन करता है (जो कि 7 की तरह प्रभावशाली है, 645120 क्रमपरिवर्तन से मेल खाता है )।

उपयोग:

Prelude> maximum.(>>=(1%)).p $ [(1,2),(3,2),(4,5),(6,7),(5,5),(4,2),(0,0)]
4

Answer 6

पायथन 2, 279 बाइट्स

golfed:

l=input()
m=0
def f(a,b):
 global m
 l=len(b)
 if l>m:m=l
 for i in a:
  k=a.index(i)
  d=a[:k]+a[k+1:]
  e=[i[::-1]]
  if not b:f(d,[i])
  elif i[0]==b[-1][1]:f(d,b+[i])
  elif i[0]==b[0][0]:f(d,e+b)
  elif i[1]==b[0][0]:f(d,[i]+b)
  elif i[1]==b[-1][1]:f(d,b+e)
f(l,[])
print m

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

कुछ टिप्पणियों के साथ एक ही बात:

l=input()
m=0
def f(a,b):
 global m
 l=len(b)
 if l>m:m=l                      # if there is a larger chain
 for i in a:
  k=a.index(i)
  d=a[:k]+a[k+1:]                # list excluding i
  e=[i[::-1]]                    # reverse i
  if not b:f(d,[i])              # if b is empty
                                 # ways the domino can be placed:
  elif i[0]==b[-1][1]:f(d,b+[i]) # left side on the right
  elif i[0]==b[0][0]:f(d,e+b)    # (reversed) left side on the left
  elif i[1]==b[0][0]:f(d,[i]+b)  # right side on left
  elif i[1]==b[-1][1]:f(d,b+e)   # (reversed) right side on the right
f(l,[])
print m

मैं पोस्ट कर रहा हूं क्योंकि मैंने किसी भी अजगर के जवाब को नहीं देखा था ... कोई मेरे जवाब को देखेगा और घृणा में, कुछ बहुत छोटा और कुशल पोस्ट करने के लिए मजबूर हो जाएगा।

Answer 7

क्लोजर, 198 183 बाइट्स

अद्यतन: "संभवतः खाली अनुक्रम की अधिकतम" से बेहतर हैंडलिंग

(defn F[a C](remove(fn[i](identical? i a))C))(defn M[C](apply max 0 C))(defn L([P](M(for[p P l p](L l(F p P)))))([l R](+(M(for[r R[i j][[0 1][1 0]]:when(=(r i)l)](L(r j)(F r R))))1)))

पुराना संस्करण:

(defn F[a C](remove(fn[i](identical? i a))C))(defn M[C](apply max 1 C))(defn L([P](if(empty? P)0(M(for[p P l p](L l(F p P))))))([l R](M(for[r R[i j][[0 1][1 0]]:when(=(r i)l)](+(L(r j)(F r R))1)))))

सम्मेलन और परीक्षण मामलों को बुलाना:

(L [])
(L [[2 4] [3 2] [1 4]])
(L [[3, 1] [0, 3], [1, 1]])
(L [[17 -7] [4 -9] [12 -3] [-17 -17] [14 -10] [-6 17] [-16 5] [-3 -16] [-16 19] [12 -8]])
(L [[0 -1] [1 -1] [0 3] [3 0] [3 1] [-2 -1] [0 -1] [2 -2] [-1 2] [3 -3]])
(L [[1 1] [1 1] [1 1] [1 1] [1 1] [1 1] [1 1]])

Fतत्व के Cबिना सूची के तत्वों को रिटर्न करता है a, Mइनपुट इंगरर्स या 1 का अधिकतम रिटर्न देता है।

Lमुख्य कार्य है, जब एक ही तर्क के साथ कहा जाता है यह सभी संभव शुरुआती टुकड़े उत्पन्न करता है और उनमें से प्रत्येक के लिए अधिकतम लंबाई पाता है। जब दो तर्कों के साथ बुलाया जाता lहै, तो अनुक्रम का पहला तत्व होता है, जिसमें अगले टुकड़े का मिलान करना होता है और Rबाकी के टुकड़े होते हैं।

क्रमपरिवर्तन उत्पन्न करना और "एक तत्व का चयन करना और आराम करने के लिए विभाजित करना" सफलतापूर्वक लागू करने के लिए काफी मुश्किल थे।