Nel mondo dell'arte ASCII, ci sono acqua, pareti di hash e meccanismi di lettere.

Sei in una stanza composta da muri di hash ( #segni):

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

Installi una fonte di acqua S ( Ssegno) e un serbatoio di acqua E ( Esegno) che può ricevere acqua da qualsiasi direzione, ma hai solo una fonte S e un serbatoio E.

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

Quindi devi selezionare saggiamente dove posizionare la fonte. È qui che tiri fuori le tue abilità nel code-golf .

L'obiettivo

Ottieni un input costituito da una stringa che rappresenta una stanza con la sorgente e il serbatoio:

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

Devi scoprire se alla fine l'acqua raggiunge il serbatoio. L'acqua scorre verso il basso, se possibile, altrimenti a sinistra e a destra, se possibile. L'acqua non si accumula perché non sale.

Quindi, per l'input sopra, il risultato è:

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

L'acqua raggiunge felicemente il serbatoio, quindi è necessario fornire un valore veritiero.

Ma se l'acqua non raggiunge il serbatoio:

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

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

Quindi è necessario generare un valore errato.

Scrivi un programma per decidere se l'acqua raggiunge il serbatoio. Il tuo codice dovrebbe essere il più breve possibile.

ipotesi

• Supponiamo che l'input sia sempre valido (l'intera stanza è una regione rettangolare chiusa con la S e la E).

• Supponiamo che ci sia solo una stanza fornita come input.

Casi test

Il tuo programma dovrebbe restituire un valore di verità per i seguenti casi di test:

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

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

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

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

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

Ma un valore falso per i seguenti casi di test:

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

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

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

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

La penultima stanza della categoria Vero e l'ultima stanza della categoria Falso sono state sottratte senza vergogna in prestito da Koth: Jump and Run di Manu (che ha eliminato il post sandbox).

L'ultima stanza nella categoria True è dalla risposta di Martin Buttner a Retina .

Lumache , 20 byte

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

Stampa 0per il valore di falsità e 1per il valore di verità.

Provalo online!

• \Spartite Sall'inizio
• d imposta la direzione verso il basso
• {...}, corrisponde al materiale tra parentesi graffe 0 o più volte
• =\#è un'asserzione che ha successo se c'è un #carattere davanti alla lumaca, ma non la sposta
• n ruota di 90 gradi in entrambe le direzioni
• (...)? corrisponde allo schema tra parentesi 0 o 1 volte
• \ ​ abbina uno spazio e sposta la lumaca su di esso
• !(... è un'affermazione negativa
• t si teletrasporta su qualsiasi quadrato senza pari nella griglia
• \E fiammiferi E

Slip , 20 + 2 = 22 byte

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

Quindi Slip è ancora rotto come non mai, ma per una volta questa è stata una sfida che potrebbe effettivamente fare. Non è mai stato progettato per essere così golfoso, quindi non batterà mai le lumache in niente: P

Ha bisogno del rflag (senza celle ripetute) per terminare.

Provalo online . L'output è il percorso preso per la verità, vuoto per la falsità.

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 byte

Il conteggio dei byte presuppone la codifica ISO 8859-1.

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

Provalo online!

Per quanto l'elaborazione delle stringhe 2D sia possibile in Retina (o regex .NET in generale), non è esattamente conciso ...

Spiegazione

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

Si tratta di un'inondazione che segna tutte le cellule raggiunte dall'acqua S. Lo fa facendo corrispondere i caratteri che possono essere raggiunti e poi traslitterare a Scon T-MODE. Questo inondazione attraversa entrambi gli spazi e E. Il+L'all'inizio ripete questo fino a quando l'uscita smette di cambiare.

Per quanto riguarda l'effettiva regex contiene due casi separati:

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

Questo corrisponde a uno spazio o Eche è esattamente una cella sotto un S. La corrispondenza verticale viene eseguita contando il prefisso sulla riga corrente utilizzando i gruppi di bilanciamento in modo da garantire che la posizione orizzontale sia la stessa. Questo si occupa della caduta dell'acqua.

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

Questo è molto simile: corrisponde a Se se disponibile il personaggio prima e dopo di esso, a condizione che il personaggio direttamente sotto a Ssia a# . Questo si occupa della diffusione dell'acqua lungo il terreno.

Quando abbiamo finito è molto facile determinare se l'acqua ha raggiunto E. In caso Eaffermativo , è stato rimosso dalla stringa nel riempimento dell'inondazione e, in caso contrario, Eè ancora presente. Quindi contiamo il numero di Es:

M`E

Ma ora è 0(che considererei falsa) per casi di test di verità e 1(che considererei verità) per casi di test di falsità. Possiamo invertire molto facilmente contando il numero di 0s in questo risultato:

0

Fatto.