40

Uno degli aspetti interessanti della gravità è che, per quanto ne so, non si può semplicemente fare galleggiare a mezz'aria.

Tuttavia, sembra che non tutti in Association of Random Castle Builders siano a conoscenza di questo fatto, portando a castelli come questo:

                      #
                      #
    #  #      #  #   ###
    ####      ####   # #
    #### #  # ####   ###
    ##############   ###
    ######  ######   ###
    #####    #####   ###
                     ###
``````````````````````````````

e questo:

                                       # # #    # # #   
                                       ##############
                                       ###  ####  ###
    #  #      #  #      #  #      #  # ###  ####  ### #  #      #  #      #  #      #  #
    ####      ####      ####      #### ############## ####      ####      ####      ####
    #### #  # #### #  # #### #  # #### ## ######## ## #### #  # #### #  # #### #  # ####
    ####################################################################################
    ######  ########  ########  ########  ########  ########  ########  ########  ######
    ###################################    ######    ###################################
    ###################################    ######    ###################################
                                       ##
                                         ##
                                           ##
                                             ##
                                               ##
````````````````````````````````````````````````````````````````````````````````````````````

e anche questo:

       ##########
   ####   #      ###
#######################
            #
              #
                #
                  #
                    #  # # #
                  #   #  ###
                   #   # ###
                # # #  #  ##
                # # ##   ###
                 #  #  #####
                   #   #####
                  # #  #####
                       #####
                       ## ##
                       #####
                       #####
                       ## ##
                       ## ##
````````````````````````````````````````````

Sfida

Per un castello valido, tutti i blocchi saranno collegati al suolo direttamente o indirettamente. Al tuo programma o funzione verrà assegnato un castello come quelli sopra come input e il tuo programma deve restituire un valore di verità o falsità che rifletta se il castello è valido o meno.

Regole

L'input è dato come una stringa.
Tutti i castelli valide trovino su una superficie, ````````. (Se la stringa di input non contiene una superficie, il castello non è valido.)
Puoi presumere che tutti gli input soddisfino questi criteri:
- La superficie sarà sempre piatta.
- La superficie sarà sempre larga almeno quanto il castello, quindi non ci saranno blocchi a sinistra o a destra del terreno.
- L'ingresso non avrà mai #sotto la superficie.
- L'input conterrà solo personaggi indicati in questa sfida. ( #, `, Spazio o di nuova riga.)
- Si può presumere che l'input conterrà sempre almeno un carattere.
I blocchi sono collegati se sono adiacenti orizzontalmente o verticalmente. La diagonale non conta!
- Collegato:
```
#	or	##
#
```
- Non connesso:
```
#      or	# #	or	 #
                  		#
#
```
I castelli devono esistere per essere validi. (In altre parole, gli input senza nessuno #devono dare un valore falso.)
L'input conterrà solo personaggi indicati in questa sfida. ( #, `, Spazio o di nuova riga.)
Si può presumere che l'input conterrà sempre almeno un carattere.
Si applicano le regole I / O standard e scappatoia .

Casi test

Falsy

Tutti gli esempi sopra riportati.

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

(Nessun terreno.)

# 
### #### 
#### # # #### 
############## 
###### ###### 
##### # #### 
`` `` `` `` `` `` `` `

(Il blocco più in alto non è collegato né in orizzontale né in verticale.)

```
   
`` `
```
(Nessun castello.)



                                     # # # # # #    
                                     ############## 
                                     ##### ## ##### 
  # # # # # # # # #### # # #### # # # # # # # # 
  #### #### #### #### ## #### ## #### #### #### #### 
  ## ## # # #### # # #### # # #### # # #### # # #### # # #### # # #### # # #### 
  ################################################## ################################## 
  ###### ######## ## ###### ######## ######## ######## ######## ####### ######## #### ## 
  ################################### ###### ###### ####### ############################
  ################################### ###### ########## ########################## 
`` `` `` `` `` `` `` `` `` `` `` `` `` ` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` ``

(La torre centrale non è collegata al resto del castello perché non ci sono blocchi adiacenti orizzontalmente o verticalmente che la collegano.)

```
   
```
(Nessun castello.)
(Nessun castello, solo un singolo personaggio newline.)
```
# # 
# 
`` `` `` `
```
(Il blocco più a destra non è collegato né in orizzontale né in verticale.)
```
   
`` `
```
(Nessun castello.)

Truthy

```
# 
`
```

# # # # 
#### #### 
#### # # #### 
############## 
###### ###### 
## ### ##### 
`` `` `` `` `` `` `` `

                      # 
                      # 
    # # # # ### 
    #### #### # # 
    #### # # #### ### 
    ##################### ### 
    # ##### ###### ### 
    ##### ##### ### 
    ##### ##### ### 
`` `` `` `` `` ` `` `` `` `` `` `` `` `` `` ``

                                       # # # # #    
                                       ############## 
                                       ### #### ### 
    # # # # # # # ### #### ### # # # # # # # 
    #### #### #### #### ############## #### #### #### ## ## 
    #### # # #### # # #### # # #### ## ######## ## #### # # #### # # ## ## # # #### 
    ################################################## ########################################## 
    ####### ###### ## ###### ######## ######## ######## ######## ####### ######## #### #### ###### 
    ########################################## ###### ##### # ##########################################
    ################################### ###### ########## ########################## 
`` `` `` `` `` `` `` `` `` `` `` `` `` ` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` ``

                      #### ### 
                      # #### ### 
                      # ### 
                      # ## 
                      # 
                     ### 
                    ##### 
                   ####### ####### 
                  ######### 
                 ### ## ##### 
                ##### ##### 
               ###### ###### 
              ######################## 
              # ### ########## # 
                ############# 
                ############# 
                #################### 
                ###### ###### 
                ###### ###### 
                #############
                ############# 
                ############# 
                ############# 
                ####### ###### ##### # 
                ###### ###### 
                ############# 
                ############# 
                ############ ## 
                ############# 
                ###### ###### 
                ###### ###### 
                ############ ## 
                ############# 
                ############# 
                ############# 
                ########## #### 
                ##### ##### 
                ##### ##### 
                ##### ##### 
            `` `` `` `` `` `` `` `` `` `` `` `

                                                
                                          ####   
                                         #####   
                                        ######   
                                         ####    
                                         ####    
                                        #####    
                                       ######## 
                                      ########## 
                                      #### ###### 
                                     ########### 
                                    ############ 
                                  ############## 
   ##### ## ############## 
  ########### #################  
  ##################################################    
   ####### #################################      
    ######################### ####################        
     ###################################### ####          
        ############################             
            ########################## #                  
`` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` ` `

In bocca al lupo!

code-golf ascii-art decision-problem

— user2428118
fonte

Possiamo supporre che tutte le righe dell'input avranno la stessa lunghezza (ovvero riempite di spazi)?

— smls

@smls No, non puoi presumere che l'input sia imbottito.

— user2428118,

1

@smls Re # 1 e # 2: in realtà intendevo specificare che le presentazioni non devono gestirlo, ma ora vedo che non è così che l'ho scritto. Poiché non ci sono ancora soluzioni pubblicate che gestiscono queste cose, aggiornerò la domanda in modo che sia chiaro che non è necessario gestirle. Ri # 3: Non riesco davvero a pensare a una situazione in cui il codice gestisca correttamente i casi di test Falsy 2, 4 e 6 e tuttavia non riesca a rilevare una situazione in cui non ci sono blocchi collegati a terra. Ri # 4: Non sono sicuro di cosa tu voglia dire. Questo non è già gestito dal test case numero 1 di Truthy ?

— user2428118

1

Relazionato.

— Zgarb,

2

Un castello di banane? MIGLIOR CASTELLO DI SEMPRE

— Matthew Roh,

11

Lumache , 21 18 byte

-3 byte a causa di ulteriori vincoli di input modificati in sfida.

!{t=\#!(\#o`+\`}\#

Sfortunatamente la complessità temporale è fattoriale, quindi la maggior parte degli input non è eseguibile.

Emette 0 per casi falsi e il numero di #per casi veritieri.

                 ,,
!{ t             ,, Assert that nowhere in the grid,
    =\#          ,, there is a '#'
    !(           ,, such that there does not exist
        (\# o)+  ,, an orthogonally connected path of '#'
        \`       ,, ending at a '`'
    )            ,,
}                ,,
\#               ,, Match '#' at starting position

— feersum
fonte

Questo non riconosce l'esempio che hai pubblicato sulla risposta di Zgarb come un castello. Non vedo nulla nelle regole che dice che questi non dovrebbero essere rilevati come castelli? Le regole dicono solo che è un castello se ognuna #è collegata al suolo.

— Martin Ender,

@Zgarb No, c'è un bug nella spiegazione - in +realtà è 1 o più volte, non 0. sembrerà comunque diverso dopo aver permesso i castelli disconnessi.

— feersum

9

Ottava, 53 51 byte

@(s)([~,n]=bwlabel(s>32,4))|n==1&&nnz(diff(+s)==61)

Provalo online!

* Da quando è stato eliminato l'obbligo di verificare la risposta di input vuota ripristinata alla mia prima modifica.

Spiegazione:

nnz(s)                       check for empty input
([~,n]=bwlabel(s~=' ',4))    label nonempty regions and count number of labels

n==1                         check if number of labels is 1.

nnz(diff(+s)==61)            check if blocks connected to the surface

— rahnema1
fonte

6

Grime , 29 byte

C=\`|\#&<0C>oX
e`\#&C!v#!&\##

Provalo online! La maggior parte dei casi di test scade su TIO. Sostituisci <0C>con <0CoF>per renderlo un po 'più veloce.

Spiegazione

Sto verificando che da ogni punto #esista un percorso verso a `, e che esista almeno uno #. Di recente ho aggiunto i comandi di rotazione a Grime, che rendono questa sfida molto più semplice.

C=\`|\#&<0C>oX  First line:
C=               Define nonterminal C as
  \`             the literal `
    |            or
     \#          the literal #
       &<  >     which is contained in a larger rectangle
         0C      containing said literal adjacent to a match of C
            oX   rotated by any multiple of 90 degrees.
e`\#&C!v#!&\##  Second line:
e`               Match entire input against this pattern:
         !       does not
       v#        contain
  \#             the literal #
    &C!          which is not a match of C,
          &      and
             #   contains
           \#    the literal #.

— Zgarb
fonte

6

JavaScript (ES6), 197 196 byte

f=(s,l=Math.max(...s.split`\n`.map(t=>t.length)),t=s.replace(/^.*/g,t=>t+' '.repeat(l-t.length)),u=t.replace(eval('/(#|`)([^]{'+l+'})?(?!\\1)[#`]/g'),'`$2`'))=>t==u?/#/.test(s)>/#/.test(t):f(s,l,u)

Dove \nrappresenta il carattere letterale di newline. Cerca di rimuovere tutti #i messaggi uno alla volta trovandone uno adiacente a `e cambiandolo in a `. Restituisce truese in origine ce n'era almeno uno #ma erano stati tutti rimossi. Versione che richiede input imbottito per ~~118~~ 117 byte:

f=(s,t=s,u=t.replace(eval('/(#|`)([^]{'+s.search`\n`+'})?(?!\\1)[#`]/'),'`$2`'))=>t==u?/#/.test(s)>/#/.test(t):f(s,u)

— Neil
fonte

5

Perl 6 , 180 byte

{?/\#/&&?all map ->\c{my \b=[map {[$^a.comb]},.lines];sub f(\y,\x){with b[y;x] ->$_ {b[y;x]=0;/\#/??f(y+(1|-1),x)|f(y,x+(1|-1))!!/\`/??1!!|()}}(|c)},map {|($++X ^$^a.comb)},.lines}

Verifica se l'input ne contiene almeno uno #e se ognuno #può trovare un percorso per a `.

Piuttosto inefficiente, perché l'individuazione del percorso è forzata brutalmente usando una funzione ricorsiva che visita sempre tutte le altre #della stessa regione connessa (cioè non cortocircuita).

Utilizza una cattiva interazione tra operatori di Junction e slittamento , per garantire che il test del percorso venga ignorato per i caratteri dello spazio senza richiedere un controllo separato per quello esterno alla funzione di pathfinding.

— LMS
fonte

5

Python 3 , 214 206 byte

def f(s):
 C=s.split('\n');n=max(map(len,C));o=[''];C=[*''.join(t.ljust(n)for t in C+o)]
 while C>o:o=C;C=['`'if z>' 'and'`'in{C[i+y]for y in(1,-1,n,-n)}else z for i,z in enumerate(C)]
 return'#'in{*s}-{*C}

Provalo online!

La prima riga qui è dedicata al riempimento di tutte le linee della stessa lunghezza: dividiamo la stringa ( s.split('\n')è un carattere più corto di s.splitlines()), troviamo la lunghezza massima di una linea e assegniamo a C un elenco appiattito di tutti i caratteri dopo aver riempito ciascuno linea. (Le nuove righe sono sparite.)

Quindi creiamo un elenco in cui ogni carattere non spaziale adiacente ad almeno un backtick viene sostituito da un backtick e continuiamo fino a quando non si verifica alcun cambiamento (quando il vecchio elenco oè uguale a C. Possiamo confrontare con C>oinvece che C!=operché sostituendo # (ASCII 35 ) con `(ASCII 96) può solo aumentare l'ordinamento lessicografico dell'elenco.)

Se non rimane #, e almeno uno era presente inizialmente, il castello è valido.

Ho salvato otto byte controllando # nella differenza impostata, anziché '#'in s and'#'not in C

— Nick Matteo
fonte

Rileva castelli falliti

Sfida

Regole

Casi test

Falsy

Truthy

Lumache , 21 18 byte

Ottava, 53 51 byte

Grime , 29 byte

Spiegazione

JavaScript (ES6), 197 196 byte

Perl 6 , 180 byte

Python 3 , 214 206 byte