रोबोजल दुभाषिया

10

आपका काम एक RoboZZle दुभाषिया लिखना है। यदि आप खेल से परिचित नहीं हैं, तो कृपया robozzle.com पर वीडियो देखें या नीचे मेरा विवरण पढ़ें।

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

इनपुट:

  • a- एक 12x16 वर्ण मैट्रिक्स (जैसा कि आमतौर पर आपकी भाषा में दर्शाया जाता है, उदाहरण के लिए स्ट्रिंग का सरणी) जो एक नक्शे को एन्कोड करता है - एक '#'दुर्गम (काले) वर्गों के लिए, '*'एक स्टार के साथ वर्गों के '.'लिए, बाकी के लिए

  • c- सुलभ वर्गों के रंगों का वर्णन करने वाला एक 12x16 वर्ण मैट्रिक्स - 'R'(लाल), 'G'(हरा), या 'B'(नीला)। दुर्गम वर्गों को तीनों से एक मनमाना पत्र द्वारा दर्शाया जाएगा।

  • yऔर x- रोबोट की 0-आधारित पंक्ति और स्तंभ; a[y][x]होने की गारंटी है'.'

  • d- दिशा रोबोट है सामना: 0 1 2 3अधिकार के लिए, नीचे, अर्थात की ओर बाएं, ऊपर (y,x+1), (y+1,x), (y,x-1),(y-1,x)

  • f- एक एकल स्ट्रिंग, एफ 1 ... एफ 5 का संक्षिप्त कार्यान्वयन। प्रत्येक क्रियान्वयन एक (संभवतः खाली) अनुक्रम-एक्शन जोड़े (सबरूटीन में अधिकतम 10 जोड़े) पर है, जिसे एक के साथ समाप्त किया गया है '|'।

    • विधेय: '_'कोई नहीं, 'r'लाल, 'g'हरा, 'b'नीला

    • कार्रवाई: 'F'आगे बढ़ो, 'L'बाएं मुड़ें, 'R'दाएं मुड़ें, 'r'लाल 'g'रंग, हरे 'b'रंग को पेंट '1'करें , नीले रंग को पेंट करें, एफ 1 को कॉल करें ..., '5'एफ 5 को कॉल करें, '_'कुछ भी न करें

आपको ऊपर दिए गए इनपुट्स का नाम नहीं देना है, लेकिन उनके मान निर्दिष्ट होने चाहिए।

आउटपुट: 1(या true) यदि रोबोट नियमों के अनुसार सभी तारों को इकट्ठा करता है, 0( false) अन्यथा।

उदाहरण :

a=["################","################","##*....*...*#.##","##.####.#####.##","##.####.#####.##","##.####*...*#.##","##.########.####","##*........*#.##","################","################","################","################"]
c=["RRRRRRRRRRRRRRRR","RRRRRRRRRRRRRRRR","RRRBBBBRGGGGRRRR","RRBRRRRGRRRRRRRR","RRBRRRRGRRRRRRRR","RRBRRRRRGGGBRRRR","RRBRRRRRRRRGRRRR","RRRBBBBGGGGBRBRR","RRRRRRRRRRRRRRRR","RRRRRRRRRRRRRRRR","RRRRRRRRRRRRRRRR","RRRRRRRRRRRRRRRR"]
y=2; x=6; d=2

// and then depending on "f":
f="_FrLg2_1|_FbLrR_2||||" // result:1
f="_FrRg2_1|_FbLrR_2||||" // result:0 (stepped on a black square)
f="_FrLrL_1|_FbLrR_2||||" // result:0 (1000-step limit exceeded)
f="_FrLg2__|________||||" // result:0 (stack underflow)

एक और उदाहरण , जिसमें "पेंट" निर्देश शामिल हैं:

a=["#***************","#*###*###*###*##","#*###*###*###*##","***#***#***#***#","***#***#***#***#","*###*###*###*###","***#***#***#***#","***#***#***#***#","***#***#***#***#","*###*###*###*###","*.*#***#***#***#","***#***#***#***#"]
c=["RGGGGGGGGGGGGGGG","RBRRRGRRRGRRRGRR","RBRRRGRRRGRRRGRR","RBRRGGGRGGGRGGGR","BRRRGGGRGGGRGGGR","BRRRGRRRGRRRGRRR","BRRRGGGRGGGRGGGR","RBRRGGGRGGGRGGGR","BRRRGGGRGGGRGGGR","BRRRGRRRGRRRGRRR","BGRRGGGRGGGRGGGR","RBRRGGGRGGGRGGGR"]
y=10; x=1; d=0
f="_2_R_R_1|_FgRgFgFg3rRr4b2_Fgb|_F_F_R|_2_L_r||"
// result:1

अपना स्वयं का परीक्षण उत्पन्न करने के लिए, robozzle.com पर सूची से एक पहेली पर जाएं , इसे हल करने का प्रयास करें (या इसे हल न करें), अपने ब्राउज़र में F12 दबाएं, JS कंसोल में टाइप करें:

r=robozzle;s=JSON.stringify;with(r.level)console.log('a='+s(Items)+'\nc='+s(Colors)+'\ny='+RobotRow+'\nx='+RobotCol+'\nd='+RobotDir+'\nf='+s(r.encodeSolution()))

और आपकी भाषा के लिए परिणाम को पुन: स्वरूपित करता है।

सबसे छोटी जीत। कोई खामियां नहीं।

code-golf  grid  interpreter 
— NGN
स्रोत
1
क्या हम प्रदान किए गए डेटा के बजाय डेटा का प्रतिनिधित्व करने के लिए किसी अलग वर्ण का उपयोग कर सकते हैं?
— हाइपरनेट्रिनो
1
"लूप इट" चुनौती के लिए अपने एपीएल जवाब के लिए, आप जटिल परिमाण को कम करके अंतिम कोण मान को सॉर्ट कर सकते हैं।
— user202729
1
@ user202729 उह, मुझे यहाँ उस चुनौती के बारे में टिप्पणी की उम्मीद नहीं थी :) आपका विचार काम करता है, धन्यवाद! मैं चरित्र को बहुत अपमानजनक बनाने के बिना इसे लागू करने की कोशिश करूंगा।
— NGN
1
क्या हम चरित्र मैट्रीस को स्थानों और पात्रों के जोड़े की सूची के रूप में ले सकते हैं?
— 0 '
1
@ 0 'जिस सिद्धांत का मैं यहां अनुसरण कर रहा हूं (यह भी देखें कि HyperNeutrino की टिप्पणी भी) वास्तव में robozzle.com पर उपयोग किए जाने वाले इनपुट प्रारूप के करीब रहना है, इसलिए मुझे डर है कि यह जोड़े की सूची नहीं होनी चाहिए।
— नागिन 27'18

जवाबों:

5

प्रोलोग (एसडब्ल्यूआई) , 574 बाइट्स

Z*A:-findall(X^Y-D,(nth0(Y,Z,O),nth0(X,O,C),plus(32,C,D)),L),list_to_assoc(L,A).
N^C^G^[P,I|R]^F^X^Y^D:-map_assoc(\=(74),G);N<1e3,get_assoc(X^Y,G,J),J>67,put_assoc(X^Y,G,78,H),T=N+1,((I\=95,(P=95;get_assoc(X^Y,C,P)))->(between(49,53,I),plus(48,M,I),nth1(M,F,Q),append(Q,R,S),T^C^H^S^F^X^Y^D;member(I,`RL`),E is(D-I//3)mod 4,T^C^H^R^F^X^Y^E;I=70,(D=0,U is X+1;D=1,V is Y+1;D=2,U is X-1;D=3,V is Y-1),(U=X;V=Y),T^C^H^R^F^U^V^D;I>97,put_assoc(X^Y,C,I,W),T^W^H^R^F^X^Y^D);N^C^H^R^F^X^Y^D).
A+C+F+L:-A*G,C*B,split_string(F,"|","",P),maplist(string_codes,P,[M|N]),0^B^G^M^[M|N]^L.

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

यह एक विधेय को परिभाषित करता है कि जब कहा जाता है कि अगर सभी सितारों को सफलतापूर्वक एकत्र किया जाता है और अन्यथा विफल रहता है। विधेय तर्क को इस प्रकार लेता है a+c+f+x^y^d.:। aऔर cbacktick उद्धृत स्ट्रिंग की सूची होनी चाहिए, जबकि fएक डबल उद्धृत स्ट्रिंग होना चाहिए।

व्याख्या

इस कार्यक्रम के तीन विधेय होता है, */2, ^/2, और +/2। */2पहली पंक्ति में परिभाषित की जाने वाली विधेय इनपुट प्रसंस्करण के हिस्से के लिए जिम्मेदार है। ^/2विधेय रिकर्सिवली गणना कैसे रोबोट चाल चरण दर चरण और सफल होता है रोबोट कानूनी तौर पर सभी सितारों इकट्ठा और अन्यथा विफल रहता है। +/2विधेय कार्यक्रम का मुख्य विधेय है और के लिए इनपुट तैयार करता है ^/2से कुछ मदद के साथ विधेय */2विधेय। ध्यान दें कि इनमें से प्रत्येक तकनीकी रूप से केवल दो तर्क देता है, लेकिन ऑपरेटरों और पैटर्न के मिलान का उपयोग करके वे व्यवहार कर सकते हैं जैसे कि उनके पास अधिक तर्क थे (मैं यहां इस घटना पर अधिक गहराई से चर्चा करता हूं )।

*/2

Z*A:-findall(X^Y-D,(nth0(Y,Z,O),nth0(X,O,C),plus(32,C,D)),L),list_to_assoc(L,A).

यह विधेय दो तर्क लेता है। पहला चरित्र कोड की सूचियों की एक सूची है (यह है कि प्रोलॉग पार्स बैकटिक उद्धृत स्ट्रिंग्स)। दूसरा 12x16 मैप में पॉइंट्स से एक एसोसिएटिव मैप ( X^Y32%) दर्शाया गया है और कैरेक्टर कोड की सूचियों की सूची में उस बिंदु पर संग्रहीत कैरेक्टर कोड है। 32 को प्रत्येक वर्ण कोड में जोड़ा गया है ताकि रंग मैट्रिक्स के लिए यह अपरकेस रंग वर्णों को लोअरकेस रंग वर्णों में बदल देगा।

जिस तरह से यह करता है वह बिंदुओं के जोड़े की सूची बनाता है और उस बिंदु पर वर्ण कोड का उपयोग करता है findall/3। इसके बाद list_to_assoc/2उस बिंदु पर वर्ण कोड से संबंधित साहचर्य मानचित्र बनाने के लिए उपयोग करता है।

findall/3विधेय अंतर्निहित अपना पहला तर्क, अपने दूसरे तर्क के रूप में एक लक्ष्य है और इसके तीसरा तर्क के रूप में एक सूची के रूप में एक "टेम्पलेट" लेता है। विधेय सूची को टेम्पलेट के सभी संभावित मूल्यों से भरता है जो लक्ष्य को सफल होने का कारण बनाते हैं। ऑपरेटर पूर्वता के कारण, जिस टेम्पलेट को पास किया findall/3जाता */2है उसे पार्स किया जाता है (X^Y)-D। -इसलिए टेम्पलेट बिंदु के स्थान (प्रतिनिधित्व करता ऑपरेटर Prolog में दो मानों की एक जोड़ी का प्रतिनिधित्व करता है X^Y32 प्लस पॉइंट का किरदार कोड के साथ जोड़ा) ( D)। ध्यान दें कि ^बिंदु का प्रतिनिधित्व करने के लिए उपयोग किसी भी तरह से ^/2विधेय से जुड़ा नहीं है।

आइए हम उस लक्ष्य पर विचार करें जिसे findall/3विधेय के लिए पारित किया गया है।

nth0(Y,Z,O),nth0(X,O,C),plus(32,C,D) % Note that the O (oh) is not a 0 (zero)

लक्ष्य में तीन विधेय होते हैं जिनमें से प्रत्येक को सफल होने के लिए लक्ष्य की आवश्यकता होती है। nth0/3दो बार प्रयोग किया जाने वाला विधेय सूची के किसी विशेष सूचकांक में मान प्राप्त करने के लिए उपयोग किया जाता है ( 0इसके नाम में यह इंगित करता है कि यह शून्य सूचकांक है)। इसमें पहला कॉल Yवर्ण मैट्रिक्स की वें पंक्ति को संग्रहीत करता है Oजबकि दूसरा कॉल Xउस पंक्ति में वें चरित्र को संग्रहीत करता है C। यदि अंतिम plus/3दो तर्क इसके तीसरे तर्क के योग हैं तो अंतिम विधेयक सफल होता है। इसका उपयोग वर्ण कोड बनाने के लिए किया जाता है, जो कि वर्ण मैट्रिक्स में वर्ण कोड से 32 अधिक है, जैसा कि ऊपर कहा गया है, सभी अपरकेस अक्षरों को लोअरकेस अक्षरों में बदल देगा।

अंत में findall/3उन सभी X^Y-Dसंयोजनों को संग्रहीत करता है जो इसके लक्ष्य को उस सूची में सफल होने का कारण बनाते हैं Lजो साहचर्य मानचित्र से बनाया गया है।

अधिक जल्द ही आ रहा...

— 0 '
स्रोत
4

जावास्क्रिप्ट (ईएस 6), 298 276 264 बाइट्स

@Ngn की बदौलत 8 बाइट्स बचाए

इनपुट के रूप में ले जाता है (a,c,x,y,d,f), जहां aऔर cवर्णों के सरणियों के सरणियाँ हैं। लौटाता है 0या 1।

(a,c,x,y,d,f,k=1e3)=>(g=(F,p=0,s=f.split`|`[F],r=a[y])=>!k|!r|x&16||r[x]<'$'?2:/\*/.test(a)?(r[x]=o=0,(I=s[p+1],P=s[p])&&(P<'b'|P==c[y][x].toLowerCase()&&I!='_'&&k--?+I?o=g(I-1):I=='L'?d--:I=='R'?d++:I<'b'?y+=(d&=3,x-=~-d%2,2-d)%2:c[y][x]=I:0,o||g(F,p+2))):1)(0)&1

परीक्षण के मामलों

कोड स्निपेट दिखाएं

टिप्पणी की गई

(                                           // main function taking:
  a, c, x, y, d, f,                         //   - input variables
  k = 1e3                                   //   - k = instruction counter
) => (                                      //
  g = (                                     // g = recursive execution function, taking:
    F,                                      //   - F = subroutine id
    p = 0,                                  //   - p = instruction pointer
    s = f.split`|`[F],                      //   - s = instruction string
    r = a[y]                                //   - r = current row in a[]
  ) =>                                      //
    !k |                                    // if we've executed 1000 instructions
    !r | x & 16 ||                          // or we've felt out of the map
    r[x] < '$' ?                            // or we've reached a black square:
      2                                     //   exit with error code 2
    :                                       // else:
      /\*/.test(a) ? (                      //   if there are still some stars:
        r[x] = o = 0,                       //     mark the current cell as visited
        (I = s[p + 1], P = s[p]) &&         //     I = instruction, P = predicate
        (                                   //     if P is defined:
          P < 'b' |                         //       if the predicate is '_'
          P == c[y][x].toLowerCase()        //       or it matches the color of the cell
          && I != '_'                       //       and the instruction is not '_',
          && k-- ?                          //       then decrement k and:
            +I ?                            //         if I is '1' ... '5':
              o = g(I - 1)                  //           process call to subroutine
            :                               //         else:
              I == 'L' ?                    //           if I is 'L':
                d--                         //             turn left
              :                             //           else:
                I == 'R' ?                  //             if I is 'R':
                  d++                       //               turn right
                :                           //             else:
                  I < 'b' ? (               //               if I is not a color:
                    y += (                  //                 I must be 'F',
                      d &= 3,               //                 so make the bot advance
                      x -= ~-d % 2,         //                 by updating x
                      2 - d                 //                 and y
                    ) % 2                   //
                  ) :                       //               else:
                    c[y][x] = I             //                 paint the current cell
          :                                 //       else:
            0,                              //         do nothing
          o ||                              //       provided that o is equal to 0,
          g(F, p + 2)                       //       go on with the next instruction
        )                                   //     end of instruction execution
      ) :                                   //   else:
        1                                   //     success: return 1
  )(0) & 1                                  // initial call to the subroutine F1
— Arnauld
स्रोत
x+='2101'[d&3]-1,y+='1210'[d&3]-1->d&=3,x+=(1-d)%2,y+=(2-d)%2
— ngn
1
x, सबसे 1 पर से बदल जाता है तो मुझे लगता है आप बदल सकते हैं x&~15के साथx&16
— NGN
1

एपीएल (डायलॉग क्लासिक) , 236 233 बाइट्स

-3 एग्री द आउटग्राफर को धन्यवाद

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

a c r d f←⎕⋄c←819⌶c⋄F←0,('|'=¯1⌽f)/⍳≢f⋄t←n←0
{~(⊂r)∊⍳⍴a:0⋄'#'=r⌷a:0⋄p q←2↑f↓⍨⊃⌽t⋄(_←p≡'|')∧×≢t:0⋄_:∇t↓←¯1⋄(⊃⌽t)+←2⋄~p∊'_',r⌷c:∇0⋄n+←1⋄n>999:0⋄(r⌷a)←'.'⋄~'*'∊a:1⋄r+←(q≡'F')×11 9○0j1*d⋄d+←4|'.R.L'⍳q⋄q∊'rgb':∇(r⌷c)←q⋄q∊⎕d:∇t,←F[⍎q]⋄∇0}0

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

उपरोक्त के रूप में ही, टिप्पणियों के साथ विस्तारित:

⎕io←0                   ⍝ 0-based indices (not counted in the score)
a c r d f←⎕             ⍝ decompose eval'ed input (⎕) into variables
c←819⌶c                 ⍝ make c lowercase
F←0,('|'=¯1⌽f)/⍳≢f      ⍝ split f at the '|'-s
t←n←0                   ⍝ t:stack, n:step counter
{                       ⍝ lambda
  ~(⊂r)∊⍳⍴a:0           ⍝ if the robot is off the map, return 0
  '#'=r⌷a:0             ⍝ if the robot is on a wall, return 0
  p q←2↑f↓⍨⊃⌽t          ⍝ current instruction - p:predicate, q:action
  (_←p≡'|')∧1≥≢t:0      ⍝ if at end of func and stack is empty, return 0
  _:∇t↓←¯1              ⍝ if at end of func, pop from stack and recurse
  (⊃⌽t)+←2              ⍝ increment program counter (top of stack)
  ~p∊'_',r⌷c:∇0         ⍝ if predicate doesn't match cell colour, recurse
  n+←1⋄n>999:0          ⍝ if too meany steps, return 0
  (r⌷a)←'.'             ⍝ consume star
  ~'*'∊a:1              ⍝ if no more stars left, return 1
  r+←(q≡'F')×11 9○0j1*d ⍝ if action is F, move forward
  d+←4|'.R.L'⍳q         ⍝ if action is L or R, turn left or right
  q∊'rgb':∇(r⌷c)←q      ⍝ if action is paint (r,g,b), do it
  q∊⎕d:∇t,←F[⍎q]        ⍝ if action is F1...F5, push on stack and recurse
  ∇0                    ⍝ action is nop (_), recurse
}0                      ⍝ call the lambda (argument will be ignored)
— NGN
स्रोत
— एग आउटोलॉफ़र
@EriktheOutgolfer परिवर्तन लागू, धन्यवाद
— ngn
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.