aussehen! Es ist ein ASCII-Labyrinth! Also Coolzors, Amazing Balls und so.

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

Aber, aber, aber ... es ist eine Qual herauszufinden, in welche Richtung alle Teile des Labyrinths gehen. Ich möchte nur das Layout zeichnen und das Labyrinth sooper kul machen, ohne viel Zeit.

Was wäre, wenn ich das einfach einzeichnen könnte ...

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

Das wäre sooo süß!

Die Regeln (weil Regeln cool sind):

• Schreiben Sie Code, um eine Zeichenfolge in ein ASCII-Labyrinth zu konvertieren und das Ergebnis auszugeben.
• Jedes Nicht-Leerzeichen wird als Wand gelesen.
• Jeder Wandcharakter entscheidet anhand seiner Nachbarn, welcher Charakter verwendet werden soll (nur in Nord-, Süd-, Ost- und Westrichtung).
  • Wenn ein Zeichen keine Nachbarn ohne Leerzeichen hat, ist dies ein Pluszeichen (+).
  • Wenn ein Zeichen Nachbarn in vertikaler (Nord-Süd) und horizontaler (Ost-West) Richtung hat, ist dies ein Pluszeichen (+).
  • Wenn ein Zeichen nur in vertikaler Richtung (Nord-Süd) Nachbarn hat, ist dies ein Pipe-Symbol (|).
  • Wenn ein Zeichen nur in horizontaler (Ost-West-) Richtung Nachbarn hat, ist dies ein Minuszeichen (-).
• Die Eingabe kann eine einzelne Zeichenfolge sein (mit durch Zeilenumbrüche getrennten Zeilen oder ein Array von Zeichenfolgen).
• Alle eingegebenen Zeichen sind druckbare ASCII-Zeichen. Erweiterte Zeichensätze sind nicht erforderlich.
• Verwenden Sie eine beliebige alte Sprache.
• Befindet sich vor einer Zeile ein Leerraum, sollte dieser in jeder Zeile gleich groß sein. Alle Leerzeichen nach jeder Ausgabezeile sind in Ordnung.
• Versuchen Sie es mit der kleinsten Anzahl von Bytes zu lösen.

Testfälle:

1: Frame

Eingang:

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

Ausgabe:

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

2: Klassisches Labyrinth

Eingang:

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

Ausgabe:

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

3: Grüne Eier, Mann.

Eingang:

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!

Ausgabe:

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

4: Eiszapfen

Eingang:

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

Ausgabe:

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

APL (Dyalog Unicode) , 57 35 Bytes ^SBCS

–22 dank einer neuartigen lösung von ngn .

Anonyme implizite Funktion, die eine Zeichenmatrix als Argument verwendet.

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

Probieren Sie es online!

{Wenden Sie }⌺3 3 auf jede 3-mal-3-Nachbarschaft die folgende Funktion an:

 ,⍵ Ravel (Abflachen)

 ' '≠ Boolescher Wert ohne Leerzeichen

 ⍱∘⌽⍨ dass NOR ist es umgekehrt (inkl. weder oben noch unten, weder links noch rechts)

 5 4 2⊃¨⊂Wähle das ^fünfte , ^vierte und ^zweite Element aus der gesamten Liste,
  dh leeres Selbst, keine Vertikale, keine Horizontale

 2⊥
  bewerte  in der Basis 2 (binär) dh ≥4: leeres Selbst; 3: keine Nachbarn; 2: keine horizontalen Nachbarn; 1: keine Vertikale; 0: hat beides

 '+-|+'↓⍨ lösche so viele Elemente aus dieser Zeichenkette,
  dh leeres Selbst :; allein +:; vertikale Nachbarn (e): |+; horizontal -|+:; beide:+-|+

 ⊃ wähle das erste Element (Pad mit Leerzeichen, falls nicht vorhanden)
  dh leeres Selbst :; allein +:; vertikale Nachbarn (e): |; horizontal -:; beide:+

Alte Lösung

Anonyme implizite Funktion, die eine Zeichenmatrix als Argument verwendet.

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

Probieren Sie es online!

{Wenden Sie }⌺3 3 auf jede 3-mal-3-Nachbarschaft die folgende Funktion an:

 ,⍵ Ravel (Abflachen)

 (… )/ Filtern mit folgender Maske:

  9⍴0 1 zyklisch [0,1]auf Länge 9 umformen (Auswahl von N, W, E, S)

 ' '≠ Boolescher Wert ohne Leerzeichen

 1⌽ einen Schritt nach links drehen; [W,E,S,N]

 2 2⍴ umformen in 2-mal-2-Matrix; [[W,E],[S,N]]

 ∨/ zeilenweise ODER Reduzierung: [horizontal,vertical]

 (… ) Wenden folgende stillschweigende Funktion an:

  ⊢ Die Identität; [horizontal,vertical]

  ∧/, davor UND-Verknüpfung; [both,horizontal,vertical]

 (… ), Folgendes voranstellen:

  ,⍵ die Nachbarschaft verwirren

  5⊃ wählt das 5 ^th Element (selbst)

  ' '= Boolean if space (dh leer)

 Jetzt haben wir [empty,both,horizontal,vertical]

 1⍳⍨ Index ganz links 1 (gibt 5, wenn überhaupt keine Nachbarn)

 ' +-|+'⊃⍨ Verwenden Sie das, um ein Symbol auszuwählen

JavaScript (ES6), 110 Byte

E / A-Format: Array von Zeichenfolgen.

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

Probieren Sie es online!

Oder 108 Bytes, indem stattdessen eine Zeichenmatrix verwendet wird.

Python 2 , 181 168 Bytes

Danke an Leaky Nun für -13 Bytes

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

Probieren Sie es online!

MATLAB, 113 110 101 Bytes

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)

Konvertiert Eingaben in logische Werte, wendet Faltungen in horizontaler und vertikaler Richtung an und kombiniert die Ausgaben, um die entsprechenden Zeichen zu erstellen.

3 Bytes wurden von @Adriaan gespeichert, um mir mitzuteilen, dass Sie die Ausgabe in PPCG verstopfen können: P

9 Bytes gespart dank zahlreicher @flawr-Kommentare!

J , 49 47 Bytes

Danke an FrownyFrog für -2 Bytes!

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

Probieren Sie es online!

Retina 0,8,2 , 92 Bytes

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

Probieren Sie es online! Benötigt rechteckige Eingabe. Link enthält Testfälle. Erläuterung:

\S
0

Ändern Sie alle Nicht-Leerzeichen in 0s.

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

Suchen Sie nach allen 0s mit einem anderen 0unmittelbar darüber oder darunter in derselben Spalte und ändern Sie sie in eine 1. Die 1s sind jetzt die Orte mit vertikalen Nachbarn, während die 0s keine vertikalen Nachbarn haben.

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

Suchen Sie nach allen Ziffern ohne horizontale Nachbarn. Die 0s haben auch keine vertikalen Nachbarn, also werden sie zu +s, während die 1s vertikale Nachbarn haben, also werden sie zu |s.

T`d`-+

Die restlichen Ziffern haben horizontale Nachbarn. Die 1s haben auch vertikale Nachbarn, so dass sie zu +s werden, während die 0s nur horizontale Nachbarn haben, so dass sie zu -s werden.

Python 3 , 336 Bytes

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)

Probieren Sie es online!

Ich musste viel Code verwenden, um mit Randfallfehlern umzugehen.

C (gcc) 143 Bytes

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);}}

Probieren Sie es online!

Die Funktion f ändert ein Array von Strings an Ort und Stelle. Der Bereich um das Array muss mit Leerzeichen aufgefüllt werden (etwas eingeschränkt). Auch wenn dies nicht genau den Anforderungen entspricht, die die meisten Lösungen verwenden, entspricht es den Regeln, wenn wir sagen, dass wir eine Newline mit zwei Leerzeichen darstellen (und eine Reihe von Strings verwenden, die in Newlines enden).

Ungolfed

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 = '+';
                }
            }
        }
    }
}

Dies war eine lustige Herausforderung der Zeigerarithmetik. Mit der C-Zeiger-Iteration ist es einfach, die horizontalen Nachbarn zu ermitteln, aber die vertikalen waren härter. Glücklicherweise ist der y-Zeiger immer noch in der Nähe (was auf den Anfangswert von z zeigt), sodass ich meinen Index daraus ableiten und damit auf dasselbe Element in einer anderen Zeile zugreifen kann. Es fühlte sich sehr falsch an zu schreiben, y[-1][z-*y]da es jedem vernünftigen Stil widerspricht!