Setiap programmer tahu bahwa persegi panjang □benar-benar menyenangkan. Untuk memperburuk kesenangan ini, diagram lucu dan kabur ini dapat diubah menjadi kelompok kurung terjalin.

Tantangan ini adalah kebalikan dari saya sebelumnya .

Katakanlah Anda memiliki sekelompok persegi panjang yang saling terkait seperti:

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

Catatan tambahan:

• Tidak ada dua +s yang akan berdekatan
• Tidak ada dua persegi panjang yang akan berbagi tepi atau sudut
• Hanya akan ada paling banyak satu tepi vertikal di setiap kolom

Langkah pertama adalah melihat ujung paling kiri dari setiap persegi panjang. Tetapkan salah satu dari empat jenis braket ({[<. Saya memilih [.

   +------------+
   |            |
[--+-]     +----+-+
[  | ]     |    | |
[  | ] +---+--+ | |
[  | ] |   |  | | |
[--+-] | +-+--+-+-+-+
   |   | | |  | | | |
   |   | | |  | | | |
   |   | | |  | | | |    +-+
   |   +-+-+--+ | | |    | |
   |     | |    | | |  +-+-+-+
   +-----+-+----+ | |  | | | |
         | |      | |  | +-+ |
         | +------+ |  |     |
         |          |  |     |
         +----------+  +-----+

Sekarang lihat kotak paling kiri kedua. Karena tumpang tindih [persegi panjang, itu harus dari jenis yang berbeda. Saya memilih (.

   (------------)
   (            )
[--(-]     +----)-+
[  ( ]     |    ) |
[  ( ] +---+--+ ) |
[  ( ] |   |  | ) |
[--(-] | +-+--+-)-+-+
   (   | | |  | ) | |
   (   | | |  | ) | |
   (   | | |  | ) | |    +-+
   (   +-+-+--+ ) | |    | |
   (     | |    ) | |  +-+-+-+
   (-----+-+----) | |  | | | |
         | |      | |  | +-+ |
         | +------+ |  |     |
         |          |  |     |
         +----------+  +-----+

Kotak paling kiri berikutnya tidak bersinggungan dengan kotak sebelumnya, tetapi bersarang di kotak sebelumnya. Saya memilih untuk menetapkannya (lagi. Biasanya merupakan dugaan yang baik untuk menetapkan sebuah persegi panjang dengan tipe yang sama dengan apa yang bersarang di dalamnya jika memungkinkan, tetapi kadang-kadang diperlukan backtracking.

   (------------)
   (            )
[--(-]     +----)-+
[  ( ]     |    ) |
[  ( ] (---+--) ) |
[  ( ] (   |  ) ) |
[--(-] ( +-+--)-)-+-+
   (   ( | |  ) ) | |
   (   ( | |  ) ) | |
   (   ( | |  ) ) | |    +-+
   (   (-+-+--) ) | |    | |
   (     | |    ) | |  +-+-+-+
   (-----+-+----) | |  | | | |
         | |      | |  | +-+ |
         | +------+ |  |     |
         |          |  |     |
         +----------+  +-----+

Persegi panjang berikutnya ini dapat ditugaskan [lagi.

   (------------)
   (            )
[--(-]     +----)-+
[  ( ]     |    ) |
[  ( ] (---+--) ) |
[  ( ] (   |  ) ) |
[--(-] ( [-+--)-)-+-]
   (   ( [ |  ) ) | ]
   (   ( [ |  ) ) | ]
   (   ( [ |  ) ) | ]    +-+
   (   (-[-+--) ) | ]    | |
   (     [ |    ) | ]  +-+-+-+
   (-----[-+----) | ]  | | | |
         [ |      | ]  | +-+ |
         [ +------+ ]  |     |
         [          ]  |     |
         [----------]  +-----+

Persegi panjang berikutnya ini agak menyenangkan. Itu memotong a (dan [persegi panjang, jadi saya bisa menyebutnya {persegi panjang (atau <tapi tidak ada yang suka itu).

   (------------)
   (            )
[--(-]     {----)-}
[  ( ]     {    ) }
[  ( ] (---{--) ) }
[  ( ] (   {  ) ) }
[--(-] ( [-{--)-)-}-]
   (   ( [ {  ) ) } ]
   (   ( [ {  ) ) } ]
   (   ( [ {  ) ) } ]    +-+
   (   (-[-{--) ) } ]    | |
   (     [ {    ) } ]  +-+-+-+
   (-----[-{----) } ]  | | | |
         [ {      } ]  | +-+ |
         [ {------} ]  |     |
         [          ]  |     |
         [----------]  +-----+

Dua persegi panjang terakhir tidak terlalu buruk. Mereka bisa dari dua jenis yang berbeda.

   (------------)
   (            )
[--(-]     {----)-}
[  ( ]     {    ) }
[  ( ] (---{--) ) }
[  ( ] (   {  ) ) }
[--(-] ( [-{--)-)-}-]
   (   ( [ {  ) ) } ]
   (   ( [ {  ) ) } ]
   (   ( [ {  ) ) } ]    {-}
   (   (-[-{--) ) } ]    { }
   (     [ {    ) } ]  <-{-}->
   (-----[-{----) } ]  < { } >
         [ {      } ]  < {-} >
         [ {------} ]  <     >
         [          ]  <     >
         [----------]  <----->

Membacanya dari segi empat, saya mengerti [(]([{))}]<{}>. Ini akan menjadi salah satu kemungkinan output untuk input di atas. Berikut daftar banyak opsi yang mungkin, tidak lengkap:

[(]([{))}]<{}>
<(>(<{))}>{()}
{<}[{(]>)}[<>]
any of the 4! permutations of ([{<, you get the idea...

Memasukkan

ASCII-art empat persegi panjang, dengan asumsi bahwa mereka tidak ambigu (lihat catatan di atas) dan dapat dengan benar dikonversi menjadi string kurung. Anda dapat mengasumsikan tidak ada spasi tambahan atau empuk ke persegi panjang, dengan baris tambahan opsional. Tidak akan ada spasi putih terkemuka.

Keluaran

Salah satu string braket yang valid yang mematuhi batasan persimpangan persegi panjang. Selain garis tambahan opsional, tidak boleh ada karakter lain selain tanda kurung. Aturan utamanya adalah, jika dua kotak berpotongan, maka mereka harus diberi jenis braket yang berbeda.

Tujuan

Ini adalah kode-golf, (kurangnya) kuantitas melebihi kualitas.

Python 3, 519 byte

def c(i):
 a,b,c,d={},0,[],{}
 for e in map("".join,zip(*i.split("\n"))):
  if"+"in e:
   f=e.index("+"),e.rindex("+")
   if f in a:j=a.pop(f);d[j]=f+(d[j],len(c));c.append(j)
   else:a[f]=b;d[b]=len(c);c.append(b);b+=1
 g,h={},0
 while d:
  i={list(d)[0]};
  for j,(k,l,m,n)in d.items():
   for(o,p,q,r)in(d[v]for v in i):
    if not(m>r or n<q or k>p or l<o or(q<m<n<r and o<k>l<p)):break
   else:i.add(j)
  for j in i:del d[j];g[j]=h
  h+=1
 s,u=set(),""
 for t in c:u+="[{(<]})>"[g[t]+4*(t in s)];s.add(t)
 return u

Inilah upaya pertama untuk sebuah solusi. Algoritma yang digunakan murni melihat sudut-sudut dalam diagram, menyalahgunakan fakta hanya satu garis vertikal dapat terjadi dalam kolom, dan oleh karena itu + pertama dan terakhir dalam kolom harus menjadi sudut-sudut persegi panjang. Kemudian mengumpulkan semua persegi panjang dan melakukan pencarian naif (dan agak tidak deterministik) untuk kelompok tanpa tabrakan. Saya tidak yakin apakah ini akan selalu menemukan solusi yang paling optimal, tetapi ini berhasil untuk semua contoh yang saya coba sejauh ini. Atau bisa juga diganti dengan pencarian brute-force untuk jumlah kelompok yang paling sedikit.

Input: string yang berisi seni ascii. Tidak ada baris baru, dan semua baris harus diisi dengan panjang yang sama menggunakan spasi. Ini juga benar-benar baik-baik saja dengan Anda tidak menempatkan salah satu atau -'s di sana karena hanya melihat sudut.

Karena golf sangat sederhana (hanya minimisasi spasi putih dan penggantian nama variabel sebagian besar) mungkin bisa lebih pendek, tetapi karena tidak ada jawaban lain tentang ini, namun saya akan membiarkannya seperti ini untuk saat ini.