Diyelim ki bir zindan haritası ...

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

Kahramanın A Odasında (sol üstte) ve hedeflerinin (sıkıntıdaki bir prens?) B Odasında (sağ altta) olduğunu varsayalım. Haritamız, kahramanın hedeflerine ilerlemesine izin vermiyor.

Bir geçit eklememiz gerek ...

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

Orada, çok daha iyi!

kurallar

• Bir zindan haritasını kabul eden bir program veya işlev (karma ve boşluklardan oluşan, satırlar yeni satır karakterleriyle ayrılmış).
• Boşluk karakterleri arasında doğrudan bir yolda bulunan tüm boşluklardaki geçişleri belirtmek için noktaların eklendiği bir harita çıkarır.
• Satır uzunluğunu veya satır sayısını değiştirmez.
• Pasajların tümü uzaydan uzaylara doğrudan bir çizgidedir.
  • Pasajlar köşelerde dönemez
  • Boşluklarla haritanın kenarı arasında olmayacaklar.
• Herhangi bir dil kullanın.
• Dönüştürmeyi en az baytta gerçekleştirmeyi deneyin.
• Hiçbir geçit çizilemiyorsa, haritayı değiştirmeden geri gönderin.
• Haritanın her zaman tüm kenarlarında karmaları olmalıdır (Kenardaki boşlukları işlemenize gerek yoktur).
• Girdi haritaları her zaman dikdörtgen şeklindedir, her satır aynı genişlikte olmalıdır.

Test senaryoları

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

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

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

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

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

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

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

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

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

Jöle , 17 bayt

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

Çevrimiçi deneyin!

User202729 sayesinde zor -1 .

Açıklama:

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

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

Çevrimiçi deneyin!

APL + WIN, 87 bayt

Karakter matrisi için bilgi istemleri:

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

Haskell , 209 165 162 bayt.

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

Çevrimiçi deneyin!

Haskell'de yapmanın en etkili yolu emin değilim. Sevdiğim için çok fazla parantez var ama nasıl daha fazla kaldırılacağından emin değilim.

Python 2 , 173148 bayt

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)

Çevrimiçi deneyin!

Retina 0.8.2 , 95 bayt

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

Çevrimiçi deneyin! Açıklama:

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

Bu #, boşlukların veya işaretlerin üzerinde olan işaretleri arar .ve hiçbir şey kalmayana kadar noktalara dönüştürür. Lookbehind #'s sütununu bulur ve sonra ileriye doğru bir sonraki satıra atlar ve atomik olarak aşağıdaki aynı sütuna atlar, böylece boşluk veya .yalnızca tam olarak altındaysa eşleşebilir #.

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

Bu ., boşlukların veya .s'nin altında olmayan s'leri arar ve #hiç kalmayana kadar bunları s'ye dönüştürür . İlerleme .sütununun sütununu bulur ve sonra gözetleme bir önceki satıra ve atomik olarak yukarıdaki aynı sütuna çok benzer şekilde atlar, böylece boşluk veya .yalnızca tam olarak üstündeyse eşleşebilir #. Negatif bir gözetleme kullanılır, böylece bu .üst sıradaki s için de çalışır .

 (\S+) 
 $.1$*. 

(Her iki satırda da boşluk bulunduğuna dikkat edin) Bu, boşluklar arasındaki boşluk olmayan karakterlerin tüm çalışmalarını arar ve hepsinin .s olmasını sağlar .

Ruby , 104 bayt

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

Çevrimiçi deneyin!

Harika değil, ama en azından kıvrık. Eminim geliştirilebilir.

Stax , 19 bayt

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

Çalıştır ve hata ayıkla

JavaScript (node.js) , 205 193 190 186 181 175 172 bayt

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

Çevrimiçi deneyin!

Yorumlananlar

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