W świecie sztuki ASCII istnieje woda, ściany mieszające i mechanizmy literowe.

Jesteś w pokoju zbudowanym ze ścian mieszających ( #znaków):

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

Instalujesz źródło wody S ( Sznak) i zbiornik wody E ( Eznak), który może odbierać wodę z dowolnego kierunku, ale masz tylko jedno źródło S i jeden zbiornik E.

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

Musisz więc mądrze wybrać, gdzie umieścić źródło. Właśnie tam wykorzystujesz swoje umiejętności gry w golfa .

Zadanie

Otrzymujesz dane wejściowe składające się z łańcucha reprezentującego pomieszczenie ze źródłem i zbiornikiem:

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

Musisz dowiedzieć się, czy woda ostatecznie dotrze do zbiornika. Woda spływa w miarę możliwości w lewo i prawo, jeśli to możliwe. Woda nie gromadzi się, ponieważ nie podnosi się.

Tak więc dla powyższego wejścia wynik jest następujący:

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

Woda szczęśliwie dociera do zbiornika, więc musisz podać prawdziwą wartość.

Ale jeśli woda nie dociera do zbiornika:

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

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

Następnie musisz podać wartość fałszowania.

Napisz program, aby zdecydować, czy woda ostatecznie dotrze do zbiornika. Twój kod powinien być jak najkrótszy.

Założenia

• Załóżmy, że dane wejściowe są zawsze prawidłowe (cały pokój jest zamkniętym prostokątnym obszarem z literami S i E).

• Załóżmy, że jako wejście jest tylko jeden pokój.

Przypadki testowe

Twój program powinien zwrócić prawdziwą wartość dla następujących przypadków testowych:

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

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

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

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

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

Ale wartość fałsz dla następujących przypadków testowych:

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

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

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

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

Przedostatni pokój w kategorii True i ostatni pokój w kategorii False zostały bezwstydnie skradzione pożyczone od Koth: Jump and Run przez Manu (który usunął post z piaskownicy).

Ostatni pokój w kategorii True pochodzi od odpowiedzi Martina Buttnera w Retinie .

Ślimaki , 20 bajtów

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

Drukuje 0dla wartości falsey i 1dla prawdziwej wartości.

Wypróbuj online!

• \Smecze Sna początku
• d ustawia kierunek w dół
• {...}, dopasowuje rzeczy w nawiasach klamrowych 0 lub więcej razy
• =\#to twierdzenie, które się powiedzie, jeśli #przed ślimakiem jest znak, ale go nie porusza
• n obraca się o 90 stopni w dowolnym kierunku
• (...)? dopasowuje wzór w nawiasach 0 lub 1 razy
• \ ​ dopasowuje spację i przesuwa na nią ślimaka
• !(... jest twierdzeniem negatywnym
• t teleportuje się na dowolny niepasujący kwadrat w siatce
• \E mecze E

Poślizg , 20 + 2 = 22 bajtów

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

Więc Slip wciąż jest zepsuty jak zawsze, ale chociaż raz było to wyzwanie, które mogło faktycznie zrobić. Nigdy nie został tak zaprojektowany, aby być tak golfowym, więc nigdy nie pokona Ślimaków: P

Potrzebuje rflagi (bez powtarzających się komórek), aby zakończyć.

Wypróbuj online . Wyjście to ścieżka przyjęta dla prawdy, pusta dla fałszu.

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

Siatkówka , 87 bajtów

Liczba bajtów zakłada kodowanie ISO 8859-1.

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

Wypróbuj online!

O ile przetwarzanie łańcuchów 2D jest możliwe w Retina (lub ogólnie .NET regex), nie jest to dokładnie zwięzłe ...

Wyjaśnienie

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

Jest to wypełnienie zalewowe, które oznacza wszystkie komórki, do których dociera woda S. Czyni to poprzez dopasowanie znaków, które mogą zostać osiągnięte, a następnie je do transliteracji Sz T-mode. To wypełnienie zalewowe przechodzi przez obie przestrzenie i E. Na +początku powtarza to, dopóki wyjście nie przestaje się zmieniać.

Jeśli chodzi o rzeczywiste wyrażenie regularne, zawiera dwa osobne przypadki:

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

Odpowiada to spacji lub Edokładnie jednej komórce poniżej S. Dopasowywanie w pionie odbywa się poprzez zliczanie prefiksu w bieżącej linii za pomocą grup równoważących, dzięki czemu możemy zapewnić, że położenie w poziomie jest takie samo. Ten dba o spadającą wodę.

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

Jest to bardzo podobne: pasuje do znaku Si, jeśli jest dostępny, przed i po znaku, pod warunkiem, że znak bezpośrednio pod Sznakiem to #. Dzięki temu woda rozlewa się po ziemi.

Kiedy skończymy, bardzo łatwo będzie ustalić, czy woda osiągnęła E. Jeśli tak, to Ezostał usunięty z ciągu w zalewie, a jeśli nie, Eto nadal tam jest. Policzmy więc liczbę Es:

M`E

Ale teraz jest to 0(co uważam za fałszywe) w przypadku prawdziwych przypadków testowych i 1(które uważam za prawdziwe) w przypadku fałszywych przypadków testowych. Możemy to bardzo łatwo odwrócić, licząc liczbę 0s w tym wyniku:

0

Gotowy.