Saya tidak suka mengetik, jadi saya menggambar labirin dalam format yang sangat sederhana:

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

Bukankah ini membingungkan ? Tentu saja, saya pikir semua labirin harus terlihat 3d, serupa tetapi tidak sama dengan tantangan ini , untuk labirin maksimum, jadi saya (enggan) secara manual memperbarui labirin agar terlihat seperti ini:

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

Sayangnya, sulit untuk bekerja dengan labirin dalam format itu, dan setelah semua itu mengetik manual, saya tidak ingin hanya mengetik ulang yang asli, jadi saya ingin Anda menulis sebuah program untuk melakukan pembalikan untuk saya.

Aturan

• Masukan akan menjadi string atau karakter matriks multiline hanya terdiri dari " ", "|", "\", "+", "-", dan baris baru.
• Output terdiri dari " "dan "#", dalam pola yang dijelaskan oleh labirin.
• Karena keterampilan merancang labirin yang luar biasa, Anda tidak dapat menganggap apa pun tentang struktur labirin, selain itu memiliki dekonstruksi yang valid.
• Dalam 3d-ification, (proses yang sekarang harus Anda batalkan,) masing #- masing dikonversi ke blok karakter 3x4x7 ini:

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

• Blok yang berdekatan digabungkan bersama, seperti ini:

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

  tetapi tanpa bergabung dengan garis, jadi itu benar-benar terlihat seperti ini:

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

• Ruang cekung terkadang menghalangi bagian dinding lainnya.

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

• Membuntuti spasi putih di input atau output dapat diterima. (Anda harus menentukan apakah jawaban Anda memerlukan spasi kosong di input.)
• Spasi terkemuka harus sesuai dengan spasi kosong di input.
• Saya masih tidak suka mengetik, jadi kode terpendek menang

Kasus uji:

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)

Cobalah online!

Mengambil input sebagai daftar string (atau daftar daftar karakter). Mencetak output, mengakhiri dengan kesalahan.

Idenya mirip dengan tsh . Kami melihat karakter yang ditandai seperti di ?bawah ini untuk melihat spasi dan mana yang \:

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

Di dalam setiap baris dengan ?'s, \menandai punggung bukit vertikal antara sel yang diisi dan sel kosong dari labirin. Karena punggungan ini berada di lapisan atas labirin, \karakter mereka tidak pernah dikaburkan oleh elemen labirin lainnya.

Untuk melihat ?posisi, kode ini berderet melalui baris k=1,4,7,...(indeks-nol), dan di setiap baris terlihat setiap posisi ke-6 dimulai dengan posisi k. Ini melacak apakah kita berada dalam sel kosong atau penuh dalam bit b, dan membalik bit itu setiap kali \ditemui. Setelah masing-masing karakter membaca, itu menambahkan karakter untuk kosong ( ) atau penuh ( #) sesuai dengan b, dan mencetak string yang dihasilkan setelah baris selesai.

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

Cobalah online!

Ide adalah: kita hanya peduli pada karakter pada . Jika itu adalah tanda hubung ( ), sel saat ini memiliki nilai yang berbeda dengan sel di atasnya, dan jika itu adalah spasi ( ), sel saat ini memiliki nilai yang sama.$(6x+3y+3,3y)$-

Terima kasih @ Arnauld , menyimpan 7 byte

Jelly , 22 20 byte

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

Cobalah online!

Tautan monadik yang mengambil string Jelly sebagai input dan mengembalikan labirin yang diproses sebagai string Jelly termasuk satu baris spasi spasi tambahan.

1 byte Ḋdapat disimpan jika satu baris spasi putih terkemuka dapat diterima.

Mengambil beberapa inspirasi dari formula @ tsh , jadi pastikan untuk menghapusnya juga!

Penjelasan

ṫ"  $                | 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 terima kasih kepada Kevin Cruijssen

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

Cobalah online!

Port jawaban Python xnor . Mengambil input sebagai matriks karakter. TIO link menunjukkan input sebagai string multiline untuk keterbacaan, dengan |€Sheader mengubahnya menjadi format matriks karakter.

Retina 0.8.2 , 72 byte

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

Cobalah online! Penjelasan:

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

Hapus semua garis.

-4G`

Hapus tiga baris terakhir karena saya tidak membutuhkannya.

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

Pertahankan hanya bagian tengah dari setiap kelompok yang terdiri dari tiga garis. (Dalam Retina 1, saya percaya dua tahap di atas dapat dilakukan dalam satu tahap:. ,G1,3,-5`)

T` `#`\\  +\\

Isi wajah balok.

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

Simpan hanya karakter kedua dari setiap blok.

C (dentang) , 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;}

Cobalah online!

Terinspirasi oleh jawaban yang lain.

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