टीएल; डीआर: वर्णों की एक सरणी और एक रोबोट की शुरुआत की स्थिति को देखते हुए, एक एल्गोरिथ्म लिखो जो आंदोलनों के साथ एक स्ट्रिंग पढ़ सकता है ( F"आगे बढ़ो" के लिए, R"90 डिग्री दाएं घुमाएं" और L"90 डिग्री घुमाएगी" के लिए) बाएँ ") और रोबोट की समाप्ति स्थिति की गणना करें। संपूर्ण पाठ में अधिक विवरण।

हमारे पास घर पर बच्चों के लिए एक बहुत ही सरल प्रोग्राम डिवाइस है: वाहन को आगे बढ़ाने के लिए बटन के साथ एक छोटा वाहन, 90 डिग्री बाएं या 90 डिग्री दाएं मुड़ें। इसके समान कुछ:

हमारे पास इस तरह के अक्षरों के साथ एक फोम चटाई भी है:

इन सबका उद्देश्य बच्चों को एक साथ सभी वर्णमाला और प्रोग्रामिंग की अशिष्टता को सिखाना है।

चुनौती

मान लीजिए कि हमने अपने फोम मैट को इस तरह बेतरतीब ढंग से व्यवस्थित किया है:

+---+---+---+---+---+---+---+
| E | R | L | B | I | X | N |
+---+---+---+---+---+---+---+
| O | A | Q | Y | C | T | G |
+---+---+---+---+---+---+---+
| F | W | H | P | D | Z | S |
+---+---+---+---+---+---+---+
    | K | V | U | M | J |   
    +---+---+---+---+---+
            |   |
            +---+

मान लीजिए कि हमने वाहन को भी संशोधित किया है ताकि जब हम "आगे बढ़ें" कमांड प्रोग्राम करें, तो वाहन चटाई में एक वर्ग के आकार के आगे बढ़ता है। इसलिए, यदि वाहन Uवर्ग में है और उत्तर की ओर जाता है, तो यह Pवर्ग में बिल्कुल रुक जाता है ।

वाहन को ले जाने से पहले निर्देश सभी को दिए गए हैं, और वे हैं:

F: वाहन अगले वर्ग में आगे बढ़ता है।
R: वाहन अपनी जगह (कोई और गति नहीं) में 90 डिग्री सही जाता है।
L: वाहन अपनी जगह (कोई और गति नहीं) में 90 डिग्री को छोड़ देता है।

निर्देश दिए जाने के बाद, आप "GO" बटन दबा सकते हैं और वाहन को दिए गए स्थान पर भेज सकते हैं क्योंकि यह दिए गए क्रम में प्रत्येक निर्देश का पालन करेगा। तो, आप बच्चे को दिए गए पत्र पर जाने के लिए वाहन के लिए आवश्यक निर्देश सम्मिलित करने के लिए कह सकते हैं।

आपको सबसे छोटा प्रोग्राम / फ़ंक्शन लिखना होगा stringजो निर्देशों के एक सेट के साथ एक (इनपुट पैरामीटर) को संसाधित करता है और उस पत्र की गणना करता है जो वाहन बंद हो जाता है (आउटपुट string)।

विवरण:

वाहन हमेशा निचले वर्ग में शुरू होता है, और उत्तर की ओर ( Uवर्ग की ओर )।
इनपुट स्ट्रिंग केवल अक्षर होगा F, R, Lऔर G( "जाना" बटन के लिए)। आप चटाई और निर्देशों के लिए लोअरकेस अक्षरों का उपयोग कर सकते हैं, यदि आप ऐसा पसंद करते हैं।
एल्गोरिथ्म को पहले स्ट्रिंग में हर निर्देश का पालन करना चाहिए G(इसके बाद का हर निर्देश नजरअंदाज कर दिया जाता है क्योंकि वाहन आगे बढ़ना शुरू हो गया है)।
यदि वाहन किसी भी समय मैट से बाहर चला जाता है (भले ही इनपुट स्ट्रिंग को पूरी तरह से संसाधित नहीं किया गया है), एल्गोरिथ्म को स्ट्रिंग वापस करना होगा Out of mat।
यदि नहीं, तो एल्गोरिथ्म को उस वाहन को वापस करना होगा जो वाहन ने बंद कर दिया है। शुरुआती बिंदु एक चार (या एक खाली स्ट्रिंग) के रूप में गिना जाता है ।

उदाहरण:

Input: FFG
Output: P

Input: FRFRFG
Output: Out of mat

Input: RRFFG
Output: Out of mat

Input: FFFRFFLFG
Output: X

Input: FFFRFFLF
Output:      <-- Nothing or a whitespace (the robot has not started moving)

Input: FFFRRFFFG
Output:      <-- Nothing or a whitespace (the robot has returned to the starting point)

Input: RRRRRLFFFLFFRFRFGFFRRGRFF
Output: L    (Everything after the first G is ignored)

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा की जीत के लिए सबसे छोटा कार्यक्रम हो सकता है!

code-golf simulation

— चार्ली
स्रोत

1

अगला: एक ही बात है, लेकिन स्ट्रिंग इनपुट के रूप में चटाई विन्यास के साथ @, प्रारंभिक स्थिति और रिक्त स्थान चटाई से दूर होने के साथ, इसलिए यह विन्यास होगा ERLBIXN\nOAQYCTG\nFWHPDZS\n KVUMJ \n @(विभिन्न रिक्ति के साथ, एसई ने इसे गड़बड़ कर दिया)

— स्टीफन

3

जावास्क्रिप्ट (ईएस 6), 194 176 169 163 बाइट्स

@Luke और @Arnauld की बदौलत कुछ बाइट्स बचाए।

s=>(p=35,d=3,t='ERLBIXN1OAQYCTG1FWHPDZS11KVUMJ11111 11',[...s].every(i=>i=='L'?d--:i>'Q'?d++:i<'G'?+t[p+=[1,8,-1,-8][d%4]]||!t[p]?p=1/0:p:0)?'':t[p]||'Out of mat')

Ungolfed:

s=>(
  p=35,
  d=3,
  t='ERLBIXN1OAQYCTG1FWHPDZS11KVUMJ11111 11',
  [...s].every(i=>i=='L'?d--:
                  i<'Q'?d++:
                  i<'G'?+t[p+=[1,8,-1,-8][d%4]]||!t[p]?p=1/0:p:
                  0
              )?'':
               t[p]||'Out of mat'
)

f=
s=>(p=35,d=3,t='ERLBIXN1OAQYCTG1FWHPDZS11KVUMJ11111 11',[...s].every(i=>i=='L'?d--:i>'Q'?d++:i<'G'?+t[p+=[1,8,-1,-8][d%4]]||!t[p]?p=1/0:p:0)?'':t[p]||'Out of mat')

console.log(f('FFG')); //P
console.log(f('FRFRFG')); //Out of mat
console.log(f('RRFFG')); //Out of mat
console.log(f('FFFRFFLFG')); //X
console.log(f('FFFRFFLF')); //(space)
console.log(f('FFFRRFFFG')); //(space)
console.log(f('RRRRRLFFFLFFRFRFGFFRRGRFF')); //L
console.log(f('FFFFFRRFG')); //Out of mat

स्निपेट का विस्तार करें

— रिक हिचकॉक
स्रोत

1

आप false!1

— ल्यूक

धन्यवाद, @ ल्यूक। मैं वास्तव में "जी" परीक्षण को पूरी तरह से हटाकर बाइट्स का एक गुच्छा बचा सकता हूं। यदि यह "L", "R" या "F" नहीं है, तो इसे "G" माना जा सकता है (जब तक कि "G" गायब नहीं है)। किसी भी तरह से, everyविधि इसे संभालती है।

— रिक हिचकॉक

यहाँ 165 बाइट्स के लिए एक समाधान है:

(s,p=35,d=3,t='ERLBIXN1OAQYCTG1FWHPDZS11KVUMJ11111 11')=>[...s].every(i=>i=='L'?d--:i=='R'?d++:i=='F'?+t[p+=[1,8,-1,-8][d%4]]||!t[p]?p=1/0:1:0)?'':t[p]||'Out of mat'

— ल्यूक

मुझे यकीन नहीं है कि यह मुझे 165 बाइट्स (?) में कैसे मिलता है, लेकिन मुझे निश्चित रूप से [1,8,-1,-8]सरणी के लिए एक अलग चर की आवश्यकता नहीं है, धन्यवाद!

— रिक हिचकॉक

उफ़, यह गलत हो गया, यह 171 है। मैंने एक ऐसी जगह को भी हटा दिया है जिसकी आपको आवश्यकता नहीं है, जो अभी भी वर्तमान उत्तर में है (यह अंतिम स्थान है)।

— ल्यूक

2

पायथन 2 , 235 बाइट्स

x=0;y=1;a=4;b=3
p='ERLBIXN','OAQYCTG','FWHPDZS','aKVUMJ','aaa '
r=''
for i in input():
 if'G'==i:r=p[a][b];break
 elif'G'>i:
  b+=x;a-=y;
  if(-1<a<5)-1or(''<p[a][b:]<'a')-1:r='Out of mat';break
 else:x,y=[[y,-x],[-y,x]][i<'R']
print r

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

— OVS
स्रोत

2

पायथन 3 , 226 231 241 बाइट्स

दूसरा संपादन; अब काम करना चाहिए। फिर से, बहुत सारे अनुकूलन किए जाने हैं।

n=input();s="0ERLBIXN00OAQYCTG00FWHPDZS000KVUMJ000000 00000";d=1;c=40;i=0;w=[-1,-9,1,9]
while n[i]!="G"and c>=0:
 if n[i]=="F":c+=w[d]
 else:d=[d+[-1,3][d<0],-~d%4][n[i]=="R"]
 i+=1
print(["Out of mat",s[c]][c in range(len(s))and s[c]!="0"])

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

— Fedone
स्रोत

0

वोल्फ्राम भाषा / गणितज्ञ, 300 बाइट्स

p=Re[(1-7I)#[[1]]]&;d=Drop;t=Throw;s=Switch;s[#,0,"Out of mat",_,StringPart["000 0000KVUMJ0FWHPDZSOAQYCTGERLBIXN",p@#]]&@Catch@Fold[If[MemberQ[d[d[Range[4,35],{2,5}],{7}],p@#],#,t@0]&@(s[#2,"F",#+{#[[2]],0},"R",#{1,-I},"L",#{1,I},_,t[#]]&)[#1,#2]&,{4,I},If[StringFreeQ["G"]@#,{"G"},Characters@#]&@#]&

Ungolfed:

p = Re[(1 - 7 I) #[[1]]] &;
d = Drop;
t = Throw;
s = Switch;
s[#,
    0, "Out of mat",
    _, StringPart["000 0000KVUMJ0FWHPDZSOAQYCTGERLBIXN", p@#]] &@
  Catch@
  Fold[
    If[MemberQ[d[d[Range[4, 35], {2, 5}], {7}], p@#], #, 
        t@0] &@(s[#2, "F", # + {#[[2]], 0}, "R", # {1, -I}, 
          "L", # {1, I}, _, t[#]] &)[#1, #2] &,
    {4, I},
    If[StringFreeQ["G"]@#, {"G"}, Characters@#] &@#] &

— चू Y
स्रोत

बच्चों के लिए रोबोट के साथ खेलना - मैं किस पत्र तक पहुंचूंगा?

चुनौती

उदाहरण:

जावास्क्रिप्ट (ईएस 6), 194 176 169 163 बाइट्स

पायथन 2 , 235 बाइट्स

पायथन 3 , 226 231 241 बाइट्स

वोल्फ्राम भाषा / गणितज्ञ, 300 बाइट्स