Mentre siamo su una griglia triangolare , vorrei sottolineare che esiste un equivalente di poliomino su una griglia triangolare. Si chiamano poliamondi , e sono forme formate incollando triangoli equilateri lungo i loro bordi. In questa sfida dovrai decidere quali sottoinsiemi di una griglia triangolare sono poliamammanti e se presentano buchi. Poiché bastano 9 triangoli per creare un poliamondolo con un foro, il codice deve essere il più corto possibile.

La griglia

Useremo il layout a griglia triangolare di Martin per l'input:

Prestare attenzione al fatto che i centri dei triangoli formano una griglia approssimativamente rettangolare e che il triangolo superiore sinistro "punta" verso l'alto. Possiamo descrivere un sottoinsieme di questa griglia, quindi, dando una "mappa stellare" rettangolare che indica quali triangoli sono inclusi e quali non sono inclusi. Ad esempio, questa mappa:

** **
*****

corrisponde al più piccolo poliammide che contiene un foro:

fori

Un poliammide che contiene un buco come nell'esempio sopra (una regione non parte del poliamondolo, che è circondata su tutti i lati da regioni che lo sono ) non è, topologicamente parlando, semplicemente collegata .

La sfida

Scrivi una funzione o un programma che accetta come input una "mappa stellare" come descritto sopra e genera un vero se e solo se il sottoinsieme indicato della griglia triangolare è un poliamondolo semplicemente connesso .

Altri esempi

*** ***
*******

corrisponde al poliammide

che è semplicemente connesso.

*   *
** **
 ***

corrisponde al poliammide

che è semplicemente connesso.

**  **
*** **
 ****

corrisponde al non- poliamminico

che non potrebbe essere semplicemente connessa anche se fosse un polyiamond.

Input Spec

• L'input consisterà solo di asterischi, spazi e avanzamenti di riga.
• Il primo carattere di input sarà sempre uno spazio o un asterisco (corrispondente al triangolo rivolto verso l'alto nell'angolo in alto a sinistra della griglia).
• Ci sarà sempre almeno un asterisco nella prima e nell'ultima riga.
• Non vi è alcuna garanzia che le righe dopo la prima riga non saranno vuote. Due input di riga di seguito possono apparire in un input legittimo.
• Le lunghezze delle linee non devono necessariamente essere tutte uguali.

Condizioni vincenti

Questo è code-golf , quindi vince la risposta più breve in byte.

Casi test

Mappe veritiere:

1) *

2) *
   *

3) **

4) *** ***
   *******

5) *   *
   ** **
    ***

6) *
   **
    *

7)    **
     ***
   ****

8) ****
   **   *
    *****

9) ***********
   **    **  **
    ****  **  **
              **
   ************

Mappe Falsy:

1) *
   *
   *

2) * *

3) *
    *

4)  **
   **

5) ***

   ***

6) ** **
   *****

7) **  **
   *** **
    ****

8)  *
    *

9) *****
   **   *
    *****

Lumache , 95 byte

F&
lr|=((ul.)2 ,l~a~)d|!((ul.)2 ,l~a~)u}\*}+l\ ,~a~|{\ (lr|=((ul.)2 ,l~a~)d|!((ul.)2 ,l~a~)u}+~

Questo ha sofferto davvero di duplicazione, poiché non ho implementato macro o alcun tipo di riferimento indietro. Ciò che fa è verificare che per ogni stella, esista un percorso verso la stella più a sinistra sulla linea superiore; e per ogni spazio, c'è un percorso verso un bordo della griglia.

F&                         ,, option F: pad lines with spaces to the length of the longest
                           ,, option &: print 1 iff match succeeds from every cell
lr                         ,, direction left or right, or
      | =((ul.)2 ,l~a~) d  ,, direction down, if we are an even number of orthogonal moves from the top left
      | !((ul.)2 ,l~a~) u  ,, or, direction up if we are odd number of moves from the top left
    }  \*                  ,, literal '*'
}+                         ,, 1 or more times
l\ ,~a~                    ,, check that we are on the leftmost * in the top line

|                          ,, the part before this is for starting on '*'; part after for starting on ' '

{ \                        ,, literal ' '
    (   lr                 ,, direction left or right, or
      | =((ul.)2 ,l~a~) d  ,, same drill as before...
      | !((ul.)2 ,l~a~) u 
}+                         ,, 1 or more times
~                          ,, end on an out of bounds cell

CJam, 101 98 byte

qN/_z,f{' e]}{S2*f+W%z}4*:eeee::f+:~{_(aL{+_{_2,.+1$2,.-@_:+1&!2*(a.+}%2${a1$&},\;@1$-@@}h;\;-}2*!

Provalo online.

Alla fine ho superato la mia paura di implementare un'inondazione in CJam. È brutto come mi aspettavo e sicuramente può essere giocato a golf.

L'idea generale è di eseguire due alluvioni (che sono effettivamente implementate come rimozioni dall'elenco di celle non visitate). Il primo passaggio rimuoverà tutti gli spazi raggiungibili dal bordo. Il secondo passaggio sceglierà quindi il primo *in ordine di lettura e rimuoverà tutti i triangoli raggiungibili da quello. Se e solo se l'elenco risultante è vuoto, il poliamondolo era semplicemente collegato:

• Se il poliamondone aveva un buco, il primo riempimento di alluvione non è in grado di raggiungere e rimuovere quel buco.
• Se l'input è costituito da diversi poliamonali disconnessi, il secondo riempimento di inondazione non è in grado di raggiungerli e rimuoverli tutti.