In der ASCII-Kunstwelt gibt es Wasser, Hash-Wände und Briefmechanismen.

Sie befinden sich in einem Raum, der aus Hash-Wänden ( #Schildern) besteht:

#######
#     #
#     #
#     #
# ### #
#     #
#######

Sie installieren eine S-Wasserquelle ( SSchild) und einen E-Wassertank ( ESchild), der Wasser aus jeder Richtung aufnehmen kann, aber Sie haben nur eine S-Wasserquelle und einen E-Tank.

#######
#  S  #
#     #
#     #
# ### #
#  E  #
#######

Sie müssen also mit Bedacht auswählen, wo die Quelle platziert werden soll. Hier können Sie Ihre Code-Golf- Fähigkeiten unter Beweis stellen.

Die Aufgabe

Sie erhalten eine Eingabe, die aus einer Zeichenfolge besteht, die einen Raum mit der Quelle und dem Tank darstellt:

#######
#  S  #
#     #
#     #
# ### #
#  E  #
#######

Sie müssen herausfinden, ob das Wasser letztendlich den Tank erreicht. Das Wasser fließt wenn möglich nach unten, wenn möglich nach links und rechts. Das Wasser sammelt sich nicht an, weil es nicht steigt.

Für die obige Eingabe lautet das Ergebnis also:

#######
#  *  #
#  *  #
#*****#
#*###*#
#**O**#
#######

Das Wasser gelangt glücklich in den Tank, daher müssen Sie einen Wahrheitswert ausgeben.

Aber wenn das Wasser den Tank nicht erreicht:

#######
#S    #
#     #
#  E  #
# ### #
#     #
#######

#######
#*    #
#*    #
#* X  #
#*### #
#*****#
#######

Dann müssen Sie einen falschen Wert ausgeben.

Schreiben Sie ein Programm, um zu entscheiden, ob das Wasser letztendlich den Tank erreicht. Ihr Code sollte so kurz wie möglich sein.

Annahmen

• Angenommen, die Eingabe ist immer gültig (der gesamte Raum ist ein umschlossener rechteckiger Bereich mit S und E).

• Angenommen, es wird nur ein Raum als Eingabe bereitgestellt.

Testfälle

Ihr Programm sollte für die folgenden Testfälle einen Wahrheitswert zurückgeben:

#######
#  S  #
#     #
#     #
# ### #
#  E  #
#######

#######
#  S  #
#     #
#  E  #
#     #
#     #
#######

#######
#     #
#     #
# SE  #
# ### #
#     #
#######

###############################################
#                      S                      #
#                                             #
#                                             #
#                                             #
#               ###############               #
#                                             #
#  ##################     ##################  #
#                                             #
#                                             #
#                    #####                    #
#                      E                      #
###############################################

#######
#  S  #
#     #
#     #
# ### #
#   # #
### ###
## E ##
#     #
#######

Aber ein falscher Wert für folgende Testfälle:

#######
#S    #
#     #
#  E  #
# ### #
#     #
#######

#######
#     #
# SE  #
#     #
#     #
#     #
#######

#######
#     #
#  E  #
#     #
#  S  #
#     #
#######

####################################
#                                  #
#                                  #
#                                  #
#S             #                  E#
####################################

Die zweite bis letzte Zimmer in der wahren Kategorie und das letzte Zimmer in der False Kategorie wurden schamlos gestohlen aus geliehenen Jump and Run: Koth von Manu (der die Sandbox - Beitrag gelöscht).

Der letzte Raum in der Kategorie True stammt von Martin Buttners Antwort in Retina .

Schnecken , 20 Bytes

\S{d(=\#n)?^#},!(t\E

Drucke 0für den Falsey-Wert und 1für den Wahrheitswert.

Probieren Sie es online!

• \SSpiele Sam Start
• d legt die Richtung nach unten fest
• {...}, Entspricht dem Inhalt in geschweiften Klammern 0 oder mehrmals
• =\#ist eine Behauptung, die erfolgreich ist, wenn sich ein #Saibling vor der Schnecke befindet, diese aber nicht bewegt
• n dreht sich um 90 Grad in beide Richtungen
• (...)? Entspricht dem Muster in Klammern 0 oder 1 Mal
• \ ​ Stimmt mit einem Feld überein und verschiebt die Schnecke darauf
• !(... ist eine negative Behauptung
• t teleportiert sich zu einem unübertroffenen Feld im Gitter
• \E Streichhölzer E

Beleg , 20 + 2 = 22 Bytes

S>( ^4|^4(?|`#)^T)*E

Also ist Slip immer noch kaputt wie immer, aber diesmal war es eine Herausforderung, die es tatsächlich schaffen konnte. Es war nie wirklich so golfen, also wird es niemals Snails schlagen: P

Benötigt das rFlag (keine sich wiederholenden Zellen) zum Beenden.

Probieren Sie es online aus . Ausgabe ist der Pfad, der für Wahrhaftigkeit genommen wird, leer für Falschheit.

S                 Match S
>                 Rotate pointer downward
(                 Either...
 <space>^4          Match a space and point downwards
 |                  or
 ^4                 Point downwards
 (?|`#)             Match # below then reset pointer
 ^T                 Either turn left or right
)*                ... 0+ times
E                 Match E

Retina , 87 Bytes

Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

+mT`E `S`(?<=^(?(1)!)(?<-1>.)*S.*¶(.)*)[E ]|.?S(?=(.)*¶.*#(?<-2>.)*(?(2)!)$)[E ]?
M`E
0

Probieren Sie es online!

So viel wie die Verarbeitung von 2D-Strings in Retina (oder allgemein in .NET Regex) möglich ist, ist es nicht genau ...

Erläuterung

+mT`E `S`(?<=^(?(1)!)(?<-1>.)*S.*¶(.)*)[E ]|.?S(?=(.)*¶.*#(?<-2>.)*(?(2)!)$)[E ]?

Dies ist eine Überflutung, die alle Zellen markiert, mit denen Wasser erreicht S. Dazu werden die erreichbaren Zeichen abgeglichen und anschließend Smit T-mode transliteriert . Diese Überflutung geht durch beide Räume und E. Das +am Anfang wiederholt dies, bis sich der Ausgang nicht mehr ändert.

Was den eigentlichen regulären Ausdruck betrifft, so enthält dieser zwei getrennte Fälle:

(?<=^(?(1)!)(?<-1>.)*S.*¶(.)*)[E ]

Dies entspricht einem Leerzeichen oder Egenau einer Zelle unter einem S. Der vertikale Abgleich erfolgt durch Zählen des Präfixes in der aktuellen Zeile mithilfe von Bilanzgruppen, sodass sichergestellt wird, dass die horizontale Position identisch ist. Dieser kümmert sich um fallendes Wasser.

.?S(?=(.)*¶.*#(?<-2>.)*(?(2)!)$)[E ]?

Dies ist sehr ähnlich: Es entspricht einem Sund, falls verfügbar, dem Zeichen davor und danach, vorausgesetzt, das Zeichen direkt unter dem Sist ein #. Dies sorgt dafür, dass sich das Wasser am Boden verteilt.

Wenn wir fertig sind, ist es sehr einfach festzustellen, ob das Wasser erreicht ist E. Wenn dies der Fall ist, Ewurde es aus der Zeichenfolge in der Überflutung entfernt, und wenn dies nicht der Fall ist, Eist es immer noch da. Zählen wir also die Anzahl der Es:

M`E

Aber das ist 0(was ich für falsch halten würde) für wahrheitsgemäße Testfälle und 1(was ich für wahrheitsgemäße halten würde) für falsch gemachte Testfälle. Wir können dies sehr einfach umkehren, indem wir die Anzahl der 0s in diesem Ergebnis zählen:

0

Getan.