(Rubiks) पॉकेट क्यूब को हल करें

Question

आपका कार्य

.. यह करना है कि ब्रायन फंटाना स्पष्ट रूप से क्या नहीं कर सके, और 2x2x2 रूबिक क्यूब को हल करें।

अभिन्यास

- -   A B   - -   - -
- -   C D   - -   - -

E F   G H   I J   K L
M N   O P   Q R   S T

- -   U V   - -   - -
- -   W X   - -   - -

और आपको स्टडिन या कमांड लाइन (आपकी पसंद - कृपया अपने उत्तर में निर्दिष्ट करें) के माध्यम से प्रारूप में दिया जाएगा:

ABCDEFGHIJKLMNOPQRSTUVWX

ध्यान दें कि AD, U- फेस (अप) को बनाता है, EFMN को L- फेस (लेफ्ट) को बनाते हैं, GHOP को F- फेस (फ्रंट) को, IJQR को R- फेस (राइट) को बनाते हैं, KLST को अप करते हैं। बी-फेस (बैक), और यूएक्स डी-फेस (डाउन) बनाते हैं।

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

विशेष विवरण

• आपके कोड को केवल राइट (R), अपर (U), और फ्रंट (F) चेहरों का उपयोग करके एक आउटपुट का उत्पादन करना चाहिए, और मानक अंकन का उपयोग करना चाहिए: R, R ', R2, U, U', U2, F, F ', F2। आप अधिक जानकारी यहाँ पा सकते हैं । आरयूएफ सबसेट के लिए प्रतिबंध 2x2 घन (संकेत: नीचे-पीछे-बाएं कोने को काम करने के लिए एक निश्चित आधार के रूप में मानते हैं) के लिए मानक है।
• आपका कोड पॉकेट क्यूब के सभी संभावित क्रमपरिवर्तन को हल करने में सक्षम होना चाहिए।
• प्रत्येक समाधान को पूरा करने के लिए 30 सेकंड से कम समय लेना चाहिए।
• प्रत्येक समाधान 30 चालों से कम होना चाहिए।
• हमेशा 20 चालों से कम जवाब देने वाले समाधानों के लिए -20% का बोनस दिया जाएगा (कृपया अपने जवाब में इसका विज्ञापन दें ताकि मैं इसकी पूरी जाँच कर सकूँ)
• -50% का बोनस कोड के लिए दिया जाएगा जो हमेशा एक इष्टतम समाधान प्रदान करता है। - फिर से, कृपया अपने उत्तर में विज्ञापन दें
• समाधान में एक ही चेहरे पर दो लगातार चाल नहीं होनी चाहिए, क्योंकि उन्हें आसानी से एक चाल में जोड़ा जा सकता है।
• समाधान में वैकल्पिक रूप से एक एकल स्थान हो सकता है - और केवल एक स्थान - प्रत्येक चाल के बीच।
• संपूर्ण समाधान अनुक्रम, यदि आवश्यक हो, कोष्ठक, उद्धरण चिह्नों, ब्रेसिज़, कोष्ठक या देखभाल की एक जोड़ी में शामिल किया जा सकता है, लेकिन किसी अन्य बाहरी आउटपुट की अनुमति नहीं है।
• कृपया अपने कोड का संक्षिप्त टिप्पणी संस्करण या अपने कोड का संपूर्ण विवरण प्रदान करें।
• बाहरी फ़ाइलों का कोई उपयोग नहीं। इसमें इस तरह की समस्या के लिए इंटरनेट, डेटा टेबल और लाइब्रेरी / पैकेज शामिल हैं।
• बाइट काउंट जीत से सबसे छोटा कोड।
• विजेता ने बुधवार (30 जुलाई, 2014) को चुना।

Comments

हमारे पास 2x2, और 3x3 , और 4x4 हैं , लेकिन मैं अभी भी चमकने के अपने मौके के लिए 1x1 चुनौती की प्रतीक्षा कर रहा हूं। मैं एक आदर्श एल्गोरिथ्म है!

— दरवाज़े

यहाँ K में एक ~ 500 वर्ण सॉल्वर है, जो इष्टतम (= सबसे छोटा) समाधान भी उत्पन्न करता है: speed.com/.com/um /…

— Jakube

30 सेकंड के लिए यह पर्याप्त होना चाहिए कि यह दिज्क्स्त्र का उपयोग करते हुए बलपूर्वक करें: केवल 3674160 पद हैं।

— पीटर टेलर

1. मुझे लगता है कि आउटपुट में व्हॉट्सएप पर कोई प्रतिबंध नहीं हैं। 2. उद्देश्य के लिए, आपको "विवेकाधीन" के रूप में छोड़ने के बजाय 20 से कम चाल के समाधान के लिए बोनस को परिभाषित करना चाहिए।

— लेवल रिवर सेंट

@steveverrill ने इसे ठीक किया। व्हाट्सएप के स्पेसिफिकेशन को भी जोड़ा। धन्यवाद!

— काइल मैककॉर्मिक

Answer 1

पायथन 2.7: 544 बाइट्स -50% = 272 बाइट्स **

import sys;o=''.join;r=range;a=sys.argv[1];a=o([(' ',x)[x in a[12]+a[19]+a[22]] for x in a]);v={a:''};w={' '*4+(a[12]*2+' '*4+a[19]*2)*2+a[22]*4:''}
m=lambda a,k:o([a[([0x55a5498531bb9ac58d10a98a4788e0,0xbdab49ca307b9ac2916a4a0e608c02,0xbd9109ca233beac5a92233a842b420][k]>>5*i)%32] for i in r(24)])
def z(d,h):
 t={}
 for s in d[0]:
  if s in d[1]:print d[h][s]+d[1-h][s];exit()
  n=[d[0][s],'']
  for k in r(3):
   for j in r(3):s=m(s,k);t[s]=n[h]+'RUF'[k]+" 2'"[(j,2-j)[h]]+n[1-h]
   s=m(s,k)
 d[0]=t;return d
while 1:v,w=z([v,w],0);w,v=z([w,v],1)

Stackexchange कई व्हाट्सएप के साथ टैब को बदलता है। तो तकनीकी इस संस्करण में 549 बाइट्स हैं। बस सारणी में पहले दो स्थानों को 6-10 लाइनों में बदलें।

मेरे कार्यक्रम के पीछे आइडिया: मेरा पहला विचार एक सांस पहले खोज था। लेकिन इसमें बहुत समय लगा। एक कठिन (11 चाल इष्टतम) हाथापाई के लिए लगभग 2 मिनट। इसलिए मैंने दोनों तरफ से समस्या का फैसला किया। मैं दो सेट का उपयोग करता हूं। मैं क्रमिक रूप से सभी राज्यों की दूरी 1,2,3, ... स्क्रैम्बल के साथ उत्पन्न करता हूं और उन्हें सेट 1 में सहेजता हूं, और साथ ही सभी राज्य 1,2,3 की दूरी के साथ ... हल किए गए राज्य और उन्हें बचाते हैं। सेट 2 में। पहली बार किसी राज्य में दोनों सेट हैं, हमने इसका हल ढूंढा।

इसके लिए मुझे हल किए गए क्यूब के रंगों की आवश्यकता है, जो ज्ञात नहीं हैं। १३, २० और २३ वर्ण बाएं, पीछे और नीचे रंग को परिभाषित करते हैं। लेकिन ये 3 रंग घन का प्रतिनिधित्व करने के लिए पर्याप्त हैं। मैं बस अन्य 3 रंगों को व्हाट्सएप से बदल देता हूं और मैं अपने हल किए गए राज्य को '____ll____bbll____dddd' के रूप में प्रदर्शित कर सकता हूं।

ओह, और क्रमपरिवर्तन को छोटा करने के लिए मैंने /codegolf//a/34651/29577 से एक विचार का उपयोग किया

Ungolfed संस्करण:

import sys

#define permutations for R,U,F
permutation = [[0,7,2,15,4,5,6,21,16,8,3,11,12,13,14,23,17,9,1,19,20,18,22,10],
            [2,0,3,1,6,7,8,9,10,11,4,5,12,13,14,15,16,17,18,19,20,21,22,23],
            [0,1,13,5,4,20,14,6,2,9,10,11,12,21,15,7,3,17,18,19,16,8,22,23]]

def applyMove(state, move):
    return ''.join([state[i] for i in permutation[move]])

scramble = sys.argv[1]
#remove up,front,rigth colors
scramble = ''.join([(' ', x)[x in scramble[12]+scramble[19]+scramble[22]] for x in scramble])
solved = ' '*4+scramble[12]*2+' '*4+scramble[19]*2+scramble[12]*2+' '*4+scramble[19]*2+scramble[22]*4

dict1 = {scramble: ''} #stores states with dist 0,1,2,... from the scramble
dict2 = {solved: ''} #stores states with dist 0,1,2,... from the solved state

moveName = 'RUF'
turnName = " 2'"

for i in range(6):
    tmp = {}
    for state in dict1:
        if state in dict2:
            #solution found
            print dict1[state] + dict2[state]
            exit()
        moveString = dict1[state]
        #do all 9 moves
        for move in range(3):
            for turn in range(3):
                state = applyMove(state, move)
                tmp[state] = moveString + moveName[move] + turnName[turn]
            state = applyMove(state, move)
    dict1 = tmp
    tmp = {}
    for state in dict2:
        if state in dict1:
            #solution found
            print dict1[state] + dict2[state]
            exit()
        moveString = dict2[state]
        #do all 9 moves
        for move in range(3):
            for turn in range(3):
                state = applyMove(state, move)
                tmp[state] = moveName[move] + turnName[2 - turn] + moveString
            state = applyMove(state, move)
    dict2 = tmp

मैं परिणाम से बहुत खुश हूं, क्योंकि मैं पायथन के लिए काफी नया हूं। यह मेरे पहले अजगर कार्यक्रमों में से एक है।

संपादित करें: आधा साल बाद: 427 - 50% = 213.5

पायथन में और गोल्फिंग में थोड़ा अधिक अनुभव प्राप्त किया। इसलिए मैंने अपने मूल कोड को संशोधित किया और 100 से अधिक चरित्र बचा सकता था।

import sys;o=''.join;a=sys.argv[1];d=[{o((' ',x)[x in a[12]+a[19]+a[22]]for x in a):[]},{' '*4+(a[12]*2+' '*4+a[19]*2)*2+a[22]*4:[]}]
for h in[0,1]*6:
 for s,x in d[h].items():
  for y in range(12):
   d[h][s]=x+[y-[1,-1,1,3][h*y%4]];
   if s in d[1-h]:print o('RUF'[x/4]+" 2'"[x%4]for x in d[0][s]+d[1][s][::-1]);exit()
   s=o(s[ord(c)-97]for c in'acahabcdnpbfegefhugiovjgqkciljdeklflmmmnnvoopxphrqdjrrbsstttuuqsviwwwkxx'[y/4::3])

मैं मूल रूप से ठीक उसी दृष्टिकोण का उपयोग करता हूं। सबसे बड़ा परिवर्तन यह है, कि मैं अब किसी फ़ंक्शन को परिभाषित नहीं करता हूं। के बजाय

def z(d,h):
 for s in d[0]:
  if s in d[1]:...
while 1:v,w=z([v,w],0);w,v=z([w,v],1)

मैं कर सकता हूँ

for h in[0,1]*6:
 for s in d[h]:
  if s in d[1-h]:...

साथ ही मैंने चाल लमडा को थोड़ा बदल दिया। पहले शोर्ट, और फिर सीधे कोड को एकीकृत किया, क्योंकि फ़ंक्शन कॉल केवल एक बार दिखाई देता है।

मैं प्रत्येक राज्य के लिए 0 और 11 के बीच संख्याओं की एक सूची रखता हूं, जो चालों का प्रतिनिधित्व करता है, बजाय एक चाल युक्त स्ट्रिंग के। संख्याएं बहुत अंत में परिवर्तित हो जाती हैं।

इसके अलावा, मैंने दो फॉर-लूप 'for k in r(3):for j in r(3):को एक में जोड़ दिया for y in r(12)। इसलिए मुझे भी मूव्स करने होंगे U4, R4, F4। बेशक इस तरह के एक कदम सबसे कम समाधान में प्रकट नहीं होता है, इसलिए " 2'"[x%4]काम करता है। (यदि x % 4 == 3, कोई अपवाद सीमा से बाहर का सूचकांक होगा)

यह थोड़ा तेज भी है, क्योंकि मैं पहले दूसरे सेट में प्रवेश की तलाश में हूं। 11 चाल के समाधान के लिए लगभग 0.5 सेकंड।

Comments

द्विदिश bfs - मेरे पसंदीदा खोज एल्गोरिथ्म (आईडीए के बगल में) का उपयोग करने के लिए बनाया गया। यदि समय अनुमति देता है, तो मैं इसे कुछ घंटों में इष्टतमता के लिए परीक्षण करूंगा। इसके अलावा, मुझे महसूस नहीं हुआ कि पहेली को हल करने के लिए आपको U / R / F रंगों की आवश्यकता नहीं है। अच्छी तरह से किया!

— काइल मैककॉर्मिक

शुद्धता और अनुकूलता के लिए मेरे 20 परीक्षण मामलों के लिए पारित।

— काइल मैककॉर्मिक

बहुत अच्छा .. 24 से अधिक तेजी से लागू करने के लिए मेरी मदद की! js में एकल दिशात्मक bfs

— RE60K

वास्तव में '____ll____bbll____dddd' '____ll____bbll____bbdddd' होना चाहिए

— RE60K

Answer 2

सी, 366 - 50% इष्टतम बोनस = 183

char c[99],t[3][26]={"ZGONFZCPTEZBHUMZ","ZIQPHZRUGAZJWOCZ","ZACB@ZJHFDZKIGEZ"};r=20;f(int m,int n){int e,i,j;for(i=4;i--;){for(j=15;j--;)c[t[n][j+1]]=c[t[n][j]];c[m]="FRU"[n],c[m+1]="4'2 "[i],c[m+2]=0;for(e=0,j=68;j<76;j++) e+= (c[j]!=c[j+8]) + (c[j]!=c[j^1]);i&&e&&e<45-m*2&m<r?f(m+2,(n+1)%3),f(m+2,(n+2)%3):e||(puts(c),r=m);}}main(){scanf("%s",c+64);f(0,2),f(0,1),f(0,0);}

पुनरावर्तन का उपयोग करते हुए, प्रोग्राम 11 तक के पेड़ के माध्यम से खोज करता है गहरी ( http://en.wikipedia.org/wiki/Pocket_Cube और नीचे उल्लिखित पृष्ठ के अनुसार एक इष्टतम विलेय की अधिकतम लंबाई ) और जब यह एक समाधान पाता है यह इसे (22 अक्षरों तक लंबा, फंक्शन लॉजिक द्वारा ट्रैक किया गया है m) प्रिंट करता है । उपयोग किया जाने वाला ऑर्डर एक तरह का डिक्शनरी ऑर्डर है, जिसमें यू, यू 2, यू 'के सभी मार्गों की खोज की जाती है, जो आर या एफ शुरू करने वाले किसी भी मार्ग की खोज करते हैं। इस प्रकार यह आवश्यक नहीं है कि पहले इष्टतम समाधान मिल जाए।

जब एक समाधान मुद्रित किया जाता है, rतो उसके बराबर बनाया जाता है, mजो यह सुनिश्चित करता है कि केवल समान या छोटे समाधान बाद में मुद्रित किए जाएंगे। पुट लगाना r=m-2एक अतिरिक्त 2 वर्णों की लागत को सुनिश्चित करता है, लेकिन यह पाया जाता है कि प्रत्येक लंबाई का केवल एक ही हल (इष्टतम से नीचे) मुद्रित होता है। यदि आप चाहते हैं कि यह केवल इष्टतम समाधान दिखाए, तो अब तक पाया गया सबसे अच्छा समाधान एक चर के लिए संग्रहीत किया जाना चाहिए, और कार्यक्रम के अंत में मुद्रित इष्टतम समाधान (यह एक अतिरिक्त 15 वर्णों के बारे में होगा।)

इनपुट c[]64 सूचकांक से सरणी में पढ़ा जाता है । यह मूवमेंट में वर्णमाला वर्णों का उपयोग करने के लिए आवश्यक है। प्रश्न के अनुसार X के माध्यम @से प्रतीकों Wका उपयोग किया जाता है, क्योंकि समाधान कार्य के लिए परीक्षण करने के लिए सम संख्या पर शुरू करना आवश्यक है। c['Z']अस्थायी भंडारण के लिए भी उपयोग किया जाता है, क्योंकि 4-गुना रोटेशन करने के लिए कुल 5 असाइनमेंट की आवश्यकता होती है। क्योंकि इसका पहला हिस्सा c[]अप्रयुक्त है, यह समाधान को संग्रहीत करने के लिए उपलब्ध है (जिसे शून्य बाइट के साथ समाप्त किया जाता है, जैसे कि सभी सी स्ट्रिंग)।

for(i..)द्वारा निर्दिष्ट चेहरे के 4 तिमाही के अनुक्रम के माध्यम से जाता है n।

पहला for(j..)टेबल के अनुसार वास्तविक स्वैपिंग करता है t[]।

यह जांचने के लिए कि क्या क्यूब हल किया गया है, केवल चार पक्ष के चेहरे की जांच करना आवश्यक है। यूआरएफ और डीएफआर के टुकड़ों को यू और डी स्टिकर हटाए जाने के साथ भी अलग किया जा सकता है, क्योंकि एक टुकड़ा एक्सआरएफ को घड़ी की दिशा में और दूसरे एक्सएफआर को पढ़ता है। यदि दो टुकड़े आपस में जुड़े हुए हैं, ताकि U नीचे वाले चेहरे पर दिखाई दे और इसके विपरीत, F रंग दाहिने चेहरे पर दिखाई दे और इसके विपरीत।

दूसरा for(j..)चार भुजाओं वाले चेहरे पर बेमेल की संख्या गिनता है। उदाहरण के लिए सामने वाले के सामने यह G & O, H & P, और G & H (दो बार) की तुलना करता है। यदि e== 0, घन हल हो गया है। यदि e<9 या e<13, तो अगले एक चाल या क्रमशः 2 चालों में घन को हल करना संभव हो सकता है। अन्यथा निश्चित रूप से इस संख्या में चालों में घन को हल करना संभव नहीं है। समय बचाने के लिए, इस अनुमानी का उपयोग खोज पेड़ को चुभाने और उन 10 या 11 की गहराई वाली कई शाखाओं पर समय बर्बाद करने से बचने के लिए किया जाता है जो अनुपयुक्त होगा। एक सूत्र के रूप में व्यक्त, यह बन जाता है e<45-m*2।

अघोषित कोड

char c[99],t[3][26]={"ZGONFZCPTEZBHUMZ","ZIQPHZRUGAZJWOCZ","ZACB@ZJHFDZKIGEZ"};
r=20;                                                       //All moves are output as 2 characters. The index of the last move of the longest solution (11 moves) shall be 20.

f(int m,int n){                                             //perform a cycle through four 1/4 turns of the face specified in n. The index of the move reported in the solution is m.
  int e,i,j;                                                //e is for counting mismatches. i loops through the four 1/4 turns. j performs other functions.
  for(i=4;i--;){

    for(j=15;j--;)c[t[n][j+1]]=c[t[n][j]];                  //A 1/4 turn is performed as three 4-sticker rotations of the type z=a;a=b;b=c;c=d;d=z using the data in the movetable t[][]

    c[m]="FRU"[n],c[m+1]="4'2 "[i],c[m+2]=0;                //Write to the output in c[] the face to be turned and the number of 1/4 turns. Terminate with a zero byte to overwrite any longer solution that may have been found before. 

    for(e=0,j=68;j<76;j++)e+=(c[j]!=c[j+8])+(c[j]!=c[j^1]); //Compare each sticker of the top row of the side faces (64+4 through 64+11) with the stickers below and beside it. Count the number of mismatches.

    i && e && e<45-m*2 & m<r?                               //if the number of 1/4turns is not 4 AND the cube is not solved AND the heuristic (as described in the text) is good AND a shorter solution has not already been found,
      f(m+2,(n+1)%3), f(m+2,(n+2)%3):                       //deepen the search to another faceturn of the other two faces. 
      e||(puts(c),r=m);                                     //otherwise, if a solution has been found, print the solution and reduce the value of r to the new max solution length.
  } 
}

main(){
  scanf("%s",c+64);                                         //scan in the current cube state to c[] at index 64.
  f(0,2),f(0,1),f(0,0);                                     //call f() three times to search for solutions beginning with U R and F.
}

प्रदर्शन

कार्यक्रम http://www.jaapsch.net/patalog/cube2.htm पर पैटर्न 1 से 13 के साथ परीक्षण किया गया था

परिणाम इस प्रकार हैं कि मेरी मशीन पर सभी इष्टतम समाधान खोजने के लिए समय दें (जिज्ञासु दिमाग के लिए।) इसके अलावा अधिक जटिल पदों के लिए, 2-बाइट संशोधन के लिए समय दिया गया है जो ऊपर उल्लिखित है जो सिर्फ एक इष्टतम समाधान ढूंढता है। इसके लिए पहले समाधान खोजने और कार्यक्रम को समाप्त करने के लिए दोनों समय दिए गए हैं। दिए गए समाधान (जो आम तौर पर लिंक्ड पेज पर जनरेटर को उलट कर प्राप्त किए गए समाधानों के लिए भिन्न होते हैं) को एक ऑनलाइन क्यूब सिम्युलेटर के साथ सत्यापित किया गया है।

U 4 (1 move) horizontal flags (not mirror symmetric)
1 solution 1 sec

U2 (1 move) 4 horizontal flags (mirror symmetric)
1 solution 1 sec

F2 R2 F2 (3 moves) 4 vertical flags  
UUUULRBFRLFBLRBFRLFBDDDD 2 solutions 1 sec

U2 F2 R2 U2 (4 moves) Supertwist; 6 flags
DDUURRBFRRFBLLBFLLFBUUDD 3 solutions 1 sec

U F2 U2 R2 U (5 moves) 4 vertical flags, 2 checkerboards
UDDULBRFRFLBLBRFRFLBUDDU 2 solutions 1 sec

R2 F2 R2 U2 (4 moves) 4 checkerboards
UUUURLFBLRBFLRBFRLFBDDDD 4 solutions 1 sec

R U2 R' F2 R U' R2 U F2 U' (10 moves) Cube in cube
FFFUDDRFRULLLDRRUULBBBDB 18 solutions 26 sec; 1 solution U F2U'R2U R'F2R U2R' 1,13 sec 

R F U' R2 U F' R U F2 R2 (10 moves) Cube in cube 2
DDDUFFLFRBRRLFLLBBRBUUDU 8 solutions 28 sec; 1 solution R F U'R2U F'R U F2R2 12,21 sec 

U R F2 U R F2 R U F' R (10 moves)3-Cycle
UFFULDRFRULBLLFRURBBDBDD 45 solutions 26 sec; 1 solution U R'F U'F'R'F2U R F2 8,14 sec 

U R U' R2 U' R' F' U F2 R F' (11 moves) Column turn
UUUDLLFRFRBBLLFRFRBBDUDD many solutions 29 sec; 1 solution U R U'F U2R F'R'F'U2F' 3,27 sec 

F' U R' F2 U' R F U R2 U R' (11 moves)Corner swap
UUUURLFBLRBFLLFFRRBBDDDD 29 sec 24 solutions; 1 solution R U'F R U'R2U'F'R'U F2 12,28 sec

U F2 U' (3 moves) Zig-zag 
UDUDLLFRFFLBLBRRFRBBUUDD 1 solution 1 sec 

U' F2 U2 R2 U' F2 U2 R2 U' (9 moves) 2 Checkerboards, 4 L
DUUDLLFBRRBFLRFFRLBBUDDU 8 solutions 13 sec; 1 solution U F2U2R2U R2U2F2U' 1,5 sec

Comments

बढ़िया है। मैं यहां एक करीबी प्रतियोगिता देखना पसंद करूंगा।

— काइल मैककॉर्मिक

@KyleMcCormick मेरा कार्यक्रम अंत में समाप्त हो रहा है और अच्छी तरह से चल रहा है, लेकिन मुझे लगता है कि आप प्रतीक्षा करते-करते थक गए और दूसरे उत्तर को स्वीकार कर लिया। यह मेरी पोस्ट से 2 दिन पहले की तुलना में बहुत बेहतर है जिसमें एक बग था (गलत तरीके से मुड़ने वाले चेहरे।) इसके अलावा, हेयुरिस्टिक को 2 स्तरों पर लागू करने से गति में सुधार हुआ है। यह अभी भी कई समाधानों का उत्पादन करता है, लेकिन अंतिम समाधान इष्टतम होने की गारंटी है (पाठ में संभावित उत्पादन परिवर्तनों पर अधिक।) यह अन्य सबमिशन की तुलना में बहुत कम है। यदि आपके पास आउटपुट प्रारूप पर कोई समस्या है तो मुझे बताएं।

— लेवल रिवर सेंट

बुनियादी गोल्फ के माध्यम से 358 बाइट्स ।

— एमडी एक्सएफ