Détecter les châteaux défaillants

40

L'un des aspects intéressants de la gravité est que, autant que je sache, vous ne pouvez pas laisser simplement des objets flotter dans les airs.

Cependant, il semble que tous les membres de l'Association of Random Castle Builders ne soient pas conscients de ce fait, ce qui conduit à des châteaux comme celui-ci:

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

et celui-là:

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

et même celui-ci:

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

Défi

Pour un château valide, tous les blocs seront connectés au sol, directement ou indirectement. Votre programme ou votre fonction recevra un château tel que ceux ci-dessus, et votre programme devra renvoyer une valeur de vérité ou de fausseté indiquant si le château est valide ou non.

Règles

  • L'entrée est donnée sous forme de chaîne.
  • Tous les châteaux valides reposent sur une surface, ````````. (Si la chaîne d'entrée ne contient pas de surface, le château n'est pas valide.)
  • Vous pouvez supposer que toutes les entrées répondront à ces critères:
    • La surface sera toujours plate.
    • La surface sera toujours au moins aussi large que le château, il n'y aura donc pas de blocs à gauche ou à droite du sol.
    • L'entrée n'aura jamais #sous la surface.
    • Les entrées ne contiendront que des caractères donnés dans ce challenge. ( #, `, L' espace ou saut de ligne).
    • Vous pouvez supposer que l'entrée contiendra toujours au moins un caractère.
  • Les blocs sont connectés s'ils sont adjacents horizontalement ou verticalement. La diagonale ne compte pas!
    • Connecté: 
      #	or	##
      #
    • Pas connecté: 
      #      or	# #	or	 #
                        		#
      #
  • Les châteaux doivent exister pour être valides. (En d'autres termes, les entrées sans aucun #doivent donner une valeur de fausseté.)
  • Les entrées ne contiendront que des caractères donnés dans ce challenge. ( #, `, L' espace ou saut de ligne).
  • Vous pouvez supposer que l'entrée contiendra toujours au moins un caractère.
  • Les règles standard d' entrée / sortie et d' échappatoire s'appliquent.

Cas de test

Fausseté

  • Tous les exemples donnés ci-dessus.
  • # # # # 
    ##### #### 
    #### # # #### 
    ############# 
    ###### ###### 
    ## ### #####
    (Pas de terrain.)
  • # 
    ### #### 
    #### # # #### 
    ############# 
    ###### ###### 
    ##### # #### 
    `` `` `` `` `` ``
    (Le bloc le plus haut n'est pas connecté horizontalement ou verticalement.)
  •    
    `` `
    (Pas de château.)


  •                                      # # # # # # #    
                                         ############## 
                                         ##### ## ##### 
      # # # # # # # # # # ### # # # # # # # # 
      #### #### #### #### ## #### ## #### #### #### #### 
      ## ## # # #### # # #### # # #### # # #### # # #### # # #### # # #### # # ### 
      ################################################# ################################## 
      ###### ########## ###### ######## ######## ######## ####### ########### ## 
      ################################### ###### ####### ##############################
      ################################### ###### ######### ########################### 
    `` `` `` `` `` `` `` `` `` `` ``. `.........`....... `. Non pas. Non pas non pas non pas non pas pas pas pas pas pas pas `` `` `` `` ``
    (La tour centrale n'est pas connectée au reste du château car il n'y a pas de blocs adjacents horizontalement ou verticalement le connectant.)
  •
    (Pas de château.)

  • (Pas de château, juste un seul caractère newline.)
  • # # 
    # 
    `` `` `` `
    (Le bloc le plus à droite n'est pas connecté horizontalement ou verticalement.)
  •    
    `` `
    (Pas de château.)

Vérité

  • # 
    `
  • # # # # 
    ##### #### 
    #### # # #### 
    ############# 
    ###### ###### 
    ## ### ##### 
    `` `` `` `` `` `` `
  •                       # 
                          # 
        # # # # ### 
        #### #### # # 
        #### # # #### ### 
        ############## ### 
        # ##### ###### ### 
        ##### ##### ### 
        ##### ##### ### 
    `` `` `` `` ` `` `` `` `` `` `` `` `
  •                                        # # # # # #    
                                           ############### 
                                           ### #### ### 
        # # # # # # # # # ### #### ### # # # # # # # # 
        #### # #### #### #### ############# #### #### #### ## ## 
        #### # # #### # # #### # # #### ## ######## ## #### # # #### # ### ## # # #### 
        ######################################### ########################################## 
        ###### ## ###### ######## ######## ######## ####### ########### #### ###### 
        ####################################### # #####################################
        ################################### ###### ######### ########################### 
    `` `` `` `` `` `` `` `` `` `` ``. `.........`....... `. Non pas. Non pas non pas non pas non pas pas pas pas pas pas pas `` `` `` `` `` `` ``
  •                       #### ### 
                          # #### ### 
                          # ### 
                          # ## 
                          # 
                         ### 
                        ##### 
                       ####### 
                      ######### 
                     ### ## ##### 
                    ##### ##### 
                   ###### ###### 
                  ################ 
                  ### ########## # 
                    ############## 
                    ############ 
                    ############ 
                    ###### ###### 
                    ###### ###### 
                    #############
                    ############# 
                    ############# 
                    ############ 
                    ########## # 
                    ###### ###### 
                    ############# 
                    ############ 
                    ########## ## 
                    ############ 
                    ###### ###### 
                    ###### ###### 
                    ########## ## 
                    ############# 
                    ############# 
                    ############# 
                    ######### #### 
                    ##### ##### 
                    ##### ##### 
                    ##### ##### 
                `` `` `` `` `` `` ` `` `` `
                                        
  •                                                 
                                              ####   
                                             #####   
                                            ######   
                                             ####    
                                             ####    
                                            #####    
                                           ######## 
                                          ########## 
                                          #### ###### 
                                         ########### 
                                        ############ 
                                      ############## 
       ##### ## ############## 
      ########### #################  
      ###########################################    
       ####### ##################################      
        ################ #####################        
         ############################ ####          
            #############################             
                ################# #                  
    `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` ` `

Bonne chance!

code-golf  ascii-art  decision-problem 
— utilisateur2428118
source
Peut-on supposer que toutes les lignes de l'entrée auront la même longueur (c'est-à-dire remplies d'espaces)?
— smls
@smls Non, vous ne pouvez pas supposer que l'entrée sera complétée.
— user2428118
1
@smls Re # 1 and # 2: Je voulais en fait préciser que les soumissions ne doivent pas gérer cela, mais je vois maintenant que ce n'est pas comme ça que je l'ai écrit. Comme il n'y a pas encore de solutions postées qui gèrent ces choses, je mettrai à jour la question afin qu'il soit clair que vous n'avez pas à les gérer. Re # 3: Je ne peux pas vraiment penser à une situation dans laquelle le code gérera correctement les cas de test Falsy 2, 4 et 6 sans pour autant détecter une situation dans laquelle il n'y a pas de bloc connecté à la terre. Re # 4: Je ne suis pas sûr de comprendre ce que vous entendez par là. Cela n’est-il pas déjà traité par le cas d’essai numéro 1 de Truthy ?
— user2428118
1
— Zgarb
2
Un château de banane? MEILLEUR CHATEAU
— Matthew Roh

Réponses:

11

Escargots , 21 à 18 octets

-3 octets en raison de contraintes d'entrée supplémentaires modifiées dans challenge.

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

Malheureusement, la complexité temporelle étant factorielle, la plupart des entrées ne sont pas exécutables.

Sorties 0 pour les cas de fausseté et nombre de #cas pour les cas de vérité.

                 ,,
!{ 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
source
Cela ne reconnaît pas l'exemple que vous avez posté sur la réponse de Zgarb en tant que château. Je ne vois rien dans les règles qui dit que ceux- ci ne devraient pas être détectés comme des châteaux? Les règles disent seulement que c'est un château si chacun #est connecté au sol.
— Martin Ender
@Zgarb Non, l'explication comporte un bogue: il +s'agit en fait d'une ou plusieurs fois, et non de 0. Il sera de toute façon différent une fois que des châteaux déconnectés auront été autorisés.
— Feersum
9

Octave, 53 51 octets

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

Essayez-le en ligne!

* Depuis que l'opération a été supprimée, l'exigence de vérifier la réponse d'entrée vide est revenue à ma première modification.

Explication:

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
source
6

Grime , 29 octets

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

Essayez-le en ligne! La plupart des cas de test expirent sur TIO. Remplacez le <0C>par <0CoF>pour le rendre un peu plus rapide.

Explication

Je vérifie qu'il #existe un chemin d'accès à un `et qu'il en existe au moins un #. J'ai récemment ajouté des commandes de rotation à Grime, ce qui facilite grandement ce défi.

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
source
6

JavaScript (ES6), 197 196 octets

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)

Où \nreprésente le caractère de nouvelle ligne littéral. Essaie de supprimer tous les #s un à la fois en trouvant un à côté de a `et en le changeant en `. Renvoie trues'il y en avait au moins un à l' #origine mais tous ont été supprimés. Version nécessitant une entrée complétée pour 118 117 octets:

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

Perl 6 , 180 octets

{?/\#/&&?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}

Vérifie si l'entrée en contient au moins un #et si chacun #peut trouver un chemin d'accès à un `.

Plutôt inefficace, parce que la recherche de chemin est brutale en utilisant une fonction récursive qui visite toujours tous les autres #de la même région connectée (c'est-à-dire ne court-circuite pas).

Utilise des interactions impies entre opérateurs de jonction et glissements pour garantir que le test de chemin d'accès est ignoré pour les espaces, sans nécessiter une vérification distincte pour celles situées en dehors de la fonction de recherche de chemin d'accès.

— smls
source
5

Python 3 , 214 206 octets

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}

Essayez-le en ligne!

La première ligne ici est consacrée au remplissage de toutes les lignes à la même longueur: nous scindons la chaîne ( s.split('\n')un caractère est plus court que s.splitlines()), trouvons la longueur maximale d’une ligne et attribuons à C une liste aplatie de tous les caractères après chaque remplissage. ligne. (Les nouvelles lignes ont disparu.)

Ensuite, nous faisons une liste où chaque caractère non-espace adjacent à au moins un backtick est remplacé par un backtick, et continuons jusqu'à ce qu'aucun changement ne se produise (lorsque l'ancienne liste oest égale à C. Nous pouvons comparer avec C>oau lieu de C!=oparce que remplacer # (ASCII 35 ) avec `(ASCII 96) ne peut qu'accroître l'ordre lexicographique de la liste.)

S'il ne reste plus # et qu'il y en a au moins un présent au départ, le château est valide.

  • Huit octets enregistrés vérifiant la présence de # dans la différence définie, plutôt que '#'in s and'#'not in C
— Nick Matteo
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.