Junte-se aos quartos

15

Então, aqui está um mapa de, digamos, uma masmorra ...

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

Digamos que o herói esteja na Sala A (no canto superior esquerdo) e seu objetivo (um príncipe em perigo?) Esteja na Sala B (no canto inferior direito). Nosso mapa não permite que o herói progrida para seu objetivo.

Precisamos adicionar uma passagem ...

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

Lá, muito melhor!

Regras

  • Um programa ou função que aceita um mapa de masmorra (composto de hashes e espaços, com linhas separadas por novos caracteres de linha).
  • Ele exibirá um mapa com pontos adicionados para indicar passagens em todos os espaços que estão em um caminho direto entre os caracteres do espaço.
  • Não altera o comprimento da linha ou o número de linhas.
  • As passagens estão todas em uma linha direta de espaços para espaços.
    • Passagens não podem virar as esquinas
    • Eles não estarão entre os espaços e a borda do mapa.
  • Use qualquer idioma.
  • Tente realizar a conversão no menor número de bytes.
  • Se nenhuma passagem puder ser desenhada, retorne o mapa inalterado.
  • O mapa sempre deve ter hashes em todas as bordas (você não precisa manipular espaços na borda).
  • Os mapas de entrada são sempre retangulares, cada linha deve ter a mesma largura.

Casos de teste

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

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

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

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

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

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

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

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

##########        ##########
####  ####        ####  ####
####### ##        ####..# ##
###### ###        ####.. ###
# ### ## #    =>  # ... .. #
# ## ### #        # .. ... # 
### ######        ### ..####
## #######        ## #..####
####  ####        ####  ####
##########        ##########
code-golf string ascii-art geometry AJFaraday
fonte
Posso usar caracteres diferentes de #e .?
usar o seguinte comando
1
@ user202729 Não. Estava nas regras desde o início, e já havia uma resposta. Provavelmente é melhor deixar as solicitações consistentes.
precisa saber é o seguinte
@ user202729 O caso de teste que você sugeriu é semelhante ao meu penúltimo caso. Eu posso adicioná-lo na próxima alteração da pergunta, mas isso não adiciona muito.
AJFaraday
... Eu simplesmente não rolei para baixo. Sem problemas.
usar o seguinte comando
@ l4m2 As mesmas regras se aplicam, sempre que houver uma linha reta entre os quartos, é uma passagem. Assim, uma sala em forma de u teria a lacuna preenchida com passagens.
precisa saber é o seguinte

Respostas:

7

Gelatina , 17 bytes

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

Experimente online!

Tricky -1 graças a user202729 .

Explicação:

ỴḲ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, o Outgolfer
fonte
2
Sempre me surpreende a rapidez com que as pessoas conseguem enfrentar esses desafios e em tão poucos personagens.
AJFaraday
@AJFaraday Bem, então você também pode fazer parte disso. :) Comece com idiomas de golfe baseados em pilha (por exemplo, CJam, 05AB1E) e trabalhe a partir daí.
Erik the Outgolfer
Parece muito além de mim, para ser honesto, mas adoro ver como o processo funciona.
precisa saber é o seguinte
7
Espere, TNB é a abreviação de 'chá e biscoitos'? Ou eu estou sendo super-britânico agora?
precisa saber é o seguinte
5
Uma explicação seria legal para esta resposta.
Tamás Sengel
5

Perl 5 -p0 , 56 bytes

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

Experimente online!

Ton Hospel
fonte
3

APL + WIN, 87 bytes

Solicita matriz de caracteres:

n←(' '=m←⎕)⋄c←(∨⍀n)+⊖∨⍀⊖n⋄r←(∨\n)+⌽∨\⌽n⋄((,c>1)/,m)←'.'⋄((,r>1)/,m)←'.'⋄((,n)/,m)←' '⋄m
Graham
fonte
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

Experimente online!

Não é a maneira mais eficiente de fazê-lo em Haskell, tenho certeza. Tem muitos parênteses para o meu gosto, mas não sei mais como removê-lo.

aoemica
fonte
2
Bem vindo ao site! Você pode reduzir alguns parênteses usando $( (k(take 2 c))torna-se (k$take 2 c)). Você também pode usar em !!0vez de, headem alguns casos.
Post Rock Garf Hunter
Na verdade, no caso específico de (k(take 2 c))você, basta remover os parênteses externos, eles não são necessários. Mas no caso de drop(length(head d))você ainda pode usar o $, substituindo-o por drop(length$head d)(e atédrop(length$d!!0) ).
Post Rock Garf Hunter
Além disso, se você usar em kvez de, ++poderá reduzir bastante a última linha. k[' '<$k(take 2 c),'.'<$d!!0,drop(length$d!!0)$f$k$d].
Post Rock Garf Hunter
Um último golfe, a última linha pode ser substituída por f b|(e:g:d@(h:_:_))<-group b=k[' '<$e++g,'.'<$h,drop(length h)$f$k d]|1>0=' '<$b , isso usa uma correspondência de padrão para fazer muito do trabalho pesado que estava sendo feito antes.
Post Rock Garf Hunter
1
Obrigado pelo golfe pesado @ user56656! Ungolfed, eu tinha 2 funções e apenas as colei sem otimizar como um todo. É uma coisa boa a ter em mente.
Aoemica 7/04
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)

Experimente online!

ovs
fonte
2

Retina 0.8.2 , 95 bytes

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

Experimente online! Explicação:

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

Ele procura por #sinais que estão acima de espaços ou .se os transforma em pontos até não sobrar nenhum. O lookbehind encontra a #coluna da e, em seguida, o lookahead pula para a próxima linha e atomicamente para a mesma coluna abaixo, de forma que o espaço ou. possa corresponder apenas se estiver exatamente abaixo do #.

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

Ele procura .s que não estão abaixo dos espaços ou .se os transforma novamente em #s até não sobrar nenhum. O lookahead encontra a .coluna da e, em seguida, o lookbehind pula para a linha anterior e atomicamente para a mesma coluna acima da mesma maneira, de modo que o espaço ou .possa corresponder apenas se estiver exatamente acima do# . Um lookbehind negativo é usado para que isso também funcione para .s na linha superior.

 (\S+) 
 $.1$*.

(Observe o espaço à direita nas duas linhas) Isso simplesmente procura todas as execuções de caracteres que não sejam espaços em branco entre espaços e garante que todos sejam .s.

Neil
fonte
1

Ruby , 104 bytes

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

Experimente online!

Bem, não é ótimo, mas pelo menos é complicado. Tenho certeza que pode ser melhorado.

Restabelecer Monica - notmaynard
fonte
1

Stax , 19 bytes

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

Execute e depure

recursivo
fonte
Receio que seu link de depuração mostre código em branco.
precisa saber é o seguinte
@AJFaraday: Qual navegador você está usando? Está funcionando para mim no Chrome para Windows.
recursivo
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`
`

Experimente online!

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
fonte