Vous avez un petit robot avec quatre capteurs de distance. Il connaît la disposition d'une pièce, mais il n'a aucun sens de l'orientation autre que de pouvoir se verrouiller sur l'orientation de la grille. Vous voulez pouvoir savoir où le robot est basé sur les lectures, mais cela peut être ambigu en raison des capteurs limités.

Explication du défi

Vous recevrez une disposition de la pièce et quatre lectures de distance dans le sens horaire donnant le nombre de cellules entre vous et un mur. Il peut y avoir des murs au milieu de la pièce et les bords de la grille sont également des murs. Le robot ne peut pas être placé au sommet d'un mur.

Votre objectif est de répertorier tous les emplacements dans la pièce dans lesquels le robot pourrait se trouver et qui donneraient les lectures données. Gardez à l'esprit que le robot n'a aucun sens de l'orientation (autre que d'être verrouillé à des angles de 90 degrés sur la grille, c'est-à-dire que le robot ne sera jamais orienté en diagonale ou un autre angle d'inclinaison), donc une lecture de [1, 2, 3, 4], par exemple, est identique à la lecture [3, 4, 1, 2].

Exemples

Pour ces exemples, les coordonnées des cellules seront données sous forme de paires indexées 0 (x, y) à partir de la cellule en haut à gauche. Les lectures seront données dans le sens horaire dans une liste entre crochets. Les mises en page utiliseront des signes dièse pour les murs et d'autres caractères (généralement des points) pour représenter les cellules vides.

Cas 1

. . . .
. . . .
. . # .
. . . .

• [1, 0, 2, 3] ==> (1, 0), (3, 1)
• [0, 0, 3, 3] ==> (0, 0), (3, 0), (0, 3), (3, 3)
• [2, 1, 1, 0] ==> (0, 2), (2, 1)
• [1, 1, 2, 2] ==> (1, 1)

Cas 2

# a . # a .
a # . . # a
. . # . . #
# . . # . .
a # . . # a
. a # . a #

• [0, 0, 1, 1] ==> chaque position sur la grille qui est un point
• [1, 0, 0, 0] ==> tous les a de la grille

Cas 3

.

• [0, 0, 0, 0] ==> (0, 0)

Cas 4

. # #
. . .

• [1, 2, 0, 0] ==> (0, 1)
• [0, 1, 2, 0] ==> (0, 1)
• [0, 0, 1, 0] ==> (0, 0)
• [1, 0, 1, 0] ==> (1, 1)
• [0, 1, 0, 1] ==> (1, 1)

Cas 5

. # . .
. . . .
. . # .
. . . .

• [2, 1, 1, 0] ==> (0, 2), (2, 1)
• [0, 2, 2, 1] ==> (1, 1)
• [1, 0, 2, 2] ==> (1, 1)
• [0, 3, 0, 0] ==> (0, 0)
• [1, 0, 1, 1] ==> (1, 2)

Autres règles

• L'entrée peut être dans n'importe quel format pratique. L'entrée est une grille de murs et d'espaces et une liste de quatre distances dans le sens des aiguilles d'une montre.
• La sortie peut être soit une liste de toutes les cellules qui satisfont la lecture, soit une version modifiée de la grille montrant quelles cellules satisfont la lecture. Le format exact de la sortie n'a pas d'importance tant qu'il est raisonnable et cohérent. Les formats de sortie valides incluent, mais ne sont pas limités à :
  • Impression d'une ligne pour chaque coordonnée de cellule sous la forme d'une paire ordonnée
  • Impression de la grille avec ., #et !pour l'espace, les murs et les emplacements possibles, respectivement.
  • Renvoyer une liste de paires ordonnées
  • Renvoyer une liste d'index
  • Renvoyer une liste de listes utilisant différentes valeurs pour les espaces, les murs et les emplacements possibles
  • Renvoie / imprime une matrice de 0 et de 1, en utilisant 1 pour représenter les cellules où la lecture se produira. (Il n'est pas nécessaire d'inclure des murs)
  • Encore une fois, cette liste n'est pas exhaustive, donc d'autres représentations sont valables tant qu'elles sont cohérentes et montrent chaque emplacement valide possible dans une grille ou une liste. Si vous n'êtes pas sûr, laissez un commentaire et je serai heureux de clarifier.
• Vous pouvez supposer qu'une lecture correspond à au moins un emplacement sur la grille.
• Vous pouvez supposer que la grille d'entrée a une taille d'au moins 1x1 et possède au moins un espace vide.
• Vous pouvez supposer que la grille d'entrée ne dépasse pas 256 cellules dans chaque dimension.
• Vous pouvez supposer que la grille d'entrée est toujours un rectangle parfait et non dentelée.
• Il n'y a aucune pénalité ou bonus si votre programme donne des sorties sensées pour des entrées invalides.
• C'est le golf de code, donc le code le plus court gagne.

JavaScript (ES6),  130 128 126  125 octets

$(m)(l)$$m$$0$$1$$l$

$1$

m=>l=>m.map((r,y)=>r.map((v,x)=>v&!!([...'3210321'].map(d=>(g=X=>(m[Y+=~-d%2]||0)[X+=(d-2)%2]?1+g(X):0)(x,Y=y))+g).match(l)))

Essayez-le en ligne! (avec sortie post-traitée pour plus de lisibilité)

Commenté

m => l =>                         // m[] = layout matrix; l[] = list of distances
  m.map((r, y) =>                 // for each row r[] at position y in m[]:
    r.map((v, x) =>               //   for each cell v at position x in r[];
      v &&                        //     yield 0 if v = 0
      !!(                         //     otherwise, test whether we can find l[] within a
        [...'3210321']            //     list containing twice the results of the sensors
        .map(d =>                 //       for each direction d:
          (g = X => (             //         g = recursive function taking X
              m[Y += ~-d % 2]     //         add dy[d] to Y
              || 0                //         use a dummy object if we're out of the board
            )[X += (d - 2) % 2] ? //         add dx[d] to X; if (m[Y] || 0)[X] is equal to 1:
              1 +                 //           add 1 to the final result
              g(X)                //           and do a recursive call
            :                     //         else:
              0                   //           yield 0 and stop recursion
          )(x, Y = y)             //         initial call to g with X = x and Y = y
        )                         //       end of map() over directions
        + g                       //       coerce the result to a comma-separated string,
                                  //       followed by harmless garbage
      ).match(l)                  //     test whether l[] can be found in this string
                                  //     (l[] is implicitly coerced to a string as well)
    )                             //   end of map() over r[]
  )                               // end of map() over m[]

Python 2 , 234 202 200 191 octets

lambda m,a:[(i,j)for j,l in e(m)for i,c in e(l)if('#'<c)*[(''.join(L)[::-1]+'#').find('#')for L in l[:i],zip(*m)[i][:j],l[:i:-1],zip(*m)[i][:j:-1]]in[a[q:]+a[:q]for q in 0,1,2,3]]
e=enumerate

Essayez-le en ligne!

Fusain , 42 octets

ＰθＦθ¿⁼¶ι⸿¿№Ｅ⁴Ｅ⁴⊖⌕⁺⪫ＫＤ⊕⌈η✳§⟦→↓←↑⟧⁺κμω#¦#η!ι

Essayez-le en ligne! Le lien est vers la version détaillée du code. Le charbon de bois semble ajouter un rembourrage à la sortie pour une raison quelconque; Je suppose que c'est un bug dans le charbon de bois. Explication:

Ｐθ

Imprimez la carte sans déplacer le curseur.

Ｆθ

Faites une boucle sur chaque personnage de la carte.

¿⁼¶ι⸿

S'il s'agit d'une nouvelle ligne, déplacez le curseur au début de la ligne suivante.

⊖⌕⁺⪫ＫＤ⊕⌈η✳§⟦→↓←↑⟧⁺κμω#¦#

Trouvez la distance au mur en direction k+m.

¿№Ｅ⁴Ｅ⁴...η!ι

Faites une boucle sur les quatre directions de départ k, jetez un œil dans les quatre directions dans le sens des aiguilles d'une montre met si le résultat inclut la deuxième entrée, imprimez un !sinon imprimez le caractère actuel.