2 डी बिंदुओं के एक सेट का उत्तल हल खोजें

Question

जब आप एक लकड़ी के बोर्ड में नाखूनों के एक सेट को हथौड़ा करते हैं और उनके चारों ओर एक रबर बैंड लपेटते हैं, तो आपको एक उत्तल हल मिलता है ।

आपका मिशन, क्या आपको इसे स्वीकार करने का निर्णय लेना चाहिए, किसी दिए गए सेट के 2D अंक का उत्तल हल ढूंढना है ।

---

कुछ िनयम:

• इसे एक फ़ंक्शन के रूप में लिखें, बिंदु की सूची निर्देशांक (किसी भी प्रारूप में आप चाहते हैं) का तर्क है
• आउटपुट को उत्तल नली में सूचीबद्ध बिंदुओं में से किसी एक पर शुरू करते हुए क्लॉकवाइज या एंटीक्लॉकवाइज बिंदुओं की सूची होनी चाहिए
• आउटपुट सूची किसी भी उचित प्रारूप में हो सकती है, जहां प्रत्येक बिंदु के निर्देशांक स्पष्ट रूप से भिन्न होते हैं। (उदाहरण के लिए नहीं एक मंद सूची {0.1, 1.3, 4, ...})
• यदि उत्तल पतवार के एक खंड में तीन या अधिक बिंदु गठबंधन किए जाते हैं, तो आउटपुट पर केवल दो चरम सीमाओं को रखा जाना चाहिए

नमूना डेटा:

नमूना ०

इनपुट:

{{1, 1}, {2, 2}, {3, 3}, {1, 3}}

आउटपुट:

{{3, 3}, {1, 3}, {1, 1}}

(आंकड़े सिर्फ दृष्टांत हैं)

नमूना 1

इनपुट:

{{4.4, 14}, {6.7, 15.25}, {6.9, 12.8}, {2.1, 11.1}, {9.5, 14.9}, 
 {13.2, 11.9}, {10.3, 12.3}, {6.8, 9.5}, {3.3, 7.7}, {0.6, 5.1}, {5.3, 2.4}, 
 {8.45, 4.7}, {11.5, 9.6}, {13.8, 7.3}, {12.9, 3.1}, {11, 1.1}}

आउटपुट:

{{13.8, 7.3}, {13.2, 11.9}, {9.5, 14.9}, {6.7, 15.25}, {4.4, 14}, 
 {2.1, 11.1}, {0.6, 5.1}, {5.3, 2.4}, {11, 1.1}, {12.9, 3.1}}

नमूना २

इनपुट:

{{1, 0}, {1, 1}, {1, -1}, {0.68957, 0.283647}, {0.909487, 0.644276}, 
 {0.0361877, 0.803816}, {0.583004, 0.91555}, {-0.748169, 0.210483}, 
 {-0.553528, -0.967036}, {0.316709, -0.153861}, {-0.79267, 0.585945},
 {-0.700164, -0.750994}, {0.452273, -0.604434}, {-0.79134, -0.249902}, 
 {-0.594918, -0.397574}, {-0.547371, -0.434041}, {0.958132, -0.499614}, 
 {0.039941, 0.0990732}, {-0.891471, -0.464943}, {0.513187, -0.457062}, 
 {-0.930053, 0.60341}, {0.656995, 0.854205}}

आउटपुट:

{{1, -1}, {1, 1}, {0.583004, 0.91555}, {0.0361877, 0.803816}, 
 {-0.930053, 0.60341}, {-0.891471, -0.464943}, {-0.700164, -0.750994}, 
 {-0.553528, -0.967036}}

मानक कोड-गोल्फ नियम लागू होते हैं। कोई तदर्थ ज्यामिति पुस्तकालय नहीं। शार्ट कोड जीतता है।

संपादित करें 1

हम यहां एक एल्गोरिथम उत्तर की तलाश कर रहे हैं, न कि उत्तल पतवार खोजक पूर्व-क्रमबद्ध दिनचर्या जैसे कि मैटलैब में यह या मैथमेटिका में यह एक

संपादित करें 2

टिप्पणियों और अतिरिक्त जानकारी का जवाब देना:

1. आप मान सकते हैं कि इनपुट सूची में न्यूनतम संख्या में बिंदु हैं जो आपके अनुरूप हैं। लेकिन आपको संरेखित (उप) सेटों का उचित उपचार सुनिश्चित करना चाहिए।
2. आपको इनपुट सूची में बार-बार अंक मिल सकते हैं
3. उपलब्ध स्मृति द्वारा केवल अंकों की अधिकतम संख्या सीमित होनी चाहिए
4. "फ़्लोटिंग पॉइंट": आपको दशमलव निर्देशांक के साथ इनपुट सूचियों को संसाधित करने में सक्षम होना चाहिए जैसा कि नमूनों में दिया गया है। आप फ्लोटिंग पॉइंट प्रतिनिधित्व का उपयोग करके ऐसा कर सकते हैं

।

Comments

मैं भविष्यवाणी करता हूं कि MATLAB इसे जीतेगा।

— पॉल आर।

क्या हम मान सकते हैं कि कम से कम 3 अंक हैं? क्या हम मान सकते हैं कि अंक अलग हैं? क्या हमें फ़्लोटिंग पॉइंट निर्देशांक का समर्थन करने की आवश्यकता है?

— पीटर टेलर

@PeterTaylor उदाहरण बताता है कि अंतिम उत्तर सही है

— जॉन ड्वोरक

क्या हम इनपुट को अधिलेखित कर सकते हैं?

— जॉन ड्वोरक

लगातार टकराने वाले बिंदुओं के इलाज में समस्या गोलमोल मुद्दे हैं। हमें गलती करने की अनुमति दी जानी चाहिए।

— जॉन ड्वोरक

Answer 1

रूबी, 168 वर्ण

C=->q{r=[]
f=m=q.sort[0]
t=-0.5
(_,_,t,*f=q.map{|x,y|a=x-f[0]
b=y-f[1]
[0==(d=a*a+b*b)?9:(-t+e=Math.atan2(b,a)/Math::PI)%2,-d,e,x,y]}.sort[0]
r<<=f)while
!r[1]||f!=m
r}

यह रूबी कोड उपहार रैपिंग एल्गोरिथ्म का भी उपयोग करता है। फ़ंक्शन Cपॉइंट की एक सरणी को स्वीकार करता है और उत्तल पतवार को सरणी के रूप में लौटाता है।

उदाहरण:

>p C[[[4.4, 14], [6.7, 15.25], [6.9, 12.8], [2.1, 11.1], [9.5, 14.9], 
     [13.2, 11.9], [10.3, 12.3], [6.8, 9.5], [3.3, 7.7], [0.6, 5.1], [5.3, 2.4], 
     [8.45, 4.7], [11.5, 9.6], [13.8, 7.3], [12.9, 3.1], [11, 1.1]]]

[[5.3, 2.4], [11, 1.1], [12.9, 3.1], [13.8, 7.3], [13.2, 11.9], [9.5, 14.9], [6.7, 15.25], [4.4, 14], [2.1, 11.1], [0.6, 5.1]]

Answer 2

गणितज्ञ १५१

अभी भी प्रगति पर है

f = For[t = Sort@#; n = 1; l = Pi; a = ArcTan; c@1 = t[[1]],
       n < 2 || c@n != c@1, 
       n++,
      (l = a @@ (# - c@n); c[n + 1] = #) & @@
      t[[Ordering[Mod[a@## - l, 2 Pi] & @@ (#2 - #1) & @@@ Tuples@{{c@n}, t}, 1]]]] &

परिक्षण:

ClearAll[a, c, t];
s = {{1, 0}, {0.68957, 0.283647}, {0.909487, 0.644276}, {0.0361877, 0.803816}, 
     {0.583004, 0.91555}, {-0.748169, 0.210483}, {-0.553528, -0.967036}, 
     {0.316709, -0.153861}, {-0.79267, 0.585945}, {-0.700164, -0.750994}, 
     {0.452273, -0.604434}, {-0.79134, -0.249902}, {-0.594918, -0.397574}, 
     {-0.547371, -0.434041}, {0.958132, -0.499614}, {0.039941, 0.0990732}, 
     {-0.891471, -0.464943}, {0.513187, -0.457062}, {-0.930053, 0.60341}, 
     {0.656995, 0.854205}};
f@s
Show[Graphics@Line@Table[c@i, {i, n}], 
     ListPlot[{t, Table[c@i, {i, n}]}, 
     PlotStyle -> {PointSize[Medium], PointSize[Large]}, 
     PlotRange -> All]]

Answer 3

कॉफीस्क्रिप्ट, 276:

f=($)->z=$[0];e.r=Math.atan2(e.x-z.x,e.y-z.y)for e in $;$.sort((x,y)->(x.r>y.r)-(x.r<y.r));(loop(a=$[i-1]||$[$.length-1];b=$[i];c=$[i+1]||$[0];break if!b;s=(b.x-a.x)*(c.y-b.y)-(b.y-a.y)*(c.x-b.x);break if s<0||!s&&(a.x-b.x)*(b.x-c.x)<0;$.splice i,1))for i in [$.length-1..0];$

यदि फ़ंक्शन को पहुंच की आवश्यकता नहीं है, तो f=दो और पात्रों को शेव करने के लिए निकालें ।

इनपुट / आउटपुट बिंदुओं का एक एकल सरणी है, जिसके प्रत्येक बिंदु को x,yगुणों द्वारा परिभाषित किया जाता है। इनपुट सरणी को संशोधित किया गया है, साथ ही वापस लौटाया गया है (यदि बाद की आवश्यकता नहीं है, तो अंतिम दो वर्ण हटा दें)।

स्पष्टीकरण बाद में जोड़ा जा सकता है।

टेस्ट सूट (पुराने काम नहीं करेगा):

alert JSON.stringify f({x:e[0], y:e[1]} for e in JSON.parse "
{{1, 1}, {2, 2}, ...}
".replace(/{/g,"[").replace(/}/g,"]"))

सुझाया गया परीक्षण वातावरण: http://coffeescript.org/

Comments

मैंने इसके साथ कोशिश की {{1, 1}, {2, 2}, {3, 3}, {1, 3}}और यह लौट आया, [{"x" : 1, "y" : 1, "r" : 0}, {"x" : 1, "y" : 3, "r" : 0}, "x" : 2, "y" : 2, "r" : 0.78..}]जबकि मुझे लगता है कि सही उत्तर कुछ क्रमचय है{{3, 3}, {1, 3}, {1, 1}}

— डॉ। बेलिसरियस

अंकों के साथ @belisarius मुद्दा पहले कभी-कभी गलत पतवार के उत्पादन के साथ टकरा जाता है

— जॉन ड्वोरक

@ सबिसरियस कृपया इसे प्रश्न के परीक्षण के मामले के रूप में जोड़ें।

— जॉन ड्वोरक

यह अब ठीक से काम करने लगता है :)

— डॉ। बेलिसरियस

Answer 4

पायथन, 209 205 195

from math import*
s=lambda(a,b),(c,d):atan2(d-b,c-a)
def h(l):
 r,t,p=[],pi/2,min(l)
 while 1:
    q=min(set(l)-{p},key=lambda q:(s(p,q)-t)%(2*pi));m=s(p,q);r+=[p]*(m!=t);p=q;t=m
    if p in r:return r

एक उपहार रैपिंग एल्गोरिथ्म का उपयोग करता है। परिणाम सबसे बाएं बिंदु से शुरू होता है और काउंटर-क्लॉकवाइज लपेटता है।

उदाहरण: h([(1, 1), (2, 2), (3, 3), (1, 3)])रिटर्न[(1, 3), (1, 1), (3, 3)]

Comments

क्या आपको printआउटपुट प्राप्त करने की आवश्यकता नहीं है ?

— डॉ। बेलीज़ेरियस

मुझे लगा कि "आउटपुट" से आपका मतलब फंक्शन के आउटपुट से है। क्या आप चाहते हैं कि फ़ंक्शन इसे वापस करने के बजाय परिणाम प्रिंट करे?

— कार्डबोर्ड_बॉक्स

मैंने सोचा था कि आवश्यकता the output list can be in any reasonable formatकाफी स्पष्ट थी। क्या आपको लगता है कि इसे स्पष्ट रूप से कहा जाना चाहिए?

— डॉ। बिसरिसेर

ऐसा लगता है कि फ्लोटिंग पॉइंट का उपयोग करने पर आपके आउटपुट पॉइंट हमेशा इनपुट वाले से मेल नहीं खाते हैं। उदाहरण के लिए h([(0, 1), (0,1), (0.1 , 1)])मुझे देता है[(0, 1), (0.10000000000000001, 1)]

— डॉ। बेलिसरियस