आपकी कार केवल सही हो जाती है!

Question

परिचय

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

यांत्रिकी

आपकी कार 8x8 मैप के ऊपरी-बाएँ कोने में शुरू होती है, और निचले-दाएँ कोने में सुरक्षा के लिए कोशिश कर रही है। कार में एक अभिविन्यास है (शुरू में दाईं ओर), 90-डिग्री वेतन वृद्धि में मापा जाता है। कार दो कार्यों में से एक कर सकती है:

1. एक वर्ग को आगे बढ़ाएं, या
2. 90 डिग्री को दक्षिणावर्त घुमाएं, फिर एक वर्ग को आगे बढ़ाएं

ध्यान दें कि कार एक एकल वर्ग पर 180 डिग्री की बारी करने के लिए तेजी से चालू करने में असमर्थ है।

कुछ वर्ग बाधाएं हैं। यदि कार एक बाधा वर्ग में प्रवेश करती है, तो यह दुर्घटनाग्रस्त हो जाती है। 8x8 कोर्स के बाहर की सभी चीजों को बाधा माना जाता है, इसलिए कोर्स को बंद करना दुर्घटनाग्रस्त होने के बराबर है।

निचला-दायां वर्ग सुरक्षित वर्ग है, जो कार को बाधा कोर्स से बचने की अनुमति देता है। शुरुआती वर्ग और सुरक्षित वर्ग को बाधा नहीं माना जाता है।

कार्य

आपको एक प्रोग्राम या फ़ंक्शन लिखना होगा जो इसके इनपुट के रूप में 8x8 सरणी (मैट्रिक्स, सूचियों की सूची, आदि) के रूप में लेता है, बाधा कोर्स का प्रतिनिधित्व करता है। कार्यक्रम एक बूलियन, या कुछ इसी तरह की सच्चाई देता है। अगर दुर्घटनाग्रस्त हुए बिना कार को सुरक्षित चौक पर पहुंचाना संभव है (यानी, अगर नक्शा सॉल्व है), तो आउटपुट है True, अन्यथा, यह है False।

स्कोरिंग

मानक कोड गोल्फ नियम - विजेता सबसे कम बाइट्स वाला कोड है।

बोनस:

• यदि, एक सॉल्व करने योग्य मानचित्र के लिए, आपका कोड ड्राइवर इनपुट की एक वैध श्रृंखला को आउटपुट करता है जो कार को सुरक्षित वर्ग के लिए निर्देशित करता है, तो आपके स्कोर से 10 प्रतिशत अंक काट लेता है। एक उदाहरण आउटपुट प्रारूप हो सकता है SRSSR(सीधे, सीधे, सीधे, सीधे इंगित करते हुए)। यह आउटपुट मानक आउटपुट को प्रतिस्थापित करेगा True।

• यदि, एक बेकार नक्शे के लिए, आपके कोड का आउटपुट उन स्थितियों के बीच अंतर करता है, जहां कोई दुर्घटना अपरिहार्य है, और ऐसी परिस्थितियां जहां बाधा कोर्स के आसपास हमेशा ड्राइव करना संभव है, तो अपने स्कोर से 10 प्रतिशत अंक काट लें। एक उदाहरण आउटपुट हो सकता है Crashयदि कोई दुर्घटना अपरिहार्य है, या Stuckयदि कार हमेशा के लिए बाधा कोर्स में फंस गई है। ये आउटपुट एक मानक Falseनक्शे के लिए मानक आउटपुट को बदल देगा ।

उदाहरण

यदि प्रोग्राम को इस तरह से एक 8x8 सरणी दिया जाता है:

[[0, 0, 0, 0, 0, 1, 0, 0],
 [0, 0, 0, 0, 0, 0, 1, 0], 
 [1, 1, 0, 0, 0, 0, 0, 0], 
 [0, 1, 0, 1, 0, 0, 0, 0], 
 [0, 0, 1, 1, 0, 0, 0, 0], 
 [0, 0, 0, 0, 1, 0, 1, 0], 
 [0, 0, 0, 0, 0, 0, 1, 0], 
 [0, 1, 1, 0, 0, 0, 1, 0]]

इसकी व्याख्या इस तरह के नक्शे के रूप में की जाएगी, जिसमें काले वर्ग बाधाओं का संकेत देते हैं:

और एक संभावित समाधान हो सकता है:

चूंकि एक समाधान मौजूद है, कार्यक्रम को Trueइस नक्शे के लिए वापस लौटना चाहिए / प्रिंट करना चाहिए । यहाँ दिखाए गए चालों का क्रम है SSSSRSRRRSRSSRRRSSRSSS।

Comments

मैंने कुछ अविश्वसनीय रूप से सरल परीक्षण मामलों को लिखा Crashऔर Stuck। वे यहाँ हैं क्योंकि वे कितने समय से हैं। रो 2 भरा, बाकी सब खाली -> Crash। पंक्ति 7 भरी, बाकी सब खाली ->Stuck

— भूमिगत

मैं प्रतिशत अंक (प्रतिशत के विपरीत) के बारे में उलझन में हूं । या तो बोनस प्राप्त करना आपके स्कोर को 0.9 से गुणा करता है। क्या दोनों को 0.8 या 0.9 ^ 2 से गुणा करना है?

— अंडरग्राउंडोरेल

ज़रूर, एस और सी ठीक हैं। मेरे आउटपुट केवल सुझाव थे।

— फोसजेन

"दो गलतियाँ एक अधिकार नहीं बनाती हैं, लेकिन तीन लेफ़्ट करती हैं।" - पिता।

— होसियरईई

"आपकी कार केवल शून्य या तीन लेफ़्ट कर सकती है!"

— feersum

Answer 1

जावास्क्रिप्ट (ईएस 6) - 122 124 148 162 172 178 187 190 193 208 बाइट्स

इस कोड को बेहतर बनाने के लिए उपयोगी सुझाव के लिए ऑप्टिमाइज़र और डॉकमैक्स को बहुत धन्यवाद:

F=a=>(D=(x,y,d)=>!D[i=[x,y,d]]&&(D[i]=1,x-=~d%2,y-=~-~d%2,x*y==49||!((x|y)&8||a[y][x])&&(D(x,y,d)||D(x,y,~-d%4))),D(-1,0))

trueसॉल्वेबल के लिए रिटर्न (सत्य) और falseबेकार के लिए (झूठा)।

आज के समय में केवल फ़ायरफ़ॉक्स में ही काम करता है।

टेस्ट बोर्ड

Comments

यह 193 बाइट्स है D=(x,y,d,t,a)=>!t[i=x+y*8+d*64]&&(t[i]=1,x+=d==0?1:d==2?-1:0,y+=d==1?1:d==3?-1:0,x==7&&y==7||!((x|y)&~7||a[y][x])&&G(x,y,d,t,a));G=(x,y,d,t,a)=>D(x,y,d,t,a)||D(x,y,d+1&3,t,a);F=a=>G(0,0,0,[],a):।

— ऑप्टिमाइज़र

172: D=d=>!t[i=x+y*8+d/4]&&(t[i]=1,x+=d?d^2?0:-1:1,y+=d^1?d^3?0:-1:1,x==7&&y==7||!((x|y)&~7||b[y][x])&&G(x,y,d));G=(X,Y,d)=>D(d,x=X,y=Y)||D(d+1&3,x=X,y=Y);F=a=>G(0,0,0,b=a,t={})- परीक्षण किया गया।

— ऑप्टिमाइज़र

@Optimizer मैं अभी भी दूसरे परीक्षण के मामले के लिए सच हो रहा हूँ [[0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0]]। वह असत्य देना चाहिए।

— मैं और मेरी बिल्ली 15

ऐसा इसलिए है क्योंकि दोनों ग्लोबल्स हैं xऔर yआप पृष्ठ को फिर से लोड करने से पहले दो टेस्टकेस नहीं चला सकते हैं ...

— ऑप्टिमाइज़र

आप के x+=d?d^2?0:-1:1साथ x+=d&1?0:1-dऔर के y+=d^1?d^3?0:-1:1साथ कुल 9 और अधिक बचा सकता है y+=d&1&&2-d।

— डॉकमैक्स

Answer 2

अजगर 2 - 123 125 133 146 148 150 154 160

Trueसफलता पर, Falseअसफलता पर।

def f(h=1,v=0,b=0,x=0,y=0,c=[]):s=x,y,h,v;a=b,x+h,y+v,c+[s];return(s in c)==(x|y)&8==b[y][x]<(x&y>6or f(h,v,*a)|f(-v,h,*a))

आपको इनपुट की आपूर्ति करनी चाहिए f(b=var_containing_board)।

लैंबडा संस्करण - 154

सफलता के लिए 0, असफलता के लिए रिटर्न (मिथ्या) True।

F=lambda b,x=0,y=0,h=1,v=0,c=[]:0if[x,y,h,v]in c or x|y>7or x|y<0 or b[y][x]else x&y==7or F(b,x+h,y+v,h,v,c+[[x,y,h,v]])or F(b,x+h,y+v,-v,h,c+[[x,y,h,v]])

समारोह और मेमने की तुलना में कम बनाने के लिए विल और ब्रैंडन का धन्यवाद। इसके अलावा अधिक क्षैतिज स्क्रॉलिंग जोड़ने के लिए: डी

बेहतर बिट-कोशिंग और तर्क के लिए xnor का धन्यवाद!

नोट संपादित करें: मुझे पूरा विश्वास है कि b[y][x]कभी भी सीमा से बाहर जाने पर इसे निष्पादित नहीं किया जाएगा। चूंकि हम बोर्ड से बाहर हैं, इसलिए इतिहास की जाँच s in cहोगी False। फिर बाउंड्री चेक (x|y)&8होगी 8। फिर अजगर अंतिम मूल्य की भी जांच नहीं करेगा ==क्योंकि पहले दो पहले से ही अलग हैं।

Comments

कार्यात्मक संस्करण दोनों ifs को संयोजित कर सकता है जो दोनों वापस लौटते हैं; के रूप में वापसी अकेले कोई भी जो falsy है देता है, तो आप भी पक्ष लौटने .just 0. वापस जाने के लिए की जरूरत नहीं है;)

— विल

यदि आप चैक फ्लिप करते हैं तो आप दोनों को जोड़ सकते हैं

— विल

क्या आप दोनों रिटर्न स्टेटमेंट को मिला सकते हैं?

— ब्रैंडन

@ धन्यवाद धन्यवाद, मुझे पता था कि ऐसा करने का एक बेहतर तरीका था: डी उम, मुझे हटाने के लिए कोई रिक्त स्थान नहीं मिला जिससे मुझे सिंटैक्स त्रुटि न हो। मैं वास्तव में x|y>7orकाम x|y<0orनहीं करता है, लेकिन नहीं ...

— FryAmTheEggman

आप एक ऑक्टल शाब्दिक शुरुआत कर सकते हैं 0o।

— ०४ पर feersum

Answer 3

सी (जीएनयू-सी), 163 बाइट्स * 0.9 = 146.7

# सी (जीएनयू-सी), 186 बाइट्स * 0.9 = 167.4

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

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

g(long long o) {
    typeof(o) a=0,i=255,r=1,u=0,l=0,d=0,M=~0LLU/i,D;
    for( ;i--;d = D<<8&~o)
        a |= D = d|r,
        r = (r|u)*2&~M&~o,
        u = (u|l)>>8&~o,
        l = ((l|d)&~M)/2&~o;
    return a<0?:-!(d|r|u|l);
}

परीक्षण कार्यक्रम

f(long long o){typeof(o)a=0,i=255,r=1,u=0,l=0,d=0,M=~0LLU/i,D;for(;i--;d=D<<8&~o)a|=D=d|r,r=(r|u)*2&~M&~o,u=(u|l)>>8&~o,l=((l|d)&~M)/2&~o;return a<0?:-!(d|r|u|l);}
{
    char* s[] = {"Crash", "Stuck", "Escape"};
    #define P(x) puts(s[f(x)+1])
    L ex = 0x4640500C0A034020;
    P(ex);
    L blocked = 0x4040404040404040;
    P(blocked);

    L dead = 0x10002;
    P(dead);

    return 0;
}

उत्पादन

Escape
Stuck
Crash

पायथन एरे-टू-हेक्स कन्वर्टर:

a2b=lambda(A):"0x%X"%sum(A[i/8][i%8]<<i for i in range(64))

Comments

memset(&M,~1,8)(15 वर्णों) को M=~(-1ULL/255)(14 वर्णों) से प्रतिस्थापित करें ।

— आर ..

@ आर .. एक अच्छा! उस से -4 बाइट्स।

— feersum

मुझे इनपुट प्रारूप पसंद है - बहुत अच्छा!

— phosgene

मैं P(0x00fefefefefefefe);= के लिए 'क्रैश' कर रहा हूं (सीधे ऊपरी दाएं, एक मोड़ पर, सीधे कोने में P(0x00eeeeeeeeeeeeee);a

@tolos आपको पंक्ति / स्तंभ-प्रमुख ऑर्डर ट्रांसपोज़ हो गया है। शीर्ष पंक्ति और दायां स्तंभ खुला होने के लिए, यह होना चाहिए 0x7f7f7f7f7f7f7f00। इसके अलावा इसे आरंभ करना आवश्यक है aक्योंकि बाद में इसे केवल अतिरिक्त बिट्स में ओरिंग द्वारा संशोधित किया जाता है, इसलिए मैं शुरू में अवांछित बिट सेट नहीं कर सकता।

— feersum

Answer 4

पायथन, 187 213

207 चार्ट, मुद्रण पथ के लिए 10% बोनस

b=map(ord," "*9+" ".join("".join("o "[i]for i in j)for j in input())+" "*9)
def r(p,d,s):
 p+=(1,9,-1,-9)[d]
 if b[p]&1<<d:b[p]^=1<<d;return(s+"S")*(p==79)or r(p,d,s+"S")or r(p,(d+1)%4,s+"R")
print r(8,0,"")

परीक्षण इनपुट पर यह थोड़ा अलग रास्ता खोजता है: SSSSRSRSRRSSRSSRRSRSSRSSSSS

सामान्य दृष्टिकोण पहले इनपुट को एक रिक्त स्थान में बदलना है और oएस। रिक्त स्थान का एक हेक्स होता है 20, इसलिए सभी चार निचले बिट्स परेशान होते हैं। oकी एक हेक्स है 6F, इसलिए कम चार बिट्स सभी सेट हैं।

एस की एक सीमा oबोर्ड के चारों ओर रखी गई है ताकि हमें खराब सूचकांकों के बारे में चिंता न करनी पड़े।

जैसा कि हम बोर्ड पर चलते हैं, हम प्रत्येक टाइल में बिट्स का उपयोग करते हैं यह देखने के लिए कि क्या हमें उस तरफ से आने के दौरान पारित करने की अनुमति है। इस तरह, हम अनंत छोरों से बचते हैं। इसकी प्रति टाइल एक एकल बूलियन के लिए पर्याप्त नहीं है, क्योंकि आपकी निकास दिशा आपकी प्रवेश दिशा पर निर्भर करती है, इसलिए टाइलों का दो बार दौरा किया जा सकता है।

हम फिर एक सुरक्षित रास्ते की खोज करते हैं।

Comments

"आपकी कार 8x8 मानचित्र के ऊपरी-बाएँ कोने में शुरू होती है" - क्या आप 9इसके स्थान पर हार्डकोड नहीं कर सकते हैं w=len(b[0])+1, आदि?

— FryAmTheEggman

@FryAmTheEggman धन्यवाद, मैं इसे कैसे अनदेखा कर सकता था? : D

— होगा

आप अपने त्रिगुट बयान रिवर्स और जगह ले सकता है p==79के साथ p-79। मैं एक वाक्यविन्यास त्रुटि से पहले दोनों जगह के बिना यह कर रहा है else। मुझे लगता है कि ट्रिक केवल साथ काम करती है if।

— FryAmTheEggman

@FryAmTheEggman मुझे लगता है कि गहराई परीक्षण से पहले पुनरावृत्ति होना है? मैं इसके बजाय बूलियन द्वारा गुणा के साथ खेल रहा हूं।

— विल

मैं सिर्फ एक बहुत साफ चाल पाया। आप शायद जानते हैं कि -~x== x+1लेकिन दोनों एकात्मक संचालकों में गुणन, विभाजन और मापांक की तुलना में अधिक पूर्वता है! तो (d+1)%4हो सकता है -~d%4! यह भी काम करेगा x-1लेकिन ~-xइसके बजाय सिर्फ उपयोग करें ।

— FryAmTheEggman

Answer 5

जावास्क्रिप्ट - 270 - 20% = 216 262 - 20% = 210 बाइट्स

चूंकि कम से कम एक समाधान होना चाहिए जो दोनों बोनस कमाता है (और एक हास्यास्पद स्टैक गहराई तक नहीं जाता है;) ...

न्यूनतम किया गया:

V=I=>{n=[N=[0,0,0]];v={};v[N]='';O='C';for(S='';n[0];){m=[];n.map(h=>{[x,y,d]=h;D=i=>[1,0,-1,0][d+i&3];p=v[h];for(j=2;j--;){O=v[c=[X=x+D(j),Y=y+D(3-3*j)),d+j&3]]?'K':O;J=X|Y;J<0||J>7||I[Y][X]||v[c]?O:(m.push(c),v[c]=p+'SR'[j])}S=(x&y)>6?p:S});n=m;}return S||O;};

विस्तारित:

V = I => {
    n = [N=[0,0,0]];
    v = {};
    v[N] = '';
    O = 'C';

    for( S = ''; n[0]; ) {
        m = [];
        n.map( h => {
            [x,y,d] = h;
            D = i => [1,0,-1,0][d+i&3];
            p = v[h];
            for( j = 2; j--; ) {
                O = v[c = [X = x+D(j),Y = y+D(3-3*j),d+j&3]] ? 'K' : O;
                J = X|Y;
                J<0 || J>7 || I[Y][X] || v[c] ? O : (
                    m.push( c ),
                    v[c] = p + 'SR'[j]
                );
            }

            S = (x&y) > 6 ? p : S;
        } );
        n = m;
    }
    return S || O;
};

vकुंजियों के साथ एक हैशटेबल है जो (x,y,d)(x, y) समन्वय और प्रवेश की दिशा के अनुरूप राज्य त्रिक हैं d। प्रत्येक कुंजी में एक संबद्ध मान होता है जो कुंजी द्वारा दर्शाए गए राज्य तक पहुंचने के लिए आवश्यक S(स्ट्रेट) और R(दाईं ओर) चालें हैं।

यह कोड उन त्रिगुणों (वैरिएबल n) का ढेर भी रखता है जिन्हें अभी तक संसाधित नहीं किया गया है। स्टैक में शुरू में केवल ट्रिपल (0,0,0) होता है, राज्य के अनुरूप जहां कार (0,0) सेल में सही बैठती है। बाहरी लूप में for( S = ... ), रूटीन चेक करता है कि क्या कोई अनप्रोसेस्ड ट्राइसेप्स बना रहता है। यदि हां, तो यह, भीतरी लूप के माध्यम से प्रत्येक असंसाधित ट्रिपल चलाता है n.map( ...।

भीतर का पाश पाँच काम करता है:

1. वर्तमान स्थिति से दो संभावित चाल (सीधे चलते हुए, दाएं मुड़ते हुए) की गणना करता है
2. यदि इनमें से कोई भी चाल पहले से ही हैशटेबल में पंजीकृत राज्य की ओर ले जाती है, तो इसे आगे की प्रक्रिया के लिए नजरअंदाज कर दिया जाता है। हम FALSE आउटपुट को ध्वजांकित करते हैं K(हालांकि), क्योंकि हमने कम से कम एक लूप पाया है, जहां कार दुर्घटनाग्रस्त होने के बाद भी हमेशा के लिए जारी रह सकती है।
3. यदि कोई राज्य कानूनी और उपन्यास है, तो उसे बाहरी लूप के अगले पास के लिए हैशटेबल ( v) और अनप्रोसेस्ड ट्राइअन्स ( ) के ढेर में जोड़ा जाता है।m
4. जब नया राज्य पंजीकृत होता है v, तो उसका मूल्य मूल स्थिति (चाल का क्रम) के मान Rया Sवर्तमान चाल के आधार पर निर्धारित होता है
5. यदि xऔर yहैं 7, तो मूल स्थिति (मूल स्थिति तक पहुंचने के लिए उठाए गए चालों का क्रम) के मूल्य को कॉपी किया जाता है S, क्योंकि यह चाल अनुक्रम समस्या का समाधान है

आंतरिक लूप समाप्त होने के बाद, n(स्टैक) को m(नए स्टैक) से बदल दिया जाता है ।

बाहरी लूप समाप्त होने के बाद (कोई नए राज्य नहीं पहुंचे थे), फ़ंक्शन अपना आउटपुट देता है। यदि (7,7) सेल पहुँच गया था, Sतो इस सेल में ले जाने के लिए एक क्रम होगा, और यह आउटपुट है। यदि सेल तक नहीं पहुंचा गया था, Sतो खाली स्ट्रिंग होगी, और रूटीन आउटपुट के माध्यम से गिरता है O, जिसमें K(यदि) लूप पाया गया था और केवल C(क्रैश) होगा, अगर कार अनिवार्य रूप से दुर्घटनाग्रस्त हो जाएगी।

Comments

ओपी से पुष्टि मिली, आप 'क्रैश' और 'अटक' का नाम बदलकर 'सी' और 'एस' कर सकते हैं।

— FryAmTheEggman

आह। वह थोड़ा बचाता है, फिर। धन्यवाद। ;)

— सीओटीओ

क्या आप बता सकते हैं कि आपका कोड क्या कर रहा है? मैं इसके प्रमुख या पूंछ नहीं बना सकता।

— फोसजेन

@phosgene: मैंने एक विस्तृत विवरण इनलाइन को शामिल किया है।

— सीओटीओ

यह एक चतुर प्रक्रिया है। कुछ भी व्यर्थ नहीं है।

— phosgene

Answer 6

पायथन 339 - 10% = 305 बाइट्स

मैंने एक पुनरावर्ती गहराई-पहली खोज का उपयोग किया, जिसे सफलता के माध्यम से जल्दी समाप्त कर दिया जाता है exit। सही के लिए , सीधे के लिए 00001010101010101010101110100111001000, के रूप में सफलता पर भी मुद्रण पथ । इसका उत्तर इष्टतम से अधिक लंबा होगा, क्योंकि यह गहराई-पहले है। मुझे यकीन है कि एल्गोरिथ्म के कुछ अनुकूलन बाइट की गिनती को थोड़ा नीचे ला सकते हैं।01

b=input()
D=[(-1,0),(0,-1),(1,0),(0,1)]
def a(l):
 x,y=0,0
 v=2
 for d in l:
  if d=='1':v=(v+1) % 4
  x+=D[v][0]
  y+=D[v][1]
  if x<0 or x>7 or y<0 or y>7:return 0,x,y
  if b[y][x]:return -1,x,y
 return 1,x,y
def c(l):
 if len(l) < 39:
  t,x,y=a(l)
  if t==1:
   if (x,y)==(7,7):
    print l;exit(0)
   c(l+"0")
   c(l+"1")
c("")
print 0

Comments

चूंकि यह अजगर 2 है, तो आप, इंडेंट के लिए टैब और रिक्त स्थान में मिश्रण कर सकते हैं की तरह aके forपाश। आपको ऑपरेटरों के आसपास रिक्त स्थान की भी आवश्यकता नहीं है, जैसे (v+1) % 4-> (v+1)%4। तुम भी उपयोग करके एक लाइन पर कई बयान शामिल हो सकते हैं ;, अगर वहाँ कोई ifया forलाइन, जैसे पर, आदि c(l+"0");c(l+"1")। कुछ अन्य golfs: x,y,v=0,0,2, x|y>7 or x|y<0, x==y==7। सौभाग्य :)

— फ्रायअम्मिअंगमैन