Non mi piace scrivere, quindi disegno i miei labirinti in un formato molto semplice:

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

Non è un labirinto ? Certo, penso che tutti i labirinti dovrebbero apparire in 3d, simili ma non uguali a quelli di questa sfida , per la massima meraviglia del labirinto , quindi ho (a malincuore) aggiornato manualmente il labirinto in questo modo:

+-----+     +-----------------------------+
|\     \    |\                             \
+ \     \   + \                             \
 \ \     \   \ +-----------------------+     \
  \ \     \   \|                       |\     \
   \ \     \   +-----------------------+ \     \
    \ \     \     +-----------------+   \ \     \
     \ \     \    |\                 \   \ \     \
      \ \     \   + \                 \   \ \     \
       \ \     \   \ \     +-----+     \   \ \     \
        \ \     \   \ \     \    |\     \   \ \     \
         \ \     \   \ \     \---+ \     \   \ \     \
          \ \     \   \ +-----+   \ \     \   \ \     \
           \ \     \   \|     |    \ \     \   \ \     \
            \ \     \   +-----+     \ \     \   \ \     \
             \ \     +-----------------+     \   \ \     \
              \ \                             \   \ \     \
               \ \                             \   \ \     \
                \ +-----------------------------+   \ +-----+
                 \|                             |    \|     |
                  +-----------------------------+     +-----+

Sfortunatamente, è difficile lavorare con labirinti in quel formato, e dopo tutto quel tipo di digitazione manuale, non voglio solo riscrivere l'originale, quindi ho bisogno che tu scriva un programma per fare l'inversione per me.

Regole

• Ingresso sarà una matrice o stringa di caratteri multilinea costituito solo " ", "|", "\", "+", "-"e ritorni a capo.
• L'output consiste " "e "#", nello schema descritto dal labirinto.
• Grazie alle mie incredibili capacità di progettazione del labirinto, non puoi assumere nulla sulla struttura del labirinto, a parte questo ha una decostruzione valida.
• Nella 3d-ification, (il processo che ora devi annullare), ognuno è #stato convertito in questo blocco di caratteri 3x4x7:

  +-----+
  |\     \
  + \     \
   \ +-----+
    \|     |
     +-----+
  

• I blocchi adiacenti sono stati uniti insieme, in questo modo:

  +-----+-----+
  |\     \     \
  + \     \     \
   \ +-----+-----+
    \|\     \     \
     + \     \     \
      \ +-----+-----+
       \|     |     |
        +-----+-----+
  

  ma senza unire le linee, quindi in realtà sembra così:

  +-----------+
  |\           \
  + \           \
   \ \           \
    \ \           \
     \ \           \
      \ +-----------+
       \|           |
        +-----------+
  

• Gli spazi concavi a volte bloccano parti di altri muri.

  +-----------+
  |\           \
  + \           \
   \ \     +-----+
    \ \     \    |
     \ \     \---+
      \ +-----+
       \|     |
        +-----+
  

• Lo spazio bianco finale nell'input o nell'output è accettabile. (È necessario specificare se la risposta richiede spazi vuoti finali nell'input.)
• Gli spazi bianchi iniziali devono corrispondere a spazi vuoti nell'input.
• Non mi piace ancora digitare, quindi vince il codice più breve

Casi test:

Input:
+-----+     +-----------------------------+
|\     \    |\                             \
+ \     \   + \                             \
 \ \     \   \ +-----------------------+     \
  \ \     \   \|                       |\     \
   \ \     \   +-----------------------+ \     \
    \ \     \     +-----------------+   \ \     \
     \ \     \    |\                 \   \ \     \
      \ \     \   + \                 \   \ \     \
       \ \     \   \ \     +-----+     \   \ \     \
        \ \     \   \ \     \    |\     \   \ \     \
         \ \     \   \ \     \---+ \     \   \ \     \
          \ \     \   \ +-----+   \ \     \   \ \     \
           \ \     \   \|     |    \ \     \   \ \     \
            \ \     \   +-----+     \ \     \   \ \     \
             \ \     +-----------------+     \   \ \     \
              \ \                             \   \ \     \
               \ \                             \   \ \     \
                \ +-----------------------------+   \ +-----+
                 \|                             |    \|     |
                  +-----------------------------+     +-----+

Output:
# #####
#     #
# ### #
# # # #
#   # #
##### #

Input:
+-----+
|\     \
+ \     \
 \ +-----+
  \|     |
   +-----+

Output:
#

Input:
      +-----------------+
      |\                 \
      + \                 \
   +-----+     +-----+     +-----+
   |\           \    |\           \
   + \           \---+ \           \
    \ \     +-----+   \ +-----+     \
     \ \     \    |    \|     |\     \
      \ \     \---+     +-----+ \     \
       \ \     +-----+     +-----+     \
        \ \           \    |\           \
         \ \           \   + \           \
          \ +-----+     +-----+     +-----+
           \|     |\                 \    |
            +-----+ \                 \---+
                   \ +-----------------+
                    \|                 |
                     +-----------------+

Output:
 ###
## ##
#   #
## ##
 ###

Input:
+-----------------------------------------------------------------------------------------------------+
|\                                                                                                     \
+ \                                                                                                     \
 \ +-----------------------------------------------+     +-----------------------------------------+     \
  \|                                               |\     \                                        |\     \
   +-----------------------------------------------+ \     \---------------------------------------+ \     \
      +-----+     +-----------------------------+   \ \     \     +-----------------------------+   \ \     \
      |\     \    |\                             \   \ \     \    |\                             \   \ \     \
      + \     \   + \                             \   \ \     \   + \                             \   \ \     \
       \ \     \   \ +-----------+     +-----+     \   \ \     \   \ +-----------------------+     \   \ \     \
        \ \     \   \|           |\     \    |\     \   \ \     \   \|                       |\     \   \ \     \
         \ \     \   +-----------+ \     \---+ \     \   \ \     \   +-----------------------+ \     \   \ \     \
          \ \     \     +-----+   \ \     \   \ \     \   \ \     +-----------------------+   \ \     \   \ \     \
           \ \     \    |\     \   \ \     \   \ \     \   \ \                             \   \ \     \   \ \     \
            \ \     \   + \     \   \ \     \   \ \     \   \ \                             \   \ \     \   \ \     \
             \ \     \   \ +-----+   \ \     \   \ \     \   \ +-----------------------------+   \ \     \   \ \     \
              \ \     \   \|     |    \ \     \   \ \     \   \|                             |    \ \     \   \ \     \
               \ \     \   +-----+     \ \     \   \ \     \   +-----------------------------+     \ \     \   \ \     \
                \ \     +-----------+   \ \     \   \ \     +-----------------------------------+   \ \     \   \ \     \
                 \ \                 \   \ \     \   \ \                                         \   \ \     \   \ \     \
                  \ \                 \   \ \     \   \ \                                         \   \ \     \   \ \     \
                   \ \     +-----------+   \ \     \   \ \     +-----------------------+     +-----+   \ \     \   \ \     \
                    \ \     \          |    \ \     \   \ \     \                      |\     \    |    \ \     \   \ \     \
                     \ \     \---------+     \ \     \   \ \     \---------------------+ \     \---+     \ \     \   \ \     \
                      \ \     \     +-----------+     \   \ \     \     +-----------+   \ \     \     +-----+     \   \ +-----+
                       \ \     \    |\                 \   \ \     \    |\           \   \ \     \    |\           \   \|     | 
                        \ \     \   + \                 \   \ \     \   + \           \   \ \     \   + \           \   +-----+  
                         \ \     \   \ +-----------------+   \ \     \   \ \           \   \ +-----+   \ +-----+     \            
                          \ \     \   \|                 |    \ \     \   \ \           \   \|     |    \|     |\     \            
                           \ \     \   +-----------------+     \ \     \   \ \           \   +-----+     +-----+ \     \            
                            \ \     +-----------------------------+     +-----+           +-----------------------+     +-----------+
                             \ \                                                                                                     \
                              \ \                                                                                                     \
                               \ +-----------------------------------------------------------------------------------------------------+
                                \|                                                                                                     | 
                                 +-----------------------------------------------------------------------------------------------------+  

Output:
#################
        #       #
# ##### # ##### #
#   # # #     # #
# # # # ##### # #
#   # #       # # 
### # ####### # #
#   # #    #  # # 
# ### # ## # ##
#     # ##    #  
#################

Input:
+-----------------+
|\                 \
+ \                 \
 \ \                 \
  \ \                 \
   \ \                 \
    \ \                 \
     \ \                 \
      \ \                 \
       \ +-----------------+
        \|                 | 
         +-----------------+

Output:
###
###
###

Input: (Note leading whitespace)
      +-----+     +-----+
      |\     \    |\     \
      + \     \   + \     \
   +-----+-----+-----+-----+
   |\     \    |\     \    | 
   + \     \---+ \     \---+  
    \ +-----+-----+-----+-----+
     \|     |\     \    |\     \
      +-----+ \     \---+ \     \
         +-----+-----+-----+-----+
         |\     \    |\     \    | 
         + \     \---+ \     \---+  
          \ +-----+   \ +-----+      
           \|     |    \|     |       
            +-----+     +-----+        

Output:
 # #
# #
 # #
# #

Python 2 , 81 byte

def f(M,k=1,r='',b=0):
 for c in M[k][k::6]:b^=c>' ';r+=' #'[b]
 print r;f(M,k+3)

Provalo online!

Accetta input come un elenco di stringhe (o un elenco di elenchi di caratteri). Stampa l'output, terminando con errore.

L'idea è simile a quella di tsh . Osserviamo i caratteri contrassegnati come di ?seguito per vedere quali sono gli spazi e quali sono \:

+-----------+
|?     ?     ?
+ \           \
 \ \     +-----+
  \ ?     ?    |?
   \ \     \---+
    \ +-----+
     \|?    |?
      +-----+

All'interno di ogni riga con ?'s, un \segna una cresta verticale tra una cella piena e una cella vuota del labirinto. Perché queste creste sono nello strato superiore del labirinto, loro\ personaggi non sono mai oscurati da un altro elemento labirinto.

Per esaminare le ?posizioni, il codice scorre attraverso le righe k=1,4,7,...(indicizzate a zero) e in ogni riga osserva ogni 6a posizione a partire dalla posizione k. Tiene traccia se ci troviamo in una cella vuota o piena nel bit be lancia quel bit ogni volta che \viene rilevato un. Dopo aver letto ogni carattere, aggiunge il carattere per empty ( ) o full ( #) in base a be stampa la stringa risultante al termine della riga.

JavaScript (Node.js) , 85 byte

a=>a.flatMap(u=(l,y)=>y%3?[]:[l.flatMap((c,x)=>x<y|(x-=y+3)%6?[]:' #'[u[x]^=c+1<0])])

Provalo online!

$(6x+3y+3,3y)$- ), la cella corrente ha lo stesso valore.

Grazie @ Arnauld , salvato 7 byte

Gelatina , 22 20 byte

ṫ"J‘$m3n⁶m€6Ż^\ị⁾# Ḋ

Provalo online!

Un collegamento monadico che prende una stringa Jelly come input e restituisce il labirinto elaborato come una stringa Jelly che include una fila di spazi vuoti finali.

1 byte Ḋpotrebbe essere salvato se fosse accettabile una sola riga di spazio bianco iniziale.

Ha preso ispirazione dalla formula di @ tsh , quindi assicurati di votare anche quello!

Spiegazione

ṫ"  $                | Tail each string using a paired member of the following:
  J                  | - Sequence along the list of strings
   ‘                 | - Incremented by 1
     m3              | Take every 3rd string (1st, 4th, 7th, ...)
       n⁶            | Not equal to space character
         m€6         | Within each list take every 6th item (1st, 7th, ...)
            Ż        | Prepend a zero to the list
             ^\      | Reduce using xor, collecting up results; vectorised across lists (so starts with 0 xor first list, then output of that xor second list, and so on)
               ị⁾#   | Index into "#", " "
                   Ḋ | Remove first list

05AB1E , 25 22 byte

-1 byte grazie a Kevin Cruijssen

εN3%iN.$6ιнηðÊO„ #sèJ,

Provalo online!

Port of xnor's Python answer . Accetta input come matrice di caratteri. Il collegamento TIO mostra l'input come una stringa multilinea per la leggibilità, con l' |€Sintestazione che la converte nel formato della matrice di caratteri.

Retina 0.8.2 , 72 byte

¶(?<=(.|(¶))+)(?<-2>.)+
¶
-4G`
.+¶(.+)¶.+
$1
T` `#`\\  +\\
.(.)....|.
$1

Provalo online! Spiegazione:

¶(?<=(.|(¶))+)(?<-2>.)+
¶

Elimina tutte le linee.

-4G`

Elimina le ultime tre righe poiché non ne ho bisogno.

.+¶(.+)¶.+
$1

Mantieni solo il centro di ciascun gruppo di tre righe. (In Retina 1, credo che le due fasi precedenti possano essere eseguite in una sola fase:. ,G1,3,-5`)

T` `#`\\  +\\

Riempi le facce dei blocchi.

.(.)....|.
$1

Mantieni solo il secondo carattere di ciascun blocco.

C (clang) , 120 117 byte

o,c,t,s,r;f(char*m){for(s=o=0;*m;!r?t^=*m!=32,s=t?35:46:0)*++m==10?m-=~++o,c=t=0,s=10:0,r||printf(&s),r=c++%6|o%3-1;}

Provalo online!

Ispirato dalle altre risposte.

'\'=92   ' '=32=>46='.'  '#'=35   '\n'=10 
// o offset == // l line 
// c line counter 
// t toggle 
// r => ? test, point to inspect 
for(o=s=0;*m;
!r?t=*m-32?!t:t,s=t?35:46:0) // t^=*m!=32 @ceilingcat 
// if test(r) is enabled: toggle(t) and sets (s)

*++m==10?m-=~++o,c=t=0,s=10:0,
// next char => if it's \n overwrites (s)
// and increments offset(o) and move pointer(m)

r || printf (&s)
// r or print! Thanks to @ceilingcat
// instead of 
    *++m-10?0:(m-=~++o,c=t=0,s=10),
    !r*s?putchar(s):0, 
 Saved 5 !

r=c++%6|o%3-1;// enable test every 6 x 3+1 positions