15

Alors, voici une carte, disons, d'un donjon ...

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

Disons que le héros est dans la salle A (en haut à gauche) et que son but (un prince en détresse?) Est dans la salle B (en bas à droite). Notre carte ne permet pas au héros de progresser vers son objectif.

Nous devons ajouter un passage ...

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

Là, bien mieux!

Règles

Un programme ou une fonction qui accepte une carte de donjon (composée de hachages et d'espaces, avec des lignes séparées par de nouveaux caractères de ligne).
Il produira une carte avec des points ajoutés pour indiquer les passages dans tous les espaces qui sont sur un chemin direct entre les caractères de l'espace.
Cela ne changera ni la longueur ni le nombre de lignes.
Les passages sont tous en ligne directe d'espaces en espaces.
- Les passages ne peuvent pas tourner dans les coins
- Ils ne seront pas entre les espaces et le bord de la carte.
Utilisez n'importe quelle langue.
Essayez d'effectuer la conversion dans le moins d'octets.
Si aucun passage ne peut être tracé, renvoyez la carte sans changement.
La carte doit toujours avoir des hachages sur tous les bords (vous n'avez pas besoin de gérer les espaces sur le bord).
Les cartes en entrée sont toujours rectangulaires, chaque ligne doit avoir la même largeur.

Cas de test

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

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

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

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

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

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

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

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

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

— AJFaraday
source

Puis-je utiliser des caractères différents de #et .?

— user202729

1

@ user202729 Non. C'était dans les règles depuis le début, et il y a déjà eu une réponse. Il vaut probablement mieux laisser les exigences cohérentes.

— AJFaraday

@ user202729 Le cas de test que vous avez suggéré est similaire à mon avant-dernier cas. Je pourrais l'ajouter la prochaine fois que je changerai la question, mais cela n'ajoute pas grand-chose.

— AJFaraday

... Je n'ai pas fait défiler vers le bas. Aucun problème.

— user202729

@ l4m2 Les mêmes règles s'appliquent, partout où il y a une ligne droite entre les pièces, c'est un passage. Une pièce en forme de U aurait donc un espace rempli de passages.

— AJFaraday

7

Gelée , 17 octets

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

Essayez-le en ligne!

Tricky -1 grâce à user202729 .

Explication:

ỴḲ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 le Outgolfer
source

2

Cela m'étonne toujours à quelle vitesse les gens peuvent relever ces défis, et en si peu de personnages.

— AJFaraday

@AJFaraday Eh bien, vous pouvez aussi en faire partie. :) Commencez simplement par les langages de golf basés sur la pile (par exemple CJam, 05AB1E) et continuez votre chemin à partir de là.

— Erik the Outgolfer le

Honnêtement, cela me semble bien au-delà de moi, mais j'aime voir comment le processus fonctionne.

— AJFaraday

7

Attendez, TNB est l'abréviation de «thé et biscuits»? Ou suis-je juste super-britannique en ce moment?

— AJFaraday

5

Une explication serait cool pour cette réponse.

— Tamás Sengel

5

Perl 5 `-p0` , 56 octets

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

Essayez-le en ligne!

— Ton Hospel
source

3

APL + WIN, 87 octets

Invite pour la matrice de caractères:

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

— Graham
source

3

Haskell , 209 165 162 octets.

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

Essayez-le en ligne!

Ce n'est pas la façon la plus efficace de le faire à Haskell, j'en suis sûr. ~~Il y a trop de parenthèses à mon goût mais je ne sais plus comment les supprimer.~~

— aoemica
source

2

Bienvenue sur le site! Vous pouvez réduire certaines des parenthèses en utilisant $( (k(take 2 c))devient (k$take 2 c)). Vous pouvez également utiliser !!0au lieu de headdans certains cas.

— Post Rock Garf Hunter

En fait, dans le cas particulier où (k(take 2 c))vous pouvez simplement supprimer les parenthèses externes, elles ne sont pas nécessaires. Mais dans le cas où drop(length(head d))vous pouvez toujours utiliser le $, le remplacer par drop(length$head d)(et même drop(length$d!!0)).

— Post Rock Garf Hunter

De plus, si vous utilisez à la kplace de, ++vous pouvez réduire considérablement la dernière ligne. k[' '<$k(take 2 c),'.'<$d!!0,drop(length$d!!0)$f$k$d].

— Post Rock Garf Hunter

Un dernier golf, la dernière ligne peut être remplacée par f b|(e:g:d@(h:_:_))<-group b=k[' '<$e++g,'.'<$h,drop(length h)$f$k d]|1>0=' '<$b, cela utilise une correspondance de motif pour faire beaucoup de travail lourd qui était fait auparavant.

— Post Rock Garf Hunter

1

Merci pour le golf intensif @ user56656! Ungolfed J'avais f comme 2 fonctions et je les ai juste collées ensemble sans les optimiser dans leur ensemble. C'est une bonne chose à garder à l'esprit.

— aoemica

2

Python 2 , 173 148 octets

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)

Essayez-le en ligne!

— ovs
source

2

Retina 0.8.2 , 95 octets

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

Essayez-le en ligne! Explication:

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

Cela recherche les #signes qui sont au-dessus des espaces ou des .s et les transforme en points jusqu'à ce qu'il n'en reste plus. Le lookbehind trouve la #colonne de puis le lookahead passe à la ligne suivante et atomiquement à la même colonne ci-dessous afin que l'espace ou .ne puisse correspondre que s'il est exactement en dessous de la #.

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

Cela recherche les .s qui ne sont pas en dessous des espaces ou .s et les transforme en #s jusqu'à ce qu'il n'en reste plus. Le lookahead trouve la .colonne de et puis le lookbehind passe à la ligne précédente et atomiquement à la même colonne ci-dessus de la même manière de sorte que l'espace ou .ne peut correspondre que s'il est exactement au-dessus de la #. Un lookbehind négatif est utilisé afin que cela fonctionne également pour .s dans la rangée supérieure.

 (\S+) 
 $.1$*.

(Notez l'espace de fin sur les deux lignes) Cela recherche simplement toutes les séries de caractères non blancs entre les espaces et garantit qu'ils sont tous .s.

— Neil
source

1

Rubis , 104 octets

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

Essayez-le en ligne!

Eh bien, ce n'est pas génial, mais au moins c'est compliqué. Je suis sûr que cela peut être amélioré.

— Réintégrer Monica - notmaynard
source

1

Stax , 19 octets

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

Exécuter et déboguer

— récursif
source

J'ai peur que votre lien de débogage affiche du code vierge.

— AJFaraday

@AJFaraday: Quel navigateur utilisez-vous? Cela fonctionne pour moi sur Chrome pour Windows.

— récursif

1

JavaScript (Node.js) , 205 193 190 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`
`

Essayez-le en ligne!

Commenté

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
source

Rejoignez les chambres

Règles

Cas de test

Gelée , 17 octets

Perl 5 -p0 , 56 octets

APL + WIN, 87 octets

Haskell , 209 165 162 octets.

Python 2 , 173 148 octets

Retina 0.8.2 , 95 octets

Rubis , 104 octets

Stax , 19 octets

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

Commenté

Perl 5 `-p0` , 56 octets