Erkennen Sie ausfallende Schlösser

40

Einer der interessanten Aspekte der Schwerkraft ist, dass man, soweit ich weiß, nicht einfach Sachen in der Luft schweben lassen kann.

Es scheint jedoch, dass nicht alle Mitglieder der Association of Random Castle Builders sich dieser Tatsache bewusst sind, was zu Burgen wie dieser führt:

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

und das hier:

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

und sogar dieses:

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

Herausforderung

Für eine gültige Burg werden alle Blöcke entweder direkt oder indirekt mit dem Boden verbunden. Ihr Programm oder Ihre Funktion erhält ein Schloss wie das oben genannte als Eingabe, und Ihr Programm muss einen wahren oder falschen Wert zurückgeben , der angibt, ob das Schloss gültig ist oder nicht.

Regeln

  • Die Eingabe erfolgt als String.
  • Alle gültigen Burgen ruhen auf einer Fläche ````````. (Wenn die Eingabezeichenfolge ist nicht eine Oberfläche enthält, ist das Schloss ungültig.)
  • Sie können davon ausgehen, dass alle Eingaben diese Kriterien erfüllen:
    • Die Oberfläche wird immer flach sein.
    • Die Oberfläche wird immer mindestens so breit wie die Burg sein, so dass links oder rechts vom Boden keine Blöcke sind.
    • Der Eingang wird niemals #unter der Oberfläche liegen.
    • Die Eingabe enthält nur Zeichen, die in dieser Abfrage angegeben wurden. ( #, `Leerzeichen oder Zeilenvorschub.)
    • Sie können davon ausgehen, dass die Eingabe immer mindestens ein Zeichen enthält.
  • Blöcke werden verbunden, wenn sie horizontal oder vertikal benachbart sind. Diagonale zählt nicht!
    • In Verbindung gebracht: 
      #	or	##
      #
    • Nicht verbunden: 
      #      or	# #	or	 #
                        		#
      #
  • Burgen müssen existieren, um gültig zu sein. (Mit anderen Worten, Eingaben ohne #Eingabe müssen einen falschen Wert ergeben.)
  • Die Eingabe enthält nur Zeichen, die in dieser Abfrage angegeben wurden. ( #, `Leerzeichen oder Zeilenvorschub.)
  • Sie können davon ausgehen, dass die Eingabe immer mindestens ein Zeichen enthält.
  • Standard I / O und Schlupfloch Regeln gelten.

Testfälle

Falsch

  • Alle oben angegebenen Beispiele.
  • # # # # 
    #### #### 
    #### # # #### 
    ############## 
    ###### ###### 
    ## ### #####
    (Kein Boden.)
  • # 
    ### #### 
    #### # # #### 
    ############## 
    ###### ###### 
    ##### # #### 
    `` `` `` `` `` `` `
    (Der oberste Block ist weder horizontal noch vertikal angeschlossen.)
  •    
    `` `
    (Kein Schloss.)


  •                                      # # # # # #    
                                         ############## 
                                         ##### 
      ######## # # # # # # #### # # #### # # # # # # # # 
      #### #### #### #### ## #### ## #### #### #### #### 
      ## ## # # #### # # #### # # #### # #### # #### # # #### # #### #### # #### 
      ################################################## ################################## 
      ###### ######## ## ###### ############################ ############ ## 
      ################################### ###### ####### ############################
      ################################################ ######################### 
    `` `` `` `` `` `` `` `` `` `` `` ` "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" `` `` `` `` `` ``
    (Der zentrale Turm ist nicht mit dem Rest der Burg verbunden, da keine horizontal oder vertikal angrenzenden Blöcke ihn verbinden.)
  •
    (Kein Schloss.)

  • (Keine Burg, nur ein einziger Newline-Charakter.)
  • # # 
    # 
    `` `` ``
    (Der Block ganz rechts ist weder horizontal noch vertikal angeschlossen.)
  •    
    `` `
    (Kein Schloss.)

Wahrheit

  • # 
    `
  • # # # # 
    #### #### 
    #### # # #### 
    ############## 
    ###### ###### 
    ## ### ##### 
    `` `` `` `` `` `` `
  •                       # 
                          # 
        # # # # ### 
        #### #### # # 
        #### # # #### ### 
        ############## ### 
        # ##### ###### ###### 
        ##### ### 
        ##### ##### ### 
    `` `` `` `` `` `` `` `` `` `` `` `` `` `
  •                                        # # # # # #    
                                           ############## 
                                           ### #### ### 
        # # # # # # # # ### #### ### # # # # # # # # 
        #### #### #### #### ############## #### #### #### ## ## 
        #### # # #### # # # # #### #### ## ######## ## #### # # #### # # ## ## # # #### 
        ########################################## ########################################## 
        ###### ## ###### ############################ ############ ###### #### 
        ################################### ##### # ###################################
        ################################################ ######################### 
    `` `` `` `` `` `` `` `` `` `` `` ` "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" `` `` `` `` `` `` `` ``
  •                       ####  ###
                          #  #### ###
                          #         ###
                          #           ##
                          #
                         ###
                        #####
                       #######
                      #########
                     ##### #####
                    #####   #####
                   ######   ######
                  #################
                  # ############# #
                    #############
                    #############
                    #############
                    ###### ######
                    ###### ######
                    #############
                    #############
                    #############
                    #############
                    ###### ######
                    ###### ######
                    #############
                    #############
                    #############
                    #############
                    ###### ######
                    ###### ######
                    #############
                    #############
                    #############
                    #############
                    #############
                    #####   #####
                    #####   ##### 
                    #####   #####
                `````````````````````
                                        
  •                                                 
                                              ####   
                                             #####   
                                            ######   
                                             ####    
                                             ####    
                                            #####    
                                           ######## 
                                          ########## 
                                          #### ###### 
                                         ########### 
                                        ############ 
                                      ############## 
       ##### ## ############## 
      ########### #################  
      ###########################################    
       ####### #################################      
        ################# ####################        
         ############################## ####          
            ############################             
                ################## #                  
    `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `` `

Viel Glück!

code-golf  ascii-art  decision-problem 
— user2428118
quelle
Können wir annehmen, dass alle Zeilen der Eingabe dieselbe Länge haben (dh mit Leerzeichen gefüllt sind)?
— smls
@smls Nein, Sie können nicht davon ausgehen, dass Eingaben aufgefüllt werden.
— user2428118
1
@smls Re # 1 und # 2: Eigentlich wollte ich festlegen, dass Einreichungen damit nicht umgehen müssen, aber ich sehe jetzt, dass ich es nicht so aufgeschrieben habe. Da es noch keine Lösungen gibt, die diese Dinge behandeln, aktualisiere ich die Frage, damit klar ist, dass Sie diese nicht behandeln müssen. Zu # 3: Ich kann mir keine Situation vorstellen, in der der Code die Falsy- Testfälle 2, 4 und 6 korrekt handhabt und dennoch keine Situation erkennt , in der überhaupt keine Blöcke mit dem Boden verbunden sind. Zu 4: Ich bin mir nicht sicher, was Sie damit meinen. Wird das nicht schon von Truthy- Testfall Nummer 1 erledigt ?
— user2428118
1
— Zgarb
2
Eine Bananenburg? BEST CASTLE EVER
— Matthew Roh

Antworten:

11

Schnecken , 21 18 Bytes

-3 Bytes aufgrund zusätzlicher Eingabebeschränkungen, die in challenge bearbeitet wurden.

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

Leider ist die zeitliche Komplexität faktoriell, sodass die meisten Eingaben nicht ausgeführt werden können.

Gibt 0 für falsche Fälle und die Anzahl #für wahrheitsgemäße Fälle aus.

                 ,,
!{ 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
quelle
Dies erkennt das Beispiel, das Sie auf Zgarbs Antwort gepostet haben, nicht als Schloss. Ich sehe in den Regeln nichts, was besagt, dass diese nicht als Burgen erkannt werden sollten . Die Regeln besagen nur, dass es sich um eine Burg handelt, wenn jede #mit dem Boden verbunden ist.
— Martin Ender
@Zgarb Nein, es gibt einen Fehler in der Erklärung - +ist tatsächlich 1 oder mehr Mal, nicht 0. Es wird sowieso anders aussehen, nachdem nicht verbundene Burgen zugelassen wurden.
— Feersum
9

Oktave, 53 51 Bytes

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

Probieren Sie es online!

* Da op nicht mehr benötigt wird, um nach leeren Eingaben zu suchen, wurde die Antwort auf meine erste Bearbeitung zurückgesetzt.

Erläuterung:

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

Schmutz , 29 Bytes

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

Probieren Sie es online! Bei den meisten Testfällen tritt bei TIO eine Zeitüberschreitung auf. Ersetzen Sie das <0C>durch <0CoF>, um es etwas schneller zu machen.

Erläuterung

Ich überprüfe, dass von jedem #ein Pfad zu einem `existiert und dass es mindestens einen gibt #. Kürzlich habe ich Grime Rotationsbefehle hinzugefügt, die diese Herausforderung erheblich vereinfachen.

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

JavaScript (ES6), 197 bis 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)

Wobei \ndas wörtliche Zeilenumbruchzeichen darstellt. Versucht, alle #s nacheinander zu entfernen, indem man eins neben a findet `und es in a ändert `. Gibt zurück, truewenn #ursprünglich mindestens eine vorhanden war, aber alle entfernt wurden. Version, die eine gepolsterte Eingabe für 118 bis 117 Bytes erfordert :

f=(s,t=s,u=t.replace(eval('/(#|`)([^]{'+s.search`\n`+'})?(?!\\1)[#`]/'),'`$2`'))=>t==u?/#/.test(s)>/#/.test(t):f(s,u)
— Neil
quelle
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}

Überprüft, ob die Eingabe mindestens eine enthält #und ob jeder #einen Pfad zu a finden kann `.

Eher ineffizient, da die Pfadfindung mithilfe einer rekursiven Funktion, die immer alle anderen #Bereiche derselben verbundenen Region aufruft (dh nicht kurzschließt), brachial erzwungen wird .

Verwendet eine unheilvolle Interaktion zwischen den Verknüpfungsoperatoren und dem Verrutschen , um sicherzustellen, dass der Pfadtest für Leerzeichen übersprungen wird, ohne dass eine separate Überprüfung außerhalb der Pfadfindungsfunktion erforderlich ist.

— smls
quelle
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}

Probieren Sie es online!

Die erste Zeile hier ist dem Auffüllen aller Zeilen auf dieselbe Länge gewidmet: Wir teilen die Zeichenfolge ( s.split('\n')ist ein Zeichen kürzer als s.splitlines()), ermitteln die maximale Länge einer Zeile und weisen C eine abgeflachte Liste aller Zeichen zu, nachdem jedes Zeichen aufgefüllt wurde Linie. (Die Zeilenumbrüche sind weg.)

Dann erstellen wir eine Liste, in der jedes Nicht-Leerzeichen neben mindestens einem Backtick durch ein Backtick ersetzt wird, und fahren fort, bis keine Änderung mehr erfolgt ist (wenn die alte Liste ogleich ist C. Wir können mit vergleichen, C>oanstatt C!=o# (ASCII 35) zu ersetzen ) mit `(ASCII 96) kann nur die lexikografische Reihenfolge der Liste erhöhen.)

Wenn kein # mehr vorhanden ist und anfangs mindestens eines vorhanden war, ist die Burg gültig.

  • Es wurden acht Bytes gespeichert, die auf # im eingestellten Unterschied geprüft haben, anstatt '#'in s and'#'not in C
— Nick Matteo
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.