Sie haben einen kleinen Roboter mit vier Abstandssensoren. Es kennt die Aufteilung eines Raums, hat aber keinen anderen Orientierungssinn, als sich auf die Gitterausrichtung festlegen zu können. Sie möchten anhand der Messwerte herausfinden können, wo sich der Roboter befindet, dies kann jedoch aufgrund der begrenzten Sensoren nicht eindeutig sein.

Erklärung der Herausforderung

Sie erhalten eine Raumaufteilung und vier Abstandsmessungen im Uhrzeigersinn, die die Anzahl der Zellen zwischen Ihnen und einer Wand angeben. In der Mitte des Raums können sich Wände befinden, und die Ränder des Gitters sind ebenfalls Wände. Der Roboter kann nicht auf einer Wand platziert werden.

Ihr Ziel ist es, alle Stellen innerhalb des Raums aufzulisten, an denen sich der Roboter befinden könnte, um die angegebenen Messwerte zu erhalten. Denken Sie daran, dass der Roboter keinen Orientierungssinn hat (außer dass er auf 90-Grad-Winkeln im Raster verriegelt ist, dh der Roboter wird niemals diagonal oder in einem anderen Schräglaufwinkel ausgerichtet sein), sodass ein Wert von [1, 2, 3, 4] entspricht beispielsweise dem Lesen von [3, 4, 1, 2].

Beispiele

In diesen Beispielen werden die Zellkoordinaten als 0-indizierte (x, y) Paare aus der Zelle oben links angegeben. Die Messwerte werden im Uhrzeigersinn in einer Liste in eckigen Klammern angegeben. Layouts verwenden Pfundzeichen für Wände und andere Zeichen (normalerweise Punkte), um leere Zellen darzustellen.

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

Fall 2

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

• [0, 0, 1, 1] ==> jede Position auf dem Gitter, die ein Punkt ist
• [1, 0, 0, 0] ==> alle a im Raster

Fall 3

.

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

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

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

Andere Regeln

• Die Eingabe kann in einem beliebigen geeigneten Format erfolgen. Die Eingabe ist ein Raster aus Wänden und Räumen und eine Liste von vier Abständen im Uhrzeigersinn.
• Die Ausgabe kann entweder eine Liste aller Zellen sein, die den Messwert erfüllen, oder eine modifizierte Version des Rasters, aus der hervorgeht, welche Zellen den Messwert erfüllen. Das genaue Format der Ausgabe spielt keine Rolle, solange es vernünftig und konsistent ist. Gültige Ausgabeformate umfassen, sind aber nicht beschränkt auf :
  • Drucken einer Linie für jede Zellkoordinate als geordnetes Paar
  • Drucken des Rasters mit ., #und !für Raum, Wände bzw. mögliche Positionen.
  • Rückgabe einer Liste geordneter Paare
  • Rückgabe einer Liste von Indizes
  • Rückgabe einer Liste von Listen mit unterschiedlichen Werten für Räume, Wände und mögliche Standorte
  • Geben Sie eine Matrix von 0s und 1s zurück / drucken Sie sie aus, wobei Sie 1s verwenden, um Zellen darzustellen, in denen das Lesen stattfinden würde. (Es ist nicht notwendig, Wände einzuschließen)
  • Auch diese Liste ist nicht vollständig, sodass andere Darstellungen gültig sind, solange sie konsistent sind und alle möglichen gültigen Positionen in einem Raster oder einer Liste anzeigen. Wenn Sie sich nicht sicher sind, hinterlassen Sie einen Kommentar und ich werde dies gerne klären.
• Sie können davon ausgehen, dass ein Messwert mindestens einer Stelle im Raster entspricht.
• Sie können davon ausgehen, dass das Eingaberaster mindestens 1x1 groß ist und mindestens einen leeren Bereich hat.
• Sie können davon ausgehen, dass das Eingaberaster in jeder Dimension nicht größer als 256 Zellen ist.
• Sie können davon ausgehen, dass das Eingaberaster immer ein perfektes Rechteck und nicht gezackt ist.
• Es gibt keine Strafe oder Bonus, wenn Ihr Programm vernünftige Ausgaben für ungültige Eingaben liefert.
• Dies ist Code Golf, also gewinnt der kürzeste Code.

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

Probieren Sie es online aus! (mit nachbearbeiteter Ausgabe zur besseren Lesbarkeit)

Kommentiert

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

Probieren Sie es online aus!

Holzkohle , 42 Bytes

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

Probieren Sie es online aus! Der Link führt zur ausführlichen Version des Codes. Holzkohle scheint aus irgendeinem Grund etwas Polsterung zum Ausgang hinzuzufügen; Ich gehe davon aus, dass es ein Fehler in Charcoal ist. Erläuterung:

Ｐθ

Drucken Sie die Karte, ohne den Cursor zu bewegen.

Ｆθ

Schleife über jedes Zeichen in der Karte.

¿⁼¶ι⸿

Wenn es sich um eine neue Zeile handelt, bewegen Sie den Cursor an den Anfang der nächsten Zeile.

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

Finden Sie den Abstand zur Wand in Richtung k+m.

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

Durchlaufen Sie alle vier kStartrichtungen, schauen Sie in alle vier Richtungen im Uhrzeigersinn. mWenn das Ergebnis die zweite Eingabe enthält, drucken Sie ein !anderes Zeichen.