यह एक श्रृंखला में दूसरा है, तीसरी दो सड़कें हैं जो एक पीली लकड़ी में विभाजित हैं (भाग 3)

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

प्रेरणा

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

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

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

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

दूसरी से अंतिम पंक्ति पर ध्यान दें I took the one less traveled by,। आपका लक्ष्य अपने स्ट्रिंग इनपुट में कम से कम यात्रा की गई सड़क को खोजना है। आपको 2 मानों में से एक का उत्पादन करना चाहिए जो एक दूसरे से अलग होते हैं जो उस संकेत को कहते हैं जिस मार्ग से आपको कम यात्रा करनी चाहिए। एक बार सड़क के कांटे (हेक्सागोन्स का निशान संख्याओं में बदल जाता है) आप चौराहे पर हैं। वहां से, अंकों से बने 2 मार्ग होंगे। जिस पथ के अंकों में सबसे कम राशि होगी, वह मार्ग नहीं लिया जाएगा। ध्यान दें कि नहीं ली गई सड़क में एक बड़ा पथ हो सकता है, लेकिन कम पथ राशि हो सकती है। यहां दिए गए पथ के लिए "बाएं" या "दाएं" प्रिंट करने वाले प्रोग्राम से कुछ उदाहरण / परीक्षण मामले हैं:

 1     2
  1   2
   1 2
    #
    #
    #
left (3 < 6)


 1     2
  2   2
   1 1
    #
    #
    #
left (4 < 5)


 12    2
  11  2
   1 1
    #
    #
    #
right (6 > 5)


 99   989
  99  89
  99 99
  99 99
    #
    #
    #
   # 
left (72 < 79)


1111 1110
 001 111
  11 11
  11 11
    #
   ##
  ##
 ##  
left (9 < 10) (Note: 1111 is interpreted as 1+1+1+1=4, not 1111=1111)


1       1
 0     1
  1   1
  1   1
  1   1
  1   1
   1 1 
    #
    #
    #
     #
      #
left (6 < 7)


1   1 
 0   1  
  1   1
  1   1
  1   1
  1   1
   1 1 
    #
    #
    #
     #
      #
left (6 < 7)

चीजों को ग्रहण करना और याद रखना

हमेशा 2 रास्ते होंगे। न आधिक न कम।
आप एक समय में STDIN एक लाइन से इनपुट ले सकते हैं, एक स्ट्रिंग जिसमें LF अक्षर होते हैं, या एक स्ट्रिंग जिसमें शाब्दिक बैकलैश और एक n होता है। यदि आपको किसी अन्य तरीके से इनपुट की आवश्यकता है, तो टिप्पणियों में अनुमोदन के लिए पूछें।
आपको अमान्य इनपुट या बंधे रास्तों के बारे में चिंता करने की आवश्यकता नहीं है। जिन्हें आपके प्रोग्राम / फंक्शन में कभी भी इनपुट नहीं किया जाएगा।
इनपुट आपकी भाषा की स्ट्रिंग सीमा से कम चौड़ाई या ऊंचाई में किसी भी लंबाई का हो सकता है।
#एक ही लाइन में एक नंबर और एक नंबर कभी नहीं होगा ।
मार्ग के सभी अंक सकारात्मक पूर्णांक 0 से 9 हैं।
अनुगामी न्यूलाइन के साथ इनपुट या आउटपुट की अनुमति है।
देखें मेरी जे एस ES6 जवाब एक उदाहरण के लिए नीचे दिए गए।
2 रास्तों के बीच हमेशा कम से कम 1 स्थान होगा।
2 रास्तों में हमेशा प्रत्येक नक्शे के लिए समान ऊँचाई होगी, लेकिन अन्य मानचित्रों पर भिन्न हो सकती है।
यदि आप किसी विशिष्ट परीक्षण मामले के बारे में उलझन में हैं, तो कृपया मुझे बताएं।
1111 की व्याख्या 1 + 1 + 1 + 1 = 4 के रूप में की जाती है, 1111 = 1111 के रूप में नहीं। नक्शा एक-अंकीय संख्याओं की एक श्रृंखला है, न कि मनमानी लंबाई की संख्या।
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!
मानक खामियों को मना किया

यदि आपके पास इस चुनौती के बारे में कोई प्रश्न है, तो मुझे टिप्पणियों में पूछें, और शुभकामनाएँ!

code-golf ascii-art decision-problem

— programmer5000
स्रोत

अरे, आप $("div > h1").map(function(){return $(this).text()}).get().join("\n");अपने कंसोल में पेस्ट करके सभी उत्तर और उनकी बाइट गिनती देख सकते हैं !

— प्रोग्रामर

1

हटाए गए व्हाट्सएप और नजरअंदाज किए गए स्ट्राइकथ्रू उत्तरों के साथ यहां एक वैकल्पिक संस्करण है

let answers = $('div > h1').map(function(){return $(this).clone().children(':not(a)').remove().end().text().replace(/\s+/g,' ').trim()}).get();answers.splice(0, 1);answers.join('\n');

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

2

A # षट्भुज नहीं है ...

— user253751

1

" लेकिन यह भी काफी तुच्छ था (52 बाइट्स में जावा उत्तर!) " अब 43 बाइट्स। ;)

— केविन क्रूज़सेन

फिर से बंद? आख़िर तुम्हारे साथ समस्या क्या है?

— मैथ्यू रोह

2

05AB1E , 21 15 बाइट्स

आउटपुट 0 के लिए बाएं और दाएं के लिए 1 है।

|vy#õK€SO})øO`›

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

व्याख्या

|v                # for each line in input
  y#              # split on spaces
    õK            # remove empty strings
      €S          # split each string into a list of chars
        O         # sum each sublist
         }        # end loop
          )ø      # wrap stack in a list and zip
            O     # sum each sublist (side of the tree)
             `›   # compare left to right

— Emigna
स्रोत

11

रेटिना , 28 बाइट्स

\d
$*
%r`1\G
-
Os`.
+`-1

1+

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

0बाएं और 1दाएं के लिए प्रिंट । मान लेता है कि किसी भी रेखा पर अनुगामी स्थान नहीं हैं।

व्याख्या

\d
$*

प्रत्येक अंक Nको एक रन में बदलें N।

%r`1\G
-

प्रत्येक पंक्ति ( %), \Gअंत से लगातार ( ) वाले से मेल खाती है ( r) और उनमें से प्रत्येक को प्रतिस्थापित करें -(यानी सही शाखा को -एस में बदल दें )।

Os`.

सभी वर्णों को क्रमबद्ध करें, ताकि सभी -s सीधे सभी 1s के सामने हों ।

+`-1

बार-बार की एक जोड़ी को रद्द -और 1।

1+

कम से कम एक मिलान करने का प्रयास करें 1(यदि ऐसा है, तो बाएं मार्ग में अधिक वजन थे)।

— मार्टिन एंडर
स्रोत

7

पायथन 2 , 95 89 88 87 बाइट्स

यहाँ अजगर में यह मेरी पहली यात्रा है। निश्चित रूप से इष्टतम नहीं बल्कि एक अच्छी शुरुआत है।

f=lambda x,i:sum(sum(map(int,y))for y in x.split()[i::2]if"#"<y)
lambda x:f(x,1)>f(x,0)

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

— गेहूं का जादूगर
स्रोत

मुझे लगता है कि आप की जगह ले सकता "#"!=yसाथ"#"<y

— गणित जंकी

7

चिप , 216 बाइट्स

 EZ,Z~.
E~]x-.|
F].>vm'
Ax]}#----------------.
Bx]}#---------------.|z.
Cx]}#------------.,Z|##' E
Dx]}#---------.,Z|`@@('A~^~t
 E.>#------.,Z|`@@-('
A~S`#v--.,Z|`@@-('
*f,--<,Z|`@@-('
e |,Z|`@@-('
,Z|`@@-('
>@@-('
a

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

भाग 1 के उत्तर से थोड़ा बड़ा ...

अवलोकन

चिप वास्तविक सर्किटरी से प्रेरित 2 डी भाषा है, और यह एक बाइट स्ट्रीम में प्रत्येक बाइट के घटक बिट्स के साथ संबंधित है।

यह समाधान उसके द्वारा देखे जाने वाले अंकों का एक चलता-फिरता योग रखता है, हर बार इनपुट के संकेत को फ़्लिप करने पर यह व्हाट्सएप के खिंचाव का सामना करता है, फिर पहले पर समाप्त होता है #। तो, इनपुट के लिए

हमें मिलता है 1 + 1 - 1 - 2 + 2 - 2 + 1 - 1 = -1। परिणाम का संकेत आउटपुट के रूप में दिया जाता है, एक नकारात्मक संख्या परिणाम का उत्पादन करती है 1, और सकारात्मक है 0।

इसलिए, आउटपुट का 1अर्थ है कि बाएं मार्ग को कम लिया गया है, और 0सही का मतलब है।

व्याख्या

एक उच्च स्तर पर, यह है कि यह कैसे काम करता है:

@तत्वों के साथ मुख्य विकर्ण संचयकर्ता है, उत्पादन aनीचे से तय किया जाता है । (आठ जोड़े का @अर्थ है आठ बिट्स, लेकिन सबसे अधिक बिट संकेत है, इसलिए यह समाधान +12 या या -128 के अधिकतम अंतर को संभाल सकता है। अतिप्रवाह वाला भाग ठीक है, जब तक कि हम समाप्त होने से पहले वापस आ जाते हैं।)

चार लाइनें जो शुरू होती हैं Ax]}#--... जैसे इनपुट पढ़ रहे हैं, और एक अंक के मामले में, इसे नकारने (यदि आवश्यक हो) और मूल्य को जोड़ में पारित कर रहे हैं।

पहली तीन पंक्तियाँ तय करती हैं कि क्या हम किसी अंक या व्हाट्सएप के अनुक्रम को देख रहे हैं और इस बात का ध्यान रखें कि अंकों को नकारने की आवश्यकता है या नहीं।

शेष तत्वों को इनपुट के तहत और तत्वों को सही तरीके से समाप्त करने की समाप्ति स्थिति को संभालती है, और आउटपुट को ASCII में मैप करती है (ताकि हमें वर्ण मिले '0'या '1'मूल्यों के बजाय 0x0या 0x1। इस ASCII मैपिंग के लिए अतिरिक्त बाइट्स की आवश्यकता नहीं थी, अन्यथा मैं नहीं करूंगा। इसे शामिल किया है।)

— Phlarx
स्रोत

2

मुझे पसंद है कि कोड थोड़े दो मोड़ वाली सड़कों की तरह दिखता है।

— लाकोनी

@ लैकोनी मैंने भी नहीं देखा था, कि थोड़े शांत हैं :)

— फार्लेक्स

4

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

x=>x.replace(/\d(?=.*( )|)/g,(d,s)=>t-=s?d:-d,t=0)&&t<0

मान लिया गया प्रत्येक पंक्ति पर कोई रिक्ति, और आउटपुट देखते हैं trueके लिए right, falseके लिए left। चाल इनपुट में प्रत्येक अंक से मेल खाना है, और यदि एक ही पंक्ति पर इसके बाद एक स्थान है, तो इसे कुल से घटाएं; अन्यथा, इसे कुल में जोड़ें। यदि अंतिम कुल 0 से कम है, तो सही सड़क एक कम यात्रा है, और इसके विपरीत।

कोशिश करके देखो:

f=x=>x.replace(/\d(?=.*( )|)/g,(d,s)=>t-=s?d:-d,t=0)&&t<0

<textarea placeholder = "paste in a map here..." oninput = "document.querySelector('div').innerText = f(this.value)"></textarea>
<div></div>

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

— ETHproductions
स्रोत

आपको x=शुरुआत में डालने की आवश्यकता है , क्योंकि अभिव्यक्तियों की अनुमति नहीं है, केवल एक चर और पूरे कार्यक्रमों के रूप में संग्रहीत फ़ंक्शन।

— प्रोग्रामर

@ प्रोग्रामर 5000 क्यों? यह चूक को ओवरराइड करने के लिए थोड़ा अजीब लगता है और यह इंगित नहीं करता है कि यह प्रश्न में मामला है।

— गेहूं जादूगर

1

@ programmer5000 वास्तव में, डिफ़ॉल्ट रूप से अनाम कार्यों की अनुमति है । (स्निपेट, btw के लिए धन्यवाद)

— ETHproductions

4

पायथन 3 , 85 94 बाइट्स

import re
g=lambda s,i:sum(map(int,''.join(re.findall('\d+',s)[i::2])))
lambda s:g(s,0)>g(s,1)

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

शाप! समस्या को काफी करीब से नहीं पढ़ा। फिक्स जोड़ा ( ''.join()), लेकिन 9 बाइट्स की कीमत पर।

— आकड़ों का प्रवाह
स्रोत

बहुत करीब! अच्छी पकड़, धन्यवाद!

— डेटास्ट्रीम

3

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

-1 बाइट थैंक्स टू @math_junkie

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

def F(S,r=0):
 for c in S.split():
    if'#'<c:r+=sum(map(int,c));r=-r
 print r>0

Falseबाएं रास्ते के लिए और Trueदाएं के लिए प्रिंट

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

r=-rइसके बजाय r*=-1एक बाइट बचाना चाहिए

— गणित नशेड़ी

2

रेटिना , 180 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

^(?=( *(0|(1|(?<3>2|(?<3>3|(?<3>4|(?<3>5|(?<3>6|(?<3>7|(?<3>8|(?<3>9))))))))))+.+¶)+)(.+ (0|(?<-3>1|(?<-3>2|(?<-3>3|(?<-3>4|(?<-3>5|(?<-3>6|(?<-3>7|(?<-3>8|(?<-3>9))))))))))+¶)+ *#

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

मैंने सोचा कि मैं भी एक रेग्ज-ओनली सॉल्यूशन आज़माऊँगा (ऊपर एक प्लेन .NET रेगेक्स है जो केवल इनपुट्स से मेल खाता है जहाँ सही रास्ते को लिया जाना चाहिए, सिवाय उपयोग के ¶ शॉर्टहैंड के रूप में लिए \n)।

यह कष्टप्रद दोहराव है, लेकिन ऐसा तब होता है जब आपको व्यक्तिगत रूप से प्रत्येक संभव अंक का इलाज करना होता है।

समाधान संतुलन समूहों का एक काफी सीधा-सीधा अनुप्रयोग है : सबसे पहले हम बाईं शाखा में अंकों को प्रत्येक अंक के लिए Nस्टैक पर धक्का देकर योग करते हैं । फिर हम सही शाखा में प्रत्येक अंक के लिए स्टैक बार से पॉपिंग करते हुए, तक पहुंचने की कोशिश करते हैं । यह केवल तभी संभव है जब बाईं शाखा में अंकों का योग दाहिनी शाखा में अधिक से अधिक हो (क्योंकि आप खाली स्टैक से पॉप नहीं कर सकते हैं)।3N#3 NN

— मार्टिन एंडर
स्रोत

मैं .NET रेगेक्स से परिचित नहीं हूं, लेकिन क्या आप एक वर्ण सेट नहीं कर सकते हैं: [0-9]सभी अंकों से मिलान करने के लिए या \d?

— प्रोग्रामर

@ programmer5000 बेशक, लेकिन फिर मैं यह निर्धारित करने के लिए उनके बीच अंतर नहीं कर सकता कि उन्हें योग करने के लिए मुझे कितने कैप्चर करने चाहिए।

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

2

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

s=b=>(b=b.split`\n`,c=0,d=0,b.forEach(a=>{a=a.match(/\d+/g)||[],c+=+(a[0]?a[0]:0),d+=+(a[1]?a[1]:0)}),c<d)

~~s=b=>(b=b.split("\n"),c=0,d=0,b.forEach(a=>{a=a.match(/\d+/g)||[],c+=+(a[0]?a[0]:0),d+=+(a[1]?a[1]:0)}),c<d)~~

sएक ऐसा फंक्शन है जो trueअगर वापस नहीं लिया जाता है तो सड़क बाईं तरफ है। Ungolfed:

var proc = function(str){
    str = str.split("\n");
    var left = 0;
    var right = 0;
    str.forEach(item=>{
        var match = item.match(/\d+/g) || [];
        console.log(match);
        left += +(match[0] ? match[0] : 0);
        right += +(match[1] ? match[1] : 0);
    });
    return left < right;
};

s=b=>(b=b.split`\n`,c=0,d=0,b.forEach(a=>{a=a.match(/\d+/g)||[],c+=+(a[0]?a[0]:0),d+=+(a[1]?a[1]:0)}),c<d)

<textarea placeholder = "paste in a map here..." oninput = "document.querySelector('div').innerText = s(this.value)"></textarea>
<div></div>

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

— programmer5000
स्रोत

मुझे आशा है कि किसी को इससे बेहतर स्कोर मिल सकता है ...

— प्रोग्रामर

चैलेंज स्वीकार किया @ प्रोग्रामर

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

@DavidArchibald किसी ने पहले ही कर दिया था, लेकिन मैं एक नए उत्तर की सराहना करूंगा। क्या आप श्रृंखला में तीसरे में रुचि रखते हैं ?

— प्रोग्रामर

ज़रूर। एहसास नहीं था वहाँ 3 थे

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

2

पॉवरशेल , 80 बाइट्स

$args-split'\s|#'-ne''|%{$a+=(($i=[char[]]$_-join'+'|iex),-$i)[($x=!$x)]};$a-gt0

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

(पायथन के जवाबों के तहत बस चीखना ।: D)

Trueबाएं रास्ते के Falseलिए और सही रास्ते के लिए आउटपुट ।

एक स्ट्रिंग के रूप में इनपुट लेता है `n, जिसके साथ "एक शाब्दिक बैकस्लैश और एक एन युक्त स्ट्रिंग" या एक शाब्दिक मल्टीलाइन स्ट्रिंग के रूप में पॉवरशेल होता है। फिर हम -splitउस इनपुट पर \s(व्हॉट्सएप सहित नईलाइन) या #सभी खाली परिणामों को फ़िल्टर करते हैं -ne'', इसलिए हम अंकों के एक सरणी के साथ छोड़ दिए जाते हैं। जिन्हें एक लूप में खिलाया जाता है |%{...}।

प्रत्येक पुनरावृत्ति, हम पहले वर्तमान तत्व को लेते हैं $_, इसे एक charसरणी के रूप में डालते हैं, -joinइसे एक प्लस चिह्न के साथ जोड़ते हैं +, और इसे iex(संक्षेप में Invoke-Expressionऔर इसके समान eval) पाइप करते हैं । $iइसलिए हम इस पथ के इस विशेष भाग पर अंकों को ठीक से जमा करते हैं । हम एक सरणी के दो तत्वों के रूप में इसके और इसके नकारात्मक का उपयोग करते हैं ($i, -$i), जो बूलियन मान को आगे और पीछे फ्लिप करके अनुक्रमित करते हैं। अर्थ, इस लूप के माध्यम से पहला पुनरावृत्ति, पहला बाएं मार्ग का हिस्सा, हम इसमें अनुक्रमित करेंगे -$i; अगली बार, हम लेंगे $i; और इसी तरह। जिनके $aसाथ संचित हैं +=।

अंत में, हम का मूल्यांकन है कि क्या $aहै -greater tहान 0। यदि यह है, तो सही मार्ग में एक बड़ा योग था, अन्यथा बाएं मार्ग में एक बड़ा योग था। उस बूलियन परिणाम को पाइपलाइन पर छोड़ दिया गया है, और आउटपुट निहित है।

— AdmBorkBork
स्रोत

2

CJam , 19 18 बाइट्स

qN/Sf%z{'1*:~:+}/>

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

0बाएं और 1दाएं के लिए प्रिंट ।

व्याख्या

q      e# Read all input.
N/     e# Split into lines.
Sf%    e# Split each line around runs of spaces.
z      e# Transpose to group each branch.
       e# Note that each branch will have the same number of digit segments
       e# now but the first branch will also have all the #s at the end in
       e# separate segments.
{      e# For each branch...
  '1*  e#   Join the segments into a single string with 1s as separators.
       e#   This will add the same number of 1s between digit segments in
       e#   both branches (which won't affect their relative sum) and it 
       e#   will also insert a 1 before each # in the first branch.
  :~   e#   Evaluate each character. The digit characters are simply turned
       e#   into their values, but # is the exponentiation operator in CJam.
       e#   This is why we inserted those additional 1s, because 1# is a no-op.
  :+   e#   Sum the digits in the branch.
}/
>      e# Check whether the left branch's sum is greater than the right one's.

— मार्टिन एंडर
स्रोत

1

मैथेमेटिका, 80 77 बाइट्स

3 बाइट्स बचाने के लिए मार्टिन एंडर को धन्यवाद!

#<#2&@@Total@Partition[Tr/@ToExpression[Characters@StringSplit@#/."#"->0],2]&

शुद्ध फ़ंक्शन इनपुट के रूप में एक नईलाइन-सीमांकित स्ट्रिंग Trueले रहा है, और दाएं पथ लेने के लिए बाएं पथ Falseको वापस ले रहा है। लानत है उन लंबे गणितज्ञों के नाम; यह 10 टोकन की तरह है।

— ग्रेग मार्टिन
स्रोत

0

पिप , 19 18 बाइट्स

LR+XDax:-x+$+$0SGx

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

व्याख्या

अंकों के रनों से अधिक लूप्स, अंकों को एक टैली में जोड़ते हैं। टैली के चिह्न को हर बार स्वैप किया जाता है, जिसके अंतिम परिणाम में बाएं हाथ के मान नकारात्मक होते हैं और दाएं हाथ के मूल्य सकारात्मक होते हैं। फिर हम अंतिम टैली ( -1या 1) का चिह्न प्रिंट करते हैं ।

                    a is 1st cmdline arg; XD is regex `\d`; x is "" (implicit)
                    Note that "" in a math context is treated as 0
  +XD               Apply regex + to XD (resulting in `\d+`)
LR   a              Loop over matches of that regex in a:
             $0      Regex match variable containing the full match
           $+        Sum digits by folding on +
      x:-x+          Swap the sign of the tally and add this sum
               SGx  After the loop, print the sign of the tally

— DLosc
स्रोत

0

हास्केल , 64 बाइट्स

g=sum.map fromEnum
f(a:b:r)|a>"#"=g a-g b+f r|1<3=0
(>0).f.words

इसे ऑनलाइन आज़माएं! उपयोग: अनाम फ़ंक्शन (>0).f.wordsतर्क के रूप में एक नई पंक्ति से अलग स्ट्रिंग लेता है और Falseबाईं और Trueदाईं ओर लौटता है ।

स्पष्टीकरण:

एक इनपुट दिया

यह स्ट्रिंग है " 99 989\n 99 89\n 99 99\n #\n #\n #", फिर wordsसभी नए लिंक और रिक्त स्थान को स्ट्रिप्स करता है और शेष स्ट्रिंग्स की एक सूची देता है ["99","989","99","89","99","99","#","#","#"]:। फ़ंक्शन fपहले दो तत्वों को लेता है aऔर bइस सूची से और यह जांचता है कि क्या aयह स्ट्रिंग "#" की तुलना करके अंकों का एक स्ट्रिंग है। (क्योंकि चार '#'अंकों वर्ण सब से छोटा होता है '0', '1'... हर स्ट्रिंग अंक के साथ शुरू करने से कोषगत बड़ा होगा "#"।) समारोह gअपने ASCII वर्ण कोड के लिए एक स्ट्रिंग में प्रत्येक चार नक्शे और उनके योग देता है। में fहम लागू gकरने के लिए aऔरb और गणना g a - g b, बाईं पथ शून्य से सही एक के मूल्य का मूल्य है, और करने के लिए एक पुनरावर्ती कॉल में जोड़नेfनिम्नलिखित पंक्तियों को संभालने के लिए। यदि बाएं मार्ग पर अधिक यात्रा की जाती है, तो परिणाम fनकारात्मक होगा और अन्यथा सही मार्ग के लिए सकारात्मक होगा, इसलिए (>0)जाँच करता है कि परिणाम शून्य से बड़ा है या नहीं।

— Laikoni
स्रोत

0

पायथन 3 , 84 बाइट्स

चूंकि सभी मौजूदा पायथन सबमिशन फ़ंक्शंस हैं, मैंने सोचा कि मैं एक पूर्ण कार्यक्रम में योगदान दूंगा।

x=0
try:
 while 1:
  for n in input().split():x=-x+sum(map(int,n))
except:print(x>0)

Trueयदि बाईं राह कम यात्रा की जाती है, तो प्रिंट करें False। इसे ऑनलाइन आज़माएं!

इनपुट की प्रत्येक पंक्ति के लिए, यह व्हाट्सएप पर विभाजित होता है, प्रत्येक परिणामी तत्व के अंकों को जोड़ता है, और प्रत्येक चरण में टैली के संकेत को फ़्लिप करते हुए इसे एक टैली में जोड़ता है। यह इनपुट की रीडिंग लाइनों को तब तक जारी रखता है जब तक कि यह एक के साथ एक हिट नहीं करता है #, जिस बिंदु पर map(int,n)एक अपवाद उठता है और हम लूप से बाहर निकलते हैं, Trueयदि मुद्रण सकारात्मक है और Falseअन्यथा।

— DLosc
स्रोत

0

बैच, 169 बाइट्स

@echo off
set/as=0
:l
set/pr=
if not %r: =%==# call:c - %r%&goto l
cmd/cset/a"s>>9
exit/b
:c
call:r + %3
:r
set/as%1=%2%%10,d=%2/10
if %d% gtr 0 call:r %1 %d%

जोड़ने के लिए अंकों को संभालने के 0लिए बाईं, सबरूटीन के लिए प्रिंट और फिर पहले दो मापदंडों को संभालने के लिए गिरता है। इसका मतलब यह है कि उप-रेखा को और बाएं और दाएं अंकों के मापदंडों के साथ कॉल करने से दाएं अंक जुड़ जाएंगे और बाईं ओर के अंकों को घटाएंगे। अंत में परिणाम साइन को निकालने के लिए स्थानांतरित कर दिया जाता है।-1 दाईं ओर के लिए। नोट: लाइनों को तब तक पढ़ता है जब तक कि वह एक के साथ नहीं मिलती है #, फिर पढ़ना बंद कर देता है। पथ राशि में अंतर 511 तक सीमित है (बड़े अंतर का समर्थन करने के लिए 1 बाइट जोड़ें)। प्रत्येक पथ की प्रत्येक पंक्ति में 9 अंकों से अधिक नहीं (किसी भी संख्या में पंक्तियों का समर्थन करता है)। स्पष्टीकरण:d सबरूटीन दो पैरामीटर लेता है: चाहे जोड़ना या घटाना और अंक (ओं) को। यह अंतिम अंक को modulo द्वारा 10 और शेष अंकों को 10 से विभाजित करके निकालता है और खुद को पुनरावर्ती कहता है जबकि अभी भी अंक शेष हैं। cसबरूटीन तीन पैरामीटर लेता है: जोड़ने के लिए किया जाए या घटाना, अंक जोड़ सकते हैं या घटाना, और आगे अंक जोड़ने के लिए। यह कहता हैdc-

— नील
स्रोत

0

ऑक्टेव, 46 बाइट्स

@(a)diff((a(:)-48)'*(bwlabel(a>35)(:)==1:2))<0

इसे ऑनलाइन आज़माएं! एक फ़ंक्शन जो aइनपुट के रूप में एक 2 डी चरित्र सरणी लेता है ।

स्पष्टीकरण:

a=

    1   1  
     0   1 
      1   1
      1   1
      1   1
      1   1
       1 1 
        #  
        #  
        #  
         # 
          #

a > 35                   %convert the matrix to a binary matrix
                         %where there is a number corresponing
                         %element of the binary matrix is 1.

*   *  
 *   * 
  *   *
  *   *
  *   *
  *   *
   * * 

bwlabel(a>35)            %label each connected component. 


1   2  
 1   2 
  1   2
  1   2
  1   2
  1   2
   1 2 

B=bwlabel(a>35)(:)==1:2  % a binary `[n ,2]` matrix created 
                         % each column related to one of labels

A=(a(:)-48)'             % convert array of characters to array of numbers 

A * B                    % matrix multiplication that computes 
                         % the sum of numbers under each label

diff(A*B)<0              % check if the left is grater than the right

— rahnema1
स्रोत

0

जावा 7, 219 216 बाइट्स

boolean c(String s){int l=0,r=0;for(String x:s.split("\n")){l+=f(x,0);r+=f(x,1);}return l>r;}int f(String x,int i){if(x.contains("#"))return 0;int n=0;for(int c:x.trim().split("\\s+")[i].getBytes())n+=c-48;return n;}

इस समय 52 बाइट्स से अधिक लंबा है । ;)
और फिर से falseदाईं ओर लौटता है औरtrue बाएं के लिए ।

स्पष्टीकरण:

boolean c(String s){              // Method with String parameter and boolean return-type
  int l=0, r=0;                   //  Right and left counters
  for(String x : s.split("\n")){  //  Loop over de lines
    l += f(x,0);                  //   Add all left digits to the left-counter
    r += f(x,1);                  //   Add all right digits to the right-counter
  }                               //  End of loop
  return l>r;                     //  Return whether the left-counter is larger than the right-counter
}                                 // End of method

int f(String x, int i){           // Separate method with String and integer parameters, and int return-type
  if(x.contains("#"))             //  If the current line contains "#"
    return 0;                     //   Simply return 0
  int n=0;                        //  Counter
  for(int c :                     //  Loop over the digits by
              x.trim()            //    first removing leading and trailing whitespaces
              .split("\\s+")      //    then split them right in the middle
              [i]                 //    then pick either the left or right side based on the int index parameter
              .getBytes())        //    and convert that String to a byte-array
    n += c-48;                    //   For each of those digit-characters: add it to the counter
                                  //  End of loop (implicit / single-line body)
  return n;                       //  Return the counter
}                                 // End of separate method

टेस्ट कोड:

इसे यहाँ आज़माएँ।

class M{
  boolean c(String s){int l=0,r=0;for(String x:s.split("\n")){l+=f(x,0);r+=f(x,1);}return l>r;}int f(String x,int i){if(x.contains("#"))return 0;int n=0;for(int c:x.trim().split("\\s+")[i].getBytes())n+=c-48;return n;}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c(" 1     2\n  1   2\n   1 2\n    #\n    #\n    #"));
    System.out.println(m.c(" 1     2\n  2   2\n   1 1\n    #\n    #\n    #"));
    System.out.println(m.c(" 12    2\n  11  2\n   1 1\n    #\n    #\n    #"));
    System.out.println(m.c(" 99   989\n  99  89\n  99 99\n  99 99\n    #\n    #\n    #\n   # "));
    System.out.println(m.c("1111 1110\n 001 111\n  11 11\n  11 11\n    #\n   ##\n  ##\n ##  "));
    System.out.println(m.c("1       1\n 0     1\n  1   1\n  1   1\n  1   1\n  1   1\n   1 1 \n    #\n    #\n    #\n     #\n      #"));
    System.out.println(m.c("1   1 \n 0   1 \n  1   1\n  1   1\n  1   1\n  1   1\n   1 1 \n    #\n    #\n    #\n     #\n      #"));
  }
}

आउटपुट:

false
false
true
false
false
false
false

— केविन क्रूज़सेन
स्रोत

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

प्रेरणा

चीजों को ग्रहण करना और याद रखना

05AB1E , 21 15 बाइट्स

रेटिना , 28 बाइट्स

व्याख्या

पायथन 2 , 95 89 88 87 बाइट्स

चिप , 216 बाइट्स

अवलोकन

व्याख्या

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

पायथन 3 , 85 94 बाइट्स

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

रेटिना , 180 बाइट्स

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

पॉवरशेल , 80 बाइट्स

CJam , 19 18 बाइट्स

व्याख्या

मैथेमेटिका, 80 77 बाइट्स

पिप , 19 18 बाइट्स

व्याख्या

हास्केल , 64 बाइट्स

पायथन 3 , 84 बाइट्स

बैच, 169 बाइट्स

ऑक्टेव, 46 बाइट्स

जावा 7, 219 216 बाइट्स