पृष्ठभूमि

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

इनपुट

आपका इनपुट किसी भी सुविधाजनक प्रारूप में डंडे की स्थिति का प्रतिनिधित्व करने वाले दो आयामी पूर्णांक निर्देशांक की एक सूची है। आप यह मान सकते हैं कि इसमें कोई डुप्लिकेट नहीं है, लेकिन आप इसके आदेश के बारे में कुछ भी नहीं मान सकते हैं।

ध्रुवों के बीच सीधी रेखाओं द्वारा बोर्ड का प्रतिनिधित्व किया जाता है, और सरलता के लिए, हम केवल क्षैतिज और ऊर्ध्वाधर बोर्डों पर विचार करते हैं। दो ध्रुवों को एक बोर्ड द्वारा जोड़ा जा सकता है यदि उनके बीच कोई अन्य खंभे या बोर्ड नहीं हैं, जिसका अर्थ है कि बोर्ड एक दूसरे को पार नहीं कर सकते हैं। ध्रुवों और बोर्डों की व्यवस्था अधिकतम होती है यदि इसमें कोई नया बोर्ड नहीं जोड़ा जा सकता है (समकक्ष, किसी भी दो क्षैतिज या लंबवत संरेखित ध्रुवों के बीच एक पोल या बोर्ड है)।

उत्पादन

आपका आउटपुट अधिकतम व्यवस्थाओं की संख्या है जो कि ध्रुवों का उपयोग करके बनाई जा सकती हैं।

उदाहरण

इनपुट सूची पर विचार करें

[(3,0),(1,1),(0,2),(-1,1),(-2,0),(-1,-1),(0,-2),(1,-1)]

ऊपर से देखने पर पोल की इसी व्यवस्था कुछ इस तरह दिखती है:

  o
 o o
o    o
 o o
  o

इन ध्रुवों का उपयोग करके बनाई जा सकने वाली तीन अधिकतम व्यवस्थाएँ हैं:

  o        o        o
 o-o      o|o      o-o
o----o   o||| o   o| | o
 o-o      o|o      o-o
  o        o        o

इस प्रकार सही उत्पादन होता है 3।

नियम

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

परीक्षण के मामलों

[] -> 1
[(0,0),(1,1),(2,2)] -> 1
[(0,0),(1,0),(2,0)] -> 1
[(0,0),(0,1),(1,0),(1,1)] -> 1
[(1,0),(0,1),(-1,0),(0,-1)] -> 2
[(3,0),(1,1),(0,2),(-1,1),(-2,0),(-1,-1),(0,-2),(1,-1)] -> 3
[(0,0),(4,0),(1,1),(1,-2),(3,1),(3,-2),(2,-1),(4,-1)] -> 3
[(0,0),(4,0),(1,1),(1,-2),(3,1),(3,-2),(2,-1),(4,-1),(0,-1)] -> 4
[(0,0),(4,0),(1,1),(1,-2),(3,1),(3,-2),(2,-1),(0,-1),(2,2)] -> 5
[(0,0),(4,0),(1,1),(1,-2),(3,1),(3,-2),(2,-1),(4,-1),(0,-1),(2,2)] -> 8

code-golf combinatorics graph-theory

— Zgarb
स्रोत

1

उदाहरण दो बार (-2,0) लगता है। क्या उनमें से एक (2,0) होना चाहिए?

— इसहाक

@isaacg वास्तव में, यह होना चाहिए (0,-2), अच्छी पकड़। अब बदल रहा है।

— 19

5

गणितज्ञ, 301 बाइट्स

(t~SetAttributes~Orderless;u=Subsets;c=Complement;l=Select;f=FreeQ;Count[s=List@@@l[t@@@u[Sort@l[Sort/@#~u~{2},!f[#-#2&@@#,0]&]//.{a___,{x_,y_},{x_,z_},b___,{y_,z_},c___}:>{a,{x,y},b,{y,z},c}],f[#,t[{{a_,b_},{a_,c_}},{{d_,e_},{f_,e_}},___]/;d<a<f&&b<e<c]&],l_/;f[s,k_List/;k~c~l!={}&&l~c~k=={},{1}]])&

यह एक अनाम फ़ंक्शन है जो निर्देशांक को नेस्टेड के रूप में लेता है Listऔर पूर्णांक देता है। यही है, आप या तो इसे एक नाम दे सकते हैं और इसे कॉल कर सकते हैं, या बस जोड़ सकते हैं

@ {{3, 0}, {1, 1}, {0, 2}, {-1, 1}, {-2, 0}, {-1, -1}, {0, -2}, {1, -1}}

इंडेंटेशन के साथ:

(
  t~SetAttributes~Orderless;
  u = Subsets;
  c = Complement;
  l = Select;
  f = FreeQ;
  Count[
    s = List @@@ l[
      t @@@ u[
        Sort @ l[
          Sort /@ #~u~{2}, 
          !f[# - #2 & @@ #, 0] &
        ] //. {a___, {x_, y_}, {x_, z_}, b___, {y_, z_}, c___} :> 
              {a, {x, y}, b, {y, z}, c}
      ],
      f[
        #,
        t[{{a_, b_}, {a_, c_}}, {{d_, e_}, {f_, e_}}, ___] 
          /; d < a < f && b < e < c
      ] &
    ], 
    l_ /; f[
      s, 
      k_List /; k~c~l != {} && l~c~k == {}, 
      {1}
    ]
  ]
) &

मैं यह भी व्यक्त करना शुरू नहीं कर सकता कि यह कार्यान्वयन कितना भोला है ... यह निश्चित रूप से अधिक क्रूर बल नहीं हो सकता ...

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

आश्चर्यजनक रूप से यह सभी परीक्षण मामलों को लगभग तुरंत हल करता है।

एक बहुत साफ सुथरी चाल जिसे मैंने इसके लिए खोजा Orderlessथा वह है मेरे द्वारा मैच किए जाने वाले पैटर्न की संख्या में कटौती करना। अनिवार्य रूप से, जब मैं क्रॉसिंग बाड़ के साथ बाड़ सेट करना चाहता हूं, तो मुझे ऊर्ध्वाधर और क्षैतिज बाड़ की एक जोड़ी खोजने और उन पर स्थिति की जांच करने की आवश्यकता है। लेकिन मुझे नहीं पता कि वे किस क्रम में दिखाई देंगे। चूंकि सूची पैटर्न सामान्य रूप से आदेश पर निर्भर होते हैं, इस कारण दो वास्तव में लंबे पैटर्न होंगे। इसलिए इसके बजाय मैं आसपास की सूची के साथ एक फ़ंक्शन के tसाथ प्रतिस्थापित करता हूं t @@@- जिसे परिभाषित नहीं किया गया है इसलिए इसे आयोजित किया जाता है। लेकिन वह फ़ंक्शन है Orderless, इसलिए मैं पैटर्न में केवल एक आदेश की जांच कर सकता हूं , और गणितज्ञ इसे सभी क्रमपरिवर्तन के खिलाफ जांच करेगा। बाद में, मैंने सूचियों को वापस उसी स्थान पर रख दिया List @@@।

मेरी इच्छा है कि एक निर्मित में एक) Orderless, बी) नहीं है Listable और सी) 0 तर्कों या सूची तर्कों के लिए परिभाषित नहीं है। तब मैं उससे बदल सकता tथा। लेकिन ऐसा कोई ऑपरेटर नहीं लगता है।

— मार्टिन एंडर
स्रोत

जब आप सोच रहे हैं कि क्या गणितज्ञ इसे सही या पर्याप्त तेजी से करता है, तो इसका जवाब "हां" है।

— देखिए

खैर, यह मेरे संदर्भ कार्यान्वयन के रूप में भोली के रूप में है। : पी

— ज़गर्ब

1

हास्केल, 318 बाइट्स

import Data.List
s=subsequences
k[(_,a,b),(_,c,d)]|a==c=f(\w->(1,a,w))b d|1<2=f(\w->(2,w,b))a c
f t u v=[t x|x<-[min u v+1..max u v-1]]
q l=nub[x|x<-map(k=<<)$s[a|a@[(_,n,m),(_,o,p)]<-s l,n==o||m==p],x++l==nubBy(\(_,a,b)(_,c,d)->a==c&&b==d)(x++l)]
m=q.map(\(a,b)->(0,a,b))
p l=sum[1|x<-m l,all(\y->y==x||x\\y/=[])$m l]

उपयोग: p [(1,0),(0,1),(-1,0),(0,-1)]। आउटपुट:2

यह काम किस प्रकार करता है:

इनपुट सूची के सभी उप सूची बनाएँ और दो तत्वों और बराबर x या बराबर y निर्देशांक के साथ रखें। यह डंडे के सभी जोड़ों की एक सूची है जहां बीच में एक बाड़ का निर्माण किया जा सकता है।
इसके सभी उपठेका तैयार करें
हर सूची के लिए बोर्ड जोड़ें
उन सूचियों को हटाएं जहां एक xy समन्वय दो बार दिखाई देता है (बोर्ड और डंडे)
डुप्लिकेट सूचियों (केवल बोर्ड) को हटाएं क्योंकि कई खाली सूचियों को संभालने के लिए, सीधे आसन्न डंडे (जैसे (1,0) और (1,1))
उन लोगों को रखें जो दूसरी सूची के सख्त अधीन नहीं हैं
शेष सूचियाँ गिनें

— nimi
स्रोत

गणना मैक्सिमल बाड़ व्यवस्था