দুটি রাস্তা হলুদ কাঠে বিভক্ত (অংশ 2)


25

এটি একটি সিরিজের দ্বিতীয়, তৃতীয়টি হলুদ কাঠে দুটি রাস্তা বিভক্ত (অংশ 3)

এটি হলুদ কাঠে বিভক্ত দুটি রাস্তার উপর ভিত্তি করে (অংশ 1) আমার একটি পূর্ববর্তী চ্যালেঞ্জ । এটি মোটামুটিভাবে ভালভাবে গ্রহণ করা হয়েছিল, তবে এটি মোটামুটি তুচ্ছ ছিল (52 বাইটে একটি জাভা উত্তর!) তাই আমি আরও জটিল কিছু তৈরি করেছি ...

অনুপ্রেরণা

এই চ্যালেঞ্জটি রবার্ট ফ্রস্টের বিখ্যাত কবিতা "দ্য রোড নট টেকন" দ্বারা অনুপ্রাণিত:

দুটি রাস্তা হলুদ কাঠে বিভক্ত হয়ে গেছে,
এবং দুঃখিত আমি দুজনেই ভ্রমণ করতে পারিনি
এবং একজন পথিক হতে পারলাম, আমি দাঁড়িয়ে দাঁড়িয়ে
একদিকে তাকালাম যতদূর
পেরোনোর ​​দিকে বাঁক হয়েছিল;

... 2 অনুচ্ছেদ ছাঁটা ...

আমি
যেহেতু যুগে যুগে যুগে যুগে যুগে যুগে দীর্ঘশ্বাস ফেলে বলছি :
দুটি রাস্তা একটি কাঠের দিকে বিভক্ত হয়েছিল , এবং আমি -
আমি যাতায়াতকৃত একটিকে কম করে দিয়েছি,
এবং এটি সমস্ত তাত্পর্য তৈরি করেছে।

দ্বিতীয় থেকে শেষ লাইনে লক্ষ্য করুন I took the one less traveled by,,। আপনার লক্ষ্যটি আপনার স্ট্রিং ইনপুটটিতে রাস্তাটি অন্তত ভ্রমণ করা সন্ধান করা find আপনাকে অবশ্যই দুটি মানগুলির মধ্যে একটির আউটপুট দিতে হবে যা একে অপরের থেকে স্বতন্ত্র signal এই সিগন্যালটি যে রাস্তাটি আপনাকে যাতায়াত দ্বারা কম ভ্রমণে যেতে হবে signal একবার রাস্তার কাঁটাচামচ (হেক্সাগনগুলির ট্রেইল সংখ্যায় পরিবর্তিত হয়) আপনি চৌরাস্তাতে এসেছেন। সেখান থেকে অঙ্কগুলি দিয়ে তৈরি 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 থেকে একবারে এক লাইনে ইনপুট নিতে পারেন, এলএফ অক্ষর যুক্ত স্ট্রিং, বা আক্ষরিক ব্যাকস্ল্যাশ এবং একটি এনযুক্ত স্ট্রিং। অন্য কোনও উপায়ে আপনার যদি ইনপুট দরকার হয় তবে মন্তব্যে অনুমোদনের জন্য জিজ্ঞাসা করুন।
  • আপনাকে অবৈধ ইনপুট বা বাঁধা পাথ সম্পর্কে চিন্তা করতে হবে না। এগুলি কখনই আপনার প্রোগ্রাম / ফাংশনে প্রবেশ করা যাবে না।
  • ইনপুটটি আপনার ভাষার স্ট্রিং সীমা চেয়ে কম প্রস্থ বা উচ্চতার কোনও দৈর্ঘ্যের হতে পারে less
  • #একই লাইনে কখনই একটি এবং একটি সংখ্যা থাকবে না ।
  • পাথের সমস্ত অঙ্কগুলি 0 থেকে 9 এর ধনাত্মক পূর্ণসংখ্যা।
  • একটি পিছনের নতুন লাইনের সাথে ইনপুট বা আউটপুট অনুমোদিত।
  • দেখুন আমার জাতীয় ES6 উত্তর একটি উদাহরণ জন্য নিচে।
  • সর্বদা 2 টি পথের মধ্যে কমপক্ষে 1 স্থান থাকবে।
  • 2 টি পাথের সর্বদা প্রতিটি মানচিত্রের জন্য একই উচ্চতা থাকবে তবে অন্যান্য মানচিত্রে আলাদা হতে পারে।
  • আপনি যদি একটি নির্দিষ্ট পরীক্ষার কেস সম্পর্কে বিভ্রান্ত হন তবে দয়া করে আমাকে বলুন।
  • 1111 111 = 1111 নয়, 1 + 1 + 1 + 1 = 4 হিসাবে ব্যাখ্যা করা হয়। মানচিত্রটি এক-অঙ্কের সংখ্যার একটি সিরিজ, যথেচ্ছ দৈর্ঘ্যের সংখ্যা নয়।
  • এটি , তাই বাইটের মধ্যে সংক্ষিপ্ত উত্তর!
  • স্ট্যান্ডার্ড লুফোলস নিষিদ্ধ

আপনার যদি এই চ্যালেঞ্জ সম্পর্কে কোনও প্রশ্ন থাকে তবে আমাকে মন্তব্যগুলিতে জিজ্ঞাসা করুন, এবং শুভকামনা!


আরে, আপনি $("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 # হেক্সাগন নয় ...
ব্যবহারকারী 253751

1
" তবে এটি মোটামুটি তুচ্ছ (52 বাইটে একটি জাভা উত্তর!) " এখন 43 বাইট। ;)
কেভিন ক্রুইজসেন

ক্লোজভোটস আবার? কি জাহান্নাম আপনার সঙ্গে ভুল?
ম্যাথু রোহ

উত্তর:


2

05 এ বি 1 ই , 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

11

রেটিনা , 28 বাইট

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

1+

এটি অনলাইন চেষ্টা করুন!

0বাম এবং 1ডানদিকে প্রিন্ট করুন । ধরে নেওয়া যায় যে কোনও লাইনে পিছনে স্থান নেই।

ব্যাখ্যা

\d
$*

প্রতিটি সংখ্যাকে একক Nএকটি রানে রূপান্তর করুন N

%r`1\G
-

প্রতিটি লাইন একটি ( %), একটানা ( \G) প্রান্তটি ( ) থেকে rমিলিত করুন এবং তাদের প্রত্যেককে প্রতিস্থাপন করুন -(অর্থাত্ ডান শাখাটি গুলিে পরিণত করুন -)।

Os`.

সমস্ত অক্ষর বাছাই করুন, যাতে সমস্ত -গুলি সমস্ত এস এর সামনে উপস্থিত থাকে 1

+`-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 এর উত্তরের চেয়ে কিছুটা বড় ...

সংক্ষিপ্ত বিবরণ

চিপ হ'ল প্রকৃত সার্কিটরি দ্বারা অনুপ্রাণিত 2D ভাষা এবং এটি বাইট স্ট্রিমের প্রতিটি বাইটের উপাদান বিট নিয়ে কাজ করে।

এই দ্রষ্টব্যটি এটি দেখায় এমন অঙ্কের চলমান যোগ রাখে, প্রতিবার যখন এটি হোয়াইটস্পেসের প্রসারিত হয় তারপরে ইনপুটটির চিহ্নটি উল্টে দেয় এবং তারপরে প্রথমে সমাপ্ত হয় #। সুতরাং, ইনপুট জন্য

 11   12
  2   2
   1 1
    #
    #
    #

আমরা পেতে 1 + 1 - 1 - 2 + 2 - 2 + 1 - 1 = -1। ফলাফলের চিহ্নটি আউটপুট হিসাবে দেওয়া হয়, একটি নেতিবাচক সংখ্যা ফলাফল দেয় 1, এবং ধনাত্মক হয় 0

সুতরাং, এর আউটপুট 1মানে বাম পথটি কম নেওয়া হয় এবং এর 0অর্থ ডান।

ব্যাখ্যা

একটি উচ্চ স্তরে, এটি এইভাবে কাজ করে:

@উপাদানগুলির সাথে প্রধান তির্যকটি হ'ল সঞ্চালক, আউটপুট aনীচে নীচে সিদ্ধান্ত নেওয়া হয় । ( @আট বিটের অর্থ আটটি বিট, তবে সর্বাধিক বিটটি হ'ল লক্ষণ, সুতরাং এই সমাধানটি সর্বাধিক +127 বা -128 এর পার্থক্য পরিচালনা করতে পারে part

চারটি লাইন যা শুরু করে Ax]}#--... তা ইনপুটটি পড়ছে, এবং কোনও অঙ্কের ক্ষেত্রে, এটিকে উপেক্ষা করে (যদি প্রয়োজন হয়) এবং সংযোজনকারীদের মধ্যে মানটি প্রেরণ করে।

প্রথম তিনটি লাইন সিদ্ধান্ত নিয়েছে যে আমরা কোনও অঙ্ক, বা শ্বেতক্ষেত্রের অনুক্রমের দিকে তাকিয়ে আছি এবং অঙ্কগুলি অবহেলা করা দরকার কিনা তা ট্র্যাক করে রাখি।

বাকী উপাদানগুলি ইনপুটগুলির নীচে আবদ্ধ থাকে এবং উপাদানগুলি ডানদিকে সমাপ্তির শর্তটি পরিচালনা করে এবং আউটপুটটিকে ASCII এ ম্যাপ করে (যাতে আমরা অক্ষর পেতে পারি '0'বা '1'মানগুলির পরিবর্তে 0x0বা 0x1। এই ASCII ম্যাপিংয়ে অতিরিক্ত বাইটের প্রয়োজন হয় না, আমি না চাইতাম এটি অন্তর্ভুক্ত করেছেন।)


2
আমি পছন্দ করি যে কোড কিন্ডা দুটি বিভক্ত রাস্তার মতো দেখাচ্ছে।
লাইকোনি

@ লাইকোনি আমি খেয়ালও করিনি, এটা দারুণ সুন্দর :)
ফিলারেক্স

4

জাভাস্ক্রিপ্ট (ES6), 55 বাইট

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

অনুমান প্রতিটি লাইনে কোন trailing ব্যবধান এবং আউটপুট আছে 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>


আপনাকে x=শুরুতে একটি রাখা দরকার , কারণ এক্সপ্রেশনগুলির অনুমতি নেই, কেবলমাত্র একটি চলক এবং পুরো প্রোগ্রাম হিসাবে সঞ্চিত ফাংশন।
প্রোগ্রামার

@ প্রোগ্রামার ৫০০ কেন? ডিফল্টগুলি ওভাররাইড করা কিছুটা অদ্ভুত বলে মনে হচ্ছে এবং মনে হয় না যে প্রশ্নটিতে এটিই ছিল।
গম উইজার্ড

1
@ programmer5000 আসলে, নামবিহীন ফাংশনগুলি ডিফল্টরূপে অনুমোদিত । (স্নিপেটের জন্য ধন্যবাদ,
বিটিডাব্লু

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 বাইট

-১ বাইট @ ম্যাথ_জুনকি ধন্যবাদ thanks

এটি অনলাইনে চেষ্টা করুন

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))))))))))+¶)+ *#

এটি অনলাইন চেষ্টা করুন!

আমি ভেবেছিলাম আমি একটি রেজেেক্স-কেবল সমাধানও চেষ্টা করবো (উপরেরটি একটি সরল। নেট এনজেজেক্স যা কেবলমাত্র ইনপুটগুলির সাথে মেলে যেখানে সঠিক পথটি নেওয়া উচিত, ব্যবহার ব্যতীত একটি শর্টহ্যান্ড হিসাবে\n )।

এটি বিরক্তিকরভাবে পুনরাবৃত্তিযোগ্য, তবে যখন পৃথকভাবে প্রতিটি সম্ভাব্য সংখ্যার চিকিত্সা করতে হয় তখন তা ঘটে।

সমাধানটি ভারসাম্যহীন গোষ্ঠীর মোটামুটি সোজা-ফরওয়ার্ড অ্যাপ্লিকেশন : প্রথমে আমরা প্রতিটি সংখ্যার জন্য Nস্ট্যাকের উপর ক্যাপচারগুলি ঠেলে বাম শাখায় অঙ্কগুলি যোগ করি । তারপরে আমরা ডান শাখায় প্রতিটি সংখ্যার জন্য স্ট্যাক বার থেকে পপ করার সময় আমরা পৌঁছানোর চেষ্টা করি । এটি কেবল তখনই সম্ভব যখন বাম শাখায় অঙ্কের যোগফল ডান শাখায় (যেহেতু আপনি খালি স্ট্যাক থেকে পপ করতে পারবেন না) তার চেয়ে বেশি হয়।3N#3 NN


আমি নেট নেট রেজিক্সের সাথে পরিচিত নই, তবে আপনি একটি অক্ষর সেট করতে পারবেন না: [0-9]সমস্ত অঙ্কের সাথে মেলে নাকি \d?
programmer5000

@ প্রোগ্রামার ৫০০০ অবশ্যই, তবে তার সংখ্যার জন্য কয়টি ক্যাপচার আমাকে ধাক্কা দিতে হবে তা নির্ধারণ করতে আমি তাদের মধ্যে পার্থক্য করতে পারি না।
মার্টিন ইন্ডার

2

জাভাস্ক্রিপ্ট (ES6), 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>


আমি আশা করি কেউ এর থেকে আরও ভাল স্কোর পেতে পারে ...
প্রোগ্রামার

চ্যালেঞ্জটি @ প্রোগ্রামার
ডেভিড আর্চিবাল্ড

@ ডেভিড আর্চিবাল্ড ইতিমধ্যে কেউ করেছে, তবে আমি একটি নতুন উত্তরটির প্রশংসা করব। আপনি কি সিরিজের তৃতীয়টিতে আগ্রহী ?
প্রোগ্রামার

নিশ্চিত করুন। বুঝতে পারেন নি যে সেখানে 3 রয়েছে
ডেভিড আর্চিবাল্ড

2

পাওয়ারশেল , 80 বাইট

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

এটি অনলাইন চেষ্টা করুন!

(কেবল পাইথনের উত্তরের নীচে চেঁচাচ্ছে:: ডি)

Trueবাম পথের আউটপুট এবংFalse সঠিক পথের ।

স্ট্রিং হিসাবে ডিলিনেটেড হিসাবে ইনপুট নেয় `n, যা "আক্ষরিক ব্যাকস্ল্যাশ এবং একটি এন" সহ একটি স্ট্রিং, বা আক্ষরিক বহুরেখার স্ট্রিং হিসাবে পাওয়ারশেলের সমতুল্য । আমরা তখন -splitযে ইনপুট \s(নতুন লাইন সহ হোয়াইটস্পেস) অথবা #এবং ফিল্টার সব আউট খালি ফলাফল-ne'' , তাই আমরা ডিজিটের একটি অ্যারের অবশিষ্ট করছি। এগুলিকে একটি লুপে খাওয়ানো হয় |%{...}

প্রতিটি পুনরাবৃত্তি, আমরা প্রথমে বর্তমান উপাদানটি গ্রহণ $_করি char, -joinএটিকে অ্যারে হিসাবে নিক্ষেপ করি , এটি একত্রে আরও একটি চিহ্ন সহ +, এবং এটিতে পাইপ iex(সংক্ষিপ্ত Invoke-Expressionএবং অনুরূপ eval)। এটি এতে সঞ্চিত আছে $iতাই আমরা সঠিকভাবে পথের এই নির্দিষ্ট অংশে অঙ্কগুলি সংখ্যায়িত করব। তারপরে আমরা এবং তার নেগেটিভটিকে অ্যারের দুটি উপাদান হিসাবে ব্যবহার করি ($i, -$i), বুলিয়ান মানটি পিছনে পিছনে উল্টিয়ে সূচকযুক্ত। অর্থ, এই লুপটির মাধ্যমে প্রথম পুনরাবৃত্তি, প্রথম বাম পথটি, আমরা ইনডেক্স করব -$i; পরের বার, আমরা গ্রহণ করব $i; ইত্যাদি। এর সাথে জমে $aআছে +=

পরিশেষে, আমরা মূল্যায়ন কিনা $aহয় -greater tহান 0। যদি এটি হয় তবে ডান পথটির বৃহত্তর যোগফল ছিল, অন্যথায় বাম পথটিতে একটি বৃহত্তর যোগফল ছিল। সেই বুলিয়ান ফলাফলটি পাইপলাইনে রেখে গেছে, এবং আউটপুট অন্তর্ভুক্ত।


2

সিজেম , 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 বাইট by

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

0

Haskell, , 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
  99  89
  99 99
    #
    #
   # 

এটি স্ট্রিং " 99 989\n 99 89\n 99 99\n #\n #\n #", তারপরে wordsসমস্ত নতুনলাইন এবং স্পেসগুলি স্ট্রিপ করে এবং বাকী স্ট্রিংগুলির একটি তালিকা প্রদান করে:["99","989","99","89","99","99","#","#","#"]। ফাংশনটি fপ্রথম দুটি উপাদান নেয় aএবং bএই তালিকা থেকে এবং a"#" স্ট্রিংয়ের সাথে তুলনা করে অঙ্কের একটি স্ট্রিং কিনা তা পরীক্ষা করে । (কারণ গৃহস্থালির কাজ '#'অঙ্ক অক্ষর সব চেয়ে ছোট '0', '1'... যে স্ট্রিং একটি অঙ্ক দিয়ে শুরু তুলনায় lexicographically বড় হতে হবে "#"।) ফাংশন gতার ASCII অক্ষর কোডে একটি স্ট্রিং প্রতিটি গৃহস্থালির কাজ মানচিত্র এবং তাদের যোগফল ফেরৎ। ইন fআমরা প্রয়োগ gকরতে aএবং bএবং Compute g a - g b, বাম পাথ বিয়োগ সঠিক মান মান, এবং একটি recursive কল থেকে এটি যোগfনিম্নলিখিত লাইন পরিচালনা করতে। যদি বাম পথটি আরও ভ্রমণ করা হয় তবে ফলাফলটি fনেতিবাচক এবং অন্যথায় সঠিক পথের জন্য ইতিবাচক হবে, সুতরাং (>0)ফলাফলটি শূন্যের চেয়ে বড় কিনা তা পরীক্ষা করে দেখুন।


0

পাইথন 3 , 84 বাইট

যেহেতু সমস্ত পাইথন জমা রয়েছে সেগুলি ফাংশন, তাই আমি ভেবেছিলাম আমি একটি সম্পূর্ণ প্রোগ্রামে অবদান রাখব।

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

Trueবাম পথটি যদি কম ভ্রমণ হয় তবে মুদ্রণ করুন Falseotherwise এটি অনলাইন চেষ্টা করুন!

ইনপুট প্রতিটি রেখার জন্য, এটি হোয়াইটস্পেসে বিভক্ত হয়, প্রতিটি ফলাফলের উপাদানের অঙ্কগুলি যোগ করে এবং প্রতিটি পদক্ষেপে ট্যালির চিহ্নটি উল্টানোর সময় এটি ট্যালিতে যোগ করে। এটি ইনপুটগুলির লাইনগুলি পড়া অব্যাহত রাখে যতক্ষণ না এটি একটির সাথে হিট #হয়, যার বিন্দুতে map(int,n)একটি ব্যতিক্রম উত্থাপিত হয় এবং Trueটপটি ইতিবাচক এবং Falseঅন্যথায় যদি আমরা লুপ থেকে প্রস্থান করি ।


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 সাবরুটাইন দুটি পরামিতি নেয়: যোগ বা বিয়োগ করতে হবে এবং অঙ্ক (গুলি)। এটি 10 ​​দ্বারা মডিউল দিয়ে শেষ সংখ্যাটি এবং 10 দ্বারা বিভাজন করে বাকী সংখ্যাগুলি বের করে এবং এখনও পুনরাবৃত্তভাবে কল করে যখন এখনও বাকী সংখ্যা রয়েছে। cসাবরুটিন তিন প্যারামিটার নেয়: যোগ করার জন্য কিনা বা বিয়োগ, সংখ্যা যোগ করতে অথবা বিয়োগ করতে, এবং আরো ডিজিট যোগ করুন। এটি কলdc সাব্রোটিনকে পরামিতি সাথে-এবং বাম এবং ডান অঙ্কগুলি ডান অঙ্কগুলি যুক্ত করবে এবং বাম সংখ্যাগুলি বিয়োগ করবে। অবশেষে ফলাফলটি সাইনটি সরানোর জন্য স্থানান্তরিত হয়।


0

অক্টাভা, 46 বাইট

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

এটি অনলাইন চেষ্টা করুন! একটি ফাংশন যা aইনপুট হিসাবে 2D অক্ষরের অ্যারে নেয় ।

ব্যাখ্যা:

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

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
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.