1-आयामी भूलभुलैया के लिए रहस्य अनलॉक करना

Question

पृष्ठभूमि

आप खुद को एक आयामी भूलभुलैया में खो जाने के लिए जागते हैं! एक रहस्यमय जिन्न (या कुछ) प्रकट होता है और बताता है कि निकास आपके सामने है, लेकिन आपके और बाहर निकलने के बीच चुनौतियों की एक श्रृंखला है। जैसा कि आप आगे भटकते हैं आप महसूस करते हैं कि सभी तथाकथित चुनौतियां केवल बंद दरवाजे हैं। आप पहले एक टी-आकार के की-होल के साथ एक दरवाजा देखते हैं, और इस तरह की कोई चाबी नहीं होने के कारण, अपने कदमों को वापस करें, एक Tआकृति के साथ एक चाबी की तलाश करें ।

निराश होकर, आप जमीन पर चाबियों का एक सूप पाते हैं, जिनमें से कोई भी आपके द्वार पर आए दरवाजे से मेल नहीं खाता है। प्रतिभा (या मूर्खता) के कुछ स्ट्रोक से, आप तय करते हैं कि निचली-केस- tशेप्ड कुंजी स्लॉट में फिट करने में सक्षम हो सकती है यदि आप इसे वहां पर्याप्त रूप से जाम करते हैं। जैसे ही आप tहाथ में लोअर-केस की चाबी के साथ दरवाजे पर पहुंचते हैं , Tछेद हरा हो जाता है और दरवाजा आपके सामने घुल जाता है।

एक नीचे, कई और जाने के लिए ...

चुनौती

इस चुनौती का लक्ष्य यह चिह्नित करना है कि आप भूलभुलैया से बाहर निकलने के लिए कितने कदम उठाते हैं।

इस चुनौती का इनपुट भूलभुलैया है: एक स्ट्रिंग जिसमें केवल वर्ण हैं [A-Za-z^$ ]। शब्दावली:

• ^- प्रारंभ स्थान। इनपुट में बिल्कुल एक होगा ^।
• $- निकास (स्वतंत्रता!)। इनपुट में बिल्कुल एक होगा $।
• [A-Z]- बड़े अक्षर दरवाजे को दर्शाते हैं। यदि आप पहले से ही अपेक्षित कुंजी एकत्र कर चुके हैं तो आप केवल इस दरवाजे से जा सकते हैं।
• [a-z]- लोअर केस लेटर्स कुंजियों को दर्शाते हैं। आप इन कुंजियों को उस स्थान पर चलाकर एकत्रित करते हैं जिसमें कुंजी है।

इनपुट में प्रत्येक बड़े अक्षर में से एक होगा। इसका मतलब है कि कुल दरवाजे 0-26 समावेशी के बीच होंगे।

हर बंद दरवाजे के [A-Z]पास एक समान रूप से कम केस की चाबी होगी [a-z]। इनपुट में कोई भी स्थान ( ) हो सकता है ।

सभी दरवाजे शुरुआत के दाईं ओर और निकास के बाईं ओर होंगे। इस प्रकार कोई भी शानदार दरवाजे नहीं होंगे। सभी इनपुट सॉल्व होंगे।

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

कलन विधि

इस मनहूस जगह से बाहर निकलने का आपका तरीका इस प्रकार है:

• शुरुआत में शुरू करें ( ^) और आगे बढ़ें (दाएं) आपके सामने आने वाली किसी भी कुंजी को इकट्ठा करते हुए।
• जब आप एक दरवाजे के पार आते हैं, अगर आपके पास सही चाबी है, तो आप दरवाजे पर आगे बढ़ते हैं। यदि आपके पास सही कुंजी नहीं है, तो आप पीछे की ओर (बाएं) एकत्रित कुंजियों को चलते हैं जब तक कि आप सबसे हाल के दरवाजे की कुंजी नहीं ढूंढ लेते हैं जो आप खोल नहीं सकते।
• एक बार जब आप वर्तमान परेशानी वाले दरवाजे के लिए कुंजी एकत्र करते हैं, तो आप दाईं ओर मुड़ते हैं और आगे बढ़ते हैं।
• इस प्रक्रिया को तब तक दोहराएं जब तक आप बाहर निकलने के लिए कदम नहीं उठाते ( $)।

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

गिनती

हर बार जब आप एक वर्ग से दूसरे वर्ग में कदम रखते हैं, तो एक कदम के रूप में गिना जाता है। 180 no मोड़ना कोई अतिरिक्त कदम नहीं है। आप अपेक्षित कुंजी के बिना एक दरवाजे पर आगे नहीं बढ़ सकते। आपको इसे लेने के लिए एक कुंजी पर कदम रखना चाहिए, और जीतने के लिए निकास पर कदम रखना चाहिए। आपकी पहली चाल के बाद, स्टार्ट स्पेस ( ^) किसी अन्य नियमित स्थान की तरह ही व्यवहार करता है।

उदाहरण

इन उदाहरणों में मैंने मानव-पठनीयता के लिए रिक्त स्थान को रेखांकित किया है।

इनपुट है _a_^_A__$__। आउटपुट है 11। आप 1कदम आगे बढ़ाते हैं, ध्यान दें कि आपके पास Aदरवाजे के लिए कोई चाबी नहीं है , और फिर चेहरे के बारे में। आप पीछे की ओर चलते हैं जब तक कि आप उस स्थान पर कब्जा नहीं कर लेते हैं a( 3पीछे की ओर कदम, अब 4कुल)। आप तब तक आगे बढ़ते हैं जब तक कि आप बाहर निकलने वाले स्थान पर कब्जा नहीं कर लेते ( 7आगे, 11कुल)।

इनपुट है b__j^__a_AJB_$। आउटपुट 41आप भूलभुलैया के पीछे दो अलग-अलग यात्राएं करते हैं, एक jकुंजी प्राप्त करने के लिए , और अगले एक bकुंजी प्राप्त करने के लिए ।

इनपुट है __m__t_^__x_T_MX_$____। आउटपुट है 44। xकुंजी प्राप्त करने के लिए आप कोई अतिरिक्त यात्रा नहीं करेंगे , जैसा कि आपने इसे शुरू से ही अपने रास्ते पर उठाया था T।

इनपुट है g_t_^G_T$। आउटपुट है 12। आप Gएक कुंजी के बिना अंतरिक्ष पर नहीं जा सकते , और तुरंत चेहरे के बारे में। आप भाग्यशाली हैं कि tकुंजी के रास्ते पर कुंजी को उठाओ g, और इस तरह से स्वतंत्रता के लिए अपने रास्ते पर दोनों दरवाजे खोलें।

इनपुट है _^_____$। आउटपुट है 6। वह तो आसान था।

मैं / हे दिशानिर्देश और जीत मानदंड

मानक I / O नियम लागू होते हैं। यह एक कोड-गोल्फ चुनौती है।

Comments

अच्छी चुनौती के अलावा, मैं यह बताना चाहता हूं कि शब्दांकन और स्पष्टीकरण कितने अच्छे हैं

— लुइस मेंडो

"इस प्रकार कोई शानदार दरवाजे नहीं होंगे।" मुझे लगता Aहै bA^aB$कि या तो शानदार नहीं होगा। ;)

— मार्टिन एंडर

@orlp मुझे यह देखने में अधिक दिलचस्पी है कि कैसे लोग इस भटकने वाले अंधेरे एल्गोरिथ्म में गोल्फ करते हैं। ऐसा लगता है कि "सभी कुंजियाँ प्राप्त करें फिर सभी द्वार खुले रहें" का इष्टतम समाधान करना तुच्छ लगता है।

— टर्बुलेंसेटू

@PeterTaylor और turbulencetoo नहीं, ऐसा नहीं है, जो यह कहना चाहते हैं कि सभी कुंजियाँ बाईं ओर हैं, और दाईं ओर सभी दरवाजे हैं? और शानदार कुंजी / दरवाजे भी दिलचस्प होंगे। यह काफी दिलचस्प होगा, क्योंकि इसका मतलब होगा एक निर्भरता ग्राफ को हल करना।

— 18

हर दरवाजे की एक चाबी होती है। क्या हर कुंजी में एक दरवाजा है?

— user2357112

Answer 1

CJam, 45

1q_'$#<'^/~\W%:A;ee{~32+A#)_T>{:T+2*+}&]0=)}/

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

स्पष्टीकरण:

1         initial step count; this 1 is actually for the last step :)
q_'$#<    read the input and only keep the part before the '$'
'^/~      split by '^' and dump the 2 pieces on the stack
\W%:A;    take the first piece, reverse it and store it in A
ee        enumerate the other piece (making [index char] pairs)
{…}/      for each [index char] pair
  ~32+    dump the index and character on the stack, and add 32 to the character;
           uppercase letters become lowercase and other chars become garbage
  A#)     find the index of this character in A and increment it (not found -> 0)
  _T>     check if this index (number of steps from '^' back to the key)
           is greater than T (which is initially 0)
  {…}&    if that's true (we need to go back), then
    :T    store that index in T (keeping track of how far we go back before '^')
    +     add to the other index (from the pair, number of steps we took after '^')
    2*    double the result (going back and forth)
    +     add it to the step count
  ]0=     keep only the first value from the bottom of the stack (step count)
           (if the condition above was false, we'd have 2 extra values)
  )       increment the step count (for the current step)

Answer 2

पायथ, 51 बाइट्स

JxQ"^"K-xQ"$"JVQI&}NrG1>JxQrN0=JxQrN0=+K*2t-xQNJ;pK

दरवाजे और उसकी कुंजी के बीच की दूरी (दोगुनी, गोल यात्रा करने के लिए), "नेस्टेड" कुंजियों की अनदेखी और शुरू से अंत तक की दूरी:

JxQ"^"                                              #Initialize the farther point with the starting position
      K-xQ"$"J                                      #Initialize the step counter with the difference between the exit and the start
              VQ                                    #iterate over the input
                I&}NrG1>JxQrN0                      #check if is upper and if the keys is father than one stored (to eliminate nested keys)
                              =JxQrN0               #update the farther key
                                     =+K*2t-xQNJ;   #update step counter with the round trip door<>key
                                                 pK #print the step counter

python2.7 में समान रूपांतर:

lab=raw_input()
farther_key=lab.index('^')
steps = lab.index('$') - farther_key
for i in lab:
    if i.isupper():
        if farther_key> lab.index(i.lower()):
            farther_key=lab.index(i.lower())
            steps+=((lab.index(i) - farther_key)-1)*2
print steps

Answer 3

पायथन 2, 155 154 134 128 बाइट्स

संपादित करें: @ user2357112 और @loovjo को उनकी टिप्पणियों के लिए धन्यवाद जिसने मेरे समाधान से एक और 20 26 बाइट दाढ़ी बनाने में मदद की !

def f(l):
 i=l.index;b=i('^');t=i('$')-b
 for d in filter(str.isupper,l):
  k=i(d.lower())
  if k<b:b=k;t+=2*(i(d)-k-1)
 print t

Comments

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

— लोजोवो

दूसरी और तीसरी पंक्ति पर सहमत, @Lovjo, लेकिन आप क्यों कहते हैं iकि अनावश्यक है? iवर्तमान में संसाधित किए जा रहे दरवाजे की स्थिति को ट्रैक करता है, और इसकी आवश्यकता होती है यदि इसकी कुंजी अभी तक नहीं ली गई है (यानी यदि k- कुंजी की स्थिति - से कम है f- हम जिस बाएं से चले गए हैं - उसके बाद हमें जोड़ना होगा 2*(i-k-1)हमारे कुल के लिए कदम (चाबी पाने के लिए बाएं चलना, और दरवाजे पर वापस चलना) ...

— केन 'जोए' मोशेर

लेकिन पांचवीं पंक्ति और चौथे पर हटाए गए असाइनमेंट द्वारा iप्रतिस्थापित नहीं किया जा सकता है l.index(d)?

— लोजो

अलग eऔर fचर निरर्थक लगते हैं। इसके अलावा, आप l.indexकिसी चर को सहेजकर वर्णों का एक समूह बचा सकते हैं ।

— user2357112

@loovjo: हाँ, आप सही कह रहे हैं ... मैंने पहली बार में आपकी टिप्पणी को गलत समझा। @ user2357112: बिल्कुल सही। xबेमानी है। लगता है कि मेरा गोल्फ नोब-इन दिखा रहा है। :) सहायता के लिए धन्यवाद!

— केन 'जॉय' मोशेर

Answer 4

सी, 136 बाइट्स

q,x,p[300],z,c,k;main(i){for(;p[c=getchar()]=++i,c-36;z&&(k+=(x=p[c+32])&&x<q?(q=q>x?x:q,2*i-2*x-1):1))z=p[94],q||(q=z);printf("%d",k);}

Answer 5

PHP 5.3, 123 बाइट्स

कोड गोल्फ पर यह मेरी पहली पोस्ट है, उम्मीद है कि यह पहली पोस्ट के लिए उच्च गुणवत्ता वाली गोल्फिंग है। निश्चित रूप से एक मजेदार चुनौती और एक भयानक सवाल!

function n($m){while('$'!=$o=$m[$i++])$o=='^'?$b=$i+$c=0:$o>'Z'||$b<=$k=stripos($m,$o))?$c++:$c+=2*$i-3-2*$b=$k;return$c;}

यह प्रोग्राम इस तथ्य का अच्छी तरह से दुरुपयोग करता है कि PHP का उपयोग करने से पहले आपको किसी भी चर को पूर्व-घोषित करने की आवश्यकता नहीं है।

यह भी 0 में शुरू करने और '^' पर शुरू करने के बजाय, जब चरित्र पाया जाता है, तो स्टेप काउंट को रीसेट करने के लिए मेरे अंतिम समाधान में एक छोटा बाइट्स निकला।

किसी भी सुझाव निश्चित रूप से स्वागत है!

Answer 6

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

s=>(i=c=>s.indexOf(c),p=i`^`,l=i`$`-p,s.replace(/[A-Z]/g,(c,j)=>p>(t=i(c.toLowerCase()))?l+=j-(p=t)-1<<1:0),l)

पोर्ट ऑफ रॉब का पाइथ उत्तर।

Answer 7

पायथन 2.7, 234 199 179

a=raw_input()
x=a.index
v=x('^')
b=x('$')-v
l=filter(str.islower,a[:v])[::-1]
for i in filter(str.isupper,a):
 k=i.lower()
 if k in l:b+=(x(i)-x(k)-1)*2;l=l[l.index(k)+1:]
print b

Answer 8

AWK, 174 बाइट्स

func f(xmS){x+=S
c=a[x]
if(c~/^[A-Z]/&&!k[c]){C=c
S=-S
s--}else{c=toupper(c)
k[c]=1
s++
if(c==C){S=-S;C=9}}if(c=="$"){print s}else f(x,S)}{split($0,a,"")
f(index($0,"^"),1)}

वहाँ शायद एक तंग एल्गोरिथ्म है, लेकिन यह वही है जो मैं साथ आया था।

ध्यान दें कि मैं उपयोग कर रहा हूं gawk। AWKहो सकता है कि कुछ कार्यान्वयन ""इस तरह से एक स्ट्रिंग को विभाजित न करें।

Answer 9

सी #, 309 बाइट्स

class P{static void Main(string[]a){string m=Console.ReadLine(),k="";var f=true;char b,c=b=' ';int j=m.IndexOf('^'),t=0;for(;m[j]!='$';j+=f?1:-1){c=m[j];if(char.IsUpper(c)){if(k.IndexOf(char.ToLower(c))<0){f=!f;b=c;t--;}}if(char.IsLower(c)){k+=c;if(char.ToUpper(c)==b){f=!f;t--;}}t++;}Console.WriteLine(t);}}

Ungolfed संस्करण:

    class P
{
    static void Main(string[] a)
    {
        string m = Console.ReadLine(), k = "";
        var f = true;
        char b, c = b = ' ';
        int j = m.IndexOf('^'), t = 0;
        for (; m[j] != '$'; j += f ? 1 : -1)
        {
            c = m[j];
            if (char.IsUpper(c))
            {
                if (k.IndexOf(char.ToLower(c)) < 0)
                {
                    f = !f; b = c; t--;
                }
            }

            if (char.IsLower(c))
            {
                k += c;
                if (char.ToUpper(c) == b) { f = !f; t--; }
            }


            t++;
        }
        Console.WriteLine(t);
        Console.ReadKey();

    }
}

यहां कुछ भी नहीं फैंसी, केवल स्ट्रिंग के माध्यम से पुनरावृति और चरित्र के आधार पर दिशा बदलें और कुंजी एक कुंजी स्ट्रिंग में निहित है या नहीं।

m = भूलभुलैया स्ट्रिंग

k = कुंजियाँ स्ट्रिंग

f = दिशा (भूलभुलैया में सच है)

b = बैकट्रैकिंग के लिए खोज करने की कुंजी

लगातार उपयोग के कारण कुछ बाइट्स को बचाने के लिए मी [जे] के लिए सी = प्लेसहोल्डर

j = स्ट्रिंग के चार सूचकांक को देखने के लिए

t = गिनती

गोल्फिंग के लिए अभी भी अपेक्षाकृत नया है अगर आप कहीं देखते हैं तो मैं इसे नीचे कर सकता हूं, मुझे बताएं!