रिवर्स इंजीनियर ब्रैकेट आयतों

Question

हर प्रोग्रामर जानता है कि आयतें □वास्तव में मज़ेदार हैं। इस मज़ा को तेज करने के लिए, इन प्यारे और फजी आरेखों को इंटरवॉवन ब्रैकेट के समूहों में बदल दिया जा सकता है।

यह चुनौती मेरे पूर्व का विलोम है ।

मान लें कि आपके पास इंटरलॉकिंग आयतों का एक समूह है जैसे:

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

अतिरिक्त नोट्स:

• कोई भी दो +एस कभी भी आसन्न नहीं होंगे
• कोई भी दो आयतें कभी एक किनारे या कोने को साझा नहीं करेंगी
• प्रत्येक स्तंभ में कभी-कभी केवल एक ऊर्ध्वाधर किनारे पर होगा

पहला कदम किसी भी आयत के बाएं-किनारे को देखना है। इसे चार ब्रैकेट प्रकारों में से एक को असाइन करें ({[<। मैं चुनता हूं [।

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

अब दूसरे बाएँ-सबसे आयत को देखें। चूंकि यह एक [आयत को ओवरलैप करता है , इसलिए यह एक अलग प्रकार का होना चाहिए। मैं चुनता हूं (।

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

अगली बाईं-सबसे आयत किसी भी पिछली आयत के साथ प्रतिच्छेद नहीं करती है, लेकिन पिछले के भीतर घोंसला बनाती है। मैं इसे (फिर से असाइन करने का चयन करता हूं । यह आम तौर पर एक आयत को उसी प्रकार असाइन करने के लिए एक अच्छा अनुमान है जो संभव हो तो अंदर घोंसला बना रहा है, लेकिन कभी-कभी बैकट्रैकिंग की आवश्यकता होती है।

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

यह अगली आयत [फिर से सौंपी जा सकती है ।

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

यह अगली आयत थोड़े मजेदार है। यह एक (और [आयत दोनों को प्रतिच्छेद करता है , इसलिए मैं इसे एक {आयत कह सकता हूं (या <कोई भी उन्हें पसंद नहीं करता है)।

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

पिछले दो आयतें इतनी बुरी नहीं हैं। वे किसी भी दो प्रकार के हो सकते हैं।

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

आयतों को पढ़कर, मैं समझ गया [(]([{))}]<{}>। यह उपरोक्त इनपुट के लिए एक संभावित आउटपुट होगा। यहां कई संभावित विकल्पों की सूची दी गई है, संपूर्ण नहीं:

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

इनपुट

ASCII- कला आयतें, इस धारणा पर कि वे असंदिग्ध हैं (ऊपर नोट देखें) और ठीक से कोष्ठक की एक स्ट्रिंग में परिवर्तित किया जा सकता है। आप वैकल्पिक अनुगामी न्यूलाइन के साथ या तो कोई अनुगामी स्थान या एक आयत को गद्देदार मान सकते हैं। कोई प्रमुख व्हाट्सएप नहीं होगा।

उत्पादन

मान्य ब्रैकेट स्ट्रिंग्स में से कोई भी जो आयतों के प्रतिच्छेदन प्रतिबंधों का पालन करता है। एक वैकल्पिक अनुगामी न्यूलाइन के अलावा, कोष्ठक के अलावा कोई अन्य वर्ण नहीं होना चाहिए। मुख्य नियम है, यदि दो वर्ग प्रतिच्छेद करते हैं, तो उन्हें अलग-अलग ब्रैकेट प्रकार सौंपे जाने चाहिए।

लक्ष्य

यह गुणवत्ता पर कोड-गोल्फ, (कमी) मात्रा है।

Comments

FYI करें "exacerbate" का अर्थ है "एक बुरी चीज़ को बदतर बनाना"।

— पॉल आर

@PaRR मुझे विश्वास है कि वह बिंदु था

— बिल्ली 16

ओह, ठीक है, जाहिर है जो भी बिंदु था वह सीधे मेरे सिर पर चला गया!

— पॉल आर।

क्या हम मान सकते हैं कि प्रत्येक आयत में कुछ ऊँचाई है? यानी यह +शीर्ष-बाएँ कोने के लिए नहीं हो सकता है , और फिर +नीचे-बाएँ कोने के लिए यह (तुरंत नीचे) है ?

— Tersosauros

Answer 1

पायथन 3, 519 बाइट्स

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

यहाँ एक समाधान पर पहला प्रयास है। एल्गोरिथ्म में शुद्ध रूप से प्रयुक्त एल्गोरिथ्म आरेख में कोनों को देखता है, इस तथ्य का दुरुपयोग करते हुए कि एक स्तंभ में केवल एक ऊर्ध्वाधर रेखा हो सकती है, और इसलिए एक स्तंभ में पहला और अंतिम + एक आयत के कोने होना चाहिए। यह तब सभी आयतों को इकट्ठा करता है और टकराव रहित समूहों के लिए एक भोले (और कुछ हद तक नॉन्डेटेरमिनिस्टिक) खोज करता है। मुझे यकीन नहीं है कि यह हमेशा सबसे इष्टतम समाधान मिलेगा, लेकिन यह उन सभी उदाहरणों के लिए काम करता है जो मैंने अब तक कोशिश की थी। वैकल्पिक रूप से इसे कम से कम समूहों के लिए एक क्रूर-बल खोज द्वारा प्रतिस्थापित किया जा सकता है।

इनपुट: एससीआई कला से युक्त एक स्ट्रिंग। कोई अनुगामी न्यूलाइन नहीं है, और सभी लाइनों को रिक्त स्थान का उपयोग करके समान लंबाई में पैड किया जाना चाहिए। यह भी पूरी तरह से ठीक है कि आप इसमें से कोई भी नहीं डाल रहे हैं। '

चूंकि गोल्फिंग काफी सरल है (ज्यादातर व्हाट्सएप मिनिमाइजेशन और वैरिएबल का नाम बदलकर ज्यादातर) यह शायद कम हो सकता है, लेकिन जैसा कि इस पर कोई अन्य उत्तर नहीं हैं, फिर भी मैं इसे अभी के लिए इस तरह छोड़ दूंगा।

Comments

आपको ईनाम मिलता है, क्योंकि मैं <1 दिन में कोई अन्य उत्तर नहीं देता। जवाब देने के लिए धन्यवाद, गोल्फिंग रखें!

— R