एक 2 डी उत्तल हल का क्षेत्र

Question

आपको 2 डी यूक्लिडियन विमान पर बिंदुओं के कार्टियरियन निर्देशांक $(x, y)$ का प्रतिनिधित्व करने वाले पूर्णांक के जोड़े की एक सरणी / सूची / वेक्टर दी गई है; सभी निर्देशांक बीच में हैं $−10^4$ और $10^4$ , डुप्लिकेट की अनुमति है। निकटतम पूर्णांक तक गोल, उन बिंदुओं के उत्तल पतवार का क्षेत्रफल ज्ञात करें ; एक सटीक मध्य बिंदु को निकटतम सम पूर्णांक तक गोल किया जाना चाहिए। आप मध्यवर्ती संगणना में फ्लोटिंग-पॉइंट नंबरों का उपयोग कर सकते हैं, लेकिन केवल अगर आप गारंटी दे सकते हैं कि अंतिम परिणाम हमेशा सही होगा। यह कोड-गोल्फ है , इसलिए सबसे छोटा सही प्रोग्राम जीत जाता है।

उत्तल पतवार अंक का एक सेट के $P$ छोटी से छोटी उत्तल सेट है कि शामिल है $P$ । यूक्लिडियन विमान पर, किसी एक बिंदु $(x,y)$ , यह स्वयं बिंदु है; दो अलग-अलग बिंदुओं के लिए, यह तीन गैर-कोलिनियर बिंदुओं के लिए उनकी रेखा है, यह त्रिकोण है जो वे बनाते हैं, और आगे।

उत्तल पतवार का एक अच्छा दृश्य विवरण, लकड़ी के बोर्ड में नाखून के रूप में सभी बिंदुओं की कल्पना करने के रूप में सबसे अच्छा वर्णन किया गया है, और फिर सभी बिंदुओं को संलग्न करने के लिए उनके चारों ओर एक रबर बैंड खींच रहा है:

कुछ परीक्षण मामले:

Input: [[50, -13]]
Result: 0

Input: [[-25, -26], [34, -27]]
Result: 0

Input: [[-6, -14], [-48, -45], [21, 25]]
Result: 400

Input: [[4, 30], [5, 37], [-18, 49], [-9, -2]]
Result: 562

Input: [[0, 16], [24, 18], [-43, 36], [39, -29], [3, -38]]
Result: 2978

Input: [[19, -19], [15, 5], [-16, -41], [6, -25], [-42, 1], [12, 19]]
Result: 2118

Input: [[-23, 13], [-13, 13], [-6, -7], [22, 41], [-26, 50], [12, -12], [-23, -7]]
Result: 2307

Input: [[31, -19], [-41, -41], [25, 34], [29, -1], [42, -42], [-34, 32], [19, 33], [40, 39]]
Result: 6037

Input: [[47, 1], [-22, 24], [36, 38], [-17, 4], [41, -3], [-13, 15], [-36, -40], [-13, 35], [-25, 22]]
Result: 3908

Input: [[29, -19], [18, 9], [30, -46], [15, 20], [24, -4], [5, 19], [-44, 4], [-20, -8], [-16, 34], [17, -36]]
Result: 2905

Comments

क्या आपके पास कोई परीक्षण मामले हैं?

— माल्टसेन

कोड गोल्फ में व्हॉट्सएप की गिनती नहीं करना एक बुरा विचार है, यह स्ट्रिंग को कोड में बदलने और इसे निष्पादित करने के लिए व्हॉट्सएप और जेनेरिक कोड के बड़े पैमाने पर तार के साथ प्रस्तुत करता है।

— xnor

एक सटीक मध्य बिंदु को निकटतम सम पूर्णांक तक गोल किया जाना चाहिए : बस सोच रहा था कि इसके पीछे तर्क क्या है?

— अरनुलद

[[0, 0], [1, 1], [0, 1]]$1/2$$0$

आमतौर पर चुनौतियां स्व-निहित होती हैं, लेकिन यह एक नहीं है। क्या आप बता सकते हैं कि उत्तल पतवार क्या है, और इसकी गणना कैसे करें? या कुछ संदर्भ ऑनलाइन संसाधन की ओर इशारा करते हैं?

— ओलिवियर ग्रेजायर

Answer 1

SQL सर्वर 2012+, 84 बाइट्स

SELECT Round(Geometry::ConvexHullAggregate(Geometry::Point(x,y,0)).STArea(),0)FROM A

SQL सर्वर में ज्यामिति फ़ंक्शंस और समुच्चय का उपयोग करता है। कोर्डिनेट टेबल के Aसाथ कॉलम से होते हैं xऔर y।

Answer 2

जावा 10, 405 ... अब फिट नहीं हुआ; संपादित इतिहास देखें .. 317 316 बाइट्स

P->{int n=P.length,l=0,i=0,p,q,t[],h[][]=P.clone(),s=0;for(;++i<n;)l=P[i][0]<P[l][0]?i:l;p=l;do for(h[s++]=P[p],q=-~p%n,i=-1;++i<n;q=(t[1]-P[p][1])*(P[q][0]-t[0])<(t[0]-P[p][0])*(P[q][1]-t[1])?i:q)t=P[i];while((p=q)!=l);for(p=i=0;i<s;p-=(t[0]+h[++i%s][0])*(t[1]-h[i%s][1]))t=h[i];return Math.round(.5*p/~(p%=2))*~p;}

-52 के लिए धन्यवाद बाइट्स @ OlivierGrégoire
-3 के लिए धन्यवाद बाइट्स @PeterTaylor
-7 के लिए धन्यवाद बाइट्स @ceilingcat

इसे ऑनलाइन आज़माएं।

या 299 गोलाई बिना बाइट्स .. ।

स्पष्टीकरण:

करने के लिए तीन चरण हैं:

1. इनपुट-निर्देशांक के आधार पर उत्तल हल के लिए अंकों की गणना करें ( जार्विस एल्गोरिथ्म / रैपिंग का उपयोग करके )
2. इस उत्तल हल के क्षेत्र की गणना करें
3. बैंकर की गोलाई ।।

कॉनवेक्स हल के हिस्से वाले निर्देशांक की गणना करने के लिए, हम निम्नलिखित दृष्टिकोण का उपयोग करते हैं:

$l$$p$$p$$l$

कोड के लिए के रूप में:

P->{                      // Method with 2D integer array as parameter & long return-type
  int n=P.length,         //  Integer `n`, the amount of points in the input
      l=0,                //  Integer `l`, to calculate the left-most point
      i=0,                //  Index-integer `i`
      p,                  //  Integer `p`, which will be every next counterclockwise point
      q,                  //  Temp integer `q`
      t[],                //  Temp integer-array/point
      h[][]=P.clone(),    //  Initialize an array of points `h` for the Convex Hull
      s=0;                //  And a size-integer for this Convex Hull array, starting at 0
  for(;++i<n;)            //  Loop `i` in the range [1, `n`):
    l=                    //   Change `l` to:
      P[i][0]<P[l][0]?    //   If i.x is smaller than l.x:
       i                  //    Replace `l` with the current `i`
      :l;                 //   Else: leave `l` unchanged
  p=l;                    //  Now set `p` to this left-most coordinate `l`
  do                      //  Do:
    for(h[s++]=P[p],      //   Add the `p`'th point to the 2D-array `h`
        q=-~p%n,          //   Set `q` to `(p+1)` modulo-`n`
        i=-1;++i<n;       //    Loop `i` in the range [0, `n`):
        ;q=               //      After every iteration: change `q` to:
                          //       We calculate: (i.y-p.y)*(q.x-i.x)-(i.x-p.x)*(q.y-i.y), 
                          //       which results in 0 if the three points are collinear;
                          //       a positive value if they are clockwise;
                          //       or a negative value if they are counterclockwise
           (t[1]-P[p][1])*(P[q][0]-t[0])<(t[0]-P[p][0])*(P[q][1]-t[1])?
                          //       So if the three points are counterclockwise:
            i             //        Replace `q` with `i`
           :q)            //       Else: leave `q` unchanged
      t=P[i];             //     Set `t` to the `i`'th Point (to save bytes)
  while((p=q)             //  And after every while-iteration: replace `p` with `q`
             !=l);        //  Continue the do-while as long as `p` is not back at the
                          //  left-most point `l` yet
  // Now step 1 is complete, and we have our Convex Hull points in the List `h`

  for(p=i=0;              //  Set `p` (the area) to 0
      i<s                 //  Loop `i` in the range [0, `s`):
      ;p-=                //    After every iteration: Decrease the area `p` by:
        (t[0]+h[++i%s][0])//     i.x+(i+1).x
        *(t[1]-h[i%s][1]))//     Multiplied by i.y-(i+1).y
    t=h[i];               //   Set `t` to the `i`'th point (to save bytes)
 return Math.round(.5*p/~(p%=2))*~p;}
                          //  And return `p/2` rounded to integer with half-even

Comments

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— केविन क्रूज़सेन

Answer 3

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 27 बाइट्स

Round@*Area@*ConvexHullMesh

इसे ऑनलाइन आज़माएं!

Answer 4

जावास्क्रिप्ट (ईएस 6),  191  189 बाइट्स

औजार जार्विस मार्च (उर्फ उपहार रैपिंग एल्गोरिथ्म)।

P=>(r=(g=p=>([X,Y]=P[p],Y*h-X*v)+(P.map(([x,y],i)=>q=(y-Y)*(P[q][0]-x)<(x-X)*(P[q][1]-y)?i:q,q=P[++p]?p:0,h=X,v=Y)|q?g(q):V*h-H*v))(v=h=0,([[H,V]]=P.sort(([x],[X])=>x-X)))/2)+(r%1&&r&1)/2|0

इसे ऑनलाइन आज़माएं!

या बोझिल गोलाई योजना के बिना 170 बाइट्स ।

Comments

गोलाई सिर्फ एक लाल हेरिंग थी क्योंकि दो बार क्षेत्र हमेशा पूर्णांक होता है।

— व्लादिमीर रेशेतनिकोव

@VladimirReshetnikov जिज्ञासा से बाहर: यदि आप जानते थे कि गोलाई एक लाल हेरिंग थी, तो इसे अन्यथा अच्छी चुनौती से विचलित करने के लिए क्यों जोड़ा जाए? .. सभी भाषाओं में बैंकर की गोलाई नहीं है, जेएस और जावा के लिए जाहिरा तौर पर अच्छी तरह से ज्ञात भाषाएं भी नहीं। मुझे सामान्य रूप से चुनौती पसंद है और मेरे जावा उत्तर को लिखने में मज़ा आया, लेकिन उत्तलता और स्पष्टीकरण की कमी के कारण कॉनवेक्स हल को चुनौती देना स्व-सम्‍मिलित है, मुझे इसे अपवित्र करने से बचना चाहिए, tbh .. PS: क्षमा करें @Arruld यह करने के लिए एक के रूप में अपने उत्तर में टिप्पणी करें ..

— केविन क्रूज़सेन

Answer 5

आर , 85 81 78 बाइट्स

function(i,h=chull(i),j=c(h,h[1]))round((i[h,1]+i[j[-1],1])%*%diff(-i[j,2])/2)

इसे ऑनलाइन आज़माएं!

2-कॉलम मैट्रिक्स के रूप में इनपुट लेता है - पहले के लिए x, दूसरा के लिए y। आर roundवास्तव में बैंकर की गोलाई पद्धति का उपयोग करता है, इसलिए हम यहां काफी भाग्यशाली हैं।

$\sum_{i}{(x_{i-1}+x)\cdot(y_{i-1}-y_i)}/2$

-3 बाइट्स के लिए Giuseppe का धन्यवाद।

Answer 6

[आर + एस पैकेज], 55 बाइट्स

function(x)round(sp::Polygon(x[chull(x),,drop=F])@area)

इसे RDRR पर आज़माएँ

एक फ़ंक्शन जो चिंता 2 मैट्रिक्स लेता है और गोल क्षेत्र देता है। यह spपैकेज का उपयोग करता है । drop=Fएक समन्वय मामले को संभालने के लिए की जरूरत है। RDRR डेमो के लिए उपयोग किया जाता है क्योंकि TIO spपैकेज का अभाव है ।