您有一个带有四个距离传感器的小机器人。它知道房间的布局，但是除了能够锁定网格方向之外，它没有方向感。您希望能够根据读数找出机器人的位置，但是由于传感器有限，它可能会模棱两可。

挑战说明

您将获得一个房间布局和四个顺时针方向的距离读数，以获取您与墙之间的单元数量。房间的中间可能有墙壁，而网格的边缘也是墙壁。机器人不能放在墙上。

您的目标是列出机器人可能在房间内的所有位置，以给出给定的读数。请记住，机器人没有方向感（除了被锁定在网格上的90度角之外，即，机器人永远不会以对角线或其他倾斜角取向），因此读取[1、2、3，例如，[4]与读取[3、4、1、2]相同。

例子

对于这些示例，单元格坐标将从左上角的单元格以0索引（x，y）对给出。读数将在方括号中的列表中按顺时针顺序给出。布局将在墙壁上使用井号，并使用其他字符（通常是点）来表示空单元格。

情况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）

情况二

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

• [0，0，1，1] ==>网格上每个点的位置
• [1，0，0，0] ==>网格上的所有a

情况3

.

• [0，0，0，0] ==>（0，0）

案例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）

案例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）

其他规定

• 输入可以采用任何方便的格式。输入是墙壁和空间的网格以及按顺时针顺序列出的四个距离。
• 输出可以是所有满足读数的单元格的列表，也可以是显示哪些单元格满足读数的网格的修改版本。只要是合理且一致的，输出的确切格式就无关紧要。有效的输出格式包括但不限于：
  • 将每个单元格坐标的一行打印为有序对
  • 分别用.，#和打印!空格，墙壁和可能位置的网格。
  • 返回有序对的列表
  • 返回索引列表
  • 使用不同的空间，墙壁和可能的位置值返回列表列表
  • 返回/打印一个0s和1s的矩阵，使用1s表示将发生读取的单元格。（没有必要包括墙壁）
  • 再一次，此列表并不详尽，因此其他表示形式只要是一致的就有效，并且在网格或列表中显示每个可能的有效位置。如果不确定，请发表评论，我很乐意澄清。
• 您可以假定读数至少对应于网格上的一个位置。
• 您可以假定输入网格的大小至少为1x1，并且至少有一个空白空间。
• 您可以假定输入网格在每个维度中均不大于256个像元。
• 您可以假设输入网格始终是一个完美的矩形并且没有锯齿。
• 如果您的程序碰巧为无效输入提供了合理的输出，则不会有任何惩罚或加分。
• 这是代码高尔夫，所以最短的代码获胜。

的JavaScript（ES6）， 130个128 126  125字节

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

在线尝试！（带有后处理的输出以提高可读性）

已评论

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字节

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

在线尝试！

木炭，42字节

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

在线尝试！链接是详细版本的代码。木炭似乎出于某种原因在输出中添加了一些填充。我假设这是木炭中的错误。说明：

Ｐθ

在不移动光标的情况下打印地图。

Ｆθ

循环遍历地图中的每个字符。

¿⁼¶ι⸿

如果是换行符，则将光标移动到下一行的开头。

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

找到方向到墙的距离k+m。

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

在所有四个开始方向上循环k，在所有四个顺时针方向上窥视m，如果结果包括第二个输入，则打印!否则，打印当前字符。