Tienes un pequeño robot con cuatro sensores de distancia. Conoce el diseño de una habitación, pero no tiene ningún sentido de orientación que no sea poder bloquear la orientación de la cuadrícula. Desea poder averiguar dónde se encuentra el robot en función de las lecturas, pero puede ser ambiguo debido a los sensores limitados.

Explicación del desafío

Se le proporcionará un diseño de la sala y cuatro lecturas de distancia en el sentido de las agujas del reloj que le darán el número de celdas entre usted y una pared. Puede haber paredes en el medio de la habitación y los bordes de la cuadrícula también son paredes. El robot no se puede colocar encima de una pared.

Su objetivo es enumerar todas las ubicaciones dentro de la sala en las que podría estar el robot que darían las lecturas dadas. Tenga en cuenta que el robot no tiene sentido de orientación (aparte de estar bloqueado en ángulos de 90 grados en la cuadrícula, es decir, el robot nunca estará orientado en diagonal o algún otro ángulo de inclinación), por lo que una lectura de [1, 2, 3, 4], por ejemplo, es lo mismo que leer [3, 4, 1, 2].

Ejemplos

Para estos ejemplos, las coordenadas de celda se darán como pares indexados a 0 (x, y) desde la celda superior izquierda. Las lecturas se darán en el sentido de las agujas del reloj en una lista entre corchetes. Los diseños usarán signos de libra para las paredes y otros caracteres (generalmente puntos) para representar celdas vacías.

Caso 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)

Caso 2

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

• [0, 0, 1, 1] ==> cada posición en la cuadrícula que es un punto
• [1, 0, 0, 0] ==> todas las a en la cuadrícula

Caso 3

.

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

Caso 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)

Caso 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)

Otras reglas

• La entrada puede estar en cualquier formato conveniente. La entrada es una cuadrícula de paredes y espacios y una lista de cuatro distancias en el sentido de las agujas del reloj.
• La salida puede ser una lista de todas las celdas que satisfacen la lectura o una versión modificada de la cuadrícula que muestra qué celdas satisfacen la lectura. El formato exacto de la salida no importa siempre que sea razonable y consistente. Los formatos de salida válidos incluyen, entre otros :
  • Imprimir una línea para cada coordenada de celda como un par ordenado
  • Imprimir la cuadrícula con ., #y !para espacio, paredes y posibles ubicaciones, respectivamente.
  • Devolver una lista de pares ordenados
  • Devolver una lista de índices
  • Devolver una lista de listas usando diferentes valores para espacios, paredes y posibles ubicaciones
  • Devuelva / imprima una matriz de 0s y 1s, usando 1s para representar las celdas donde ocurriría la lectura. (No es necesario incluir paredes)
  • Una vez más, esta lista no es exhaustiva, por lo que otras representaciones son válidas siempre que sean coherentes y muestren todas las ubicaciones válidas posibles en una cuadrícula o lista. Si no está seguro, deje un comentario y con gusto lo aclararé.
• Puede suponer que una lectura corresponde al menos a una ubicación en la cuadrícula.
• Puede suponer que la cuadrícula de entrada tiene un tamaño de al menos 1x1 y tiene al menos un espacio vacío.
• Puede suponer que la cuadrícula de entrada no es más grande que 256 celdas en cada dimensión.
• Puede suponer que la cuadrícula de entrada es siempre un rectángulo perfecto y no irregular.
• No hay penalización ni bonificación si su programa proporciona resultados razonables para entradas no válidas.
• Este es el código de golf, por lo que gana el código más corto.

JavaScript (ES6),  130 128 126  125 bytes

$(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)))

Pruébalo en línea! (con salida postprocesada para facilitar la lectura)

Comentado

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 bytes

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

Pruébalo en línea!

Carbón , 42 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. El carbón parece agregar algo de relleno a la salida por alguna razón; Supongo que es un error en el carbón. Explicación:

Ｐθ

Imprima el mapa sin mover el cursor.

Ｆθ

Recorre cada personaje en el mapa.

¿⁼¶ι⸿

Si se trata de una nueva línea, mueva el cursor al inicio de la siguiente línea.

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

Encuentra la distancia a la pared en dirección k+m.

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

Pase por las cuatro direcciones de inicio k, mire en las cuatro direcciones en el sentido de las agujas del reloj my, si el resultado incluye la segunda entrada, imprima y, de lo !contrario, imprima el carácter actual.