भूलभुलैया चलो

Question

या शायद यह वास्तव में एक भूलभुलैया नहीं है, लेकिन फिर भी।

नियम:

1. इनपुट , दो लाइन स्ट्रिंग है से मिलकर *, 1, xऔर X। उस तार के माध्यम से चलने के लिए एक भूलभुलैया है। लाइनों की लंबाई समान है ।

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

2. आउटपुट स्ट्रिंग से बाहर निकलने के लिए आपके द्वारा उठाए जाने वाले कदमों की संख्या है (अंतिम चरण वह कदम है जो आपको स्ट्रिंग से बाहर ले जाता है)।

3. आप पहले प्रतीक से पहले ऊपरी बाएं कोने (उच्च रेखा) में शुरू करते हैं।

4. प्रत्येक चरण के लिए, आप एक प्रतीक (nth से (n + 1) वें स्थान ) तक आगे बढ़ते हैं । फिर, आप जिस चरित्र पर कदम रखते हैं, उसके आधार पर परिणाम भिन्न होता है। यहाँ प्रत्येक चार क्या है:

   • *- कुछ भी तो नहीं। आप बस सामान्य रूप से उस पर कदम रखें।
   • x- एक बार जब आप उस पर कदम रखते हैं, तो लाइन को स्विच करें, लेकिन शुरुआत से उसी क्षैतिज दूरी पर रहें। उदाहरण के लिए, आपने उच्च रेखा की तीसरी स्थिति पर कदम रखा, और xयहां एक निचले हिस्से से मुलाकात की । फिर आप तुरंत निचली रेखा पर जाते हैं, लेकिन फिर से तीसरे स्थान पर।
   • X- लाइन स्विच करें और अगली स्थिति पर जाएं। उदाहरण वहाँ भी वही है, लेकिन आप तीसरे से आगे की स्थिति में भी जाते हैं (इस प्रकार आप अगली स्थिति में दूसरी पंक्ति पर हैं)।
   • 1 - बस अभी तक एक और स्थिति से आगे बढ़ना।

एक बार जब प्रत्येक पात्र अपना काम करता है, तो उसे एक स्थान से बदल दिया जाता है और अब "कार्य" नहीं किया जाता है।

उदाहरणों का पालन करें।

1. इनपुट :

   x
   *
   

   जैसा कि पहले कहा गया था, आप पहली पंक्ति के पहले प्रतीक से पहले शुरू करते हैं। पहला कदम आपको पत्र पर ले जाता है xऔर यह पत्र आपको दूसरी पंक्ति में ले जाता है। पत्र xअब के रूप में कार्य नहीं करता है x, लेकिन इसके साथ बदल दिया गया है *। यह बाद के उदाहरणों में अधिक प्रासंगिक होगा। अब आप निचली रेखा पर एक तारांकन पर हैं, और इसने आपको कुछ नहीं किया।

   दूसरा चरण आपको आगे बढ़ रहा है और आप स्ट्रिंग से बाहर निकलते हैं, इसलिए भूलभुलैया पूरा हो गया है, और इसने 2 कदम उठाए।

   आउटपुट 2 ।

2. इनपुट :

   xX*
   x1*
   

   पहला चरण : आप आगे बढ़ते हैं x, जो आपको xनिचली रेखा पर ले जाता है । यहां वह नियम आता है जो कहता है कि प्रयुक्त चरित्र को तारांकन के साथ बदल दिया गया है। फिर आप पहली पंक्ति पर वापस जाते हैं, लेकिन यह अब xनहीं है, क्योंकि इसका उपयोग किया गया है और तारांकन बन गया है। इसलिए आप इस तारांकन पर सुरक्षित रूप से चले जाते हैं और चरण पूरा हो जाता है (अब आप पहली पंक्ति के पहले स्थान पर हैं)।

   दूसरा चरण : आप आगे बढ़ते हैं X, यह आपको निचली रेखा पर धकेलता है और फिर आपको आगे बढ़ाता है। अब आप दूसरी पंक्ति (तारांकन) की तीसरी स्थिति पर रहते हैं, कभी दूसरी स्थिति (जिसमें सम्‍मिलित होती है 1) पर नहीं गए।

   तीसरा चरण : आप स्ट्रिंग से बाहर निकलते हुए आगे बढ़ते हैं।

   आउटपुट : 3।

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

1. इनपुट:

   *1*
   xxx
   

   आउटपुट: 3। (क्योंकि 1आपको तीसरी स्थिति पर कूदना पड़ता है)। वहां आप दूसरी पंक्ति में कभी नहीं जाते हैं, लेकिन इसके लिए इनपुट का आवश्यक हिस्सा है।

2. इनपुट:

   *X*1*x
   x*1xx*
   

   आउटपुट: 4।

3. इनपुट:

   1x1x
   ***X
   

   आउटपुट: 3।

4. इनपुट:

   1*x1xxx1*x
   x*x1*11X1x
   

   आउटपुट: 6।

5. इनपुट:

   xXXXxxx111*
   **xxx11*xxx
   

   आउटपुट: 6।

Comments

एक खाली स्ट्रिंग एक वैध इनपुट नहीं होना चाहिए, क्योंकि यह एक दो लाइन स्ट्रिंग नहीं है

— edc65

@ ईडीसी हाहा, मैं खुद का विरोध कर रहा हूं। हाँ सचमुच।

— nicael

"\n\n"एक दो लाइन स्ट्रिंग है ...

— feersum

@ फ़ेरसम तो मुझे लगता है कि आउटपुट होना चाहिए 1, जैसा कि आप 1 पंक्ति से पहले शुरू करते हैं, फिर आप एक कदम आगे बढ़ते हैं, और फिर आप भूलभुलैया खत्म करते हैं ...

— अमित गोल्ड

Answer 1

घोंघे, 34 बाइट्स

A^
\1r|\xud|\Xaa7},(\*|\xud=\x)r},

विस्तारित:

{
    {
        \1 r |
        \x ud |
        \X aa7
    },
    (\* | \x ud =\x)
    r
},

एक ऐसे रास्ते के लिए जो N कदम उठाता है, कार्यक्रम 0 चरणों, 1 चरणों, ..., N - 1 चरणों में से प्रत्येक के लिए एक सफल मैच पाता है।

Answer 2

हास्केल, 68 66 65 बाइट्स

(a:b)#l@(c:d)|a<'+'=1+b#d|a>'w'=l#('*':b)|a>'W'=d#b|1<2=b#d
_#_=1

फ़ंक्शन #दोनों लाइनों को अलग-अलग मापदंडों के रूप में लेता है। प्रयोग उदाहरण: "1x1x" # "***X"-> 3।

हमें बस उन सितारों को गिनना है जिन्हें *हम छोड़ने के लिए प्लस 1 पर कदम रखते हैं।

(a:b)#l@(c:d)             -- bind: a -> first char of first line
                                   b -> rest of first line
                                   l -> whole second line
                                   c -> first char of second line (never used)
                                   d -> rest of second line
   |a < '+' = 1+b#d       -- stepped on a *, so add 1 and go on
   |a > 'w' = l#('*':b)   -- x switches lines and replaces the x with *
   |a > 'W' = d#b         -- X switch lines and go on
   |1<2     = b#d         -- the rest (-> 1) simply walks forward
_#_=1                     -- base case: the empty string counts 1 for leaving

संपादित करें: @ Faersum ने एक बाइट को बचाया। धन्यवाद!

Comments

क्या आप शायद एक कामकाजी डेमो प्रदान कर सकते हैं ( ideone.com पर यह सुविधाजनक होगा), मैं हास्केल प्रोग्रामर नहीं हूं, लेकिन इसके साथ खेलना चाहूंगा।

— निकेल

@nicael: यहां देखें

— nimi

क्या आप a>'a'इसके बजाय उदा का उपयोग कर सकते हैं a=='x'?

— feersum

मुझे यह एहसास नहीं हुआ है, लेकिन वास्तव में खाली स्ट्रिंग अमान्य इनपुट है (क्योंकि मैंने खुद से कहा है कि इनपुट एक दो-पंक्ति स्ट्रिंग है), इसलिए आप इस किनारे मामले के लिए मान्यता को हटा सकते हैं :)

— nicael

@ फैर्सम: हां, यह काम करता है। धन्यवाद!

— नीम

Answer 3

जावास्क्रिप्ट (ईएस 6), 119

l=>{z=-~l.search`
`,l=[...l+' '];for(n=p=0;(c=l[p%=2*z])>' ';p+=c>'X'?z:c>'1'?z+1:c>'0'?1:(++n,1))l[p]='*';return-~n}

कम गोल्फ वाला

l=>{
  z=1+l.search`\n`;
  l=[...l+' '];
  for( n = p = 0; 
       (c=l[p%=2*z])>' '; 
       p += c>'X' ? z : c>'1' ? z+1 : c>'0'? 1 : (++n,1) )
    l[p] = '*';
  return 1+n
}

परीक्षा

f=l=>{z=-~l.search`
`,l=[...l+' '];for(n=p=0;(c=l[p%=2*z])>' ';p+=c>'X'?z:c>'1'?z+1:c>'0'?1:(++n,1))l[p]='*';return-~n}

[['x\n*',2]
,['xX*\nx1*',3]
,['*1*\nxxx',3]
,['*X*1*x\nx*1xx*',4]
,['1x1x\n***X',3]
,['1*x1xxx1*x\nx*x1*11X1x',6]
,['xXXXxxx111*\n**xxx11*xxx',6]
].forEach(t=>{
  var i=t[0],k=t[1],r=f(i) 
  console.log('Test result '+r+(r==k?' OK ':' KO (expected '+k+')')+'\n'+i)
})  
 

Answer 4

TSQL (sqlserver 2012+), 276 बाइट्स

golfed:

DECLARE @i VARCHAR(99)=
'xXXXxxx111*'+CHAR(13)+CHAR(10)+
'**xxx11*xxx'

,@t BIT=0,@c INT=1,@ INT=1WHILE @<LEN(@i)/2SELECT @t-=IIF(a like'[1*]'or'xx'=a+b,0,1),@c+=IIF(a='*'or'xx'=a+b,1,0),@+=IIF(a='x'and'x'>b,0,1)FROM(SELECT SUBSTRING(d,@t*c+@,1)a,SUBSTRING(d,(1-@t)*c+@,1)b FROM(SELECT LEN(@i)/2+1c,REPLACE(@i,'X','q'COLLATE thai_bin)d)x)x PRINT @c

Ungolfed:

DECLARE @i VARCHAR(99)=
'xXXXxxx111*'+CHAR(13)+CHAR(10)+
'**xxx11*xxx'

,@t BIT=0,@c INT=1,@ INT=1
WHILE @<LEN(@i)/2
  SELECT
    @t-=IIF(a like'[1*]'or'xx'=a+b,0,1),
    @c+=IIF(a='*'or'xx'=a+b,1,0),
    @ +=IIF(a='x'and'x'>b,0,1)
  FROM
    (
      SELECT
        SUBSTRING(d,@t*c+@,1)a,
        SUBSTRING(d,(1-@t)*c+@,1)b
      FROM 
        (SELECT LEN(@i)/2+1c,REPLACE(@i,'X','q'COLLATE thai_bin)d)x
    )x

PRINT @c

बेला

Answer 5

जावास्क्रिप्ट, 211 बाइट्स

मैं एक ऐसा संस्करण बनाने के बारे में सोच रहा हूं, जो एक वेबपेज पर प्रदर्शित एक-दूसरे के बाद खेले गए प्रत्येक चरण को दिखाता है।

(x,y)=>{t=0;l=0;n=1;while(t<x.length){c=(l?x:y);if(c[t]=='x'){l=!l;if(l){x=x.slice(0,t-2)+'*'+x.slice(t-1);}else{y=y.slice(0,t-2)+'*'+y.slice(t-1);}}if(c[t]=='X'){l=!l;t++;}if(c[t]=='1'){return n}

अधिक बाइट्स से मैं जब जगह की आशा व्यक्त की थी प्रयुक्त xसाथ *क्योंकि जे एस के अपरिवर्तनीय Strings। सुधार के सुझावों की सराहना की जाती है, विशेष रूप से प्रतिस्थापन भाग के साथ।