Hai un piccolo robot con quattro sensori di distanza. Conosce la disposizione di una stanza, ma non ha senso dell'orientamento se non quello di essere in grado di bloccare l'orientamento della griglia. Vuoi essere in grado di scoprire dove si basa il robot in base alle letture, ma può essere ambiguo a causa dei sensori limitati.

Spiegazione della sfida

Ti verrà data una disposizione della stanza e quattro letture della distanza in senso orario che danno il numero di celle tra te e un muro. Possono esserci pareti nel mezzo della stanza e anche i bordi della griglia sono pareti. Il robot non può essere posizionato sopra un muro.

Il tuo obiettivo è quello di elencare tutte le posizioni all'interno della stanza in cui potrebbe trovarsi il robot che darebbe le letture fornite. Tieni presente che il robot non ha senso dell'orientamento (tranne che essere bloccato ad angoli di 90 gradi sulla griglia, ovvero che il robot non sarà mai orientato in diagonale o in qualche altro angolo di inclinazione), quindi una lettura di [1, 2, 3, 4], ad esempio, è uguale alla lettura [3, 4, 1, 2].

Esempi

Per questi esempi, le coordinate della cella verranno fornite come coppie indicizzate 0 (x, y) dalla cella in alto a sinistra. Le letture verranno fornite in senso orario in un elenco quadrato tra parentesi. I layout utilizzeranno i segni di cancelletto per muri e altri caratteri (di solito punti) per rappresentare celle vuote.

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] ==> ogni posizione sulla griglia che è un punto
• [1, 0, 0, 0] ==> tutte le a sulla griglia

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)

Altre regole

• L'input può essere in qualsiasi formato conveniente. L'input è una griglia di pareti e spazi e un elenco di quattro distanze in senso orario.
• L'output può essere un elenco di tutte le celle che soddisfano la lettura o una versione modificata della griglia che mostra quali celle soddisfano la lettura. Il formato esatto dell'output non ha importanza purché sia ​​ragionevole e coerente. I formati di output validi includono, ma non sono limitati a :
  • Stampa una linea per ciascuna coordinata di cella come coppia ordinata
  • Stampa la griglia con ., #e !per lo spazio, pareti, e le possibili posizioni, rispettivamente.
  • Restituzione di un elenco di coppie ordinate
  • Restituzione di un elenco di indici
  • Restituzione di un elenco di elenchi che utilizzano valori diversi per spazi, muri e possibili posizioni
  • Restituisce / stampa una matrice di 0 e 1, usando 1 per rappresentare le celle in cui si verificherebbe la lettura. (Non è necessario includere muri)
  • Ancora una volta, questo elenco non è esaustivo, quindi altre rappresentazioni sono valide purché siano coerenti e mostrino ogni possibile posizione valida in una griglia o in un elenco. Se non sei sicuro, lascia un commento e sarò felice di chiarire.
• Si può presumere che una lettura corrisponda ad almeno una posizione sulla griglia.
• Si può presumere che la griglia di input abbia una dimensione di almeno 1 x 1 e che abbia almeno uno spazio vuoto.
• Si può presumere che la griglia di input non sia più grande di 256 celle in ogni dimensione.
• Si può presumere che la griglia di input sia sempre un rettangolo perfetto e non frastagliato.
• Non ci sono penalità o bonus se il tuo programma dà risultati sani per input non validi.
• Questo è il codice golf, quindi vince il codice più breve.

JavaScript (ES6),  130 128 126  125 byte

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

Provalo online! (con output post-elaborato per leggibilità)

Commentate

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[]

Pitone 2 , 234 202 200 191 byte

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

Provalo online!

Carbone , 42 byte

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

Provalo online!Il collegamento è alla versione dettagliata del codice. Il carbone sembra aggiungere qualche imbottitura all'output per qualche motivo; Suppongo sia un bug nel carbone. Spiegazione:

Ｐθ

Stampa la mappa senza spostare il cursore.

Ｆθ

Scorri su ogni personaggio della mappa.

¿⁼¶ι⸿

Se si tratta di una nuova riga, sposta il cursore all'inizio della riga successiva.

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

Trova la distanza dal muro in direzione k+m.

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

Passa su tutte e quattro le direzioni iniziali k, sbircia in tutte e quattro le direzioni in senso orario me se il risultato include il secondo input, stampa e !stampa il carattere corrente.