Đây là lần thứ hai trong một loạt, thứ ba là Hai con đường được phân chia trong một gỗ màu vàng (phần 3)

Điều này dựa trên Hai con đường được chuyển hướng trong một khúc gỗ màu vàng (phần 1) , một thử thách trước đây của tôi. Nó đã được đón nhận khá tốt, nhưng nó cũng khá tầm thường (một câu trả lời Java bằng 52 byte!) Vì vậy, tôi đã làm một cái gì đó phức tạp hơn ...

Nguồn cảm hứng

Thử thách này được lấy cảm hứng từ bài thơ nổi tiếng của Robert Frost, "Con đường chưa đi":

Hai con đường rẽ vào một khúc gỗ màu vàng,
Và xin lỗi tôi không thể đi cả hai
Và là một du khách, tôi đứng đó
và nhìn xuống một cách xa nhất có thể
đến nơi mà nó bị bẻ cong;

... 2 đoạn được cắt tỉa ...

Tôi sẽ nói điều này với một tiếng thở dài Ở
đâu đó tuổi và tuổi vì thế:
Hai con đường rẽ vào một khúc gỗ, và tôi -
tôi đã đi một con đường ít đi qua,
và điều đó đã tạo nên sự khác biệt.

Lưu ý dòng thứ hai đến dòng cuối cùng , I took the one less traveled by,. Mục tiêu của bạn là tìm đường đi ít nhất trong đầu vào chuỗi của bạn. Bạn phải xuất một trong 2 giá trị khác biệt với nhau để báo hiệu bạn nên rẽ theo con đường nào để đi ít hơn. Khi đường nhánh (đường của hình lục giác thay đổi thành số), bạn đang ở giao lộ. Từ đó, sẽ có 2 đường dẫn được tạo thành từ các chữ số. Đường có chữ số có tổng thấp nhất sẽ là đường không được lấy. Lưu ý rằng đường không được chọn có thể có đường dẫn lớn hơn nhưng tổng đường dẫn thấp hơn. Dưới đây là một số ví dụ / trường hợp thử nghiệm từ một chương trình in "trái" hoặc "phải" cho đường dẫn không được thực hiện:

 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)

Những điều cần giả định và ghi nhớ

• Sẽ luôn có 2 con đường. Không nhiều không ít.
• Bạn có thể lấy đầu vào từ STDIN một dòng tại một thời điểm, một chuỗi chứa các ký tự LF hoặc một chuỗi chứa dấu gạch chéo ngược bằng chữ và n. Nếu bạn cần đầu vào theo bất kỳ cách nào khác, yêu cầu phê duyệt trong các ý kiến.
• Bạn không phải lo lắng về đầu vào không hợp lệ hoặc đường dẫn bị ràng buộc. Những người sẽ không bao giờ được nhập vào chương trình / chức năng của bạn.
• Đầu vào có thể có chiều dài hoặc chiều cao bất kỳ, nhỏ hơn giới hạn chuỗi của ngôn ngữ của bạn.
• Sẽ không bao giờ có một #và một số trong cùng một dòng.
• Tất cả các chữ số trong đường dẫn là số nguyên dương 0 đến 9.
• Đầu vào hoặc đầu ra với một dòng mới được cho phép.
• Xem câu trả lời JS ES6 của tôi dưới đây để biết ví dụ.
• Sẽ luôn có ít nhất 1 khoảng trắng giữa 2 đường dẫn.
• Hai đường dẫn sẽ luôn có cùng chiều cao cho mỗi bản đồ, nhưng có thể khác nhau trên các bản đồ khác.
• Nếu bạn bối rối về một trường hợp thử nghiệm cụ thể, xin vui lòng cho tôi biết.
• 1111 được hiểu là 1 + 1 + 1 + 1 = 4, không phải 1111 = 1111. Bản đồ là một chuỗi các số có một chữ số, không phải số có độ dài tùy ý.
• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng!
• Sơ hở tiêu chuẩn bị cấm

Nếu bạn có bất kỳ câu hỏi nào về thử thách này, hãy hỏi tôi trong phần bình luận, và chúc may mắn!

05AB1E , 21 15 byte

Đầu ra 0 cho trái và 1 cho phải.

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

Hãy thử trực tuyến!

Giải trình

|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

Võng mạc , 28 byte

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

1+

Hãy thử trực tuyến!

In 0cho trái và 1phải. Giả sử rằng không có dấu cách trên bất kỳ dòng nào.

Giải trình

\d
$*

Chuyển đổi từng chữ số Nđể chạy N.

%r`1\G
-

Một dòng mỗi dòng ( %), khớp các dòng liên tiếp ( \G) từ cuối ( r) và thay thế từng dòng bằng -(tức là biến nhánh bên phải thành -s).

Os`.

Sắp xếp tất cả các ký tự, sao cho tất cả các -s nằm ngay trước tất cả các 1s.

+`-1

Liên tục hủy bỏ một cặp -và 1.

1+

Cố gắng khớp ít nhất một 1(nếu vậy, có nhiều trọng số hơn ở đường bên trái).

Python 2 , 95 89 88 87 byte

Đây là lần đầu tiên tôi đến đây trong python. Chắc chắn không tối ưu nhưng là một khởi đầu tốt.

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)

Hãy thử trực tuyến!

Chip , 216 byte

 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

Hãy thử trực tuyến!

Lớn hơn một chút so với câu trả lời cho phần 1 ...

Tổng quan

Chip là ngôn ngữ 2D được lấy cảm hứng từ mạch thực tế và nó xử lý các bit thành phần của mỗi byte trong luồng byte.

Giải pháp này giữ một tổng số các chữ số mà nó nhìn thấy, lật dấu hiệu của đầu vào mỗi khi nó gặp một khoảng trắng, sau đó kết thúc lần đầu tiên #. Vì vậy, cho đầu vào

 11   12
  2   2
   1 1
    #
    #
    #

Chúng tôi nhận được 1 + 1 - 1 - 2 + 2 - 2 + 1 - 1 = -1. Dấu hiệu của kết quả được đưa ra là đầu ra, một số âm tạo ra kết quả 1và dương là 0.

Do đó, đầu ra của 1phương tiện là đường dẫn bên trái ít được thực hiện và 0có nghĩa là phải.

Giải trình

Ở cấp độ cao, đây là cách nó hoạt động:

Đường chéo chính với các @yếu tố là bộ tích lũy, đầu ra được quyết định bởi aở phía dưới. (Tám cặp @có nghĩa là tám bit, nhưng bit cao nhất là dấu hiệu, vì vậy giải pháp này có thể xử lý chênh lệch tối đa là +127 hoặc -128. Việc tràn qua giữa chừng là được, miễn là chúng tôi quay lại trước khi kết thúc.)

Bốn dòng bắt đầu như Ax]}#--... đang đọc đầu vào và trong trường hợp là một chữ số, phủ định nó (nếu cần) và chuyển giá trị vào các bộ cộng.

Ba dòng đầu tiên quyết định xem chúng ta đang xem xét một chữ số hay một chuỗi khoảng trắng và theo dõi xem các chữ số có cần được phủ định hay không.

Các phần tử còn lại được đặt dưới các đầu vào và các phần tử ở bên phải xử lý điều kiện kết thúc và ánh xạ đầu ra thành ASCII (để chúng ta nhận được các ký tự '0'hoặc '1'thay vì các giá trị 0x0hoặc 0x1. Ánh xạ ASCII này không cần thêm byte, nếu không tôi sẽ không đã bao gồm nó.)

JavaScript (ES6), 55 byte

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

Giả sử không có dấu cách trên mỗi dòng và đầu ra truecho right, falsecho left. Bí quyết là khớp từng chữ số trong đầu vào và nếu có khoảng trắng sau nó trên cùng một dòng, hãy trừ nó khỏi tổng số; mặt khác, thêm nó vào tổng số. Nếu tổng số cuối cùng nhỏ hơn 0, đường bên phải là đường ít đi qua và ngược lại.

Dùng thử:

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 byte

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

Hãy thử trực tuyến!

Nguyền rủa! Không đọc vấn đề đủ gần. Đã thêm một sửa lỗi ( ''.join()), nhưng với chi phí 9 byte.

Python 2, 78 byte

-1 byte nhờ @math_junkie

Dùng thử trực tuyến

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

In Falsecho đường dẫn bên trái và Truebên phải

Võng mạc , 180 byte

Số lượng byte giả định mã hóa 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))))))))))+¶)+ *#

Hãy thử trực tuyến!

Tôi nghĩ rằng tôi cũng sẽ thử một giải pháp chỉ dành cho regex (ở trên là một regex .NET đơn giản, chỉ khớp với các đầu vào có đường dẫn đúng, ngoại trừ việc sử dụng ¶như một cách viết tắt \n).

Nó lặp đi lặp lại một cách khó chịu, nhưng đó là những gì xảy ra khi bạn phải xử lý từng chữ số có thể.

Giải pháp là một ứng dụng khá đơn giản của các nhóm cân bằng : đầu tiên chúng ta tổng hợp các chữ số ở nhánh bên trái bằng cách đẩy các Nảnh chụp lên ngăn xếp 3cho mỗi chữ số N. Sau đó, chúng tôi cố gắng đạt được #, trong khi xuất hiện từ 3 Nthời gian xếp chồng cho mỗi chữ số Ntrong nhánh bên phải. Điều này chỉ có thể nếu tổng các chữ số ở nhánh bên trái lớn hơn số đó ở nhánh bên phải (vì bạn không thể bật từ một ngăn xếp trống).

JavaScript (ES6), 106 104 byte

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)

slà một hàm trả về truenếu đường không được đặt ở bên trái. Ung dung:

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 byte

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

Hãy thử trực tuyến!

(Chỉ ré lên dưới câu trả lời của Python .: D)

Đầu ra Truecho đường dẫn bên trái và Falsecho đường dẫn bên phải.

Đưa đầu vào dưới dạng một chuỗi được mô tả bằng `n, đó là PowerShell tương đương với "một chuỗi chứa dấu gạch chéo ngược và n" hoặc là một chuỗi đa dòng theo nghĩa đen. Sau đó, chúng tôi -splitnhập dữ liệu đó vào \s(khoảng trắng bao gồm dòng mới) hoặc #lọc ra tất cả các kết quả trống -ne'', vì vậy chúng tôi chỉ còn lại một mảng các chữ số. Những người được đưa vào một vòng lặp |%{...}.

Mỗi lần lặp, trước tiên chúng ta lấy phần tử hiện tại $_, tạo nó thành một charmảng, -joinnó cùng với một dấu cộng +và đặt nó thành iex(viết tắt Invoke-Expressionvà tương tự như eval). Điều đó được lưu trữ $iđể chúng tôi tổng hợp đúng các chữ số trên đoạn đặc biệt này của đường dẫn. Sau đó, chúng tôi sử dụng điều đó và tiêu cực của nó như là hai phần tử của một mảng ($i, -$i), được lập chỉ mục bằng cách lật một giá trị Boolean qua lại. Có nghĩa là, lần lặp đầu tiên qua vòng lặp này, đoạn đường dẫn bên trái đầu tiên, chúng ta sẽ lập chỉ mục vào -$i; lần sau, chúng tôi sẽ lấy $i; vân vân Những người được tích lũy vào $avới +=.

Cuối cùng, chúng tôi đánh giá xem có phải $alà -greater than 0. Nếu đúng, thì đường bên phải có tổng lớn hơn, nếu không thì đường bên trái có tổng lớn hơn. Kết quả Boolean đó được để lại trên đường ống và đầu ra là ẩn.

CJam , 19 18 byte

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

Hãy thử trực tuyến!

In 0cho trái và 1phải.

Giải trình

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.

Toán học, 80 77 byte

Cảm ơn Martin Ender đã tiết kiệm 3 byte!

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

Hàm thuần túy lấy một chuỗi phân cách dòng mới làm đầu vào và quay lại Trueđể lấy đường dẫn bên trái, Falseđể đi theo đường dẫn bên phải. Chết tiệt những tên lệnh Mathicala dài; điều này giống như 10 mã thông báo.

Pip , 19 18 byte

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

Lấy đầu vào dưới dạng một chuỗi trên dòng lệnh (sẽ cần trích dẫn và thoát dòng mới nếu chạy trên một dòng lệnh thực tế). Đầu ra -1cho trái, 1phải. Hãy thử trực tuyến!

Giải trình

Vòng lặp trên các chữ số, thêm tổng các chữ số vào một kiểm đếm. Dấu hiệu của kiểm đếm được hoán đổi mỗi lần, với kết quả cuối cùng là các giá trị bên trái là âm và các giá trị bên phải là dương. Sau đó, chúng tôi in dấu của kiểm đếm cuối cùng ( -1hoặc 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 byte

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

Hãy thử trực tuyến! Cách sử dụng: Hàm ẩn danh (>0).f.wordslấy một chuỗi phân tách dòng mới làm đối số và trả về Falsebên trái và Truebên phải.

Giải trình:

Đưa ra một đầu vào

 99   989
  99  89
  99 99
    #
    #
   # 

đó là chuỗi " 99 989\n 99 89\n 99 99\n #\n #\n #", sau đó wordsloại bỏ tất cả các dòng mới và dấu cách và trả về một danh sách các chuỗi còn lại : ["99","989","99","89","99","99","#","#","#"]. Hàm flấy hai phần tử đầu tiên avà btừ danh sách này và kiểm tra xem có phải alà một chuỗi các chữ số hay không bằng cách so sánh nó với chuỗi "#". (Bởi vì các char '#'là nhỏ hơn so với tất cả các ký tự chữ số '0', '1', ... mỗi chuỗi bắt đầu bằng một chữ số sẽ được tự từ điển lớn hơn "#".) Chức năng gbản đồ mỗi char trong một chuỗi ký tự mã ascii của nó và trả về tổng của chúng. Trong fchúng tôi áp dụng gcho avà btính toán g a - g b, đó là giá trị của đường dẫn bên trái trừ đi giá trị của đường dẫn bên phải và thêm nó vào một cuộc gọi đệ quy đếnfđể xử lý các dòng sau. Nếu đường bên trái được di chuyển nhiều hơn, kết quả từ fsẽ là âm và ngược lại là dương đối với đường dẫn bên phải, vì vậy hãy (>0)kiểm tra xem kết quả có lớn hơn không.

Python 3 , 84 byte

Vì tất cả các lần gửi Python hiện tại là các hàm, tôi nghĩ rằng tôi đã đóng góp một chương trình đầy đủ.

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

In Truenếu đường bên trái ít đi, Falsenếu không. Hãy thử trực tuyến!

Đối với mỗi dòng đầu vào, phần này sẽ phân tách trên khoảng trắng, tính tổng các chữ số của từng phần tử kết quả và thêm nó vào một kiểm đếm trong khi lật dấu của kiểm đếm ở mỗi bước. Nó tiếp tục đọc các dòng đầu vào cho đến khi nó chạm một dòng #, tại đó map(int,n)sẽ xuất hiện một ngoại lệ và chúng ta thoát khỏi vòng lặp, in Truenếu kiểm đếm là dương và Falsengược lại.

Mẻ, 169 byte

@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%

In 0cho trái, -1phải. Lưu ý: Đọc các dòng cho đến khi tìm thấy một dòng có a #, sau đó dừng đọc. Sự khác biệt về tổng đường dẫn được giới hạn ở 511 (thêm 1 byte để hỗ trợ các chênh lệch lớn hơn). Không quá 9 chữ số trong mỗi hàng của mỗi đường dẫn (hỗ trợ bất kỳ số lượng hàng nào). Giải thích: Chương dtrình con có hai tham số: nên cộng hay trừ và (các) chữ số. Nó trích xuất chữ số cuối cùng bằng modulo cho 10 và các chữ số còn lại bằng cách chia cho 10 và tự gọi đệ quy trong khi vẫn còn các chữ số còn lại. Chương ctrình con có ba tham số: nên thêm hay bớt, các chữ số để thêm hoặc trừ và thêm các chữ số để thêm. Nó gọidchương trình con để xử lý các chữ số cần thêm và sau đó rơi vào để xử lý hai tham số đầu tiên. Điều này có nghĩa là việc gọi cchương trình con với các tham số -và các chữ số bên trái và bên phải sẽ thêm các chữ số bên phải và trừ các chữ số bên trái. Cuối cùng kết quả được chuyển sang trích xuất dấu hiệu.

Octave, 46 byte

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

Hãy thử trực tuyến! Một hàm lấy một mảng ký tự 2D alàm đầu vào.

Giải trình:

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 byte

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;}

Bit dài hơn 52 byte lần này. ;)
Và một lần nữa trả lại falsecho bên phải và truebên trái.

Giải trình:

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

Mã kiểm tra:

Hãy thử nó ở đây.

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      #"));
  }
}

Đầu ra:

false
false
true
false
false
false
false