Je n'aime pas taper, alors je dessine mes labyrinthes dans un format très simple:

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

N'est-ce pas un labyrinthe ? Bien sûr, je pense que tous les labyrinthes devraient ressembler à la 3D, mais ils ne ressemblent pas à ce défi , pour un maximum d' esprit labyrinthique . J'ai donc (à contrecoeur) mis à jour manuellement le labyrinthe pour qu'il ressemble à ceci:

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

Malheureusement, il est difficile de travailler avec des labyrinthes dans ce format, et après toute cette saisie manuelle, je ne veux pas simplement retaper l'original. J'ai donc besoin que vous écriviez un programme pour effectuer l'inversion à ma place.

Règles

• Entrée est une matrice de chaîne ou caractère multiligne constitué uniquement de " ", "|", "\", "+", "-", et les nouvelles lignes.
• La sortie consiste en " "et "#"dans le motif décrit par le labyrinthe.
• En raison de mes incroyables compétences en matière de conception de labyrinthe, vous ne pouvez rien présumer de la structure du labyrinthe, à part sa déconstruction valide.
• Dans la 3d-ification (le processus que vous devez maintenant annuler), chacun a #été converti en ce bloc de caractères 3x4x7:

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

• Les blocs adjacents ont été assemblés, comme ceci:

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

  mais sans joindre les lignes, il a donc l'aspect suivant:

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

• Les espaces concaves bloquent parfois des parties d'autres murs.

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

• Les espaces de fin en entrée ou en sortie sont acceptables. (Vous devez spécifier si votre réponse nécessite une fin d’espace dans l’entrée.)
• Les espaces de début doivent correspondre aux espaces vides de l’entrée.
• Je n'aime toujours pas taper, donc le code le plus court gagne

Cas de test:

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

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

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

Output:
#

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

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

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

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

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

Output:
###
###
###

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

Output:
 # #
# #
 # #
# #

Python 2 , 81 octets

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)

Essayez-le en ligne!

Prend la saisie comme une liste de chaînes (ou une liste de listes de caractères). Imprime la sortie en terminant par une erreur.

L'idée est similaire à celle de tsh . Nous regardons les caractères marqués ?ci-dessous pour voir quels sont les espaces et lesquels sont \:

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

Dans chaque ligne avec ?'s, a \marque une arête verticale entre une cellule remplie et une cellule vide du labyrinthe. Comme ces crêtes sont dans la couche supérieure du labyrinthe, leurs \personnages ne sont jamais masqués par un autre élément du labyrinthe.

Pour examiner les ?positions, le code parcourt des lignes k=1,4,7,...(index zéro), et chaque ligne examine chaque 6ème position en commençant par position k. Il surveille si nous sommes dans une cellule vide ou pleine dans le bit b, et retourne ce bit chaque fois que a \est rencontré. Après chaque caractère lu, il ajoute le caractère pour empty ( ) ou full ( #) en fonction de b, et affiche la chaîne résultante une fois la ligne terminée.

JavaScript (Node.js) , 85 octets

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

Essayez-le en ligne!

$(6x+3y+3,3y)$-

Merci @ Arnauld , enregistré 7 octets

Gelée , 22 à 20 octets

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

Essayez-le en ligne!

Un lien monadique prenant une chaîne Jelly en tant qu'entrée et renvoyant le labyrinthe traité sous forme d'une chaîne Jelly comprenant une ligne d'espaces de fin.

Un octet Ḋpeut être sauvegardé si une seule ligne d’espaces blancs est acceptable.

Vous vous êtes inspiré de la formule de @ tsh , assurez-vous de l'invoquer également!

Explication

ṫ"  $                | 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 octets

-1 octet grâce à Kevin Cruijssen

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

Essayez-le en ligne!

La réponse du port de xnor en python . Prend la saisie sous forme de matrice de caractères. Le lien TIO affiche l'entrée sous forme de chaîne multiligne pour la lisibilité, l'en- |€Stête étant convertie en format de matrice de caractères.

Retina 0.8.2 , 72 octets

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

Essayez-le en ligne! Explication:

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

Éliminez toutes les lignes.

-4G`

Supprimez les trois dernières lignes car je n'en ai pas besoin.

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

Ne conservez que le milieu de chaque groupe de trois lignes. (Dans Retina 1, je pense que les deux étapes ci-dessus peuvent être réalisées en une seule étape:. ,G1,3,-5`)

T` `#`\\  +\\

Remplissez les faces des blocs.

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

Ne conservez que le deuxième caractère de chaque bloc.

C (clang) , 120 117 octets

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

Essayez-le en ligne!

Inspiré par les réponses des autres.

'\'=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