Regardez! C'est un labyrinthe ASCII! Soo coolzors, amazeballs et tout ça.

+-+-----+---+
| |     |   |
| |  ++   | |
| |  ++ +-+ |
|       |   |
+-------+ | |
|         | |
+---------+-+

Mais, mais, mais ... c'est pénible de savoir dans quelle direction vont toutes les parties du labyrinthe. Je veux juste dessiner la mise en page et le labyrinthe se fait kul sans trop de temps.

Et si je pouvais juste dessiner ça ...

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

Ce serait tellement doux!

Les règles (Parce que les règles sont cool):

• Écrivez du code pour convertir une chaîne en un labyrinthe ascii et affichez le résultat.
• Tout caractère non blanc sera lu comme un mur.
• Chaque personnage du mur décidera quel personnage doit être basé sur ses voisins (uniquement dans les directions Nord, Sud, Est et Ouest).
  • Si un caractère n'a pas de voisins non blancs, ce sera un signe plus (+).
  • Si un omble chevalier a des voisins dans les directions verticale (Nord-Sud) et horizontale (Est-Ouest), ce sera un signe plus (+).
  • Si un caractère a des voisins uniquement dans une direction verticale (Nord-Sud), ce sera un symbole de tuyau (|).
  • Si un omble chevalier n'a de voisins que dans une direction horizontale (Est-Ouest), ce sera un signe moins (-).
• L'entrée peut être une seule chaîne (avec des lignes séparées par des caractères de nouvelle ligne ou un tableau de chaînes).
• Tous les caractères saisis seront des caractères ASCII imprimables, vous n'avez pas besoin de gérer les jeux de caractères étendus.
• Utilisez n'importe quelle langue ancienne qui vous plaît.
• S'il y a un espace blanc avant une ligne, il doit être identique sur chaque ligne. Tout espace blanc après chaque ligne de sortie est correct.
• Essayez de le résoudre avec le plus petit nombre d'octets.

Cas de test:

1: cadre

Contribution:

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

Production:

+--------+
|        |
|        |
|        |
+--------+

2: Labyrinthe classique

Contribution:

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

Production:

--------+-------+
        |       |
| --+-+ | ----+ |
|   | | |     | |
| + | | +---- | |
|   | |       | | 
+-- | +----+- | |
|   | |    |  | | 
| --+ | ++ | -+
|     | ++    |  
+-----+-++----+--

3: Oeufs verts, mec.

Contribution:

I do not like green eggs and ham.
I do not like them, sam I am.
Would you like them here or there?
I would not like them anywhere!

Production:

| ++ +++ ++++ +++++ +++- -++ ----
| ++ +++ ++++ +++++ +++ + +++
+-+++ +++ ++++ ++++ ++++ ++ +++---
| +++-+ +++ ++++ ++-+ +++++++++

4: Glaçons

Contribution:

Word Icicle!
Word Icicle 
Word  cicle 
 ord  cicle 
 ord   icle 
 ord   i le 
 or    i le 
 or    i l  
 or      l  
 or         
  r         

Production:

++++ ++++++-
++++ ++++++ 
++++  +++++ 
 +++  +++++ 
 +++   ++++ 
 +++   | ++ 
 ++    | ++ 
 ++    | |  
 ++      |  
 ++         
  |         

APL (Dyalog Unicode) , 57 35 octets ^SBCS

–22 grâce à une nouvelle solution de ngn .

Fonction tacite anonyme prenant comme argument une matrice de caractères.

{⊃'+-|+'↓⍨2⊥5 4 2⊃¨⊂⍱∘⌽⍨' '≠,⍵}⌺3 3

Essayez-le en ligne!

{… }⌺3 3 Sur chaque quartier 3 par 3, appliquez la fonction suivante:

 ,⍵ défiler (aplatir)

 ' '≠ Booléen où non-espace

 ⍱∘⌽⍨ que NON c'est inversé (incl. ni haut NI bas, ni gauche NI droite)

 5 4 2⊃¨⊂choisissez le 5 ^e , le 4 ^e et le 2 ^e élément de cette liste entière,
  c.-à-d. vide libre, pas vertical, pas horizontal

 2⊥ évaluer en base 2 (binaire)
  ie ≥4: soi vide; 3: aucun voisin; 2: aucun voisin horizontal; 1: pas de vertical; 0: a les deux

 '+-|+'↓⍨ supprimez autant d'éléments de cette chaîne,
  c'est-à-dire vide self :; seul +:; voisin (s) vertical (s) seulement |+:; horizontal -|+:; tous les deux:+-|+

 ⊃ choisissez le premier élément (pad avec espace si non disponible)
  c'est-à-dire vide auto :; seul +:; voisin (s) vertical (s) seulement |:; horizontal -:; tous les deux:+

Ancienne solution

Fonction tacite anonyme prenant comme argument une matrice de caractères.

{' +-|+'⊃⍨1⍳⍨(' '=5⊃,⍵),(∧/,⊢)∨/2 2⍴1⌽' '≠(9⍴0 1)/,⍵}⌺3 3

Essayez-le en ligne!

{… }⌺3 3 Sur chaque quartier 3 par 3, appliquez la fonction suivante:

 ,⍵ défiler (aplatir)

 (… )/ Filtre à l'aide du masque suivant:

  9⍴0 1 remodeler cycliquement [0,1]à la longueur 9 (sélectionne N, W, E, S)

 ' '≠ Booléen où non-espace

 1⌽ tourner d'un pas vers la gauche; [W,E,S,N]

 2 2⍴ remodeler en matrice 2 par 2; [[W,E],[S,N]]

 ∨/ réduction OU par ligne: [horizontal,vertical]

 (… ) Appliquez la fonction tacite suivante:

  ⊢ l'identité; [horizontal,vertical]

  ∧/, précédé de sa réduction ET; [both,horizontal,vertical]

 (… ), Ajoutez ce qui suit:

  ,⍵ défoncer (aplatir) le quartier

  5⊃ choisissez le 5 ^ème élément (lui-même)

  ' '= Booléen si espace (c'est-à-dire vide)

 Maintenant nous avons [empty,both,horizontal,vertical]

 1⍳⍨ indice de 1 le plus à gauche (donne 5 si aucun voisin du tout)

 ' +-|+'⊃⍨ utiliser cela pour choisir le symbole

JavaScript (ES6), 110 octets

Format d'E / S: tableau de chaînes.

a=>a.map((s,y)=>s.replace(/\S/g,(_,x)=>'+|-+'[[-1,p=0,1,2].map(c=>p|=(a[y+c%2]||0)[x+~-c%2]>' '?c&1||2:0)|p]))

Essayez-le en ligne!

Ou 108 octets en utilisant une matrice de caractères à la place.

Python 2 , 181 168 octets

merci à Leaky Nun pour -13 octets

m=input()
f=lambda x,y:(['']+m+[''])[y+1][x:x+1]>' '
print[[(c<'!')*' 'or'+-|+'[f(x+1,y)|f(x-1,y)|2*f(x,y+1)|2*f(x,y-1)]for x,c in enumerate(r)]for y,r in enumerate(m)]

Essayez-le en ligne!

MATLAB, 113 110 101 octets

function F(A)
B=A>32
c=[1 1 1]
f=@(c)conv2(B,c,'s')>1
h=f(c)
v=f(c')
char((13*h+92*v-94*(h&v)).*B+32)

Convertit l'entrée en logique, applique une convolution horizontale et verticale et combine les sorties pour créer les caractères correspondants.

3 octets enregistrés par @Adriaan pour m'avoir dit que vous pouvez obstruer la sortie dans PPCG: P

9 octets économisés grâce aux nombreux commentaires @flawr!

J , 49 47 octets

Merci à FrownyFrog pour -2 octets!

' +|-+'{~~:&' '*1+h&.|:+2*h=:g&.|.*g=:' '=#{.}.

Essayez-le en ligne!

Retina 0.8.2 , 92 octets

\S
0
(?<=(.)*)0(?=(?>.*\n(?<-1>.)*)0)|0(?=(.)*)(?<=0(?>(?<-2>.)*\n.*))
1
T`d`+|`\b.\b
T`d`-+

Essayez-le en ligne! Nécessite une entrée rectangulaire. Le lien inclut des cas de test. Explication:

\S
0

Remplacez tous les non-espaces par 0s.

(?<=(.)*)0(?=(?>.*\n(?<-1>.)*)0)|0(?=(.)*)(?<=0(?>(?<-2>.)*\n.*))
1

Recherchez tous les 0s avec un autre 0immédiatement au-dessus ou en dessous dans la même colonne et changez-les en 1. Les 1s sont maintenant les endroits avec des voisins verticaux, tandis que les 0s n'ont pas de voisins verticaux.

T`d`+|`\b.\b

Recherchez tous les chiffres sans voisins horizontaux. Les 0s n'ont pas non plus de voisins verticaux, ils deviennent donc +s, tandis que les 1s ont des voisins verticaux, ils deviennent donc |s.

T`d`-+

Les chiffres restants ont des voisins horizontaux. Les 1s ont aussi des voisins verticaux, donc ils deviennent +s, tandis que les 0s n'ont que des voisins horizontaux, donc ils deviennent -s.

Python 3 , 336 octets

def g(s):
 h,j,s=' +|-+','',s.splitlines()
 s+=['']
 for n in range(len(s)):
  s[n]+=' '
  for i in range(len(s[n])-1):
   l,r,k=s[n][i-1],s[n][i+1],0
   try:u=s[n-1][i]
   except:u=' '
   try:d=s[n+1][i]
   except:d=' '
   if not s[n][i]==' ':
    k+=1
    if not u==d==' ':k+=1
    if not l==r==' ':k+=2
   j+=h[k]
  j+='\n'
 print(j)

Essayez-le en ligne!

J'ai dû utiliser beaucoup de code pour traiter les erreurs de cas de bord.

C (gcc) , 143 octets

char**y,*z,h,v;f(char**x){for(y=x;*y;++y)for(z=*y;*z;++z)if(*z-32){h=z[1]-32|z[-1]-32;v=y[1][z-*y]-32|y[-1][z-*y]-32;*z=h?v?43:45:(v?'|':43);}}

Essayez-le en ligne!

La fonction f modifie un tableau de chaînes en place. La zone autour du tableau doit être complétée par des espaces (un peu contraints). Même si cela ne répond pas exactement aux exigences que la plupart des solutions utilisent, il est conforme aux règles si nous disons que nous représentons une nouvelle ligne avec deux espaces (et prenons un tableau de chaînes se terminant par des nouvelles lignes).

Non golfé

f(char**x){
    char **y;
    for (y = x; *y; ++y) {
        char *z;
        for (z = *y; *z; ++z) {
            if (*z != ' ') {
                if (z[1] != ' ' || z[-1] != ' ') {
                    // Horizontal exists
                    if (y[1][z-*y] != ' ' || y[-1][z-*y] != ' ')
                        // Vertical exists
                        *z = '+';
                    else
                        *z = '-';
                } else {
                    // Horizontal doesn't exist
                    if (y[1][z-*y] != ' ' || y[-1][z-*y] != ' ')
                        // Vertical exists
                        *z = '|';
                    else
                        *z = '+';
                }
            }
        }
    }
}

C'était un défi amusant de l'arithmétique des pointeurs. En utilisant l'itération du pointeur de style C, il est facile d'obtenir les voisins horizontaux, mais les verticaux étaient plus difficiles. Heureusement, le pointeur y est toujours là (ce qui pointe vers la valeur initiale de z), donc je peux en déduire mon index et l'utiliser pour accéder au même élément sur une ligne différente. Cela semblait très mal d'écrire y[-1][z-*y]car il va à l'encontre de tout style raisonnable!