Dies ist die zweite in einer Reihe, die dritte ist Zwei Straßen in einem gelben Wald auseinander (Teil 3)

Dies basiert auf zwei Straßen, die in einem gelben Wald auseinander laufen (Teil 1) , eine frühere Herausforderung von mir. Es wurde ziemlich gut angenommen, aber es war auch ziemlich trivial (eine Java-Antwort in 52 Bytes!) Also habe ich etwas komplexeres gemacht ...

Die Inspiration

Diese Herausforderung ist von Robert Frosts berühmtem Gedicht "The Road Not Taken" inspiriert:

Zwei Straßen gingen in einem gelben Wald auseinander.
Tut mir leid, dass ich nicht beide fahren konnte.
Und ich war ein Reisender, lange stand ich da
und schaute einen herunter, so weit ich konnte
.

... 2 Absätze gekürzt ...

Ich werde das mit einem Seufzer erzählen.
Irgendwo in Ewigkeit:
Zwei Straßen gingen in einem Wald auseinander, und ich -
ich nahm den weniger befahrenen,
und das hat den Unterschied ausgemacht.

Beachten Sie die vorletzte Zeile I took the one less traveled by,. Ihr Ziel ist es, die am wenigsten befahrene Straße in Ihrer Zeichenfolge zu finden. Sie müssen einen von 2 Werten ausgeben, die sich voneinander unterscheiden und angeben, in welche Richtung Sie abbiegen sollen, um die Straße zu nehmen, auf der weniger Verkehr herrscht. Sobald sich die Straße gabelt (die Spur der Sechsecke ändert sich in Zahlen), sind Sie an der Kreuzung. Von dort aus gibt es 2 Pfade, die aus Ziffern bestehen. Der Pfad, dessen Ziffern die niedrigste Summe haben, ist die Straße, die nicht genommen wurde. Beachten Sie, dass die nicht genommene Straße möglicherweise einen größeren Pfad hat, aber eine geringere Pfadsumme. Hier sind einige Beispiele / Testfälle aus einem Programm, das "left" oder "right" für den nicht genommenen Pfad ausgibt:

 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)

Dinge, die anzunehmen und zu erinnern sind

• Es wird immer 2 Wege geben. Nicht mehr und nicht weniger.
• Sie können zeilenweise eine Eingabe von STDIN, eine Zeichenfolge mit LF-Zeichen oder eine Zeichenfolge mit einem literalen Backslash und einem n übernehmen. Wenn Sie auf andere Weise Eingaben benötigen, bitten Sie in den Kommentaren um Zustimmung.
• Sie müssen sich keine Gedanken über ungültige Eingaben oder verknüpfte Pfade machen. Diese werden niemals in Ihr Programm / Ihre Funktion eingegeben.
• Die Eingabe kann eine beliebige Länge in Breite oder Höhe haben, die unter der Zeichenfolgenbeschränkung Ihrer Sprache liegt.
• Es wird niemals eine #und eine Zahl in derselben Zeile geben.
• Alle Ziffern im Pfad sind positive ganze Zahlen von 0 bis 9.
• Die Eingabe oder Ausgabe mit einem nachgestellten Zeilenumbruch ist zulässig.
• Siehe meine JS ES6 Antwort unten für ein Beispiel.
• Es wird immer mindestens 1 Leerzeichen zwischen den beiden Pfaden geben.
• Die beiden Pfade haben immer die gleiche Höhe für jede Karte, können jedoch auf anderen Karten unterschiedlich sein.
• Wenn Sie über einen bestimmten Testfall verwirrt sind, teilen Sie mir dies bitte mit.
• 1111 wird als 1 + 1 + 1 + 1 = 4 interpretiert, nicht als 1111 = 1111. Die Karte besteht aus einer Reihe von einstelligen Zahlen, nicht aus Zahlen beliebiger Länge.
• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes!
• Standardlücken verboten

Wenn Sie Fragen zu dieser Herausforderung haben, fragen Sie mich in den Kommentaren und viel Glück!

05AB1E , 21 15 Bytes

Ausgänge 0 für links und 1 für rechts.

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

Probieren Sie es online!

Erläuterung

|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

Retina , 28 Bytes

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

1+

Probieren Sie es online!

Druckt 0für links und 1rechts. Es wird davon ausgegangen, dass in den Zeilen keine Leerzeichen nachgestellt sind.

Erläuterung

\d
$*

Wandle jede Ziffer Nin eine Folge von NEinsen um.

%r`1\G
-

Jeweils eine Zeile ( %), die aufeinanderfolgenden ( \G) vom Ende ( r) abgleichen und durch jeweils ersetzen -(dh den rechten Zweig in -s umwandeln ).

Os`.

Sortieren Sie alle Zeichen so, dass alle -s direkt vor allen 1s stehen.

+`-1

Brechen Sie ein Paar von -und wiederholt ab 1.

1+

Versuchen Sie, mindestens eine zu finden 1(wenn ja, befanden sich mehr Gewichte im linken Pfad).

Python 2 , 95 89 88 87 Bytes

Hier ist mein erster Versuch in Python. Auf jeden Fall nicht optimal, aber ein ordentlicher Start.

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)

Probieren Sie es online!

Chip , 216 Bytes

 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

Probieren Sie es online!

Ein bisschen größer als die Antwort für Teil 1 ...

Überblick

Chip ist eine 2D-Sprache, die von der tatsächlichen Schaltung inspiriert ist und sich mit den Komponentenbits jedes Bytes in einem Bytestrom befasst.

Bei dieser Lösung wird eine fortlaufende Summe der angezeigten Ziffern beibehalten, wobei das Vorzeichen der Eingabe jedes Mal umgedreht wird, wenn eine Whitespace-Strecke auftritt, und dann bei der ersten beendet wird #. Also zur Eingabe

 11   12
  2   2
   1 1
    #
    #
    #

Wir bekommen 1 + 1 - 1 - 2 + 2 - 2 + 1 - 1 = -1. Das Vorzeichen des Ergebnisses wird als Ausgabe angegeben, eine negative Zahl ergibt das Ergebnis 1und eine positive ist 0.

Daher 1bedeutet Ausgabe von , dass der linke Pfad weniger belegt ist, und 0bedeutet rechts.

Erläuterung

Auf hohem Niveau funktioniert das so:

Die Hauptdiagonale mit den @Elementen ist der Akkumulator, über die Leistung wird aunten entschieden. (Acht Paare @bedeuten acht Bits, aber das höchste Bit ist das Vorzeichen, sodass diese Lösung eine maximale Differenz von +127 oder -128 verarbeiten kann. Ein teilweises Überlaufen ist in Ordnung, solange wir vor dem Beenden zurückkommen.)

Die vier Zeilen, die wie Ax]}#--folgt beginnen, lesen die Eingabe und negieren sie bei einer Ziffer (falls erforderlich) und geben den Wert an die Addierer weiter.

Die ersten drei Zeilen entscheiden, ob wir eine Ziffer oder eine Folge von Leerzeichen betrachten und verfolgen, ob die Ziffern negiert werden müssen.

Die verbleibenden Elemente, die unter den Eingaben und den Elementen ganz rechts eingeklemmt sind, behandeln die Beendigungsbedingung und ordnen die Ausgabe ASCII zu (sodass wir Zeichen '0'oder '1'anstelle von Werten 0x0oder 0x1. Diese ASCII-Zuordnung erfordert keine zusätzlichen Bytes, sonst würde ich nicht habe es aufgenommen.)

JavaScript (ES6), 55 Byte

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

Angenommen, in jeder Zeile sind keine nachgestellten Leerzeichen und Ausgaben truefür right, falsefür left. Der Trick besteht darin, jede Ziffer in der Eingabe abzugleichen. Wenn sich in derselben Zeile ein Leerzeichen dahinter befindet, subtrahieren Sie es von der Summe. Andernfalls addieren Sie es zur Summe. Wenn die Endsumme kleiner als 0 ist, ist die richtige Straße diejenige, auf der weniger gefahren wird, und umgekehrt.

Versuch es:

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 Bytes

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

Probieren Sie es online!

Flüche! Ich habe das Problem nicht nah genug gelesen. Das Update ( ''.join()) wurde hinzugefügt , allerdings auf Kosten von 9 Bytes.

Python 2, 78 Bytes

-1 Byte danke an @math_junkie

Probieren Sie es online aus

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

Druckt Falsefür den linken und den Truerechten Pfad

Retina , 180 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

^(?=( *(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))))))))))+¶)+ *#

Probieren Sie es online!

Ich dachte, ich würde auch eine regex-only-Lösung ausprobieren (die obige ist eine reine .NET-Regex, die nur Eingaben entspricht, bei denen der richtige Weg eingeschlagen werden sollte, außer ¶als Abkürzung für\n ).

Es ist ärgerlich, sich zu wiederholen, aber genau das passiert, wenn Sie jede mögliche Ziffer einzeln behandeln müssen.

Die Lösung ist eine recht einfache Anwendung von Bilanzkreisen : Zuerst addieren wir die Ziffern im linken Zweig, indem wir die NCaptures 3für jede Ziffer auf den Stapel schieben N. Dann versuchen wir das zu erreichen #, indem wir 3 Nfür jede Ziffer Nim rechten Zweig von den Stapelzeiten abspringen . Dies ist nur möglich, wenn die Summe der Ziffern im linken Zweig größer ist als die im rechten Zweig (da Sie nicht von einem leeren Stapel abspringen können).

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)

sist eine Funktion, die zurückkehrt, truewenn sich die nicht genommene Straße auf der linken Seite befindet. 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 Byte

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

Probieren Sie es online!

(Quietscht nur unter den Python-Antworten.: D)

Ausgänge Truefür den linken und Falseden rechten Pfad.

Nimmt Eingaben als Zeichenfolge an `n, die als PowerShell-Entsprechung von "Zeichenfolge mit einem wörtlichen Backslash und einem n" oder als wörtliche mehrzeilige Zeichenfolge definiert ist. Wir schalten dann -splitdiese Eingabe ein \s(Leerzeichen inklusive Zeilenumbrüche) oder #und filtern alle leeren Ergebnisse heraus -ne'', so dass wir nur ein Array der Ziffern übrig haben. Diese werden in eine Schleife eingespeist|%{...} .

Bei jeder Iteration nehmen wir zuerst das aktuelle Element $_, wandeln es als charArray -joinmit einem Pluszeichen um +und leiten es an iex(kurz für Invoke-Expressionund ähnlich für eval). Das ist in gespeichert, $iso dass wir die Ziffern auf diesem bestimmten Abschnitt des Pfades richtig zusammenfassen. Wir verwenden dann dieses und sein Negativ als die beiden Elemente eines Arrays ($i, -$i), in das durch Hin- und Herschalten eines Booleschen Werts indiziert wird. Das heißt, die erste Iteration durch diese Schleife, der erste linke Pfadabschnitt, in den wir indexieren -$i; das nächste Mal werden wir nehmen $i; und so weiter. Die werden in $amit angesammelt +=.

Schließlich bewerten wir , ob $aist -größere than 0. Wenn ja, dann hatte der rechte Pfad eine größere Summe, andernfalls hatte der linke Pfad eine größere Summe. Dieses boolesche Ergebnis verbleibt in der Pipeline, und die Ausgabe ist implizit.

CJam , 19 18 Bytes

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

Probieren Sie es online!

Drucke 0für links und1 rechts.

Erläuterung

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 Bytes

Vielen Dank an Martin Ender für das Speichern von 3 Bytes!

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

Reine Funktion, die eine durch Zeilenumbrüche getrennte Zeichenfolge als Eingabe verwendet und zurückkehrt True, um den linken Falseund den rechten Pfad zu verwenden. Verdammt diese langen Mathematica-Befehlsnamen; Das ist wie 10 Token.

Pip , 19 18 Bytes

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

Nimmt Eingaben als einzelne Zeichenfolge in die Befehlszeile auf (wobei Zeilenumbrüche in Anführungszeichen gesetzt und maskiert werden müssen, wenn sie in einer tatsächlichen Befehlszeile ausgeführt werden). Ausgänge -1für links, 1für rechts.Probieren Sie es online!

Erläuterung

Schleifen über Ziffernläufe und Addieren der Ziffernsummen zu einer Zählung. Das Vorzeichen der Zählung wird jedes Mal gewechselt, mit dem Ergebnis, dass die Werte für die linke Hand negativ und die Werte für die rechte Hand positiv sind. Dann drucken wir das Vorzeichen der Schlusszählung ( -1oder 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 Bytes

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

Probieren Sie es online! Verwendung: Die anonyme Funktion verwendet (>0).f.wordseine durch Zeilenumbrüche getrennte Zeichenfolge als Argument und gibt Falselinks und Truerechts zurück.

Erläuterung:

Bei einer Eingabe

 99   989
  99  89
  99 99
    #
    #
   # 

dass der String ist " 99 989\n 99 89\n 99 99\n #\n #\n #", dann wordsentfernt alle Zeilenumbrüche und Leerzeichen und gibt eine Liste der übrigen Strings: ["99","989","99","89","99","99","#","#","#"]. Die Funktion fnimmt die ersten beiden Elemente aund baus dieser Liste und überprüft , ob aeine Folge von Ziffern ist , indem es die Zeichenfolge „#“ zu vergleichen. (Da das '#'Zeichen kleiner ist als alle Ziffernzeichen '0', '1'... ist jede Zeichenfolge, die mit einer Ziffer beginnt, lexikografisch größer als "#".) Die Funktion gordnet jedes Zeichen in einer Zeichenfolge seinem ASCII-Zeichencode zu und gibt ihre Summe zurück. In fwenden wir gauf aundb und berechnen g a - g b, dass der Wert des linken Pfads minus dem Wert des rechten Pfads ist, und fügen ihn einem rekursiven Aufruf von hinzufum die folgenden Zeilen zu behandeln. Wenn der linke Pfad weiter zurückgelegt wird, ist das Ergebnis von fnegativ und ansonsten positiv für den rechten Pfad. (>0)Überprüfen Sie daher , ob das Ergebnis größer als Null ist.

Python 3 , 84 Bytes

Da alle aktuellen Python-Einreichungen Funktionen sind, dachte ich, ich würde ein volles Programm beitragen.

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

TrueWird gedruckt, wenn der linke Pfad weniger zurückgelegt ist False. Probieren Sie es online!

Für jede Eingabezeile wird das Leerzeichen aufgeteilt, die Ziffern jedes resultierenden Elements werden summiert und zu einer Liste hinzugefügt, während bei jedem Schritt das Vorzeichen der Liste umgedreht wird. Es liest so lange Eingabezeilen, bis es eine mit einem trifft #. An diesem Punkt wird map(int,n)eine Ausnahme ausgelöst und die Schleife verlassen. Dabei wird gedruckt, Trueob die Zählung positiv ist und Falseansonsten.

Stapel, 169 Bytes

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

Druckt 0für links, -1für rechts. Hinweis: Liest Zeilen, bis eine mit einem gefunden wird #, und beendet dann das Lesen. Die Differenz der Pfadsummen ist auf 511 begrenzt (1 Byte hinzufügen, um größere Unterschiede zu unterstützen). Nicht mehr als 9 Stellen in jeder Zeile jedes Pfads (unterstützt eine beliebige Anzahl von Zeilen). Erläuterung: Died Unterroutine akzeptiert zwei Parameter: Addieren oder Subtrahieren und die Ziffer (n). Es extrahiert die letzte Ziffer durch Modulo durch 10 und die verbleibenden Ziffern durch Teilen durch 10 und ruft sich selbst rekursiv auf, solange noch Ziffern übrig sind. Die cUnterroutine verwendet drei Parameter: ob addiert oder subtrahiert werden soll, welche Ziffern addiert oder subtrahiert werden sollen und welche weiteren Ziffern addiert werden sollen. Es ruft diedSubroutine zur Behandlung der zu addierenden Ziffern und durchläuft dann die ersten beiden Parameter. Dies bedeutet, dass der Aufruf des cUnterprogramms mit den Parametern -und den linken und rechten Ziffern die rechten Ziffern addiert und die linken Ziffern subtrahiert. Schließlich wird das Ergebnis verschoben, um das Vorzeichen zu extrahieren.

Oktave, 46 Bytes

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

Probieren Sie es online! Eine Funktion, die ein 2D-Zeichenarray aals Eingabe verwendet.

Erläuterung:

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 Bytes

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

Diesmal etwas länger als 52 Bytes . ;)
Und kehrt wieder nach falserechts und truenach links zurück.

Erläuterung:

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

Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

false
false
true
false
false
false
false