No mundo da arte ASCII, há água, paredes de hash e mecanismos de letras.

Você está em uma sala composta de paredes de hash ( #placas):

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

Você instala uma fonte de água S ( Ssinal) e um tanque de água E ( Esinal) que pode receber água de qualquer direção, mas você só tem uma fonte S e um tanque E.

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

Então você tem que selecionar sabiamente onde colocar a fonte. É aí que você desenvolve suas habilidades de código-golfe .

A tarefa

Você recebe uma entrada que consiste em uma sequência que representa uma sala com a fonte e o tanque:

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

Você tem que descobrir se a água finalmente chega ao tanque. A água flui para baixo, se possível, para a esquerda e para a direita, se possível. A água não se acumula porque não sobe.

Portanto, para a entrada acima, o resultado é:

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

Como a água chega feliz ao tanque, você deve gerar um valor verdadeiro.

Mas se a água não chegar ao tanque:

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

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

Então você deve gerar um valor falso.

Escreva um programa para decidir se a água finalmente chega ao tanque. Seu código deve ser o mais curto possível.

Suposições

• Suponha que a entrada seja sempre válida (a sala inteira é uma região retangular fechada com S e E).

• Suponha que haja apenas uma sala fornecida como entrada.

Casos de teste

Seu programa deve retornar um valor verdadeiro para os seguintes casos de teste:

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

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

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

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

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

Mas um valor falso para os seguintes casos de teste:

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

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

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

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

O penúltimo quarto na categoria Verdadeiro e o último na categoria Falso foram roubados descaradamente emprestados de Koth: Jump and Run por Manu (que excluiu a postagem da caixa de areia).

O último quarto da categoria True é da resposta de Martin Buttner em Retina .

Caracóis , 20 bytes

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

Imprime 0para o valor de falsey e 1para o valor de verdade .

Experimente online!

• \Spartidas Sno início
• d define a direção para baixo
• {...}, corresponde ao material entre chaves 0 ou mais vezes
• =\#é uma afirmação que obtém êxito se houver um #caractere antes do caracol, mas não o move
• n gira 90 graus em qualquer direção
• (...)? corresponde ao padrão entre parênteses 0 ou 1 vezes
• \ ​ combina com um espaço e move o caracol para ele
• !(... é uma afirmação negativa
• t teleporta para qualquer quadrado incomparável na grade
• \E fósforos E

Deslizamento , 20 + 2 = 22 bytes

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

Então Slip ainda está quebrado como sempre, mas pela primeira vez esse foi um desafio que ele poderia realmente fazer. No entanto, nunca foi realmente projetado para ser tão golfe, portanto nunca derrotará o Snails em nada: P

Precisa do rsinalizador (sem células repetidas) para terminar.

Experimente online . Saída é o caminho percorrido para a verdade, vazio para a falsificação.

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

A contagem de bytes assume a codificação ISO 8859-1.

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

Experimente online!

Por mais que o processamento de string 2D seja possível no Retina (ou regex .NET em geral), não é exatamente conciso ...

Explicação

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

Este é um preenchimento de inundação que marca todas as células atingidas pela água S. Fá-lo, combinando os caracteres que podem ser alcançados e, em seguida, transliterando-los para Scom T-mode. Esse preenchimento passa por ambos os espaços e E. o+ no início repete isso até que a saída pare de mudar.

Quanto ao regex real, contém dois casos separados:

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

Isso corresponde a um espaço ou Eque é exatamente uma célula abaixo de um S. A correspondência vertical é feita contando o prefixo na linha atual usando grupos de balanceamento para garantir que a posição horizontal seja a mesma. Este cuida da queda de água.

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

Isso é muito semelhante: corresponde a um Scaractere, se disponível, antes e depois dele, desde que o caractere diretamente abaixo dele Sseja a #. Isso cuida da água se espalhando pelo chão.

Quando terminamos, é muito fácil determinar se a água chegou E. Se foi, Efoi removido da sequência no preenchimento de inundação e, se não, Eainda está lá. Então, vamos contar o número de Es:

M`E

Mas agora isso é 0(o que eu consideraria falso) para casos de teste de verdade e 1(o que eu consideraria verdade) para casos de teste de falsidade. Podemos inverter isso muito facilmente contando o número de 0s neste resultado:

0

Feito.