15

Quindi, ecco una mappa di, diciamo, un sotterraneo ...

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

Diciamo che l'eroe è nella Sala A (in alto a sinistra) e il loro obiettivo (un principe in difficoltà?) È nella Sala B (in basso a destra). La nostra mappa non consente all'eroe di progredire verso il proprio obiettivo.

Dobbiamo aggiungere un passaggio ...

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

Ecco, molto meglio!

Regole

Un programma o una funzione che accetta una mappa sotterranea (composta da hash e spazi, con righe separate da nuovi caratteri di linea).
Verrà emessa una mappa con punti aggiunti per indicare i passaggi in tutti gli spazi che si trovano su un percorso diretto tra i caratteri dello spazio.
Non cambierà la lunghezza della linea o il numero di linee.
I passaggi sono tutti in linea diretta dagli spazi agli spazi.
- I passaggi non possono girare dietro gli angoli
- Non saranno tra gli spazi e il bordo della mappa.
Usa qualsiasi lingua
Tentativo di eseguire la conversione nel minor numero di byte.
Se non è possibile tracciare passaggi, restituire la mappa invariata.
La mappa dovrebbe sempre avere hash attorno a tutti i bordi (non è necessario gestire gli spazi ai bordi).
Le mappe di input sono sempre rettangolari, ogni riga deve avere la stessa larghezza.

Casi test

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

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

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

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

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

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

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

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

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

— AJFaraday
fonte

Posso usare personaggi diversi da #e .?

— user202729

1

@ user202729 No. Era nelle regole dall'inizio, e c'è già stata una risposta con esso. Probabilmente è meglio lasciare coerenti le richieste.

— AJFaraday,

@ user202729 Il caso di test che hai suggerito è simile al mio penultimo caso. Potrei aggiungerlo alla prossima modifica della domanda, ma non aggiunge molto.

— AJFaraday,

... Non ho semplicemente scorrere verso il basso. Nessun problema.

— user202729

@ l4m2 Si applicano le stesse regole, ovunque ci sia una linea retta tra le stanze, è un passaggio. Quindi una stanza a forma di U avrebbe riempito il vuoto con passaggi.

— AJFaraday,

7

Gelatina , 17 byte

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

Provalo online!

Tricky -1 grazie a user202729 .

Spiegazione:

ỴḲ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 l'Outgolfer
fonte

2

Mi stupisce sempre la velocità con cui le persone possono affrontare queste sfide e in così pochi personaggi.

— AJFaraday,

@AJFaraday Bene, allora puoi farne parte anche tu. :) Inizia con le lingue di golf basate su stack (ad esempio CJam, 05AB1E) e prosegui da lì.

— Erik the Outgolfer,

Ad essere sincero, sembra molto lontano da me, ma adoro vedere come funziona il processo.

— AJFaraday,

7

Aspetta, TNB è l'abbreviazione di "tè e biscotti"? O sono solo super-britannico in questo momento?

— AJFaraday,

5

Una spiegazione sarebbe interessante per questa risposta.

— Tamás Sengel,

5

Perl 5 `-p0` , 56 byte

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

Provalo online!

— Ton Hospel
fonte

3

APL + WIN, 87 byte

Richiede matrice caratteri:

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

— Graham
fonte

3

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

Provalo online!

Non sono certo il modo più efficiente di farlo in Haskell. ~~Ha troppe parentesi per i miei gusti, ma non sono sicuro di come rimuovere più.~~

— aoemica
fonte

2

Benvenuti nel sito! È possibile ridurre alcune parentesi utilizzando $( (k(take 2 c))diventa (k$take 2 c)). È inoltre possibile utilizzare !!0anziché headin alcuni casi.

— Post Rock Garf Hunter,

In realtà nel caso particolare di (k(take 2 c))te puoi semplicemente rimuovere le parentesi esterne, non sono necessarie. Ma nel tuo caso drop(length(head d))puoi ancora usare il $, sostituendolo con drop(length$head d)(e anche drop(length$d!!0)).

— Post Rock Garf Hunter,

Inoltre, se si utilizza al kposto di ++è possibile ridurre notevolmente l'ultima riga. k[' '<$k(take 2 c),'.'<$d!!0,drop(length$d!!0)$f$k$d].

— Post Rock Garf Hunter,

Un ultimo golf, l'ultima linea può essere sostituita f b|(e:g:d@(h:_:_))<-group b=k[' '<$e++g,'.'<$h,drop(length h)$f$k d]|1>0=' '<$b, questo utilizza una corrispondenza del modello per fare molto del sollevamento pesante che era stato fatto prima.

— Post Rock Garf Hunter,

1

Grazie per il golf pesante @ user56656! Ungolfed avevo f come 2 funzioni e le ho incollate insieme senza ottimizzarle nel loro insieme. Questa è una buona cosa da tenere a mente.

— aoemica,

2

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)

Provalo online!

— OVS
fonte

2

Retina 0.8.2 , 95 byte

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

Provalo online! Spiegazione:

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

Questo cerca # segni che si trovano sopra spazi o se .li trasforma in punti fino a quando non ne rimangono più nessuno. Il lookbehind trova la #colonna e quindi il lookahead salta alla riga successiva e atomicamente alla stessa colonna in basso in modo che lo spazio o .possa corrispondere solo se è esattamente sotto il #.

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

Questo cerca .s che non sono al di sotto degli spazi o se .li trasforma di nuovo in# s fino a quando non ne rimangono più nessuno. Il lookahead trova la .colonna e quindi il lookbehind salta alla riga precedente e atomicamente alla stessa colonna sopra allo stesso modo in modo che lo spazio o .possa corrispondere solo se è esattamente sopra il #. Viene utilizzato un lookbehind negativo in modo che funzioni anche per .s nella riga superiore.

 (\S+) 
 $.1$*.

(Nota spazio finale su entrambe le righe) Cerca semplicemente tutte le sequenze di caratteri non bianchi tra gli spazi e garantisce che siano tutti .s.

— Neil
fonte

1

Rubino , 104 byte

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

Provalo online!

Bene, non è eccezionale, ma almeno è contorto. Sono sicuro che può essere migliorato.

— Ripristina Monica - notmaynard
fonte

1

Stax , 19 byte

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

Esegui ed esegui il debug

— ricorsivo
fonte

Temo che il tuo link di debug mostri un codice vuoto.

— AJFaraday,

@AJFaraday: quale browser stai usando? Funziona per me su Chrome per Windows.

— ricorsivo

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

Provalo online!

Commentate

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
fonte

Unisciti alle stanze

Regole

Casi test

Gelatina , 17 byte

Perl 5 -p0 , 56 byte

APL + WIN, 87 byte

Haskell , 209 165 162 byte.

Python 2 , 173 148 byte

Retina 0.8.2 , 95 byte

Rubino , 104 byte

Stax , 19 byte

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

Commentate

Perl 5 `-p0` , 56 byte