15

Entonces, aquí hay un mapa de, digamos, un calabozo ...

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

Digamos que el héroe está en la Sala A (arriba a la izquierda) y su objetivo (¿un príncipe en apuros?) Está en la Sala B (abajo a la derecha). Nuestro mapa no permite que el héroe avance hacia su objetivo.

Necesitamos agregar un pasaje ...

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

Ahí, mucho mejor!

Reglas

Un programa o función que acepta un mapa de mazmorra (compuesto de hashes y espacios, con filas separadas por nuevos caracteres de línea).
Producirá un mapa con puntos agregados para denotar pasajes en todos los espacios que están en una ruta directa entre los caracteres del espacio.
No cambiará la longitud de la línea o el número de líneas.
Los pasajes están todos en línea directa de espacios a espacios.
- Los pasajes no pueden doblar esquinas
- No estarán entre espacios y el borde del mapa.
Usa cualquier idioma.
Intente realizar la conversión en la menor cantidad de bytes.
Si no se pueden dibujar pasillos, devuelva el mapa, sin cambios.
El mapa siempre debe tener hash alrededor de todos los bordes (no es necesario que maneje espacios en el borde)
Los mapas de entrada son siempre rectangulares, cada fila debe tener el mismo ancho.

Casos de prueba

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

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

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

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

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

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

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

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

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

— AJFaraday
fuente

¿Puedo usar diferentes caracteres que #y .?

— user202729

1

@ user202729 No. Estaba en las reglas desde el principio, y ya ha habido una respuesta. Probablemente sea mejor dejar los requisitos consistentes.

— AJFaraday

@ user202729 El caso de prueba que sugirió es similar a mi penúltimo caso. Podría agregarlo la próxima vez que cambie la pregunta, pero no agrega mucho.

— AJFaraday

... Simplemente no me desplacé hacia abajo. No hay problema.

— user202729

@ l4m2 Se aplican las mismas reglas, siempre que haya una línea recta entre las habitaciones, es un pasaje. Entonces, una habitación en forma de U tendría el espacio lleno de pasajes.

— AJFaraday

7

Jalea , 17 bytes

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

Pruébalo en línea!

Tricky -1 gracias a user202729 .

Explicación:

ỴḲ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 el Outgolfer
fuente

2

Siempre me sorprende lo rápido que la gente puede enfrentar estos desafíos, y en tan pocos personajes.

— AJFaraday

@AJFaraday Bueno, entonces tú también puedes ser parte de eso. :) Simplemente comience con lenguajes de golf basados en pila (por ejemplo, CJam, 05AB1E) y avance desde allí.

— Erik the Outgolfer

Para ser sincero, parece mucho más allá de mí, pero me encanta ver cómo funciona el proceso.

— AJFaraday

77

Espera, ¿TNB es la abreviatura de 'té y galletas'? ¿O solo estoy siendo súper británico en este momento?

— AJFaraday

55

Una explicación sería genial para esta respuesta.

— Tamás Sengel

5

Perl 5 `-p0` , 56 bytes

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

Pruébalo en línea!

— Ton Hospel
fuente

3

APL + WIN, 87 bytes

Solicitudes de matriz de caracteres:

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

— Graham
fuente

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

Pruébalo en línea!

No es la forma más eficiente de hacerlo en Haskell, estoy seguro. ~~Tiene demasiados paréntesis para mi gusto, pero ya no estoy seguro de cómo eliminarlos.~~

— aoemica
fuente

2

Bienvenido al sitio! Puede reducir algunos paréntesis usando $(se (k(take 2 c))convierte (k$take 2 c)). También puede usar en !!0lugar de headen algunos casos.

— Post Rock Garf Hunter

En realidad, en el caso particular de (k(take 2 c))que solo pueda eliminar los paréntesis externos, no son necesarios. Pero en el caso de drop(length(head d))que aún pueda usar el $, reemplazándolo con drop(length$head d)(e incluso drop(length$d!!0)).

— Post Rock Garf Hunter

Además, si usa en klugar de ++puede reducir considerablemente la última línea. k[' '<$k(take 2 c),'.'<$d!!0,drop(length$d!!0)$f$k$d].

— Post Rock Garf Hunter

En un último campo de golf, se puede reemplazar la última línea f b|(e:g:d@(h:_:_))<-group b=k[' '<$e++g,'.'<$h,drop(length h)$f$k d]|1>0=' '<$b, esto utiliza una coincidencia de patrones para hacer gran parte del trabajo pesado que se estaba haciendo antes.

— Post Rock Garf Hunter

1

Gracias por el trabajo pesado golfing @ user56656! Ungolfed tenía f como 2 funciones y las pegué juntas sin optimizarlas como un todo. Eso es algo bueno a tener en cuenta.

— 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)

Pruébalo en línea!

— ovs
fuente

2

Retina 0.8.2 , 95 bytes

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

Pruébalo en línea! Explicación:

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

Esto busca #signos que están por encima de los espacios o .sy los convierte en puntos hasta que no quede ninguno. El lookbehind encuentra la #columna 's y luego el lookahead salta a la siguiente línea y atómicamente a la misma columna de abajo para que el espacio o .solo pueda coincidir si está exactamente debajo del #.

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

Esto busca .s que no están debajo de espacios o .sy los convierte de nuevo en #s hasta que no quede ninguno. El lookahead encuentra la .columna de s y luego el lookbehind salta a la línea anterior y atómicamente a la misma columna de arriba de la misma manera, de modo que el espacio o .solo puede coincidir si está exactamente por encima de #. Se utiliza una mirada hacia atrás negativa para que esto también funcione para .s en la fila superior.

 (\S+) 
 $.1$*.

(Observe el espacio final en ambas líneas) Esto simplemente busca todas las ejecuciones de caracteres que no sean espacios en blanco entre espacios y asegura que todos sean .s.

— Neil
fuente

1

Ruby , 104 bytes

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

Pruébalo en línea!

Bueno, no es genial, pero al menos es complicado. Estoy seguro de que se puede mejorar.

— Restablecer a Monica - notmaynard
fuente

1

Stax , 19 bytes

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

Ejecutar y depurarlo

— recursivo
fuente

Me temo que su enlace de depuración muestra un código en blanco.

— AJFaraday

@AJFaraday: ¿Qué navegador estás usando? Me está funcionando en Chrome para Windows.

— recursivo el

1

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

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

Pruébalo en línea!

Comentado

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
fuente

Únete a las habitaciones

Reglas

Casos de prueba

Jalea , 17 bytes

Perl 5 -p0 , 56 bytes

APL + WIN, 87 bytes

Haskell , 209 165 162 bytes.

Python 2 , 173 148 bytes

Retina 0.8.2 , 95 bytes

Ruby , 104 bytes

Stax , 19 bytes

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

Comentado

Perl 5 `-p0` , 56 bytes