डेड फ्रॉग वॉकिंग

परिचय

जॉनी फ्रॉगर की भूमिका निभाना चाहते हैं। हालाँकि, वह बहुत अच्छा नहीं है। वास्तव में, वह केवल आगे बढ़ने की कोशिश करेगा, और उसके बाद ही प्लेटफार्मों को स्थानांतरित किया जाएगा।

पता करें कि क्या जॉनी मेंढक रास्ते के अंत तक पहुंचने का प्रबंधन करता है या यदि वह अपने रास्ते में मर जाता है।

चुनौती

कार्यक्रम इनपुट के रूप में एक Frogger ग्रिड के रूप में प्राप्त होगा , जो 0s और 1s द्वारा निम्न प्रारूप के साथ बनाया गया है:

ग्रिड एक यादृच्छिक चौड़ाई और लंबाई का होगा, और कम से कम 3x3 होगा
1 प्लेटफार्मों का प्रतिनिधित्व करता है
0 पानी का प्रतिनिधित्व करता है
F मेंढक की प्रारंभिक स्थिति का प्रतिनिधित्व करता है
ग्रिड की हर पहली और आखिरी लाइन केवल 1s द्वारा बनाई जाएगी , और नहीं चलेगी, और मेंढक Fको आखिरी लाइन में यादृच्छिक पर रखा जाएगा
हर मध्यवर्ती परत हमेशा आगे बढ़ जाएगा, और एक होगा <या >यह दर्शाता है कि हर पंक्ति के अंत में उसे बाएं या दाएं आ जाता है

इन प्रतीकों को अपने साथ बदलने की अनुमति है, जब तक वे सभी विशिष्ट हैं और आप अपने उत्तर में प्रतिस्थापन निर्दिष्ट करते हैं।

इनपुट किसी भी संगत प्रारूप में हो सकता है (लाइन ब्रेक के साथ स्ट्रिंग, स्ट्रिंग की सरणी, वर्णों की सरणी, ...)।

चुनौती नियम

हर मोड़, सभी प्लेटफार्मों दिशा के आधार पर, एक वर्ग पर आ जाएगा ने संकेत <या >संकेत
प्लेटफ़ॉर्म ग्रिड के दूसरी तरफ फिर से दिखाई देता है अगर उन्हें "स्क्रीन" से धक्का दिया जाता है
यदि मेंढक एक चलते हुए मंच पर है, तो यह उसके साथ आगे बढ़ेगा
उसके बाद, मेंढक शीर्ष पंक्ति की ओर एक वर्ग कूद जाएगा। मेंढक हर मोड़ पर आगे बढ़ेगा।
यदि यह पानी में कूदता है (तो 0) मेंढक की मृत्यु हो जाती है या यह चलती प्लेटफॉर्म के साथ ग्रिड के किनारे को छूता है

यदि मेंढक जीवित रहता है और मिथ्या मूल्य अन्यथा, तो आपके कार्यक्रम को एक सत्य मूल्य का उत्पादन करना होगा।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतते हैं। मानक खामियां लागू होती हैं।

उदाहरण

उदाहरण 1

इनपुट

उत्पादन

1

क्रियान्वयन

1 मोड़ें:

बारी 2:

बारी 3:

उदाहरण 2

इनपुट

उत्पादन

0

क्रियान्वयन

1 मोड़ें:

बारी 2:

बारी 3:

— BgrWorker
स्रोत

क्या मध्यवर्ती लाइनें हमेशा चलती रहेंगी? क्या हम इनपुट के रूप में लाइनों की एक सूची ले सकते हैं? यदि कोई रेखा नहीं चलती है, तो क्या हम मान सकते हैं कि यह एक चरित्र के अलावा समाप्त होता है <या >फिर हम आयताकार सरणियों को इनपुट के रूप में ले सकते हैं? वैसे, अच्छी चुनौती!

— १nan:

@dylnan मैंने इसे चुनौती पाठ में स्पष्ट किया। मध्यवर्ती परतें हमेशा चलती रहेंगी और हमेशा एक <या >अंत में रहेंगी ।

— 1823 में BgrWorker

क्या मेंढक सामने आने पर भी हर मोड़ पर आगे बढ़ता 0है, या अगले के लिए इंतजार करेगा 1? अगर यह इंतजार कर सकता है, तो क्या यह हर तरफ आगे बढ़ेगा 1, या यह स्मार्ट तरीके से इंतजार कर सकता है? यानी परीक्षण के मामले के साथ 11111 00001< 00011< 11F11, क्या यह गलत हो जाएगा क्योंकि यह पानी में कूदता है ( चरणों के पास्टिबिन ); यह falsey हो जाएगा, क्योंकि यह (फ्रेम से बाहर ले जाता है कदम की pastebin ); या क्या यह सच होगा क्योंकि यह आगे कूदने से पहले दूसरे चरण के लिए चालाकी से इंतजार करता है ( कदमों के अतीत में )?

— केविन क्रूज़सेन

@ केविनक्रूजसेन इसे हर मोड़ पर ले जाता है, और ख़ुशी से आत्महत्या कर लेगा (जैसा कि मैंने कहा, जॉनी बहुत अच्छा खिलाड़ी नहीं है)

— BgrWorker

@BgrWorker ओके, जो चुनौती को वास्तव में अधिक उल्लेखनीय बनाता है। :) हो सकता है कि इसे चुनौती विवरण में संपादित करें, कि मेंढक हर मोड़ पर आगे बढ़ेगा, भले ही यह एक में कूद जाएगा 0।

— केविन क्रूज़सेन

जवाबों:

पायथन 2 , 168 165 152 145 137 129 बाइट्स

s=input();x=s[-1].find('F');L=len(s[0]);i=k=1
for l in s[-2:0:-1]:d=('<'in l)%-2|1;k*=l[(x-d*i)%L]>'0'>-1<x+d<L;x+=d;i+=1
print k

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

इनपुट प्रारूप तार की एक सूची है; समस्या कथन में दिए गए वर्णों के अर्थ।

स्पष्टीकरण:

iटर्न नंबर है (टर्न 1 से शुरू); xउस मोड़ की शुरुआत में मेंढक की स्थिति है।

मेंढक जिस पंक्ति पर कदम रखने वाला है, वह स्ट्रिंग है l(ध्यान दें कि स्लाइसिंग के माध्यम से, ये नीचे से शीर्ष क्रम तक आते हैं)। d=('<'in l)%-2|1पैदावार -1या 1उस दिशा के आधार पर पंक्ति बढ़ रही है।

चूंकि यह iवें मोड़ है, यह पंक्ति iबाइट्स द्वारा मूल स्थिति से स्थानांतरित हो गई होगी ; और इसलिए चरित्र मेंढक कूदने वाला है l[(x-d*i)%L]जहां Lपंक्ति की चौड़ाई है, इसलिए हम चाहते हैं कि चरित्र समान हो '1'; यानी, >'0'।

इसके अलावा, हम यह जांचना चाहते हैं कि अगले मोड़ की शुरुआत में मेंढक को किनारे से स्थानांतरित नहीं किया जाएगा ; यह अभिव्यक्ति का कार्य है -1<x+d<L।

ये स्थितियाँ जंजीर हैं (चूंकि '0'>-1हमेशा होती है True); और यदि किसी भी समय परिणामी अभिव्यक्ति झूठी है, kतो बन जाएगी (और तब रहें) 0।

किसी भी मामले में, हम मेंढक की स्थिति को अपडेट करते हैं x+=dऔर पंक्ति संख्या को टकराते हैं ; उसके बाद, फिर से कुल्ला, दोहराएं।

— चास ब्राउन
स्रोत

पायथन 2 , 246 245 244 242 बाइट्स

^{मिस्टर एक्सकोडर की ओर से}^{-3 बाइट -1 जोनाथन}^{फ्रीच को}
^{बाइट धन्यवाद}

m=input()
exec"""for i,r in enumerate(m):
 d=-int(min('1',r[-1]));q=r[d*2]
 if m[i+1:]:r=sum([r[d+1:d-1],[[q,' '][q<'L']]][::d-~d],[])+r[-1:]
 if'F'in r:j=r.index('F');r[j]='L';m[i-1][j]=min('F',m[i-1][j])
 m[i]=r
"""*~-len(m)
print'F'in m[0]

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

व्याख्या

d वह दिशा है जिसमें प्रत्येक परत चलेगी
q वह चरित्र है जिसे चारों ओर लपेटा जाएगा
- [q,' '][q<'L'] मेंढक ऑफ स्क्रीन छोड़ देंगे
sum([r[d+1:d-1],[[q,' '][q<'L']]][::d-~d],[])+r[-1:]अंतिम वर्ण (दिशा) को हटा देगा, फिर पहले वर्ण को हटा देगा और इसे जोड़ देगा या दूसरा अंतिम निकाल देगा और इसे (इसके आधार पर d) पूर्व निर्धारित कर देगा , और दिशा को वापस छोड़ देगा, प्रभावी रूप से पूरी पंक्ति को बाईं / दाईं ओर ले जाएगा।
if'F'in r:j=r.index('F');r[j]='L';m[i-1][j]=min('F',m[i-1][j]) मेंढक कूद आगे कर देगा
min('F',m[i-1][j]) मेंढक पानी में गिर जाएगा
वर्ण तुलना ( minऔर <) आदेश का पालन करते हैं' ' < '0' < '1' < 'F' < 'L'

इनपुट पात्रों की सूची की एक सूची होगी:
' '- पानी
'F'- मेंढक
'L'- प्लाटफॉर्म
'0'- परत को बाईं ओर
'1'ले जाएं - परत को दाईं ओर ले जाएं

— छड़ी
स्रोत

if i<len(m)-1संभवतः हो सकता है if~-len(m)>i।

— जोनाथन फ्रीच

जावा 8, 293 277 बाइट्स

a->{for(int l=a.length-1,x=a[l].indexOf('F'),y=l,i,t=a[0].length()-1,b;y>0;y--){for(i=l;i-->1;a[i]=a[i].endsWith("<")?a[i].substring(1,t+1)+a[i].charAt(0*(x-=b))+"<":a[i].charAt(t)+a[i].substring(0*(x+=b),t)+">")b=i==y?1:0;if(x<0|x>t||a[y].charAt(x)<49)return 0>1;}return 1>0;}

चुनौती वर्णन ( 01F<>) में निर्दिष्ट डिफ़ॉल्ट वर्णों का उपयोग करता है ।

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

स्पष्टीकरण:

a->{                         // Method with String-array parameter & boolean return-type
  for(int l=a.length-1,      //  Amount of rows minus 1
       x=a[l].indexOf('F'),  //  Start x-position of the frog
       y=l,                  //  Start y-position of the frog
       i,                    //  Index-integer
       t=a[0].length()-1,    //  Length of the rows minus 1
       b;                    //  Temp integer
       y>0;                  //  Loop as long as the frog hasn't reached the other side
       y--){                 //    Jump forward once after every turn
    for(i=l;l-->1;           //   Inner loop over all the moving rows
        ;a[i]=               //     After every iteration: Change the moving row to:
         a[i].endsWith("<")? //      If the current platform moves to the left:
          a[i].substring(1,t+1)
                             //       Last part of the platform
                             //        i.e. "00101<" → "0101"
          +a[i].charAt(0     //       Appended with the first character
                             //        i.e. "00101<" → '0'
            *(x-=b))         //       We are moving left, so subtract `b` from `x`      
          +"<"               //       And append the direction "<" again
                             //        so "00101<" becomes "01010<"
         :                   //      Else (the platform moves to the right):
          a[i].charAt(t)     //       Take the last character
                             //        i.e. "00111>" → '1'
          +a[i].substring(0  //       And append the first part of the platform
                             //        i.e. "00111>" → "0011"
            *(x+=b),t)       //       We are moving right, so add `b` to `x`
          +">")              //       And append the direction "<" again
                             //        so "00111>" becomes "10011>"
      b=i==y?                //    If the frog is on the current row:
         1                   //     Set `b` to 1
        :                    //    Else:
         0;                  //     Set `b` to 0
    if(x<0|x>t               //   If the Frog is out of bounds
       ||a[y].charAt(x)<49)  //   Or jumped into the water
      return 0>1;}           //    Return false
  return 1>0;}               //  If the loop ended the frog made it to the other side,
                             //  so return true

— केविन क्रूज़सेन
स्रोत