नोट: यह दो सड़कों पर आधारित है जो एक पीली लकड़ी (भाग 2) में दी गई है, जो मेरी एक पिछली चुनौती है। उस सवाल और दो सड़कों की लोकप्रियता के कारण एक पीले रंग की लकड़ी (भाग 1) में , मैं एक तीसरा बनाना चाहता था। लेकिन पहले 2 बहुत आसान थे ( पहले पर एक 2-बाइट उत्तर, दूसरे पर 15-बाइट उत्तर)। इसलिए मैंने कुछ और जटिल बना दिया ...

प्रेरणा

यह चुनौती रॉबर्ट फ्रॉस्ट की प्रसिद्ध कविता, द रोड नॉट टेकन से प्रेरित है :

दो सड़कें एक पीले रंग की लकड़ी में निकलीं,
और खेद है कि मैं दोनों यात्रा नहीं कर सका
और एक ही यात्री हो सकता था, जब तक मैं
नीचे की ओर
झुकता था, तब तक मैं खड़ा था और एक को नीचे देखा ।

... 2 अनुच्छेदों की छंटनी की गई ...

मैं इसे
कहीं न कहीं युगों-युगों के साथ कह रहा हूँ इसलिए:
दो सड़कें एक लकड़ी में बदल जाती हैं, और मैंने -
मैंने एक कम यात्रा की,
और इससे सभी फर्क पड़ गए।

दूसरी से अंतिम पंक्ति पर ध्यान दें I took the one less traveled by,।

बैकस्टोरी

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

चुनौती

अपने लक्ष्य के लिए सड़क पर कम से कम यात्रा की गई सड़क को ढूंढना है जहां सड़क कांटे। आपका नक्शा एक स्ट्रिंग है जिसमें newlines (या \n, यदि आप पसंद करते हैं) और एक अज्ञात चौड़ाई और ऊंचाई है। मानचित्र में, सड़कें 0 से 9 तक बनी होती हैं , चौराहे एस से बने होते हैं #। आपको वह सड़क मिलनी चाहिए जो आप वर्तमान में हैं, और अन्य सड़कों में से जिस सड़क से सबसे अधिक यात्रा की गई है, और सड़क आपके अंधे साहसी के लिए कम यात्रा करती है। आप के नक्शे में मौजूद लकड़ियों को एक स्थान से दर्शाया गया है। यहाँ एक सरल नक्शा है:

यह नक्शा 5 चौड़ा और 5 लंबा है। ध्यान दें कि सड़क एक Y आकार में कैसे चलती है। Y किसी भी तरह से उन्मुख हो सकता है, इसलिए आपको "घुमाया हुआ" नक्शा समझने में सक्षम होना चाहिए।

क्या `#`मतलब है?

कहाँ नक्शा कांटे वहाँ एक हो जाएगा #। यह किसी भी पथ के स्कोर को प्रभावित नहीं करता है।

वास्तव में संख्याओं का क्या अर्थ है

प्रत्येक पथ (संख्याओं की एक पंक्ति, इसमें एक मोड़ हो सकता है) में एक अंक होता है। एक पथ का स्कोर उसके अंकों को जोड़कर निर्धारित किया जाता है, इसलिए पहले उदाहरण के लिए, पहले पथ (ऊपरी-बाएं, दक्षिणावर्त) का स्कोर 2 + 1 = 3 है, दूसरे का 2 + 0 = 2 है, और तीसरा है 2 + 2 = 4 है। सड़कों में तिरछे जुड़े नंबर हो सकते हैं।

तुम जहां हो वहीं खोजना

आप उच्चतम स्कोर के साथ पथ पर हैं। अन्य 2 रास्तों से यात्रा की जाने वाली सड़क अधिक है, और सड़क कम यात्रा करती है। आपको सबसे कम स्कोर वाली सड़क ढूंढनी होगी ।

अपने यात्री को बताना कि कहाँ जाना है

आपको अपने यात्री को "बाएं" या "दाएं" जाने के लिए कहना होगा। ध्यान रखें कि दिशा-निर्देश आपके यात्री के दृष्टिकोण से हैं (वह कांटे का सामना कर रहा है।)

उदाहरण के नक्शे

  14
9#  
  04

आउटपुट: "सही" (यात्री 9सड़क पर है, 0 + 4 <1 + 4

आउटपुट: "बाएं" (यात्री 99999सड़क पर है, 8 + 8 + 8 + 8 + 8> 8 + 8 + 8 + 8 + 7

02468      
     #98765
13579

आउटपुट: "सही" (यात्री 98765सड़क पर है, 0 + 2 + 4 + 6 + 8 <1 + 3 + 5 + 7 + 9)

आउटपुट: "सही" (यात्री 4422सड़क पर है, 4 + 4> 2 + 2)

आउटपुट "बाएं" (यात्री 999सड़क पर है, 8 + 8 + 8> 7 + 7 + 7

जानने के लिए सामान:

प्रत्येक पंक्ति को समान लंबाई बनाने के लिए रिक्त स्थान के साथ मानचित्र बनाए जाएंगे।
आपको STDOUT / कंसोल / स्ट्रिंग को फ़ाइल करना होगा leftया rightवैकल्पिक रूप से एक अनुगामी न्यूलाइन द्वारा अनुसरण करना होगा।
आपको इनपुट के रूप में या तो एक स्ट्रिंग लेनी चाहिए जिसमें newlines, \ns, या एक सरणी / लाइनों की सूची (प्रत्येक पंक्ति एक स्ट्रिंग है)। उस इनपुट को एक फ़ंक्शन, कमांड-लाइन तर्क, फ़ाइल, या STDIN एक समय या इसी तरह होना चाहिए। एक चर एक स्वीकार्य इनपुट डिवाइस नहीं है (जब तक कि यह एक फ़ंक्शन पैरामीटर नहीं है।) इसी तरह, जेएस और अन्य भाषाओं में फ़ंक्शन अभिव्यक्तियों को एक चर के लिए सौंपा जाना चाहिए।
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!
मानक खामियों को मना किया

चीजें आप मान सकते हैं

आपका इनपुट मान्य होगा। ऐसा कुछ नहीं के लिए परीक्षण किया जाएगा:

० ० ०
 ० ०
  #
 ० ०

पाथ्स के स्कोर कभी भी बंधे नहीं होंगे।
इनपुट आपकी भाषा की स्ट्रिंग सीमा से कम चौड़ाई या ऊंचाई में किसी भी लंबाई का हो सकता है।
2 रास्तों के बीच हमेशा कम से कम 1 स्थान होगा।
पथ में मोड़, मोड़ आदि हो सकते हैं, ये सड़कें हैं, राजमार्ग नहीं।

कोई भी प्रश्न है? नीचे टिप्पणी और खुश गोल्फ में मुझसे पूछो!

code-golf ascii-art decision-problem

— programmer5000
स्रोत

क्या #हमेशा केंद्र में क्षैतिज रूप से होगा?

— डेविड आर्किबाल्ड

मुझे लगता है कि यह आपके लिए सैंडबॉक्स का उपयोग करने का समय है । और शायद कुछ नई प्रेरणा मिल जाए। इस दर पर, ऐसा लगता है कि आप एक दिलचस्प चुनौती श्रृंखला बनाने की तुलना में एक कविता को बढ़ावा दे रहे हैं। खासकर जब से आप हर एक को छोड़कर कविता पोस्ट करते हैं। हम पहले से ही इसे देख चुके हैं, यह काफी है।

— mbomb007

देखो। मुझे आपकी चुनौतियाँ पसंद आई हैं, लेकिन बस कुछ कठिनाई को जोड़ना तो 3 को भी पोस्ट करने में बिना एक को स्वीकार किए 2 pt बहुत तेज़ है। 2 से संपादित करें रोटेशन, मामूली आउटपुट और इतने पर के मामूली बदलाव के लिए पर्याप्त होगा ।

— डेविड आर्चीबाल्ड

यह पिछले वाले से एक बहुत अलग चुनौती है और मुझे यह पसंद है ... हम वाई आकार ले सकते हैं जैसा कि (एक रास्ता हमेशा एक छोर पर समाप्त होता है और दूसरे दो को किनारे पर होता है), है ना?

— dnep

@dnep हाँ आप सही हैं।

— प्रोग्रामर

डी , 348 321 312 302 बाइट्स

import std.stdio,std.algorithm,std.regex,std.range;void h(R,U)(R s,U r){U[2]c;foreach(L;s.map!(a=>a.array.split)){U l=L.length-1;r>1?r=l^r-2:0;l?c[]+=l*L.map!sum.array[]:c;}write(c[r]>c[!r]?"right":"left");}void main(){auto s=stdin.byLineCopy.array;!s.join.match(`\d \d`)?h(s.transposed,2UL):h(s,3UL);}

Ungolfed

import std.stdio,std.algorithm,std.regex,std.range;

void h(R,U)(R s, U reverse) {
    U[2] counts;
    /* Now that all paths are up/down, every line we need to count up has
       precisely two space-delimited parts to sum up. */
    foreach (line; s.map!(a=>a.array.split)) {
        U len = line.length - 1;
        reverse > 1 ? reverse = len ^ reverse - 2 : 0;
        len ? counts[] += len * line.map!sum.array[] : counts;
    }

    /* Switch left/right as needed based on our orientation */
    write(counts[reverse] > counts[!reverse] ? "right" : "left");
}

void main() {
    /* Treat the input as a matrix of integers */
    auto s = stdin.byLineCopy.array;

    /* If moving left/right intead of up/down, transpose */
    !s.join.match(`\d \d`)?h(s.transposed,2UL):h(s,3UL);
}

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

— रे
स्रोत

पहले उत्तरदाता होने पर बधाई! आप इसे जीत सकते हैं ... क्या आप डी से लिंक कर सकते हैं?

— प्रोग्रामर

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

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

A=input()
S=str(A)[2:-2].replace("', '",'')
i=S.index('#')
r=len(A[0])
w=1
a=i/r
if' '<S[i-r]:w=-w;A=A[::w];a=len(A)+~a
if' '<S[i+1]:A=zip(*A[::-1]);a=i%r
if' '<S[i-1]:A=zip(*A)[::-1];a=len(A)-i%r-1
s=0
for c in' '.join(map(''.join,A[0:a])).split():s+=sum(map(int,c));s=-s
print['left','right'][::w][s>0]

यह कार्यक्रम सड़कों की दिशा को घटाता है और इस चुनौती के भाग 2 से मेरे समाधान का उपयोग करने के लिए इसे घुमाता है।

— मृत पोसुम
स्रोत

2 बाइट्स से हराया! निराशा के बारे में बात करो!

— caird coinheringaahing

@ user00001 यही कारण है कि मैं बहुत रोता हूं

— डेड

एक पीले रंग की लकड़ी में दो सड़कें (भाग 3)