นี่เป็นครั้งที่สองในซีรีส์ที่สามคือถนนสองสายที่แยกจากกันในป่าสีเหลือง (ตอนที่ 3)

นี่คือถนนสองสายที่แยกจากกันในป่าสีเหลือง (ตอนที่ 1)ซึ่งเป็นความท้าทายครั้งก่อนของฉัน มันได้รับการตอบรับค่อนข้างดี แต่มันก็ค่อนข้างเล็กน้อย (คำตอบ Java ใน 52 ไบต์!) ดังนั้นฉันจึงทำอะไรที่ซับซ้อนกว่านี้ ...

แรงบันดาลใจ

ความท้าทายนี้ได้รับแรงบันดาลใจจากบทกวีที่มีชื่อเสียงของ Robert Frost "The Road Not Taken":

ถนนสองสายแยกในไม้สีเหลือง
และขอโทษที่ฉันไม่สามารถเดินทางทั้งสอง
และเป็นหนึ่งในผู้เดินทางนานผมยืนอยู่
และมองลงไปหนึ่งเท่าที่ผมจะทำได้
เพื่อที่จะงอในพง;

... 2 ย่อหน้าถูกตัด ...

ฉันจะบอกเรื่องนี้ด้วยการถอนหายใจ
ที่ไหนสักแห่งในยุคนี้:
ถนนสองสายแยกจากกันในป่าและฉัน -
ฉันพาคนเดินทางน้อยลง
และนั่นทำให้เกิดความแตกต่าง

สังเกตบรรทัดที่สองถึงบรรทัดสุดท้ายI took the one less traveled by,. เป้าหมายของคุณคือการหาเส้นทางที่น้อยที่สุดในการป้อนสตริงของคุณ คุณต้องส่งออกหนึ่งใน 2 ค่าที่แตกต่างจากกันซึ่งเป็นสัญญาณว่าคุณควรเลี้ยวไปทางไหนเมื่อเดินทางโดยใช้ถนนน้อยลง เมื่อถนนแยกออก (รอยทางของรูปหกเหลี่ยมเปลี่ยนเป็นตัวเลข) คุณจะอยู่ที่สี่แยก จากนั้นจะมี 2 เส้นทางประกอบด้วยตัวเลข เส้นทางที่มีตัวเลขที่มีผลรวมต่ำสุดจะเป็นถนนที่ไม่ได้ใช้ โปรดทราบว่าถนนที่ไม่ได้ถ่ายอาจมีเส้นทางที่ใหญ่กว่า แต่เป็นเส้นทางรวมที่ต่ำกว่า ต่อไปนี้เป็นตัวอย่าง / กรณีทดสอบจากโปรแกรมที่พิมพ์ "left" หรือ "right" สำหรับเส้นทางที่ไม่ได้รับ:

 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
• อินพุตหรือเอาต์พุตที่มีบรรทัดใหม่ต่อท้ายได้รับอนุญาต
• ดูคำตอบ JS ES6 ของฉันด้านล่างสำหรับตัวอย่าง
• จะต้องมีอย่างน้อย 1 ช่องว่างระหว่าง 2 เส้นทาง
• เส้นทาง 2 เส้นทางจะมีความสูงเท่ากันสำหรับแต่ละแผนที่ แต่อาจแตกต่างกันในแผนที่อื่น ๆ
• หากคุณสับสนเกี่ยวกับกรณีทดสอบที่เฉพาะเจาะจงโปรดบอกฉัน
• 1111 ตีความว่า 1 + 1 + 1 + 1 = 4 ไม่ใช่ 1111 = 1111 แผนที่เป็นชุดของตัวเลขหนึ่งหลักไม่ใช่จำนวนความยาวโดยพลการ
• นี่คือโค้ดกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในจำนวนไบต์ชนะ!
• ช่องโหว่มาตรฐานต้องห้าม

หากคุณมีคำถามเกี่ยวกับความท้าทายนี้ขอให้ฉันแสดงความคิดเห็นและขอให้โชคดี!

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

เรติน่า 28 ไบต์

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

1+

ลองออนไลน์!

พิมพ์0สำหรับซ้ายและ1ขวา สมมติว่าไม่มีช่องว่างต่อท้ายในบรรทัดใด ๆ

คำอธิบาย

\d
$*

แปลงตัวเลขแต่ละตัวNให้เป็นNจำนวนเต็ม

%r`1\G
-

หนึ่งแต่ละบรรทัด ( %) จับคู่รายการที่อยู่ติดกัน ( \G) จากท้าย ( r) และแทนที่แต่ละบรรทัดด้วย-(เช่นเปลี่ยนสาขาที่ถูกต้องเป็น-s)

Os`.

เรียงลำดับอักขระทั้งหมดเพื่อให้-s ทั้งหมดอยู่ตรงหน้า1s ทั้งหมด

+`-1

ซ้ำแล้วซ้ำเล่ายกเลิกคู่และ-1

1+

พยายามจับคู่อย่างน้อยหนึ่งตัว1(ถ้าเป็นเช่นนั้นมีน้ำหนักมากขึ้นในเส้นทางซ้าย)

Python 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)

ลองออนไลน์!

ชิป 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เราได้รับ สัญลักษณ์ของผลที่จะได้รับเป็นเอาท์พุทเป็นจำนวนลบผลิตผลและในเชิงบวกคือ10

ดังนั้นผลลัพธ์ของ1วิธีการที่พา ธ ด้านซ้ายใช้เวลาน้อยลงและ0หมายถึงถูกต้อง

คำอธิบาย

ในระดับสูงนี่คือการทำงาน:

เส้นทแยงมุมหลักที่มี@องค์ประกอบคือตัวสะสมเอาต์พุตจะถูกเลือกโดยaที่ด้านล่าง (แปดคู่@หมายถึงแปดบิต แต่บิตที่สูงที่สุดคือเครื่องหมายดังนั้นวิธีนี้สามารถจัดการกับความแตกต่างสูงสุด +127 หรือ -128 การล้นบางส่วนผ่านไปก็โอเคตราบใดที่เรากลับมาก่อนที่จะยุติ)

สี่บรรทัดที่เริ่มต้นเช่นAx]}#--... กำลังอ่านอินพุตและในกรณีของตัวเลขให้ลบมัน (หากจำเป็น) และส่งค่าไปยังตัวเพิ่ม

สามบรรทัดแรกจะตัดสินว่าเราดูที่ตัวเลขหรือลำดับของช่องว่างหรือไม่และติดตามว่าจำเป็นต้องลบล้างตัวเลขเหล่านั้นหรือไม่

องค์ประกอบที่เหลืออยู่ภายใต้อินพุตและองค์ประกอบที่อยู่ด้านขวาสุดจัดการกับเงื่อนไขการสิ้นสุดและแมปผลลัพธ์ไปยัง ASCII (เพื่อให้เราได้รับอักขระ'0'หรือ'1'แทนค่า0x0หรือ0x1การแมป ASCII นี้ไม่จำเป็นต้องใช้ไบต์พิเศษมิฉะนั้นฉันจะไม่ ได้รวมมัน.)

JavaScript (ES6), 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>

Python 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 ไบต์

Python 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ขวา

เรติน่า 180 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 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))))))))))+¶)+ *#

ลองออนไลน์!

ฉันคิดว่าฉันยังต้องการลองใช้วิธีการแก้ปัญหา regex เดียว (ข้างต้นเป็น regex .NET ธรรมดาซึ่งตรงกับปัจจัยการผลิตเดียวที่เส้นทางที่เหมาะสมควรจะได้รับยกเว้นสำหรับการใช้¶เป็นชวเลขเป็น\n)

มันซ้ำ ๆ น่ารำคาญ แต่นั่นคือสิ่งที่เกิดขึ้นเมื่อคุณต้องปฏิบัติกับตัวเลขแต่ละหลักที่เป็นไปได้

การแก้ปัญหาคือการประยุกต์ใช้อย่างเป็นธรรมตรงไปข้างหน้าของกลุ่มสมดุล : ครั้งแรกที่เราสรุปตัวเลขในสาขาทางด้านซ้ายโดยการผลักดันNจับลงบนสแต็คสำหรับแต่ละหลัก3 Nจากนั้นเราพยายามที่จะเข้าถึงใน#ขณะที่ popping จาก3 Nเวลาสแต็คสำหรับแต่ละหลักNในสาขาที่เหมาะสม สิ่งนี้จะเกิดขึ้นได้ก็ต่อเมื่อผลรวมของตัวเลขในสาขาด้านซ้ายนั้นมากกว่าในสาขาที่ถูกต้อง (เนื่องจากคุณไม่สามารถป๊อปอัพจากสแต็กเปล่า)

JavaScript (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>

PowerShell , 80 ไบต์

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

ลองออนไลน์!

(เพียงแค่ส่งเสียงแหลมใต้คำตอบของ Python: D)

เอาต์พุตTrueสำหรับพา ธ ด้านซ้ายและFalseสำหรับพา ธ ด้านขวา

ใช้อินพุตเป็นสตริงที่กำหนดด้วย`nซึ่งเทียบเท่ากับ PowerShell ของ"สตริงที่มีเครื่องหมายแบ็กสแลชตามตัวอักษรและ n"หรือเป็นสตริงหลายบรรทัดตามตัวอักษร จากนั้นเรา-splitป้อนข้อมูลนั้น\s(ช่องว่างรวมถึงการขึ้นบรรทัดใหม่) หรือ#และกรองผลลัพธ์ที่ว่างเปล่าทั้งหมด-ne''ดังนั้นเราจึงเหลือเพียงตัวเลขจำนวนหนึ่ง |%{...}เหล่านั้นจะถูกป้อนเข้าห่วง

แต่ละซ้ำครั้งแรกที่เราจะใช้องค์ประกอบปัจจุบัน$_โยนเป็นcharอาร์เรย์-joinมันเข้าด้วยกันด้วยเครื่องหมายบวก+และท่อมันiex(สั้นInvoke-Expressionและคล้ายกับeval) นั่นถูกเก็บไว้$iดังนั้นเราจึงสรุปตัวเลขบนเส้นทางอันนี้โดยเฉพาะ จากนั้นเราจะใช้สิ่งนั้นและค่าลบในฐานะองค์ประกอบสองอย่างของอาร์เรย์($i, -$i)จัดทำดัชนีโดยพลิกค่าบูลีนไปมา ความหมายซ้ำแรกที่ผ่านลูปนี้เป็นครั้งแรกก้อนเส้นทางซ้ายเราจะดัชนีลง-$i; ครั้งต่อไปที่เราจะพา$i; และอื่น ๆ เหล่านี้จะสะสมเข้ากับ$a+=

สุดท้ายเราประเมินว่า$aเป็น-greater hant 0หากเป็นเช่นนั้นเส้นทางที่ถูกต้องจะมีจำนวนเงินที่มากขึ้นมิฉะนั้นเส้นทางที่เหลือจะมีจำนวนเงินที่มากกว่า ผลลัพธ์บูลีนนั้นถูกทิ้งไว้บนไพพ์ไลน์และเอาต์พุตนั้นเป็นนัย

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.

Mathematica, 80 77 ไบต์

ขอบคุณ Martin Ender สำหรับการบันทึก 3 ไบต์!

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

ฟังก์ชั่นบริสุทธิ์การสตริงที่คั่นด้วย newline เป็นอินพุตและกลับTrueไปใช้เส้นทางซ้ายFalseเพื่อใช้เส้นทางที่ถูกต้อง ประณามชื่อคำสั่ง Mathematica ที่ยาว นี่เป็นเหมือน 10 โทเค็น

Pip , 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

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คำนวณg a - g bนั่นคือค่าของเส้นทางซ้ายลบค่าของขวาหนึ่งและเพิ่มลงในการโทรซ้ำเพื่อfเพื่อจัดการกับบรรทัดต่อไปนี้ หากพา ธ ด้านซ้ายเดินทางมากกว่าผลลัพธ์จากfจะเป็นลบและเป็นไปในทางอื่นสำหรับเส้นทางที่ถูกต้องดังนั้นให้(>0)ตรวจสอบว่าผลลัพธ์มีขนาดใหญ่กว่าศูนย์หรือไม่

Python 3 , 84 ไบต์

เนื่องจากการส่ง Python ปัจจุบันทั้งหมดเป็นฟังก์ชั่นฉันคิดว่าฉันมีส่วนร่วมในโปรแกรมเต็มรูปแบบ

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

พิมพ์Trueถ้าเส้นทางซ้ายเดินทางFalseมิฉะนั้นจะน้อยกว่า ลองออนไลน์!

สำหรับแต่ละบรรทัดของการป้อนข้อมูลนี้จะแยกช่องว่างจำนวนตัวเลขขององค์ประกอบที่เกิดขึ้นแต่ละครั้งและเพิ่มลงในจำนวนในขณะที่พลิกสัญลักษณ์ของการนับในแต่ละขั้นตอน มันยังคงอ่านบรรทัดของอินพุตจนกว่าจะตีหนึ่งด้วย a #ณ จุดที่map(int,n)ยกข้อยกเว้นและเราออกจากลูปการพิมพ์Trueถ้านับเป็นบวกและFalseอย่างอื่น

แบตช์ 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ย่อยใช้เวลาสามพารามิเตอร์: ว่าจะเพิ่มหรือลบตัวเลขไปเพิ่มหรือลบและตัวเลขเพิ่มเติมเพื่อเพิ่ม มันเรียกว่าdรูทีนย่อยเพื่อจัดการกับตัวเลขเพื่อเพิ่มจากนั้นเข้าสู่การจัดการกับพารามิเตอร์สองตัวแรก ซึ่งหมายความว่าการเรียกcรูทีนย่อยด้วยพารามิเตอร์ของ-และตัวเลขทางซ้ายและขวาจะเพิ่มตัวเลขที่ถูกต้องและลบตัวเลขทางซ้าย ในที่สุดผลลัพธ์จะถูกเลื่อนเพื่อแยกสัญญาณ

อ็อกเทฟ 46 ไบต์

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

ลองออนไลน์! ฟังก์ชั่นที่ใช้อาร์เรย์อักขระ 2D aเป็นอินพุต

คำอธิบาย:

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

Java 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