ASCII Maze Rendering 3000

43

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:
 # #
# #
 # #
# #

Hiatsu
la source
L'entrée / sortie peut-elle être une liste de chaînes?
Nick Kennedy
@ Nick oui. C'est ce que je voulais dire par matrice de caractères.
Hiatsu
super voulais juste clarifier!
Nick Kennedy
1
J'aime vraiment ce défi! Juste curieux, pourquoi faire comme ça et ne pas produire le labyrinthe 3D?
AJFaraday
@AJFaraday Produire le labyrinthe (et plus) a déjà été fait dans le défi que j'ai lié.
Hiatsu

Réponses:

30

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.

Xnor
la source
Cette. Est. IMPRESSIONNANT.
connectyourcharger
19

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

tsh
la source
très belle idée
Jonah
5

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
Nick Kennedy
la source
5

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.

Grimmy
la source
1
24 octets : ε'\¢„ #sè}àðм€g„ #sè
Kevin Cruijssen le
Wow, belle trouvaille! Voir la réponse pour d'autres améliorations. PS: Je suis confus quant à la différence entre мet K.
Grimmy
3

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.

Neil
la source
2

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
AZTECCO
la source