40

Um dos aspectos interessantes da gravidade é que, até onde eu sei, você não pode simplesmente ter coisas flutuando no ar.

No entanto, parece que nem todos na Associação de Construtores Aleatórios de Castelos estão cientes desse fato, levando a castelos como este:

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

e este:

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

e até este:

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

Desafio

Para um castelo válido, todos os blocos serão conectados ao chão, direta ou indiretamente. Seu programa ou função receberá um castelo como os acima como entrada e seu programa deve retornar um valor verdadeiro ou falso, refletindo se o castelo é válido ou não.

Regras

A entrada é fornecida como uma sequência.
Todos os castelos válidos repousam sobre uma superfície ````````,. (Se a sequência de entrada não contiver uma superfície, o castelo é inválido.)
Você pode assumir que todas as entradas satisfarão estes critérios:
- A superfície sempre será plana.
- A superfície sempre será pelo menos tão larga quanto o castelo, portanto não haverá blocos à esquerda ou à direita do solo.
- A entrada nunca terá #abaixo da superfície.
- A entrada conterá apenas caracteres dados neste desafio. ( #, `espaço ou nova linha.)
- Você pode assumir que a entrada sempre conterá pelo menos um caractere.
Os blocos são conectados se estiverem adjacentes na horizontal ou na vertical. Diagonal não conta!
- Conectado:
```
#	or	##
#
```
- Não conectado:
```
#      or	# #	or	 #
                  		#
#
```
Castelos devem existir para serem válidos. (Em outras palavras, entradas sem nenhuma #devem fornecer um valor falso.)
A entrada conterá apenas caracteres dados neste desafio. ( #, `espaço ou nova linha.)
Você pode assumir que a entrada sempre conterá pelo menos um caractere.
Aplicam-se regras de E / S padrão e brecha .

Casos de teste

Falsy

Todos os exemplos dados acima.

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

(Sem chão.)

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

(O bloco superior não está conectado na horizontal ou na vertical.)

```
   
`` ``
```
(Sem castelo.)



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

(A torre central não está conectada ao resto do castelo porque não há blocos adjacentes na horizontal ou na vertical que o conectam.)

```
   
```
(Sem castelo.)
(Nenhum castelo, apenas um único caractere de nova linha.)
```
# # 
# 
`` `` `` `
```
(O bloco mais à direita não está conectado horizontal ou verticalmente.)
```
   
`` ``
```
(Sem castelo.)

Truthy

```
# 
`
```

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

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

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

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

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

Boa sorte!

code-golf ascii-art decision-problem user2428118
fonte

Podemos assumir que todas as linhas da entrada terão o mesmo comprimento (isto é, preenchidas com espaços)?

smls 03/02

@smls Não, você não pode assumir que a entrada será preenchida.

precisa saber é o seguinte

11

@smls Re # 1 e # 2: Na verdade, pretendia especificar que os envios não precisam lidar com isso, mas agora vejo que não foi assim que os escrevi. Como ainda não existem soluções publicadas que lidem com essas coisas, atualizarei a pergunta para que fique claro que você não precisa lidar com elas. Re # 3: Eu realmente não consigo pensar em uma situação em que o código lidaria corretamente com os casos de teste 2, 4 e 6 da Falsy e ainda assim não consegui detectar uma situação em que não há nenhum bloco conectado ao chão. Re # 4: Não sei o que você quer dizer com isso. Isso já não é tratado pelo caso de teste número 1 da Truthy ?

precisa saber é o seguinte

11

Relacionado.

Zgarb 3/02

2

Um castelo de bananas? MELHOR CASTELO DE SEMPRE

Matthew Roh

11

Caracóis , 21 18 bytes

-3 bytes devido a restrições adicionais de entrada editadas no desafio.

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

Infelizmente, a complexidade do tempo é fatorial; portanto, a maioria das entradas não pode ser executada.

Saídas 0 para casos falsos e o número de #casos verdadeiros.

                 ,,
!{ 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

Isso não reconhece o exemplo que você postou na resposta de Zgarb como um castelo. Não vejo nada nas regras que diga que elas não devam ser detectadas como castelos? As regras dizem apenas que é um castelo se cada uma #estiver conectada ao chão.

Martin Ender

@ Zgarb Não, há um erro na explicação - +na verdade é 1 ou mais vezes, não 0. ele ficará diferente de qualquer maneira depois de permitir castelos desconectados.

precisa saber é

9

Oitava, 53 51 bytes

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

Experimente Online!

* Desde que o op caiu, o requisito de verificar se a resposta de entrada vazia foi revertida para minha primeira edição.

Explicação:

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 bytes

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

Experimente online! A maioria dos casos de teste atinge o tempo limite no TIO. Substitua por <0C>com <0CoF>para torná-lo um pouco mais rápido.

Explicação

Estou verificando que, de todos os #modos, existe um caminho para `ae existe pelo menos um #. Recentemente, adicionei comandos de rotação ao Grime, o que facilita muito esse desafio.

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 bytes

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)

Onde \nrepresenta o caractere literal de nova linha. Tenta remover todos os #s um de cada vez, localizando um adjacente a `e alterando-o para a `. Retorna truese havia pelo menos um #originalmente, mas todos foram removidos. Versão que requer entrada acolchoada para ~~118~~ 117 bytes:

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 bytes

{?/\#/&&?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 a entrada contém pelo menos um #e se todos #podem encontrar um caminho para a `.

Bastante ineficiente, porque o caminho é forçado com força bruta usando uma função recursiva que sempre visita todas as outras #da mesma região conectada (ou seja, não provoca curto-circuito).

Usa alguma interação profana entre operadores de junção e escorregamento , para garantir que o teste de caminho seja ignorado para caracteres de espaço sem exigir uma verificação separada para fora da função de busca de caminho.

smls
fonte

5

Python 3 , 214 206 bytes

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}

Experimente online!

A primeira linha aqui é dedicada a preencher todas as linhas com o mesmo comprimento: dividimos a string ( s.split('\n')é um caractere mais curto que s.splitlines()), encontramos o comprimento máximo de uma linha e atribuímos a C uma lista achatada de todos os caracteres depois de preencher cada linha. (As novas linhas se foram.)

Em seguida, fazemos uma lista na qual cada caractere não espacial adjacente a pelo menos um backtick é substituído por um backtick e continuamos até que nenhuma mudança ocorra (quando a lista antiga oé igual a C. Podemos comparar com ao C>oinvés de C!=osubstituir # # (ASCII 35 ) com `(ASCII 96) só pode aumentar a ordem lexicográfica da lista.)

Se não houver #, e pelo menos um estiver presente inicialmente, o castelo é válido.

Salvo oito bytes, verificando # na diferença definida, em vez de '#'in s and'#'not in C

Nick Matteo
fonte

Detectar castelos com falha