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 #
#
#
- Connecté:
- 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.)
### ####
#### # # ####
#############
###### ######
##### # ####
`` `` `` `` `` ``
`` `
(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.)
# # # # # # #
##############
##### ## #####
# # # # # # # # # # ### # # # # # # # #
#### #### #### #### ## #### ## #### #### #### ####
## ## # # #### # # #### # # #### # # #### # # #### # # #### # # #### # # ###
################################################# ##################################
###### ########## ###### ######## ######## ######## ####### ########### ##
################################### ###### ####### ##############################
################################### ###### ######### ###########################
`` `` `` `` `` `` `` `` `` `` ``. `.........`....... `. Non pas. Non pas non pas non pas non pas pas pas pas pas pas pas `` `` `` `` ``
(Pas de château, juste un seul caractère newline.)# #
(Le bloc le plus à droite n'est pas connecté horizontalement ou verticalement.)
#
`` `` `` `
`` `
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
la source
la source
Réponses:
Escargots ,
21 à18 octets-3 octets en raison de contraintes d'entrée supplémentaires modifiées dans challenge.
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é.la source
#
est connecté au sol.+
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.Octave,
5351 octetsEssayez-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:
la source
Grime , 29 octets
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.la source
JavaScript (ES6),
197196 octetsOù
\n
repré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`
. Renvoietrue
s'il y en avait au moins un à l'#
origine mais tous ont été supprimés. Version nécessitant une entrée complétée pour118117 octets:la source
Perl 6 , 180 octets
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.
la source
Python 3 ,
214206 octetsEssayez-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 ques.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
o
est égale àC
. Nous pouvons comparer avecC>o
au lieu deC!=o
parce 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.
'#'in s and'#'not in C
la source