[Question]
  [
In the ASCII art world, there is water, hash walls and letter mechanisms.
You are in a room made up of hash walls (`#` signs):
```
#######
#     #
#     #
#     #
# ### #
#     #
#######
```
You install an S water source (`S` sign) and an E water tank (`E` sign) which can receive water from any direction, but you only have one S source and one E tank.
```
#######
#  S  #
#     #
#     #
# ### #
#  E  #
#######
```
So you have to select wisely where to place the source. That's where you pull off your [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'") skills.
## The task
You get an input consisting of a string representing a room with the source and the tank:
```
#######
#  S  #
#     #
#     #
# ### #
#  E  #
#######
```
You have to find out if the water ultimately reaches the tank. The water flows down, if possible, else to the left and right, if possible. The water doesn't accumulate because it doesn't go up.
So, for the above input, the result is:
```
#######
#  *  #
#  *  #
#*****#
#*###*#
#**O**#
#######
```
The water happily reaches the tank, so you must output a truthy value.
But if the water doesn't reach the tank:
```
#######
#S    #
#     #
#  E  #
# ### #
#     #
#######
#######
#*    #
#*    #
#* X  #
#*### #
#*****#
#######
```
Then you must output a falsy value.
Write a program to decide whether the water ultimately reaches the tank. Your code should be as short as possible.
## Assumptions
* Assume that the input is always valid (the entire room is an enclosed rectangular region with the S and E).
* Assume there is only one room provided as input.
## Test Cases
Your program should return a truthy value for the following test cases:
```
#######
#  S  #
#     #
#     #
# ### #
#  E  #
#######
#######
#  S  #
#     #
#  E  #
#     #
#     #
#######
#######
#     #
#     #
# SE  #
# ### #
#     #
#######
###############################################
#                      S                      #
#                                             #
#                                             #
#                                             #
#               ###############               #
#                                             #
#  ##################     ##################  #
#                                             #
#                                             #
#                    #####                    #
#                      E                      #
###############################################
#######
#  S  #
#     #
#     #
# ### #
#   # #
### ###
## E ##
#     #
#######
```
But a falsy value for the following test cases:
```
#######
#S    #
#     #
#  E  #
# ### #
#     #
#######
#######
#     #
# SE  #
#     #
#     #
#     #
#######
#######
#     #
#  E  #
#     #
#  S  #
#     #
#######
####################################
#                                  #
#                                  #
#                                  #
#S             #                  E#
####################################
```
The second to last room in the True category and the last room in the False category were shamelessly ~~stolen~~ borrowed from ~~[Koth: Jump and Run](http://meta.codegolf.stackexchange.com/a/8575/48538)~~ by [Manu](https://codegolf.stackexchange.com/users/15080/manu) (who deleted the sandbox post).
The last room in the True category is from [Martin Buttner's answer in Retina](https://codegolf.stackexchange.com/a/74468/48538).
  
[Answer]
# [Snails](https://github.com/feresum/PMA), 20 bytes
```
\S{d(=\#n)?^#},!(t\E
```
Prints `0` for the falsey value and `1` for the truthy value.
[Try it online!](http://snails.tryitonline.net/#code=XFN7ZCg9XCNuKT9eI30sISh0XEU&input=IyMjIyMjIwojICBTICAjCiMgICAgICMKIyAgICAgIwojICMjIyAjCiMgIEUgICMKIyMjIyMjIw)
* `\S` matches `S` at the start
* `d` sets direction to down
* `{...},` matches the stuff in braces 0 or more times
* `=\#` is an assertion which succeeds if there is a `#` char ahead of the snail, but does not move it
* `n` turns 90 degrees in either direction
* `(...)?` matches the pattern in parentheses 0 or 1 times
* `\ ​` matches a space and moves the snail onto it
* `!(...` is a negative assertion
* `t` teleports to any unmatched square in the grid
* `\E` matches `E`
[Answer]
## [Slip](https://github.com/Sp3000/Slip/wiki), 20 + 2 = 22 bytes
```
S>( ^4|^4(?|`#)^T)*E
```
So Slip's still as broken as ever, but for once this was a challenge it could actually do. It was never really designed to be that golfy though, so it'll never beat Snails at anything :P
Needs the `r` flag (no repeating cells) to terminate.
[Try it online](https://slip-online.herokuapp.com/?code=S%3E%28%20%5E4%7C%5E4%28%3F%7C%60%23%29%5ET%29%2aE&input=%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20S%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%20%20%20%20%20%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%23%23%23%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20E%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%23%0A%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23%23&config=r). Output is the path taken for truthy, empty for falsy.
```
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
```
[Answer]
## [Retina](https://github.com/mbuettner/retina/), 87 bytes
Byte count assumes ISO 8859-1 encoding.
```
+mT`E `S`(?<=^(?(1)!)(?<-1>.)*S.*¶(.)*)[E ]|.?S(?=(.)*¶.*#(?<-2>.)*(?(2)!)$)[E ]?
M`E
0
```
[Try it online!](http://retina.tryitonline.net/#code=K21UYEUgYFNgKD88PV4oPygxKSEpKD88LTE-LikqUy4qwrYoLikqKVtFIF18Lj9TKD89KC4pKsK2LiojKD88LTI-LikqKD8oMikhKSQpW0UgXT8KTWBFCjA&input=IyMjIyMjIwojICBTICAjCiMgICAgICMKIyAgICAgIwojICMjIyAjCiMgICAjICMKIyMjICMjIwojIyBFICMjCiMgICAgICMKIyMjIyMjIw)
As much as 2D string processing is possible in Retina (or .NET regex in general), it's not exactly concise...
### Explanation
```
+mT`E `S`(?<=^(?(1)!)(?<-1>.)*S.*¶(.)*)[E ]|.?S(?=(.)*¶.*#(?<-2>.)*(?(2)!)$)[E ]?
```
This is a flood-fill which marks all the cells that are reached by water with `S`. It does so by matching the characters that can be reached and then transliterating them to `S` with `T`-mode. This flood-fill goes through both spaces and `E`. The `+` at the beginning repeats this until the output stops changing.
As for the actual regex is contains two separate cases:
```
(?<=^(?(1)!)(?<-1>.)*S.*¶(.)*)[E ]
```
This matches a space or `E` which is exactly one cell below an `S`. The vertical matching is done by counting the prefix on the current line using [balancing groups](https://stackoverflow.com/a/17004406/1633117) so we can ensure that the horizontal position is the same. This one takes care of falling water.
```
.?S(?=(.)*¶.*#(?<-2>.)*(?(2)!)$)[E ]?
```
This is very similar: it matches an `S` and if available the character before and after it, provided that the character directly beneath the `S` is a `#`. This takes care of water spreading along the ground.
When we're done it's very easy to determine if the water reached `E`. If it did, then `E` has been removed from the string in the flood-fill, and if not the `E` is still there. So let's count the number of `E`s:
```
M`E
```
But now that's `0` (which I'd consider falsy) for truthy test cases and `1` (which I'd consider truthy) for falsy test cases. We can invert this very easily by counting the number of `0`s in this result:
```
0
```
Done.
]