BattleBlock थियेटर पहेली को हल करें

Question

गेम बैटलब्लॉक थियेटर में कभी-कभी एक पहेली होती है जो लाइट्स आउट का एक सामान्यीकृत संस्करण है । आपको तीन समीपवर्ती ब्लॉक मिले हैं, जिनमें से प्रत्येक बार और 1 के बीच एक स्तर को इंगित करता है जिसमें बार शामिल हैं, जैसे:

|
||||
||

यदि आप किसी ब्लॉक को स्पर्श करते हैं, तो उस ब्लॉक के साथ-साथ किसी भी निकटवर्ती ब्लॉक को उसके स्तर में वृद्धि होगी (4 से 1 से पीछे की ओर लपेटते हुए)। जब तीनों खंड समान स्तर दिखाते हैं (यह कोई फर्क नहीं पड़ता कि कौन सा स्तर है) पहेली हल हो गई है। चूंकि, आप जिस क्रम में ब्लॉक को स्पर्श करते हैं, वह कोई मायने नहीं रखता है, हम एक समाधान को निरूपित करते हैं कि प्रत्येक ब्लॉक को कितनी बार स्पर्श किया जाता है। उपरोक्त इनपुट के लिए इष्टतम समाधान होगा 201:

|    --> || --> |||     |||
||||     |      ||      |||
||       ||     ||  --> |||

खेल बहुत आसानी से किसी भी संख्या में ब्लॉकों को सामान्य करता है, हालांकि कुछ संख्याओं के लिए, सभी कॉन्फ़िगरेशन हल नहीं हैं।

चुनौती

ब्लॉक स्तरों के अनुक्रम को देखते हुए, पहेली को हल करने के लिए प्रत्येक ब्लॉक को कितनी बार छुआ जाना चाहिए। उदाहरण के लिए उपरोक्त उदाहरण दिया जाएगा 142और इसके 201परिणामस्वरूप परिणाम मिल सकता है । यदि कोई समाधान नहीं है, तो अपनी पसंद के कुछ सुसंगत आउटपुट लौटाएं , जो सभी संभावित समाधानों, जैसे -1या खाली स्ट्रिंग से अलग है।

आप एक फ़ंक्शन या प्रोग्राम लिख सकते हैं, किसी भी सुविधाजनक सूची या स्ट्रिंग प्रारूप में STDIN, कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले सकते हैं, और इसी तरह आउटपुट को रिटर्न मान के माध्यम से या STDOUT पर प्रिंट करके।

आपका कोड एक उचित मशीन पर एक मिनट के भीतर सभी परीक्षण मामलों के लिए सही परिणाम लौटाए। (यह पूरी तरह से सख्त सीमा नहीं है, इसलिए यदि आपके समाधान में एक मिनट और दस सेकंड का समय लगता है, तो यह ठीक है, लेकिन अगर यह 3 लेता है, तो यह नहीं है। एक अच्छा एल्गोरिदम आसानी से सेकंड में उन्हें हल करेगा।)

यह कोड गोल्फ है, इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

उदाहरण

समाधान अद्वितीय नहीं हैं, इसलिए आपको अलग-अलग परिणाम मिल सकते हैं।

Input                          Output

1                              0
11                             00
12                             No solution
142                            201
434                            101
222                            000
4113                           0230
32444                          No solution
23432                          10301
421232                         212301
3442223221221422412334         0330130000130202221111
22231244334432131322442        No solution
111111111111111111111222       000000000000000000000030
111111111111111111111234       100100100100100100100133
412224131444114441432434       113013201011001101012133

जहां तक ​​मुझे पता है, प्रत्येक इनपुट के लिए ठीक 4 समाधान हैं जहां ब्लॉक की संख्या 0 मॉड 3, या 1 मॉड 3 है, और 0 या 16 समाधान हैं जहां यह 2 मॉड 3 है।

Comments

क्या आपको एक इष्टतम समाधान का उत्पादन करने की आवश्यकता है?

— xnor

@xnor नहीं, आप नहीं।

— मार्टिन एंडर

क्या हमें एक ही समाधान छापना है या क्या हम उन सभी को भी प्रिंट कर सकते हैं?

— याकूब

@Jakube बिल्कुल एक कृपया। मुझे सभी / इष्टतम समाधान के लिए एक बोनस जोड़ा जाना चाहिए था, लेकिन मैंने इसके बारे में जल्दी नहीं सोचा था, इसलिए कोई भी (एक) समाधान है।

— मार्टिन एंडर

Answer 1

अजगर 2, 115 बाइट्स

n=input()
for F in range(4):
 t=[F];b=0;exec"x=(-n[b]-sum(t[-2:]))%4;t+=x,;b+=1;"*len(n)
 if x<1:print t[:-1];break

यह मार्टिन के साथ समस्या पर चर्चा करते हुए मेरे द्वारा लिखे गए कार्यक्रम का गोल्फ संस्करण है।

इनपुट STDIN के माध्यम से एक सूची है। आउटपुट एक सूची है जो अंतिम समाधान का प्रतिनिधित्व करती है यदि कोई समाधान है, या शून्य नहीं है। उदाहरण के लिए:

>>>
[1, 4, 2]
[2, 1, 1]
>>>
[1, 2]
0
>>>
map(int,"3442223221221422412334")
[2, 3, 3, 2, 1, 3, 2, 0, 0, 2, 1, 3, 2, 2, 0, 0, 2, 2, 3, 1, 1, 3]

---

पायथ, 32 29 बाइट्स

V4J]NVQaJ%_+s>J_2@QN4)I!eJPJB

अनिवार्य बंदरगाह। 3 बाइट की बचत के लिए @Jakube का धन्यवाद।

इनपुट विधि ऊपर के समान है, इसे ऑनलाइन आज़माएं ।

---

स्पष्टीकरण (लंबे और तर्क से भरा!)

सबसे पहले, दो बुनियादी अवलोकन:

• अवलोकन 1: इससे कोई फर्क नहीं पड़ता कि आप ब्लॉक को किस क्रम में छूते हैं

• अवलोकन 2: यदि आप किसी ब्लॉक को 4 बार छूते हैं, तो यह एक बार छूने के बराबर है

दूसरे शब्दों में, यदि कोई समाधान है तो एक समाधान है जहां स्पर्श की संख्या 0 और 3 के बीच है।

चूंकि modulo 4 इतना अच्छा है, तो आइए इसे ब्लॉक्स के साथ भी करें। इस स्पष्टीकरण के बाकी हिस्सों के लिए, ब्लॉक स्तर 0 ब्लॉक स्तर 4 के बराबर है।

अब चलो a[k]ब्लॉक के वर्तमान स्तर kऔर एक समाधान में x[k]ब्लॉक kको छूने की संख्या के होने का संकेत देते हैं। इसके अलावा nब्लॉक की कुल संख्या हो। जैसा कि @Jakube ने उल्लेख किया है, एक समाधान को संतुष्ट करना होगा:

  a[0]   + x[0] + x[1]
= a[1]   + x[0] + x[1] + x[2]
= a[2]          + x[1] + x[2] + x[3]
= a[3]                 + x[2] + x[3] + x[4]
...
= a[n-1]                                     ...  + x[n-2] + x[n-1] + x[n]
= a[n]                                       ...           + x[n-1] + x[n]
= C

जहां Cअंतिम स्तर पर सभी ब्लॉक 0 और 3 समावेशी के बीच समाप्त होते हैं (याद रखें कि हम स्तर 4 को 0 के स्तर के रूप में मान रहे हैं) और ऊपर दिए गए सभी समीकरण वास्तव में बधाई हैं modulo 4।

अब यहाँ मज़ेदार हिस्सा है:

• अवलोकन 3 : यदि कोई समाधान मौजूद है, तो समाधान किसी अंतिम ब्लॉक स्तर के लिए मौजूद है 0 <= C <= 3।

ब्लॉक मॉडुलो की संख्या के आधार पर तीन मामले हैं। उनमें से प्रत्येक के लिए स्पष्टीकरण समान है - किसी भी संख्या में ब्लॉक के लिए, ब्लॉक का एक सबसेट मौजूद है, यदि आप उनमें से प्रत्येक को एक बार छूते हैं, तो सभी ब्लॉक स्तरों को बढ़ाता है ठीक 1।

0 mod 3 (touch every third block starting from the second):
    .X. / .X. / .X.

1 mod 3 (touch every third block starting from the first):
    X. / .X. / .X. / .X

2 mod 3 (touch every third block starting from either the first or second):
    X. / .X. / .X. / .X.
    .X. / .X. / .X. / .X

यह बताता है कि क्यों 0 mod 3और के लिए 4 समाधान हैं 1 mod 3, और आमतौर पर 16 समाधान के लिए 2 mod 3। यदि आपके पास पहले से ही एक समाधान है, तो ऊपर के रूप में ब्लॉकों को छूने से एक और समाधान मिलता है जो एक उच्च ब्लॉक स्तर (चारों ओर लपेटने) पर समाप्त होता है।

अच्छा तो इसका क्या मतलब है? हम किसी भी अंतिम ब्लॉक स्तर को चुन सकते Cहैं! चलो चुनते हैं C = 0, क्योंकि यह बाइट्स पर बचाता है।

अब हमारे समीकरण बन गए:

0 = a[0] + x[0] + x[1]
0 = a[1] + x[0] + x[1] + x[2]
0 = a[2] + x[1] + x[2] + x[3]
0 = a[3] + x[2] + x[3] + x[4]
...
0 = a[n-1] + x[n-2] + x[n-1] + x[n]
0 = a[n] + x[n-1] + x[n]

और पुनर्व्यवस्थित करें:

x[1] = -a[0] - x[0]
x[2] = -a[1] - x[0] - x[1]
x[3] = -a[2] - x[1] - x[2]
x[4] = -a[3] - x[2] - x[3]
...
x[n] = a[n-1] - x[n-2] - x[n-1]
x[n] = a[n] - x[n-1]

इसलिए हम जो देख सकते हैं, अगर वह हमारे पास है x[0], तो हम सभी समीकरणों का उपयोग कर सकते हैं सिवाय आखिरी के हर दूसरे का पता लगाने के लिए x[k]। अंतिम समीकरण एक अतिरिक्त स्थिति है जिसे हमें जांचना चाहिए।

यह हमें एक एल्गोरिथ्म देता है:

• सभी मूल्यों के लिए प्रयास करें x[0]
• उपरोक्त समीकरणों का उपयोग दूसरे के सभी कार्य करने के लिए करें x[k]
• जांचें कि क्या अंतिम स्थिति संतुष्ट है। यदि हां, तो समाधान को बचाएं।

कि ऊपर समाधान देता है।

तो हमें कभी-कभी कोई समाधान क्यों नहीं मिलता है 2 mod 3? आइए इन दोनों प्रतिमानों पर एक बार फिर नज़र डालते हैं:

X. / .X. / .X. / .X.
.X. / .X. / .X. / .X

अब उन पदों पर समीकरणों पर विचार करें, यानी पहले के लिए:

0 = a[0] + x[0] + x[1]
0 = a[3] + x[2] + x[3] + x[4]
0 = a[6] + x[5] + x[6] + x[7]
0 = a[9] + x[8] + x[9] + x[10]

उन्हें जोड़ें:

0 = (a[0] + a[3] + a[6] + a[9]) + (x[0] + x[1] + ... + x[9] + x[10])

दूसरे के लिए:

0 = a[1] + x[0] + x[1] + x[2]
0 = a[4] + x[3] + x[4] + x[5]
0 = a[7] + x[6] + x[7] + x[8]
0 = a[10] + x[9] + x[10]

उन्हें फिर से जोड़ें:

0 = (a[1] + a[4] + a[7] + a[10]) + (x[0] + x[1] + ... + x[9] + x[10])

इसलिए अगर (a[1] + a[4] + a[7] + a[10])और (a[0] + a[3] + a[6] + a[9])समान नहीं हैं, तो हमारे पास कोई समाधान नहीं है। लेकिन अगर वे समान हैं, तो हमें 16 समाधान मिलते हैं। यह n = 11मामले के लिए था , लेकिन निश्चित रूप से किसी भी संख्या के लिए यह सामान्य है 2 mod 3- दूसरा से शुरू होने वाले हर तीसरे तत्व का योग है, और पहले से शुरू होने वाले हर तीसरे तत्व के योग की तुलना करें।

अब आखिरकार, क्या यह पता लगाना संभव है कि x[0]सभी संभावनाओं को आज़माने के बजाय क्या होना चाहिए? आखिरकार, चूंकि हमने अपने लक्ष्य के स्तर Cको 0 तक सीमित कर दिया है , केवल एक ही है x[0]जो मामले ( 0 mod 3या ) में एक समाधान देता है ।1 mod 34 solutions / 4 final levels = 1 solution for a specific final level

इसका जवाब है हाँ! हम इसके लिए यह कर सकते हैं 0 mod 3:

 .X..X
.X..X.

जिसका अनुवाद है:

0 = a[2] + x[1] + x[2] + x[3]   -> 0 = (a[2] + a[5]) + (x[1] + ... + x[5])
0 = a[5] + x[4] + x[5]          /


0 = a[1] + x[0] + x[1] + x[2]   -> 0 = (a[1] + a[4]) + (x[0] + x[1] + ... + x[5])
0 = a[4] + x[3] + x[4] + x[5]   /

घटाव देता है:

x[1] = (a[2] + a[5]) - (a[1] + a[4])

इसी तरह 1 mod 3हम इस पैटर्न के लिए कर सकते हैं:

 .X..X.
X..X..X

जो देता है:

x[0] = (a[2] + a[5]) - (a[0] + a[3] + a[6])

बेशक ये 3 के वेतन वृद्धि द्वारा सूचकांकों को सामान्य करते हैं।

के लिए 2 mod 3, क्योंकि हम दो सबसेट जो हर ब्लॉक को कवर है, हम वास्तव में किसी भी चुन सकते हैं x[0]। वास्तव में, यह सच है x[0], x[1], x[3], x[4], x[6], x[7], ...(मूल रूप से किसी भी सूचकांक के अनुरूप नहीं है 2 mod 3, क्योंकि वे या तो सबसेट द्वारा कवर नहीं किए गए हैं)।

इसलिए हमारे पास x[0]सभी संभावनाओं को आज़माने के बजाय चुनने का एक तरीका है ...

... लेकिन बुरी खबर यह है कि यह बाइट्स (124 बाइट्स) पर नहीं बचा है:

def f(n):s=[];L=len(n);B=sum(n[~-L%3::3])-sum(n[-~L%3::3]);x=A=0;exec"s+=B%4,;A,B=B,-n[x]-A-B;x+=1;"*L*(L%3<2or B<1);print s

Comments

चतुर। यदि आप स्लाइसिंग के बजाय अंतिम तत्व को पॉप करते हैं, तो आप 2 और 2 चार्ट के Jबजाय 1 चार्जर बचा सकते हैं । । HPJ<J_1V4J]NVQaJ%_+s>J_2@QN4)I!eJPJB

— याकूब

@ जकूब आह धन्यवाद। जब मैंने पॉप पढ़ा तो मुझे लगा कि यह पायथन पॉप की तरह है जो सूची से हटाते समय अंतिम तत्व लौटाता है। अब मैं देख रहा हूं कि ऐसा नहीं है।

— Sp3000

Answer 2

पायथ, 72 76 73 66 39 38 चरित्र

Ph+f!eTmu+G%+&H@G_3-@QH@QhH4UtQd^UT2]Y

4 संपादित करें: एहसास हुआ, कि गणना Q[N]-Q[N+1]+solution[-3]और Q[-2]-Q[-1]+solution[-3]पहचान है। इसलिए मैं समाधान को 1 से ओवरक्लॉक करता हूं, और समाधान को फ़िल्टर करता हूं, जहां अंतिम प्रविष्टि 0. है फिर मैं अंतिम प्रविष्टि को पॉप करता हूं। सौभाग्य से विशेष मामलों को इस दृष्टिकोण के साथ अतिरिक्त उपचार की आवश्यकता नहीं है। -27 वर्ण

संपादित करें 3: FryAmTheEggman से कुछ गोल्फिंग गुर को लागू करना: -7 वर्ण

2 संपादित करें: फ़िल्टर का उपयोग करें , कम करें और मानचित्र: -3 वर्ण

संपादित करें 1: मेरे पहले संस्करण में मैंने कुछ भी नहीं छापा था, अगर कोई समाधान नहीं था। मुझे नहीं लगता कि इसकी अनुमति है, इसलिए +4 वर्ण।

पूर्णांकों की एक सूची के रूप में इनपुट की अपेक्षा करता है [1,4,2]और एक वैध समाधान को आउटपुट करता है [2,0,1]यदि एक है, अन्यथा एक खाली सूची []।

स्पष्टीकरण:

आज्ञा देना Q5 स्तरों Yकी सूची और समाधान की सूची। निम्नलिखित समीकरणों को पकड़ना है:

  Q0 + Y0 + Y1 
= Q1 + Y0 + Y1 + Y2
= Q2      + Y1 + Y2 + Y3
= Q3           + Y2 + Y3 + Y4
= Q4                + Y3 + Y4

इसलिए यदि हम किसी का उपयोग करते हैं Y0और Y1, हम गणना कर सकते हैं Y2, Y3और Y4निम्नलिखित तरीके से।

Y2 = (Q0 - Q1     ) mod 4
Y3 = (Q1 - Q2 + Y0) mod 4
Y4 = (Q2 - Q3 + Y1) mod 4

सभी स्तरों को समाप्त करने के लिए पिछले एक के बराबर हैं (क्योंकि हमने समीकरण का उपयोग नहीं किया था = Q4 + Y3 + Y4। यह जांचने के लिए, यदि यह अंतिम भी अन्य स्तरों के बराबर है, तो हम बस यह देख सकते हैं (Q3 - Q4 + Y2) mod 4 == 0कि क्या । सूचना, कि बाएं भाग का मान होगा। Y5यदि मैं समाधान के 6 वें भाग की गणना करता हूं, तो मैं बस जांच कर सकता हूं, अगर यह शून्य है।

अपने दृष्टिकोण में मैं बस सभी संभव शुरू ( [0,0]पर [3,3]) से अधिक पुनरावृति करता हूं , और लंबाई (इनपुट) -1 की गणना करता हूं और एक शून्य के साथ समाप्त होने वाले सभी समाधानों को फ़िल्टर करता हूं ।

mu+G%+&H@G_3-@QH@QhH4UtQd^UT2   generates all possible solutions

यह मूल रूप से निम्नलिखित है:

G = start value           //one of "^UT2", [0,0], [0,1], ..., [9,9]
                          //up to [3,3] would be enough but cost 1 char more
for H in range(len(Q)-1): //"UtQ"
   G+=[(H and G[-3])+(Q(H)-Q(H+1))%4] //"+G%+&H@G_3-@QH@QhH4"
   //H and G[-3] is 0, when H is empty, else G[-3]

फिर मैं वैध लोगों के लिए इन संभावित समाधानों को फ़िल्टर करता हूं:

f!eT //only use solutions, which end in 0

समाधानों की इस सूची में मैं एक खाली सूची संलग्न करता हूं, ताकि इसमें कम से कम एक वस्तु हो

 +....]Y

और पहला समाधान लें h, अंतिम तत्व को पॉप करें pऔर इसे प्रिंट करें

 Ph

ध्यान दें, कि यह भी काम करता है, अगर केवल एक ब्लॉक है। मेरे दृष्टिकोण में मुझे शुरुआती स्थिति [0,0] मिलती है और इसका विस्तार नहीं होता है। चूंकि अंतिम प्रविष्टि 0 है, यह समाधान को प्रिंट करता है [0]।

दूसरा विशेष मामला (2 ब्लॉक) वह विशेष नहीं है। यकीन नहीं होता, मैंने पहले ही चीजों को क्यों उलझा दिया।

Comments

मुझे लगता है कि बिना किसी समाधान के मुद्रण के लिए कुछ भी ठीक नहीं है यदि ऐसा एकमात्र मामला है जहां आप कुछ भी नहीं छापते हैं। हालांकि पुष्टि करने के लिए @ मार्टिनबटनर लेना होगा

— Sp3000

?**lQ]0qhQeQ<lQ3h+f!%-+ePQ@T_3eQ4mu+G]%+&H@G_3-@QH@QhH4UttQd^UT2]Y66 बाइट्स है। प्रदर्शन थोड़ा प्रभावित हुआ था, लेकिन यह अभी भी मेरे लिए <1s में सबसे बड़ा परीक्षण मामला चलाता है। यदि आप कुछ गोल्फों के स्पष्टीकरण चाहते हैं तो मुझे पिंग करें; इस टिप्पणी में पर्याप्त जगह नहीं है;) आशा है कि आप Pyth का उपयोग करके आनंद ले रहे हैं: D

— FryAmTheEggman

+<list><int>के रूप में एक ही प्रभाव है +<list>]<int>, तो आप पहले को हटा सकते हैं ]। इसके अलावा, बहुत अच्छा समाधान।

— isaacg

@isaacg के लिए भी यही सच है ~? ऐसा लगता नहीं था जब मैंने कोशिश की

— Sp3000 11

@ Sp3000 बस के ~साथ बदलें a- ~<list>]<int>के बराबर है a<list><int>। ~है +=, जबकि aहै.append()

— isaacg

Answer 3

रूबी, 320 313 वर्ण

m=gets.chop.chars.map{|x|x.to_i-1}
a=m.map{0}
t=->n{m[n]+=1
m[n-1]+=1if n>0
m[n+1]+=1if n<m.size-1
m.map!{|x|x%4}
a[n]=(a[n]+1)%4}
t[0]until m[0]==1
(2...m.size).map{|n|t[n]until m[n-1]==1}
r=0
while m.uniq.size>1&&m[-1]!=1
(0...m.size).each_with_index{|n,i|([1,3,0][i%3]).times{t[n]}}
(r+=1)>5&&exit
end
$><<a*''

निश्चित रूप से अधिक गोल्फ हो सकता है। अकल्पनीय पहेली के लिए कुछ भी नहीं आउटपुट।

Ungolfed संस्करण:

#!/usr/bin/ruby

nums = gets.chomp.chars.map {|x| x.to_i-1 }
touches = nums.map {0}

# our goal: make all the numbers 1
# utility function
touch = ->n {
    nums[n] += 1
    nums[n-1] += 1 if n > 0
    nums[n+1] += 1 if n < (nums.length-1)
    nums.map! {|x| x % 4 }
    touches[n] = (touches[n] + 1) % 4
}

# first, start with the very first number
touch[0] until nums[0] == 1

# then, go from index 2 to the end to make the previous index right
(2...nums.length).each {|n|
    touch[n] until nums[n-1] == 1
}

iters = 0
if nums.uniq.length != 1
    # I have no idea why this works
    while nums[-1] != 1
        (0...nums.length).each_with_index {|n, i|
            ([1, 3, 0][i % 3]).times { touch[n] }
        }
        if (iters += 1) > 5
            puts -1
            exit
        end
    end
end

puts touches * ''

ठीक है, यह एक मजेदार था। यहाँ मूल एल्गोरिथ्म है, जिसका {n}प्रतिनिधित्व n "स्पर्श" से ऊपर की संख्या पर है n, जैसा कि एक उदाहरण पर प्रदर्शित किया गया है:

we want each number to be a 1
first make the first number a 1
3442223221221422412334
2}
1242223221221422412334
 {3} now keep "touch"ing until the number to the left is a 1
1131223221221422412334
  {2}
1113423221221422412334
   {2}
1111243221221422412334
... (repeat this procedure)
1111111111111111111110

मैं यहाँ थोड़ा रुक गया। मैं 111...1110समान संख्याओं की श्रृंखला में कैसे बदल सकता हूं ? इसलिए मैंने अपने समाधान और सही समाधान की तुलना की (ध्यान दें: "स्पर्श" मायने रखता है सभी एक से अधिक हैं, क्योंकि इनपुट 1-अनुक्रमित है, जबकि आउटपुट 0-अनुक्रमित है):

3033233103233301320210
0330130000130202221111

मैंने देखा कि प्रत्येक संख्या सही एक से दूर थी mod 4, इसलिए मैंने उन्हें +s, -s और =s के साथ चिह्नित किया :

3033233103233301320210 original program output
+-=+-=+-=+-=+-=+-=+-=+ amount to modify by (+1, -1, or 0 (=))
4334534404534602621511 result (the correct answer)

0330130000130202221111 (the original solution, digits equal to result mod 4)

कुछ समय के लिए काम किया, जब तक मैंने देखा कि कभी-कभी अंतिम परिणाम 111...11112या 11...1113भी होता था! सौभाग्य से, बार-बार जादुई फॉर्मूला लागू करने से कोई मतलब नहीं है लेकिन काम भी इनको हल करता है।

इसलिए यह अब आपके पास है। एक ऐसा कार्यक्रम, जो समझ में आने लगता है, लेकिन जैसे-जैसे यह आगे बढ़ता है, यह और अधिक बदसूरत हैकनेस में बदल जाता है। मुझे लगता है कि एक कोड गोल्फ समाधान के लिए काफी विशिष्ट है। :)

Comments

मुझे आपके कोड में अंतिम टिप्पणी पसंद है :)। आप को बदलने के द्वारा 2 वर्ण बचा सकते हैं exit if (r+=1)>5करने के लिए (r+=1)>5&&exit। इसके अलावा, (code)while condसिंटैक्स की तुलना में कम है while cond \n code \n end।

— क्रिस्टियन लुपस्कू

Answer 4

पायथन 2, 294,289,285,281 273 बाइट्स

n=input();l=len(n);s=[0]*l
for i in range(2,l):
 a=(n[i-2]-n[i-1])%4;s[i]+=a;n[i-1]+=a;n[i]+=a
 if i+1<l:n[i+1]+=a
 n=[a%4for a in n]
if l%3>1 and n!=[n[0]]*l:print"x"
else:
 for i in range(l%3,l-1,3):s[i]+=(n[l-1]-n[l-2])%4
 m=min(s);s=[(a-m)%4 for a in s];print s

डेमो

मुझे यकीन है कि इसे आगे बढ़ाया जा सकता है।

यहाँ परीक्षण मामलों से परिणाम हैं:

[1]
-> [0]

[1,1]
-> [0, 0]

[1,2]
-> x

[1,4,2]
-> [2, 0, 1]

[4,3,4]
-> [1, 0, 1]

[2,2,2]
-> [0, 0, 0]

[4,1,1,3]
-> [0, 2, 3, 0]

[3,2,4,4,4]
-> x

[2,3,4,3,2]
-> [0, 0, 3, 3, 1]

[4,2,1,2,3,2]
-> [2, 0, 2, 3, 3, 1]

[3,4,4,2,2,2,3,2,2,1,2,2,1,4,2,2,4,1,2,3,3,4]
-> [0, 3, 3, 0, 1, 3, 0, 0, 0, 0, 1, 3, 0, 2, 0, 2, 2, 2, 1, 1, 1, 1]

[2,2,2,3,1,2,4,4,3,3,4,4,3,2,1,3,1,3,2,2,4,4,2]
-> x

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,2,2]
-> [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0]

[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2,3,4]
-> [1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 3, 3]

[4,1,2,2,2,4,1,3,1,4,4,4,1,1,4,4,4,1,4,3,2,4,3,4]
-> [1, 0, 3, 0, 0, 3, 2, 3, 1, 0, 0, 1, 0, 3, 1, 1, 3, 1, 0, 0, 2, 1, 2, 3]

एल्गोरिथम पहले यह सुनिश्चित करता है कि अंतिम ब्लॉक को छोड़कर सभी ब्लॉकों के मूल्य समान हैं (पहले 2 को छोड़कर सभी ब्लॉकों के "टच काउंट" को जोड़कर)। फिर, यदि ब्लॉक की संख्या इसके लिए अनुमति देती है ( (num_of_blocks - 1) % 3 != 1), वापस जाती है और यह सुनिश्चित करती है कि बाकी ब्लॉक के मान अंतिम ब्लॉक से मेल खाते हैं। xअगर कोई हल नहीं है तो प्रिंट करें ।