Due strade divergenti in un bosco giallo (parte 2)


25

Questa è la seconda di una serie, la terza è Due strade divergenti in un bosco giallo (parte 3)

Questo si basa su due strade divergenti in un bosco giallo (parte 1) , una mia precedente sfida. È stato accolto abbastanza bene, ma è stato anche abbastanza banale (una risposta Java in 52 byte!) Quindi ho reso qualcosa di più complesso ...

L'ispirazione

Questa sfida è ispirata al famoso poema di Robert Frost, "The Road Not Taken":

Due strade divergevano in un bosco giallo,
e scusami non potevo viaggiare entrambe
ed essere un viaggiatore, a lungo mi fermai
e ne guardai giù il più lontano possibile
verso dove si piegava nel sottobosco;

... 2 paragrafi tagliati ...

Lo dirò con un sospiro
Da qualche parte secoli e secoli da qui:
due strade divergevano in un bosco, e io -
ho preso quella meno percorsa,
e questo ha fatto la differenza.

Notare la penultima riga I took the one less traveled by,,. Il tuo obiettivo è trovare la strada meno percorsa nel tuo input di stringa. È necessario emettere uno dei 2 valori distinti tra loro che segnalano il modo in cui si deve girare per prendere la strada meno percorsa. Una volta che la strada si biforca (la scia degli esagoni si trasforma in numeri) ci si trova all'incrocio. Da lì, ci saranno 2 percorsi composti da cifre. Il percorso le cui cifre hanno la somma più bassa sarà la strada non presa. Nota che la strada non percorsa potrebbe avere un percorso più grande ma una somma del percorso inferiore. Ecco alcuni esempi / casi di test di un programma che stampa "sinistra" o "destra" per il percorso non preso:

 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)

Cose da assumere e ricordare

  • Ci saranno sempre 2 percorsi. Ne più ne meno.
  • Puoi prendere input da STDIN una riga alla volta, una stringa contenente caratteri LF o una stringa contenente una barra rovesciata letterale e un n. Se hai bisogno di input in altro modo, chiedi l'approvazione nei commenti.
  • Non devi preoccuparti di input non validi o percorsi collegati. Questi non verranno mai inseriti nel tuo programma / funzione.
  • L'input può essere di qualsiasi lunghezza in larghezza o altezza, inferiore al limite di stringa della tua lingua.
  • Non ci saranno mai #un numero e nella stessa riga.
  • Tutte le cifre nel percorso sono numeri interi positivi da 0 a 9.
  • Sono consentiti input o output con una nuova riga finale.
  • Vedi la mia risposta JS ES6 di seguito per un esempio.
  • Ci sarà sempre almeno 1 spazio tra i 2 percorsi.
  • I 2 percorsi avranno sempre la stessa altezza per ogni mappa, ma potrebbero essere diversi su altre mappe.
  • Se sei confuso su un caso di test specifico, per favore dimmelo.
  • 1111 è interpretato come 1 + 1 + 1 + 1 = 4, non 1111 = 1111. La mappa è una serie di numeri a una cifra, non numeri di lunghezza arbitraria.
  • Questo è , quindi vince la risposta più breve in byte!
  • Scappatoie standard vietate

Se avete domande su questa sfida, chiedetemi nei commenti e buona fortuna!


Ehi, puoi vedere tutte le risposte e il loro numero di byte incollando $("div > h1").map(function(){return $(this).text()}).get().join("\n");nella tua console!
programmatore

1
Ecco una versione alternativa con spazi bianchi rimossi e ignorato le risposte barratelet 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');
David Archibald

2
Un # non è un esagono ...
user253751

1
" ma era anche abbastanza banale (una risposta Java in 52 byte!) " 43 byte ora. ;)
Kevin Cruijssen,

Closevotes di nuovo? Che diavolo c'è di sbagliato con te?
Matthew Roh,

Risposte:


2

05AB1E , 21 15 byte

Emette 0 per sinistra e 1 per destra.

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

Provalo online!

Spiegazione

|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

Retina , 28 byte

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

1+

Provalo online!

Stampa 0per sinistra e1 per destra. Presuppone che non vi siano spazi finali su nessuna riga.

Spiegazione

\d
$*

Converti ogni cifra Nin una sequenza di Nquelle.

%r`1\G
-

Uno per ogni riga ( %), abbina quelli consecutivi ( \G) dalla fine ( r) e sostituisci ciascuno di essi con -(cioè trasforma il ramo destro in -s).

Os`.

Ordina tutti i caratteri, in modo che tutti gli -s siano direttamente davanti a tutti gli 1s.

+`-1

Annullare ripetutamente un paio di -e 1.

1+

Prova ad abbinarne almeno uno 1(in tal caso, c'erano più pesi nel percorso a sinistra).



7

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

Provalo online!

Un po 'più grande della risposta per la parte 1 ...

Panoramica

Chip è un linguaggio 2D ispirato ai circuiti reali e si occupa dei bit componenti di ciascun byte in un flusso di byte.

Questa soluzione mantiene una somma progressiva delle cifre che vede, capovolgendo il segno dell'input ogni volta che incontra un tratto di spazio bianco, per poi terminare con la prima #. Quindi, per input

 11   12
  2   2
   1 1
    #
    #
    #

Abbiamo capito 1 + 1 - 1 - 2 + 2 - 2 + 1 - 1 = -1. Il segno del risultato è dato come output, un numero negativo produce il risultato 1e positivo è 0.

Pertanto, l'output di 1significa che il percorso sinistro è meno preso e 0significa giusto.

Spiegazione

Ad alto livello, ecco come funziona:

La diagonale principale con gli @elementi è l'accumulatore, l'uscita è decisa dalla aparte inferiore. (Otto coppie di@ significa otto bit, ma il bit più alto è il segno, quindi questa soluzione può gestire una differenza massima di +127 o -128. Il trabocco a metà strada va bene, purché torniamo prima di terminare.)

Le quattro righe che iniziano come Ax]}#--... stanno leggendo l'input e, nel caso di una cifra, la annullano (se necessario) e passano il valore negli additivi.

Le prime tre righe decidono se stiamo osservando una cifra o una sequenza di spazi bianchi e tengono traccia della necessità di negare le cifre.

Gli elementi rimanenti incastrati sotto gli input e gli elementi all'estrema destra gestiscono la condizione di terminazione e mappano l'output su ASCII (in modo da ottenere caratteri '0'o '1'invece di valori 0x0o 0x1. Questa mappatura ASCII non richiede byte aggiuntivi, altrimenti non lo farei l'ho incluso.)


2
Mi piace il fatto che il codice assomigli a due strade divergenti.
Laikoni,

@Laikoni non l'avevo nemmeno notato, è un po 'figo :)
Phlarx,

4

JavaScript (ES6), 55 byte

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

Presuppone che non vi siano spazi finali su ciascuna riga e output trueper right, falseper left. Il trucco è abbinare ogni cifra nell'input, e se c'è uno spazio dopo di esso sulla stessa linea, sottrarlo dal totale; altrimenti, aggiungilo al totale. Se il totale finale è inferiore a 0, la strada giusta è quella meno percorsa e viceversa.

Provalo:

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>


Devi inserire x=a all'inizio, poiché le espressioni non sono consentite, solo funzioni memorizzate come una variabile e interi programmi.
programmatore

@ programmer5000 Perché? Sembra un po 'strano ignorare le impostazioni predefinite e non sembra indicare che questo sia il caso nella domanda.
Wheat Wizard

1
@ programmer5000 In realtà, le funzioni senza nome sono consentite per impostazione predefinita . (Grazie per lo snippet, a proposito)
ETHproductions

4

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)

Provalo online!

Maledizioni! Non ho letto il problema abbastanza vicino. Aggiunto un fix ( ''.join()), ma al costo di 9 byte.


Così vicino! Buona cattura, grazie!
Datastream

3

Python 2, 78 byte

-1 byte grazie a @math_junkie

Provalo online

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

Stampa Falseper il percorso a sinistra e Trueper la destra


r=-rinvece di r*=-1salvare un
drogato di

2

Retina , 180 byte

Il conteggio dei byte presuppone la codifica 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))))))))))+¶)+ *#

Provalo online!

Ho pensato di provare anche una soluzione solo per regex (quanto sopra è una semplice regex .NET che corrisponde solo agli input in cui il percorso giusto dovrebbe essere preso, tranne per l'uso come abbreviazione di \n).

È fastidiosamente ripetitivo, ma è quello che succede quando devi trattare ogni possibile cifra singolarmente.

La soluzione è un'applicazione abbastanza semplice di gruppi di bilanciamento : per prima cosa sommiamo le cifre nel ramo sinistro spingendo le Nacquisizioni in pila 3per ogni cifra N. Quindi proviamo a raggiungere il #, mentre spuntiamo dai 3 Ntempi di stack per ogni cifra Nnel ramo giusto. Ciò è possibile solo se la somma delle cifre nel ramo sinistro è maggiore di quella nel ramo destro (poiché non è possibile eseguire il pop-up da uno stack vuoto).


Non ho familiarità con le regex .NET, ma non puoi fare un set di caratteri: [0-9]per abbinare tutte le cifre o \d?
programmatore

@ programmer5000 Certo, ma non riesco a distinguerli per determinare quante catture dovrei spingere per sommarle.
Martin Ender,

2

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)

sè una funzione che ritorna truese la strada non presa è sulla sinistra. 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>


Spero che qualcuno possa ottenere un punteggio migliore di questo ...
programmer5000

Sfida accettata @ programmer5000
David Archibald

@DavidArchibald qualcuno l'ha già fatto, ma apprezzerei una nuova risposta. Sei interessato al terzo della serie ?
programmatore

sicuro. Non avevo capito che ce ne fossero 3
David Archibald,

2

PowerShell , 80 byte

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

Provalo online!

(Basta cigolare sotto le risposte di Python.: D)

Uscite True per il percorso sinistro e Falseper il percorso destro.

Prende l'input come una stringa delineata con `n, che è l'equivalente di PowerShell di "una stringa contenente una barra rovesciata letterale e una n" , o come stringa letterale multilinea. Dopodiché inseriamo -splitquesto input \s(spazi bianchi comprese le nuove righe) o filtriamo #tutti i risultati vuoti -ne'', quindi ci resta solo un array di cifre. Quelli sono inseriti in un ciclo |%{...}.

Ogni iterazione, prima prendiamo l'elemento corrente $_, lo lanciamo come un chararray, -joininsieme a un segno più +, e lo reindirizziamo a iex(abbreviazione di Invoke-Expressione simile a eval). È archiviato in $imodo da riassumere correttamente le cifre su questo particolare pezzo del percorso. Usiamo quindi quello e il suo negativo come i due elementi di un array ($i, -$i), indicizzati facendo capovolgere avanti e indietro un valore booleano. Significato, la prima iterazione attraverso questo ciclo, la prima parte del percorso sinistro, indicizzeremo -$i; la prossima volta lo prenderemo $i; e così via. Quelli si accumulano in $acon +=.

Infine, valutiamo se $aè -greater than 0. Se lo è, allora il percorso giusto aveva una somma maggiore, altrimenti il ​​percorso sinistro aveva una somma maggiore. Tale risultato booleano viene lasciato sulla pipeline e l'output è implicito.


2

CJam , 19 18 byte

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

Provalo online!

Stampa 0per sinistra e 1per destra.

Spiegazione

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

Mathematica, 80 77 byte

Grazie a Martin Ender per aver salvato 3 byte!

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

Funzione pura che prende come input una stringa delimitata da una nuova riga e torna Truea prendere il percorso sinistro, Falseper prendere il percorso giusto. Dannazione a quei lunghi nomi di comandi di Mathematica; questo è come 10 token.


0

Pip , 19 18 byte

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

Accetta l'input come singola stringa nella riga di comando (che dovrà essere quotata e sfuggita alle nuove righe se eseguita su una riga di comando effettiva). Uscite -1per sinistra, 1per destra.Provalo online!

Spiegazione

Passa sopra le serie di cifre, aggiungendo le somme delle cifre a un conteggio. Il segno del conteggio viene scambiato ogni volta, con il risultato finale che i valori della mano sinistra sono negativi e i valori della mano destra sono positivi. Quindi stampiamo il segno del conteggio finale ( -1o 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 byte

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

Provalo online! Utilizzo: la funzione anonima (>0).f.wordsaccetta una stringa separata da nuova riga come argomento e restituisce Falsea sinistra ea Truedestra.

Spiegazione:

Dato un input

 99   989
  99  89
  99 99
    #
    #
   # 

che è la stringa " 99 989\n 99 89\n 99 99\n #\n #\n #", poi wordsspoglia tutte le nuove righe e gli spazi e restituisce una lista di stringhe rimanenti: ["99","989","99","89","99","99","#","#","#"]. La funzione fprende i primi due elementi ae bda questo elenco e controlla se aè una stringa di cifre confrontandola con la stringa "#". (Perché il carattere '#'è più piccolo di tutti i caratteri cifra '0', '1', ... ogni stringa che inizia con una cifra sarà più grande di lessicografico "#".) La funzione di gmappa ogni carattere in una stringa al suo codice ASCII e restituisce la loro somma. In fapplichiamo ga ae be calcolareg a - g b , che è il valore del percorso di sinistra meno il valore di quella giusta, e aggiungerlo a una chiamata ricorsiva afper gestire le seguenti righe. Se il percorso a sinistra è più percorso, il risultato fsarà negativo e altrimenti positivo per il percorso a destra, quindi (>0)controlla se il risultato è maggiore di zero.


0

Python 3 , 84 byte

Dal momento che tutte le attuali proposte di Python sono funzioni, ho pensato di contribuire con un programma completo.

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

Stampa Truese il percorso a sinistra è meno percorso, Falsealtrimenti. Provalo online!

Per ogni riga di input, questo si divide su uno spazio bianco, somma le cifre di ciascun elemento risultante e lo aggiunge a un riscontro mentre si lancia il segno del riscontro ad ogni passo. Continua a leggere le righe di input fino a quando non ne raggiunge una con a #, a quel punto map(int,n)solleva un'eccezione e usciamo dal loop, stampando Truese il conteggio è positivo e in caso Falsecontrario.


0

Lotto, 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%

Stampa 0a sinistra, -1a destra. Nota: legge le righe finché non ne trova una con a #, quindi interrompe la lettura. La differenza nelle somme del percorso è limitata a 511 (aggiungere 1 byte per supportare differenze maggiori). Non più di 9 cifre in ogni riga di ciascun percorso (supporta un numero qualsiasi di righe). Spiegazione: La subroutine per gestire le cifre da aggiungere, quindi passa attraverso per gestire i primi due parametri. Ciò significa che chiamando la subroutine con i parametri di e le cifre sinistra e destra aggiungerà le cifre giuste e sottrarrà le cifre sinistre. Alla fine il risultato viene spostato per estrarre il segno.d subroutine accetta due parametri: se aggiungere o sottrarre e le cifre. Estrae l'ultima cifra per modulo per 10 e le cifre rimanenti dividendo per 10 e si chiama in modo ricorsivo mentre ci sono ancora cifre rimanenti. Lac subroutine accetta tre parametri: se aggiungere o sottrarre, le cifre da aggiungere o sottrarre e altre cifre da aggiungere. Si chiama ildc-


0

Ottava, 46 byte

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

Provalo online! Una funzione che accetta un array di caratteri 2D acome input.

Spiegazione:

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

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

Questa volta è un po 'più lungo di 52 byte . ;)
E di nuovo ritorna falseper destra e trueper sinistra.

Spiegazione:

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

Codice di prova:

Provalo qui.

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

Produzione:

false
false
true
false
false
false
false
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.