Você tem um pequeno robô com quatro sensores de distância. Ele conhece o layout de uma sala, mas não tem senso de orientação além de ser capaz de travar na orientação da grade. Você deseja descobrir onde o robô se baseia nas leituras, mas pode ser ambíguo por causa dos sensores limitados.

Explicação do desafio

Você receberá um layout da sala e quatro leituras de distância no sentido horário, indicando o número de células entre você e a parede. Pode haver paredes no meio da sala e as bordas da grade também são paredes. O robô não pode ser colocado em cima de uma parede.

Seu objetivo é listar todos os locais dentro da sala em que o robô poderia estar e fornecer as leituras fornecidas. Lembre-se de que o robô não tem senso de orientação (além de estar bloqueado em ângulos de 90 graus na grade - ou seja, o robô nunca será orientado na diagonal ou em algum outro ângulo de inclinação), portanto, uma leitura de [1, 2, 3, 4], por exemplo, é o mesmo que ler [3, 4, 1, 2].

Exemplos

Para esses exemplos, as coordenadas das células serão fornecidas como pares indexados 0 (x, y) a partir da célula superior esquerda. As leituras serão fornecidas no sentido horário em uma lista entre colchetes. Os layouts usarão sinais de cerquilha para paredes e outros caracteres (geralmente pontos) para representar células vazias.

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] ==> todas as posições na grade que são um ponto
• [1, 0, 0, 0] ==> todos os a's na grade

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)

Outras regras

• A entrada pode estar em qualquer formato conveniente. A entrada é uma grade de paredes e espaços e uma lista de quatro distâncias no sentido horário.
• A saída pode ser uma lista de todas as células que satisfazem a leitura ou uma versão modificada da grade mostrando quais células satisfazem a leitura. O formato exato da saída não importa, desde que seja razoável e consistente. Os formatos de saída válidos incluem, mas não estão limitados a :
  • Imprimir uma linha para cada coordenada da célula como um par ordenado
  • Imprimir a grade com ., #e !para o espaço, paredes e possíveis localizações, respectivamente.
  • Retornando uma lista de pares ordenados
  • Retornando uma lista de índices
  • Retornando uma lista de listas usando valores diferentes para espaços, paredes e possíveis locais
  • Retorne / imprima uma matriz de 0s e 1s, usando 1s para representar as células onde a leitura ocorrerá. (Não é necessário incluir paredes)
  • Mais uma vez, essa lista não é exaustiva; portanto, outras representações são válidas desde que sejam consistentes e mostrem todos os locais válidos possíveis em uma grade ou lista. Se não tiver certeza, deixe um comentário e teremos prazer em esclarecer.
• Você pode assumir que uma leitura corresponde a pelo menos um local na grade.
• Você pode supor que a grade de entrada tenha pelo menos 1x1 de tamanho e tenha pelo menos um espaço vazio.
• Você pode supor que a grade de entrada não seja maior que 256 células em cada dimensão.
• Você pode assumir que a grade de entrada é sempre um retângulo perfeito e não é irregular.
• Não há penalidade ou bônus se o seu programa fornecer resultados sãos para entradas inválidas.
• Isso é código de golfe, então o código mais curto vence.

JavaScript (ES6),  130 128 126  125 bytes

Toma como entrada onde é uma matriz binária que descreve o layout da sala ( = parede, = vazio) e é a lista de distâncias.$(m)(l)$$m$$0$$1$$l$

Retorna outra matriz binária em que cada posição válida é marcada com .$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)))

Experimente online! (com saída pós-processada para facilitar a leitura)

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

Experimente online!

Carvão , 42 bytes

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

Experimente online! Link é a versão detalhada do código. O carvão parece adicionar algum preenchimento à saída por algum motivo; Estou assumindo que é um bug no carvão vegetal. Explicação:

Ｐθ

Imprima o mapa sem mover o cursor.

Ｆθ

Passe por cada caractere no mapa.

¿⁼¶ι⸿

Se for uma nova linha, mova o cursor para o início da próxima linha.

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

Encontre a distância da parede na direção k+m.

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

Passe pelas quatro direções iniciais k, dê uma olhada nas quatro direções no sentido horário me, se o resultado incluir a segunda entrada, imprima uma !impressão caso contrário, imprima o caractere atual.