Alors que nous sommes sur un coup de pied de grilles triangulaires , je tiens à souligner qu'il existe un équivalent de polyominos sur une grille triangulaire. Ils sont appelés polyiamants , et ce sont des formes formées en collant des triangles équilatéraux le long de leurs bords. Dans ce défi, vous allez décider quels sous-ensembles d'une grille triangulaire sont des polyiamants et s'ils ont des trous. Parce qu'il ne faut que 9 triangles pour faire un polyiamant avec un trou dedans, votre code doit être aussi court que possible.

La grille

Nous utiliserons la disposition de la grille triangulaire de Martin pour l'entrée:

Faites attention au fait que les centres des triangles forment une grille à peu près rectangulaire et que le triangle supérieur gauche "pointe" vers le haut. Nous pouvons alors décrire un sous-ensemble de cette grille en donnant une "carte des étoiles" rectangulaire indiquant quels triangles sont inclus et lesquels ne le sont pas. Par exemple, cette carte:

** **
*****

correspond au plus petit polyiamant qui contient un trou:

des trous

Un polyiamant qui contient un trou comme l'exemple ci-dessus (une région qui ne fait pas partie du polyiamant, qui est entourée de tous côtés par des régions qui le sont ) n'est pas, topologiquement parlant, simplement connecté .

Le défi

Écrivez une fonction ou un programme qui prend en entrée une "carte des étoiles" comme décrit ci-dessus et émettez une vérité si et seulement si le sous-ensemble indiqué de la grille triangulaire est un polyiamant simplement connecté .

Plus d'exemples

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

correspond au polyiamant

qui est simplement connecté.

*   *
** **
 ***

correspond au polyiamant

qui est simplement connecté.

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

correspond au non- polyiamant

qui ne serait pas simplement connecté même s'il s'agissait d' un polyiamant.

Spécifications d'entrée

• L'entrée se composera uniquement d'astérisques, d'espaces et de sauts de ligne.
• Le premier caractère d'entrée sera toujours un espace ou un astérisque (correspondant au triangle pointant vers le haut dans le coin supérieur gauche de la grille).
• Il y aura toujours au moins un astérisque sur les première et dernière lignes.
• Il n'y a AUCUNE garantie que les lignes après la première ligne ne seront pas vides. Deux sauts de ligne consécutifs peuvent apparaître dans une entrée légitime.
• Il n'est pas nécessaire que toutes les longueurs de ligne soient identiques.

Condition gagnante

C'est le code-golf , donc la réponse la plus courte en octets l'emporte.

Cas de test

Cartes véridiques:

1) *

2) *
   *

3) **

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

5) *   *
   ** **
    ***

6) *
   **
    *

7)    **
     ***
   ****

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

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

Cartes de falsification:

1) *
   *
   *

2) * *

3) *
    *

4)  **
   **

5) ***

   ***

6) ** **
   *****

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

8)  *
    *

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

Escargots , 95 octets

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}+~

Cela a vraiment souffert de la duplication, car je n'ai pas implémenté de macros ni aucune sorte de référence arrière. Ce qu'il fait, c'est de vérifier que pour chaque étoile, il existe un chemin vers l'étoile la plus à gauche sur la ligne supérieure; et pour chaque espace, il y a un chemin vers un bord de la grille.

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 octets

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

Essayez-le en ligne.

J'ai finalement surmonté ma peur de mettre en place un remplissage d'inondation dans CJam. C'est à peu près aussi laid que je m'y attendais, et il peut certainement être joué au golf.

L'idée générale est d'effectuer deux remplissages (qui sont en fait implémentés comme des suppressions de la liste des cellules non visitées). Le premier passage supprimera tous les espaces accessibles depuis le bord. La deuxième passe choisira ensuite la première *dans l'ordre de lecture et supprimera tous les triangles accessibles. Si et seulement si la liste résultante est vide, le polyiamant était simplement connecté:

• Si le polyiamant avait un trou, le premier remplissage d'inondation ne peut pas atteindre et retirer ce trou.
• Si l'entrée se compose de plusieurs polyiamants déconnectés, le second remplissage d'inondation ne peut pas les atteindre et les retirer tous.