Jest to drugi z serii, trzeci to Dwie drogi rozbieżne w żółtym lesie (część 3)

Opiera się to na dwóch drogach podzielonych na żółte drewno (część 1) , które było moim wcześniejszym wyzwaniem. Został dość dobrze przyjęty, ale był również dość trywialny (odpowiedź Java w 52 bajtach!) Więc zrobiłem coś bardziej złożonego ...

Inspiracja

Wyzwanie to inspirowane jest słynnym wierszem Roberta Frosta „Droga nie podjęta”:

Dwie drogi rozchodziły się w żółtym lesie.
I przepraszam, że nie mogłem podróżować obaj
I być jednym podróżnikiem, długo stałem
I patrzyłem w dół jak najdalej,
do miejsca, gdzie zakręciło się w zaroślach;

... przycięte 2 akapity ...

Będę opowiadać z westchnieniem
Gdzieś wieki wieków stąd:
Dwie drogi rozchyliły się w lesie, a ja -
wziąłem tę mniej uczęszczaną,
i to zrobiło różnicę.

Zauważ przedostatniej linii I took the one less traveled by,. Twoim celem jest znalezienie drogi najmniej przejechanej w danych wejściowych ciągu. Musisz wyprowadzić jedną z 2 wartości, które różnią się od siebie, sygnalizując, w którą stronę należy skręcić, aby wybrać drogę mniej przejechaną. Gdy droga rozwidli się (szlak sześciokątów zmienia się na liczby), jesteś na skrzyżowaniu. Stamtąd będą 2 ścieżki złożone z cyfr. Ścieżka, której cyfry mają najniższą sumę, będzie drogą niezebraną. Pamiętaj, że niezebrana droga może mieć większą ścieżkę, ale niższą sumę ścieżki. Oto kilka przykładów / przypadków testowych z programu, który drukuje „w lewo” lub „w prawo” dla niezebranej ścieżki:

 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)

Rzeczy do przyjęcia i zapamiętania

• Zawsze będą 2 ścieżki. Nie więcej nie mniej.
• Możesz pobierać dane ze STDIN jeden wiersz na raz, ciąg zawierający znaki LF lub ciąg zawierający dosłowny odwrotny ukośnik i n. Jeśli potrzebujesz danych wejściowych w jakikolwiek inny sposób, poproś o zgodę w komentarzach.
• Nie musisz się martwić o nieprawidłowe dane wejściowe lub powiązane ścieżki. Nie zostaną one nigdy wprowadzone do twojego programu / funkcji.
• Dane wejściowe mogą mieć dowolną długość, szerokość lub wysokość, mniejszą niż limit napisów w Twoim języku.
• W #tym samym wierszu nigdy nie będzie ani cyfr.
• Wszystkie cyfry na ścieżce są dodatnimi liczbami całkowitymi od 0 do 9.
• Dozwolone jest wprowadzanie lub wyprowadzanie z końcowym znakiem nowej linii.
• Zobacz moją odpowiedź JS ES6 poniżej.
• Zawsze będzie co najmniej 1 spacja między 2 ścieżkami.
• 2 ścieżki zawsze będą miały tę samą wysokość dla każdej mapy, ale mogą być inne na innych mapach.
• Jeśli masz wątpliwości co do konkretnego przypadku testowego, powiedz mi.
• 1111 interpretuje się jako 1 + 1 + 1 + 1 = 4, a nie 1111 = 1111. Mapa to ciąg liczb jednocyfrowych, a nie liczb o dowolnej długości.
• To jest golf golfowy , więc wygrywa najkrótsza odpowiedź w bajtach!
• Standardowe luki zabronione

Jeśli masz jakieś pytania dotyczące tego wyzwania, zapytaj mnie w komentarzach i powodzenia!

05AB1E , 21 15 bajtów

Wyjścia 0 dla lewej i 1 dla prawej.

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

Wypróbuj online!

Wyjaśnienie

|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

Siatkówka , 28 bajtów

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

1+

Wypróbuj online!

Drukuje 0dla lewej i 1prawej strony. Zakłada, że ​​na liniach nie ma spacji końcowych.

Wyjaśnienie

\d
$*

Konwertuj każdą cyfrę Nna ciąg Njedności.

%r`1\G
-

Jedna linia ( %), dopasuj kolejne ( \G) od końca ( r) i zamień każdą z nich -(tj. Zmień prawą gałąź na -s).

Os`.

Sortuj wszystkie znaki, aby wszystkie -s znajdowały się bezpośrednio przed wszystkimi 1.

+`-1

Wielokrotnie anuluj parę znaków -i 1.

1+

Spróbuj dopasować co najmniej jeden 1(jeśli tak, na lewej ścieżce było więcej odważników).

Python 2 , 95 89 88 87 bajtów

Oto mój pierwszy krok w Pythonie. Zdecydowanie nie optymalny, ale przyzwoity początek.

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)

Wypróbuj online!

Chip , 216 bajtów

 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

Wypróbuj online!

Nieco większa niż odpowiedź na część 1 ...

Przegląd

Chip to język 2D inspirowany rzeczywistymi obwodami, który zajmuje się bitami składowymi każdego bajtu w strumieniu bajtów.

To rozwiązanie utrzymuje bieżącą sumę cyfr, które widzi, odwracając znak wejścia za każdym razem, gdy napotyka odcinek białych znaków, a następnie kończy na pierwszej #. Tak więc dla danych wejściowych

 11   12
  2   2
   1 1
    #
    #
    #

Dostajemy 1 + 1 - 1 - 2 + 2 - 2 + 1 - 1 = -1. Znak wyniku jest podawany jako wynik, liczba ujemna daje wynik 1, a dodatnia to 0.

Dlatego wynik 1oznacza, że ​​lewa ścieżka jest mniej zajęta, a 0oznacza prawą.

Wyjaśnienie

Na wysokim poziomie działa to tak:

Główną przekątną z @elementami jest akumulator, o wydajności decyduje au dołu. (Osiem par @oznacza osiem bitów, ale najwyższy bit jest znakiem, więc to rozwiązanie może obsłużyć maksymalną różnicę +127 lub -128. Przepełnienie w połowie jest w porządku, o ile wrócimy przed zakończeniem.)

Cztery linie, które zaczynają się jak Ax]}#--... odczytują dane wejściowe, aw przypadku cyfry, negują je (w razie potrzeby) i przekazują wartość do sumatorów.

Pierwsze trzy linie decydują, czy patrzymy na cyfrę, czy sekwencję białych znaków, i sprawdzamy, czy cyfry należy zanegować.

Pozostałe elementy zaklinowane pod wejściami i elementy po prawej stronie obsługują warunek zakończenia i odwzorowują dane wyjściowe na ASCII (tak, że otrzymujemy znaki '0'lub '1'zamiast wartości 0x0lub 0x1. To odwzorowanie ASCII nie wymagało żadnych dodatkowych bajtów, inaczej nie zrobiłbym tego zawarłem to.)

JavaScript (ES6), 55 bajtów

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

Zakłada brak spacje na każdej linii, oraz wyjścia truedla right, falsedla left. Sztuczka polega na dopasowaniu każdej cyfry na wejściu, a jeśli po tej samej linii jest spacja, odejmij ją od sumy; w przeciwnym razie dodaj go do całości. Jeśli końcowa suma jest mniejsza niż 0, właściwa droga jest tą, którą mniej przejechano i odwrotnie.

Wypróbuj to:

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 bajtów

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

Wypróbuj online!

Pomstowanie! Nie przeczytałem problemu wystarczająco blisko. Dodano poprawkę ( ''.join()), ale kosztem 9 bajtów.

Python 2, 78 bajtów

-1 bajt dzięki @math_junkie

Wypróbuj online

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

Drukuje Falsedla lewej ścieżki i Truedla prawej

Siatkówka , 180 bajtów

Liczba bajtów zakłada kodowanie 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))))))))))+¶)+ *#

Wypróbuj online!

Pomyślałem, że wypróbuję również rozwiązanie tylko do wyrażenia regularnego (powyższe jest zwykłym wyrażeniem regularnym .NET, które pasuje tylko do danych wejściowych, w których należy podążać właściwą ścieżką, z wyjątkiem użycia ¶ jako skrótu \n).

Jest to denerwująco powtarzalne, ale dzieje się tak, gdy musisz traktować każdą możliwą cyfrę indywidualnie.

Rozwiązaniem jest dość proste zastosowanie grup bilansujących : najpierw sumujemy cyfry w lewej gałęzi, wypychając Nprzechwytywanie na stos 3dla każdej cyfry N. Następnie staramy się dotrzeć do #, wyskakując z 3 Nczasów stosu dla każdej cyfry Nw prawej gałęzi. Jest to możliwe tylko wtedy, gdy suma cyfr w lewej gałęzi jest większa niż w prawej gałęzi (ponieważ nie można wyskoczyć z pustego stosu).

JavaScript (ES6), 106 104 bajtów

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)

sto funkcja, która powraca, truejeśli droga nie jest zajęta po lewej stronie. Nie golfowany:

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 bajtów

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

Wypróbuj online!

(Po prostu piszczy pod odpowiedziami w języku Python.: D)

Wyjścia Truedla lewej ścieżki iFalse prawej ścieżki.

Pobiera dane wejściowe jako ciąg wyznaczony za pomocą `n, który jest odpowiednikiem programu PowerShell „ciąg zawierający dosłowny odwrotny ukośnik i n” , lub jako dosłowny ciąg wielowierszowy. Następnie -splitwłączamy to wejście \s(białe znaki, w tym nowe wiersze) lub #odfiltrowujemy wszystkie puste wyniki -ne'', więc pozostaje nam tylko tablica cyfr. Te są wprowadzane do pętli|%{...} .

Przy każdej iteracji najpierw bierzemy bieżący element $_, rzutujemy go jako chartablicę, -joinrazem ze znakiem plus +i potokujemy do iex(skrót od Invoke-Expressioni podobny do eval). Jest to zapisane w, $iwięc właściwie podsumowujemy cyfry na tym konkretnym fragmencie ścieżki. Następnie używamy tego i jego ujemnego jako dwóch elementów tablicy ($i, -$i), indeksowanych przez przerzucanie wartości logicznej tam iz powrotem. Oznacza to, że pierwsza iteracja przez tę pętlę, pierwszy fragment lewej ścieżki, do którego się indeksujemy -$i; następnym razem weźmiemy $i; i tak dalej. Są one kumulowane $az+= .

Na koniec oceniamy, czy $ajest -greater than 0. Jeśli tak, to prawa ścieżka miała większą sumę, w przeciwnym razie lewa ścieżka miała większą sumę. Ten wynik logiczny jest pozostawiany w potoku, a dane wyjściowe są niejawne.

CJam , 19 18 bajtów

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

Wypróbuj online!

Drukuje 0dla lewej i1 prawej strony.

Wyjaśnienie

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 bajtów

Dzięki Martin Ender za oszczędność 3 bajtów!

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

Czysta funkcja przyjmująca ciąg znaków rozdzielany znakiem nowej linii jako dane wejściowe i powracająca Truedo wyboru lewej ścieżki, Falseaby wybrać właściwą ścieżkę. Cholera, te długie nazwy poleceń Mathematica; to jest jak 10 żetonów.

Pip , 19 18 bajtów

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

Pobiera dane wejściowe jako pojedynczy ciąg w wierszu polecenia (który będzie wymagał cytowania i zmiany znaczenia nowych linii, jeśli zostanie uruchomiony w rzeczywistym wierszu polecenia). Wyjścia -1dla lewej, 1dla prawej. Wypróbuj online!

Wyjaśnienie

Pętle nad seriami cyfr, dodając sumy cyfr do sumy. Znak liczenia jest zamieniany za każdym razem, w wyniku czego wartości po lewej stronie są ujemne, a wartości po prawej są dodatnie. Następnie drukujemy znak końcowej sumy ( -1lub 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 bajty

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

Wypróbuj online! Użycie: Funkcja anonimowa (>0).f.wordsprzyjmuje jako argument ciąg oddzielony znakiem nowej linii i zwraca znaki Falselewy iTrue prawej.

Wyjaśnienie:

Biorąc pod uwagę wkład

 99   989
  99  89
  99 99
    #
    #
   # 

że jest łańcuch " 99 989\n 99 89\n 99 99\n #\n #\n #", a następnie wordsusuwa wszystkie znaki nowej linii i spacje i zwraca listę pozostałych strun: ["99","989","99","89","99","99","#","#","#"]. Funkcja fprzyjmuje dwa pierwsze elementy ai bz tej listy i sprawdza, czy ajest ciąg cyfr, porównując go do strun „#”. (Ponieważ char '#'jest mniejszy niż wszystkie cyfry znaków '0', '1'... każdy łańcuch rozpoczynający się cyfrą będzie leksykograficznie większy niż "#".) Funkcja godwzorowuje każdy char w ciąg jego kod ASCII i zwraca ich sumę. W fstosujemy się gdoa ib i obliczyć g a - g b, która jest wartością lewej ścieżce minus wartości prawą i dodać go do wywołania rekurencyjnegofdo obsługi następujących wierszy. Jeśli lewa ścieżka jest częściej podróżowana, wynik zfbędzie ujemna, a poza tym dodatnia dla właściwej ścieżki, więc (>0)sprawdza, czy wynik jest większy od zera.

Python 3 , 84 bajtów

Ponieważ wszystkie obecne zgłoszenia Pythona są funkcjami, pomyślałem, że wrócę pełny program.

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

Drukuje, Truejeśli lewa ścieżka jest mniej uczęszczana, w Falseprzeciwnym razie. Wypróbuj online!

Dla każdego wiersza danych wejściowych podział na białe znaki, sumuje cyfry każdego wynikowego elementu i dodaje go do licznika, jednocześnie odwracając znak licznika na każdym kroku. Kontynuuje czytanie linii wejściowych, dopóki nie natrafi na jeden z #, w którym to momencie map(int,n)powstaje wyjątek i wychodzimy z pętli, drukując, Trueczy suma jest dodatnia i Falseinaczej.

Partia, 169 bajtów

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

Drukuje 0dla lewej, -1dla prawej. Uwaga: odczytuje wiersze, dopóki nie znajdzie linii z #, a następnie przestaje czytać. Różnica w sumach ścieżek jest ograniczona do 511 (dodaj 1 bajt, aby obsłużyć większe różnice). Nie więcej niż 9 cyfr w każdym rzędzie każdej ścieżki (obsługuje dowolną liczbę wierszy). Objaśnienie: Podprogram do obsługi cyfr, które należy dodać, a następnie przechodzi do obsługi dwóch pierwszych parametrów. Oznacza to, że wywołanie podprogramu z parametrami oraz cyframi lewymi i prawymi doda cyfry prawe i odejmie cyfry lewe. Ostatecznie wynik jest przesuwany, aby wyodrębnić znak.d Podprogram ma dwa parametry: dodawanie lub odejmowanie oraz cyfry. Wyodrębnia ostatnią cyfrę modulo przez 10, a pozostałe cyfry dzieląc przez 10 i wywołuje się rekurencyjnie, podczas gdy pozostały jeszcze cyfry. cPodprogram pobiera trzy parametry: czy dodać lub odjąć, cyfry, aby dodać lub odjąć, a kolejne cyfry dodać. To nazywadc-

Oktawa, 46 bajtów

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

Wypróbuj online! Funkcja, która pobiera tablicę znaków 2D ajako dane wejściowe.

Wyjaśnienie:

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 bajtów

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

Tym razem nieco dłuższy niż 52 bajty . ;)
I znowu wraca falsena prawo i truena lewo.

Wyjaśnienie:

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

Kod testowy:

Wypróbuj tutaj.

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

Wydajność:

false
false
true
false
false
false
false