Vì vậy, đây là bản đồ, giả sử, một hầm ngục ...

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

Hãy nói rằng anh hùng ở phòng A (ở phía trên bên trái) và mục tiêu của họ (một hoàng tử gặp nạn?) Nằm ở phòng B (phía dưới bên phải). Bản đồ của chúng tôi không cho phép anh hùng tiến tới mục tiêu của họ.

Chúng ta cần thêm một lối đi ...

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

Ở đó, tốt hơn nhiều!

Quy tắc

• Một chương trình hoặc chức năng chấp nhận bản đồ ngục tối (bao gồm các giá trị băm và khoảng trắng, với các hàng được phân tách bằng các ký tự dòng mới).
• Nó sẽ xuất ra một bản đồ với các dấu chấm được thêm vào để biểu thị các đoạn trong tất cả các khoảng trống nằm trên một đường dẫn trực tiếp giữa các ký tự khoảng trắng.
• Nó sẽ không thay đổi độ dài dòng hoặc số dòng.
• Các đoạn đều nằm trong một đường thẳng từ không gian đến không gian.
  • Lối đi không thể quay vòng
  • Chúng sẽ không nằm giữa không gian và cạnh của bản đồ.
• Sử dụng bất kỳ ngôn ngữ.
• Cố gắng thực hiện chuyển đổi trong vài byte nhất.
• Nếu không có lối đi nào có thể được vẽ, trả lại bản đồ, không thay đổi.
• Bản đồ phải luôn có các giá trị băm xung quanh tất cả các cạnh (Bạn không cần xử lý các khoảng trắng ở cạnh).
• Bản đồ đầu vào luôn là hình chữ nhật, mỗi hàng phải có cùng chiều rộng.

Các trường hợp thử nghiệm

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

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

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

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

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

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

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

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

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

Thạch , 17 byte

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

Hãy thử trực tuyến!

Lừa -1 nhờ người dùng202729 .

Giải trình:

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

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

Hãy thử trực tuyến!

APL + THẮNG, 87 byte

Lời nhắc cho ma trận ký tự:

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

Haskell , 209 165 162 byte.

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

Hãy thử trực tuyến!

Tôi chắc chắn không phải là cách hiệu quả nhất trong Haskell. Nó có quá nhiều dấu ngoặc đơn theo ý thích của tôi nhưng tôi không biết làm cách nào để xóa nữa.

Python 2 , 173 148 byte

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)

Hãy thử trực tuyến!

Võng mạc 0.8.2 , 95 byte

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

Hãy thử trực tuyến! Giải trình:

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

Điều này tìm kiếm các #dấu hiệu ở trên không gian hoặc .s và biến chúng thành các dấu chấm cho đến khi không còn lại. Người tìm kiếm tìm thấy #cột của và sau đó người nhìn sẽ bỏ qua dòng tiếp theo và nguyên tử đến cùng cột bên dưới để không gian hoặc .chỉ có thể khớp nếu chính xác bên dưới #.

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

Cái này tìm những .s không nằm dưới dấu cách hoặc .s và biến chúng trở lại thành #s cho đến khi không còn lại. Cái nhìn tìm thấy .cột của cái nhìn và sau đó cái nhìn sẽ bỏ qua dòng trước đó và nguyên tử đến cùng một cột ở trên theo cùng một cách để không gian hoặc .chỉ có thể khớp nếu nó chính xác ở trên #. Một cái nhìn tiêu cực được sử dụng để nó cũng hoạt động cho .s ở hàng trên cùng.

 (\S+) 
 $.1$*. 

(Lưu ý dấu cách trên cả hai dòng) Điều này chỉ đơn giản là tìm kiếm tất cả các ký tự không phải khoảng trắng giữa các khoảng trắng và đảm bảo rằng tất cả chúng đều là .s.

Ruby , 104 byte

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

Hãy thử trực tuyến!

Chà, nó không tuyệt lắm, nhưng ít nhất thì nó cũng bị xáo trộn. Tôi chắc chắn rằng nó có thể được cải thiện.

Stax , 19 byte

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

Chạy và gỡ lỗi nó

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

Hãy thử trực tuyến!

Đã bình luận

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