Oto mapa, powiedzmy, lochu ...

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

Powiedzmy, że bohater jest w pokoju A (w lewym górnym rogu), a jego cel (książę w niebezpieczeństwie?) Znajduje się w pokoju B (w prawym dolnym rogu). Nasza mapa nie pozwala bohaterowi przejść do celu.

Musimy dodać przejście ...

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

Tam, o wiele lepiej!

Zasady

• Program lub funkcja, która akceptuje mapę lochów (złożoną z skrótów i spacji, z wierszami oddzielonymi znakami nowej linii).
• Wyświetli mapę z kropkami dodanymi w celu oznaczenia przejść we wszystkich przestrzeniach, które znajdują się na bezpośredniej ścieżce między znakami spacji.
• Nie zmieni długości ani liczby linii.
• Wszystkie przejścia są w linii prostej od spacji do spacji.
  • Przejścia nie mogą zawracać za rogami
  • Nie będą one znajdować się między spacjami a krawędzią mapy.
• Użyj dowolnego języka.
• Spróbuj wykonać konwersję w jak najmniejszej liczbie bajtów.
• Jeśli nie można narysować żadnych przejść, zwróć mapę bez zmian.
• Mapa powinna zawsze mieć skróty wokół wszystkich krawędzi (nie musisz obsługiwać spacji na krawędzi).
• Mapy wejściowe są zawsze prostokątne, każdy rząd powinien mieć tę samą szerokość.

Przypadki testowe

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

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

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

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

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

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

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

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

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

Galaretka , 17 bajtów

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

Wypróbuj online!

Podstępne -1 dzięki user202729 .

Wyjaśnienie:

ỴḲ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

Perl 5 -p0 , 56 bajtów

#!/usr/bin/perl -p0
/
/;$n="(.{@+})*";s%#%/ #*\G#+ |(?= )$n\G$n /s?".":$&%eg

Wypróbuj online!

APL + WIN, 87 bajtów

Monity o matrycę znaków:

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

Haskell , 209 165 162 bajtów.

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

Wypróbuj online!

Nie jestem najbardziej efektywnym sposobem na zrobienie tego w Haskell, jestem tego pewien. Mam na to za dużo nawiasów, ale nie jestem pewien, jak je usunąć.

Python 2 , 173 148 bajtów

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)

Wypróbuj online!

Retina 0.8.2 , 95 bajtów

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

Wypróbuj online! Wyjaśnienie:

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

Szuka #znaków znajdujących się nad spacjami lub .s i zamienia je w kropki, dopóki nie zostaną żadne. Lookbehind znajduje #kolumnę, a następnie lookahead przeskakuje do następnej linii i atomowo do tej samej kolumny poniżej, aby spacja lub .pasowała tylko wtedy, gdy jest dokładnie poniżej #.

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

Wyszukuje .s, które nie znajdują się poniżej spacji lub .s i zamienia je z powrotem w #s, dopóki nie zostaną żadne. Lookahead znajduje .kolumnę, a następnie lookbehind przeskakuje do poprzedniej linii i atomowo do tej samej kolumny powyżej w bardzo podobny sposób, aby spacja lub .mogła się dopasować tylko, jeśli jest dokładnie powyżej #. Zastosowano ujemny wygląd, więc działa to również dla .s w górnym rzędzie.

 (\S+) 
 $.1$*. 

(Zwróć uwagę na końcowe spacje w obu wierszach) To po prostu wyszukuje wszystkie przebiegi znaków spacji między spacjami i zapewnia, że ​​wszystkie są .s.

Rubinowy , 104 bajty

->s{2.times{s=((0...s=~/\n/).map{|i|s.lines.map{|b|b[i]}*""}*"\n").gsub(/ [#.]+(?= )/){$&.tr(?#,?.)}};s}

Wypróbuj online!

Cóż, to nie jest świetne, ale przynajmniej jest skomplikowane. Jestem pewien, że można to poprawić.

Stax , 19 bajtów

╛XA╟φkôα`æbπ┐w↨╙j≥☺

Uruchom i debuguj

JavaScript (Node.js) , 205 193 190 186 181 175 172 bajtów

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`
`

Wypróbuj online!

Skomentował

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`
`