Verbinde die Räume

15

Also, hier ist eine Karte von, sagen wir, einem Dungeon ...

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

Nehmen wir an, der Held befindet sich in Raum A (oben links) und sein Ziel (ein Prinz in Not?) Befindet sich in Raum B (unten rechts). Unsere Karte erlaubt es dem Helden nicht, ihr Ziel zu erreichen.

Wir müssen einen Durchgang hinzufügen ...

##########
#    #####
#    #####
####.#####
####.#####
####.#####
####.#####
####    ##
####    ##
##########

Dort viel besser!

Regeln

  • Ein Programm oder eine Funktion, die eine Dungeon-Map akzeptiert (bestehend aus Hashes und Leerzeichen, wobei die Zeilen durch neue Zeilenzeichen getrennt sind).
  • Es wird eine Karte mit Punkten ausgegeben, die Passagen in allen Räumen kennzeichnen, die sich auf einem direkten Pfad zwischen den Leerzeichen befinden.
  • Die Zeilenlänge oder die Anzahl der Zeilen wird nicht geändert.
  • Passagen verlaufen alle in direkter Linie von Raum zu Raum.
    • Durchgänge können nicht um Ecken drehen
    • Sie befinden sich nicht zwischen Leerzeichen und dem Rand der Karte.
  • Verwenden Sie eine beliebige Sprache.
  • Versuchen Sie, die Konvertierung in den wenigsten Bytes durchzuführen.
  • Wenn keine Durchgänge gezeichnet werden können, geben Sie die Karte unverändert zurück.
  • Die Karte sollte immer um alle Kanten herum mit Hashes versehen sein (Leerzeichen am Rand müssen nicht behandelt werden).
  • Eingabe-Maps sind immer rechteckig. Jede Zeile sollte dieselbe Breite haben.

Testfälle

####       ####
#  #   =>  #  #
#  #       #  #
####       ####

##########        ##########
#    #####        #    #####
#    #####        #    #####
##########        ####.#####
##########    =>  ####.#####
##########        ####.##### 
##########        ####.#####
####    ##        ####    ##
####    ##        ####    ##
##########        ##########

##########        ##########
#    #####        #    #####
#    #####        #    #####
##########        ##########
##########    =>  ##########
##########        ########## 
##########        ##########
######  ##        ######  ##
######  ##        ######  ##
##########        ##########

##########        ##########
#    #####        #    #####
#    #####        #    #####
##########        ####.#####
##########    =>  ####.#####
####   ###        ####   ### 
##########        ######.###
######  ##        ######  ##
######  ##        ######  ##
##########        ##########

##########        ##########
#    #####        #    #####
#    #####        #    #####
##########        ##..######
##########    =>  ##..######
##########        ##..###### 
##########        ##..######
## #######        ## .######
##  ######        ##  ######
##########        ##########

##########        ##########
#    #####        #    #####
#    #####        #    #####
##########        #.########
##########    =>  #.########
##########        #.######## 
#######  #        #.#####  #
#######  #        #.#####  #
# #####  #        # .....  #
##########        ##########

##########        ##########
#    #####        #    #####
#    #####        #    #####
##########        #.########
#####  ###    =>  #.###  ###
#####  ###        #.###  ### 
#######  #        #.#####  #
#######  #        #.#####  #
# #####  #        # .....  #
##########        ##########

##########        ##########
##       #        ##       #
##########        ##......##
##########        ##......##
##########    =>  ##......##
##########        ##......## 
##########        ##......##
##########        ##......##
#       ##        #       ##
##########        ##########

##########        ##########
####  ####        ####  ####
####### ##        ####..# ##
###### ###        ####.. ###
# ### ## #    =>  # ... .. #
# ## ### #        # .. ... # 
### ######        ### ..####
## #######        ## #..####
####  ####        ####  ####
##########        ##########
code-golf  string  ascii-art  geometry 
— AJFaraday
quelle
Kann ich andere Zeichen als #und verwenden .?
— user202729
1
@ user202729 Nein. Es war von Anfang an in den Regeln, und es gab bereits eine Antwort damit. Am besten lassen Sie die Anforderungen konsistent.
— AJFaraday
@ user202729 Der von Ihnen vorgeschlagene Testfall ähnelt meinem vorletzten Fall. Ich könnte es hinzufügen, wenn ich die Frage das nächste Mal ändere, aber es fügt nicht viel hinzu.
— AJFaraday
... Ich habe nur nicht nach unten gescrollt. Kein Problem.
— user202729
@ l4m2 Die gleichen Regeln gelten, wenn zwischen den Räumen eine gerade Linie verläuft, ist es eine Passage. So würde ein U-förmiger Raum die Lücke mit Durchgängen füllen.
— AJFaraday

Antworten:

7

Gelee , 17 Bytes

ỴḲaLḊṖƊ¦”.KƊ€Z$⁺Y

Probieren Sie es online!

Tricky -1 dank user202729 .

Erläuterung:

ỴḲaLḊṖƊ¦”.KƊ€Z$⁺Y Arguments: S
Ỵ                 Split S on newlines
 ḲaLḊṖƊ¦”.KƊ€Z$   Monadic link
 ḲaLḊṖƊ¦”.KƊ€      Map over left argument
 ḲaLḊṖƊ¦”.KƊ        Monadic link
 Ḳ                   Split on spaces
  aLḊṖƊ¦”.           Dyadic link with right argument '.'
  aLḊṖƊ¦              Apply at specific indices
  a                    Logical AND (vectorizes)
   LḊṖƊ                Monadic link
   L                    Length
    Ḋ                   Range [2..n]
     Ṗ                  Remove last element
          K          Join with spaces
             Z     Zip
               ⁺  Previous link
                Y Join with newlines
— Erik der Outgolfer
quelle
2
Es wundert mich immer wieder, wie schnell Menschen diese Herausforderungen meistern können und mit so wenigen Charakteren.
— AJFaraday,
@ AjFaraday Nun, dann können Sie auch ein Teil davon sein. :) Beginnen Sie einfach mit Stack-basierten Golfsprachen (z. B. CJam, 05AB1E) und arbeiten Sie sich von dort aus vor.
— Erik der Outgolfer
Um ehrlich zu sein, scheint es mir ein langer Weg zu sein, aber ich mag es zu sehen, wie der Prozess funktioniert.
— AJFaraday
7
Warten Sie, ist TNB die Abkürzung für "Tee und Kekse"? Oder bin ich jetzt nur ein Super-Brite?
— AJFaraday
5
Eine Erklärung wäre cool für diese Antwort.
— Tamás Sengel
3

APL + WIN, 87 Bytes

Eingabeaufforderungen für die Zeichenmatrix:

n←(' '=m←⎕)⋄c←(∨⍀n)+⊖∨⍀⊖n⋄r←(∨\n)+⌽∨\⌽n⋄((,c>1)/,m)←'.'⋄((,r>1)/,m)←'.'⋄((,n)/,m)←' '⋄m
— Graham
quelle
3

Haskell , 209 165 162 Bytes.

import Data.List
t=transpose
k=concat
j a=(foldr1 max<$>)<$>t<$>t[a,f<$>a,t$f<$>t a]
f b|(e:g:d@(h:_:_))<-group b=k[f$e++g,'.'<$h,drop(length h)$f$k d]|1>0=' '<$b

Probieren Sie es online!

Ich bin mir sicher, dass dies in Haskell nicht die effizienteste Methode ist. Es gibt zu viele Klammern für meinen Geschmack, aber ich bin nicht sicher, wie ich sie wieder entfernen soll.

— Aoemica
quelle
2
Willkommen auf der Seite! Sie können einige der Klammern mit $( (k(take 2 c))wird (k$take 2 c)) reduzieren . Sie können !!0statt headin einigen Fällen auch verwenden.
— Weizen-Assistent
Im konkreten Fall (k(take 2 c))können Sie einfach die äußeren Klammern entfernen, sie werden nicht benötigt. Aber im Falle, dass drop(length(head d))Sie immer noch das verwenden können $, ersetzen Sie es durch drop(length$head d)(und sogar drop(length$d!!0)).
— Weizen-Assistent
Außerdem können Sie, wenn Sie kanstelle von ++verwenden, die letzte Zeile stark reduzieren. k[' '<$k(take 2 c),'.'<$d!!0,drop(length$d!!0)$f$k$d].
— Weizen-Assistent
Ein letztes Golfspiel, bei dem die letzte Linie ersetzt werden f b|(e:g:d@(h:_:_))<-group b=k[' '<$e++g,'.'<$h,drop(length h)$f$k d]|1>0=' '<$bkann. Hierbei wird ein Mustervergleich verwendet, um einen Großteil des zuvor durchgeführten schweren Trainings durchzuführen.
— Weizen-Assistent
1
Vielen Dank für die schwere Golf @ user56656! Ungolfed Ich hatte 2 Funktionen und fügte sie einfach zusammen, ohne sie als Ganzes zu optimieren. Das ist gut zu bedenken.
— Aoemica
2

Python 2 , 173 148 Bytes

m=input().split('\n')
exec"m=zip(*[[c*(c!='#')or'#.'[(' 'in r[i:])*(' 'in r[:i])]for i,c in enumerate(r)]for r in m]);"*2
for r in m:print''.join(r)

Probieren Sie es online!

— ovs
quelle
2

Retina 0.8.2 , 95 Bytes

+`(?<=(.)*)#(?=.*¶(?>(?<-1>.)*)[ .])
.
+`\.(?=(.)*)(?<![ .](?>(?<-1>.)*)¶.*)
#
 (\S+) 
 $.1$*.

Probieren Sie es online! Erläuterung:

+`(?<=(.)*)#(?=.*¶(?>(?<-1>.)*)[ .])
.

Dies sucht nach #Zeichen, die über Leerzeichen oder .s liegen, und wandelt sie in Punkte um, bis keine mehr übrig sind. Der Lookbehind findet die #Spalte s und der Lookahead springt dann zur nächsten Zeile und atomar zur gleichen Spalte darunter, so dass das Leerzeichen oder .nur, wenn es genau unter dem übereinstimmt #.

+`\.(?=(.)*)(?<![ .](?>(?<-1>.)*)¶.*)
#

Das sucht . s, die sich nicht unter Leerzeichen oder .s befinden, und wandelt sie wieder in #s um, bis keine mehr übrig sind. Der Lookahead findet die .Spalte 's' und der Lookbehind springt in etwa der gleichen Weise in die vorherige Zeile und atomar in die gleiche Spalte darüber, sodass das Leerzeichen oder .nur dann übereinstimmen kann, wenn es genau über dem ist #. Ein negativer Lookbehind wird verwendet, damit dies auch für .s in der oberen Reihe funktioniert .

 (\S+) 
 $.1$*.

(Beachten Sie das nachfolgende Leerzeichen in beiden Zeilen.) Dies sucht einfach nach allen Durchläufen von Nicht-Leerzeichen zwischen Leerzeichen und stellt sicher, dass sie alle .s sind.

— Neil
quelle
1

JavaScript (Node.js) , 205 193 190 186 181 175 172 Byte

r=>r.split`
`.map(x=>[...x]).map((R,y,r)=>R.map((c,x)=>{for(D=2;c<"#"&&D--;){for(;(T=(r[y+=D]||0)[x+=!D])>" ";);for(;r[y-=D][x-=!D]>c;)T?r[y][x]=".":0}})&&R.join``).join`
`

Probieren Sie es online!

Kommentiert

f=r=>r.split`
` ->                                     //getting as string with lines
.map(x=>[...x])                          //to 2d string array
  .map((R,y,r)=>                         //r - the new 2d string array
    R.map((c,x)=>{                       //
      for(D=2;c<"#"&&D--;)              //instead of using if joining c==" " with the loop,D=1/0
        {for(;                           //
         (T=(r[y+=D]||0)[x+=!D])>" ";);  //0[num] = undefined. checking for a path - consisting of # or .(or not consisting of space or undefined), we dont need temp (X,Y) because in the next loop we will return to our original position regardless of the correctness of the path
           for(;T&&r[y-=D][x-=!D]>c;)    //again instead of if(T) combine with loop. if T is not undefined it will be a space because the array can return .#(space). and we then go back to the source(x,y)
                                         //remeber that c==" "
             r[y][x]="."                 //and just putting . where weve been
     }})&&R.join``                       //instead of return r as string at the end , we know that we cant change a row at a smaller index(due to D-0/1) so we can return R.join`` already
    ).join`
`
— DanielIndie
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.