हैप्पी एंडर समस्या

Question

सुखद अंत समस्या (वास्तव में एक प्रमेय) कहा गया है कि

सामान्य स्थिति में विमान में पाँच बिंदुओं के किसी भी सेट में चार बिंदुओं का एक सबसेट होता है जो उत्तल चतुर्भुज के कोने बनाता है।

इस समस्या को पॉल एर्दो द्वारा नाम दिया गया था जब दो गणितज्ञों ने पहली बार समस्या पर काम किया था, एस्टर क्लेन और जॉर्ज ज़ेकेरेस ने सगाई की और बाद में शादी कर ली।

स्पष्टीकरण:

• यहां सामान्य स्थिति का अर्थ है कि कोई भी तीन बिंदु आपस में नहीं मिलते हैं।

• चार शीर्षों द्वारा गठित चतुर्भुज हमेशा बिंदुओं के क्रम के बावजूद, गैर-प्रतिच्छेदन माना जाएगा। उदाहरण के लिए, चार अंक दिए गए [1 1], [1 2], [2 1], [2 2]इरादा चतुर्भुज वर्ग, नहीं धनुष टाई है:

  

• यदि कोई आंतरिक कोण 180 डिग्री से अधिक नहीं है तो एक गैर-प्रतिच्छेदन चतुर्भुज उत्तल है ; या समकक्ष यदि दोनों विकर्ण चतुर्भुज के अंदर स्थित हों।

चुनौती

सकारात्मक पूर्णांक निर्देशांक के साथ 5 अंकों को देखते हुए, उन बिंदुओं के आउटपुट 4 जो उत्तल चतुर्भुज बनाते हैं।

नियम

यदि कई समाधान हैं (जो कि 4 अंक के कई सेट हैं), तो आप लगातार उनमें से एक या सभी को आउटपुट करने का विकल्प चुन सकते हैं।

इनपुट और आउटपुट प्रारूप हमेशा की तरह लचीले होते हैं (सरणियाँ, सूचियाँ, सूचियों की सूची, उचित विभाजक के साथ तार, आदि)।

कोड गोल्फ, सबसे कम बाइट्स जीतता है।

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

1. इनपुट:

   [6 8] [1 10] [6 6] [5 9] [8 10]
   

   केवल एक ही संभावित आउटपुट है:

   [6 8] [1 10] [6 6] [5 9]
   

2. इनपुट:

   [3 8] [7 5] [6 9] [7 8] [5 1]
   

   पाँच उपाय हैं:

   [3 8] [7 5] [6 9] [7 8]
   [3 8] [7 5] [6 9] [5 1]
   [3 8] [7 5] [7 8] [5 1]
   [3 8] [6 9] [7 8] [5 1]
   [7 5] [6 9] [7 8] [5 1]
   

3. इनपुट:

   [4 8] [1 9] [9 9] [10 2] [1 6]
   

   तीन समाधान हैं:

   [4 8] [1 9] [10 2] [1 6]
   [4 8] [9 9] [10 2] [1 6]
   [1 9] [9 9] [10 2] [1 6]
   

   उदाहरण के लिए, इस मामले के तीन समाधान हैं:

Comments

मैं एक सकारात्मक भाव के साथ मार्टिन से जवाब की उम्मीद कर रहा हूं।

— एलेंडिया स्ट्राटन

खुश अंत समस्या खुश अंत समस्या के साथ भ्रमित नहीं होना है, जो कि सैन्य रंगरूटों को रोकने के लिए एक रास्ता खोजने के लिए है जो वे वास्तविक हैं सिमुलेशन की खोज कर रहे हैं ।

— user253751

Answer 1

CJam, 37 34 32 बाइट्स

{e!Wf<{2*3ew{)f.-~W%.*:-V>},!}=}

यकीन नहीं है कि अगर :-Vकाफी खुश है, लेकिन जैसा कि के झांग बताते हैं, वहाँ =}अंत में है। :)

यह केवल एक समाधान प्रिंट करता है क्योंकि डुप्लिकेट को निकालना अधिक महंगा होगा।

इसका परीक्षण यहां करें।

व्याख्या

विचार काफी सरल है। हम सभी संभव चतुर्भुज उत्पन्न करते हैं (अंकों के सभी आदेशों सहित) और फिर बस उत्तल लोगों का चयन करें। हम हर जोड़ी के किनारों को देखकर उत्तलता का परीक्षण करते हैं और जाँचते हैं कि वे सभी एक ही दिशा में मुड़ रहे हैं।

टर्निंग सेंस को एक डॉट प्रोडक्ट से काफी आसानी से प्राप्त किया जा सकता है। यदि आप एक चतुर्भुज पर तीन लगातार बिंदुओं को लेते हैं, और पहली से दूसरी तक की रेखाएँ खींचते हैं, और पहली से तीसरी, और फिर बाद वाले को पूर्व के लंबवत पर प्रोजेक्ट करते हैं ... आपको एक संख्या मिलती है जिसका संकेत आपको बताता है। चाहे ये तीन बिंदु बाएँ या दाएँ मुड़ते हों। (मुझे शायद इसके लिए एक आरेख जोड़ना चाहिए।) यह "लंबवत पर पेश करना" काफी शामिल है, लेकिन वास्तव में इसका मतलब है कि हम दो वैक्टरों में से एक को उल्टा करते हैं और घटकों को जोड़ने के बजाय गुणा के बाद घटाते हैं। तो यहाँ कोड है ...

e!       e# Generate all permutations of the five input points.
Wf<      e# Discard the fifth point in each permutations, giving all
         e# possible quadrilaterals.
{        e# Select the first for which this block gives a truthy result...
  2*     e#   Double the list of points, so that it includes each cyclically
         e#   adjacent set of three points.
  3ew    e#   Get all sublists of length 3, i.e. all sets of three consecutive
         e#   points (with two duplicates).
  {      e#   Filter these sets of three points...
    )    e#     Pull off the last point.
    f.-  e#     Subtract it from the other two, giving vectors from it to
         e#     to those.
    ~    e#     Unwrap the array dumping both vectors on the stack.
    W%   e#     Reverse one of them.
    .*   e#     Element-wise multiplication.
    :-   e#     Subtract the second element from the first. This completes
         e#     the projection.
    V>   e#     Check whether it's greater than 0. This is *false* for right-
         e#     turning sets of three points.
  },     e#   If all corners are right-turning, this will result
         e#   in an empty array.
  !      e#   Logical NOT - hence, only quadrilaterals where all corners
         e#   are right-turning give something truthy.
}=

Comments

ज़रूर, एक खुश बतख!

— लुइस मेंडो

@LuisMendo मुझे लगता है कि आखिरी दो अक्षर एक स्माइली =} की तरह लगते हैं

— के झांग

!}एक पलक भी मानी जा सकती है

— Jezzamon

कोडगोल्फ के जॉन स्कीट .. यह आश्चर्यजनक है

— एलेक्स कार्लसन

Answer 2

MATLAB, 67 बाइट्स

I=input('');for k=~eye(5);if nnz(convhull(I(k,:)))>4;I(k,:),end;end

इनपुट 2 डी मैट्रिक्स के रूप में है जहां कॉलम क्रमशः X और Y हैं:

[6 8; 1 10; 6 6; 5 9; 8 10]
[3 8; 7 5; 6 9; 7 8; 5 1]
[4 8; 1 9; 9 9; 10 2; 1 6]

उत्तल चतुर्भुज बनाने वाले 4 बिंदुओं के सभी सेट एक ही प्रारूप में प्रदर्शित किए जाते हैं।

यहां एक डेमो है जिसे ऑक्टेव के साथ काम करने के लिए थोड़ा संशोधित किया गया है

व्याख्या

यह समाधान इनपुट के 4 बिंदुओं के सभी सबसेट ले लेता है (ऑर्डर कोई फर्क नहीं पड़ता)। ऐसा करने के लिए, हम पहचान मैट्रिक्स बनाते हैं और इसे नकारात्मक करते हैं ~eye(5):। हम इस मैट्रिक्स के कॉलम के माध्यम से लूप करते हैं और k(लूप इंडेक्स) एक लॉजिकल ऐरे है जो 4 बिंदुओं पर विचार करता है। हम फिर इनपुट ( I(k,:)) से इन 4 XY बिंदुओं को हथियाने के लिए इसका उपयोग करते हैं ।

हम फिर इन 4 बिंदुओं ( convhull) के उत्तल पतवार की गणना करते हैं । का आउटपुट convhullइनपुट के सूचकांक हैं जो उन बिंदुओं के साथ मेल खाते हैं जो उत्तल पतवार बनाते हैं (पहले सूचकांक को पतवार को बंद करने के लिए दोहराया गया)।

एक उत्तल चतुर्भुज के लिए, सभी चार बिंदु समान बिंदुओं ( nnz(convhull(points)) > 4) के उत्तल पतवार का हिस्सा होंगे । यदि हम पता लगाते हैं कि यह मामला है, तो हम उन बिंदुओं को प्रदर्शित करते हैं जो इस विशेष पुनरावृत्ति के लिए उपयोग किए गए थे।

Answer 3

जावास्क्रिप्ट (ईएस 6), 306 293 283 बाइट्स

c=(v,w,x)=>(w[0]-v[0])*(w[1]-x[1])-(w[1]-v[1])*(w[0]-x[0])>0?1:0
i=(v,w,x,y)=>(c(v,w,x)+c(w,x,y)+c(x,y,v)+c(y,v,w))%4==0&&r.push([v,w,x,y])
j=(v,w,x,y)=>{i(v,w,x,y);i(v,w,y,x);i(v,x,w,y)}
k=(v,w,x,y,z)=>{j(v,w,x,y);j(v,w,x,z);j(v,w,y,z);j(v,x,y,z);j(w,x,y,z)}
f=(v)=>(r=[],k(...v),r)

स्पष्टीकरण :

फ़ंक्शन cपॉलीगोन के 3 आसन्न बिंदुओं के बीच वेक्टर के क्रॉस उत्पाद की गणना करता है और 1 सकारात्मक होने पर रिटर्न करता है और अन्यथा 0 (नोट: क्रॉस उत्पाद शून्य नहीं हो सकता है क्योंकि अंक सह-रैखिक नहीं हो सकते हैं)।

j=(v,w,x,y)=>{i(v,w,x,y);i(v,w,y,x);i(v,x,w,y)}
k=(v,w,x,y,z)=>{j(v,w,x,y);j(v,w,x,z);j(v,w,y,z);j(v,x,y,z);j(w,x,y,z)}

फ़ंक्शन kऔर jइनपुट सरणी के सभी चक्रीय क्रमपरिवर्तन (आदेश की अनदेखी करते हुए) उत्पन्न करते हैं।

i=(v,w,x,y)=>(c(v,w,x)+c(w,x,y)+c(x,y,v)+c(y,v,w))%4==0&&r.push([v,w,x,y])

फ़ंक्शन 'i' को प्रत्येक चक्रीय क्रमचय के लिए कहा जाता है ताकि cआसन्न को-ऑर्डिनेट्स के 4 ट्रिपल में से प्रत्येक के लिए फ़ंक्शन की राशि की गणना की जा सके । यदि क्रॉस उत्पादों में सभी समान चिह्न हैं तो वे सभी 0 या 1 और कुल 0 (modulo 4) होंगे और बहुभुज अवतल होता है और आउटपुट सरणी में धकेल दिया जाता है। यदि किसी भी ट्रिपल में एक अलग संकेत है तो कुल गैर-शून्य (मॉडुलो 4) होगा और बहुभुज उत्तल है।

f=(v)=>(r=[],k(...v),r)

फ़ंक्शन fका उपयोग आउटपुट सरणी को इनिशियलाइज़ करने के लिए किया जाता है और फिर आउटपुट को वापस करने से पहले उपरोक्त फ़ंक्शन को कॉल करता है।

टेस्ट :

c=(v,w,x)=>(w[0]-v[0])*(w[1]-x[1])-(w[1]-v[1])*(w[0]-x[0])>0?1:0
i=(v,w,x,y)=>(c(v,w,x)+c(w,x,y)+c(x,y,v)+c(y,v,w))%4==0&&r.push([v,w,x,y])
j=(v,w,x,y)=>{i(v,w,x,y);i(v,w,y,x);i(v,x,w,y)}
k=(v,w,x,y,z)=>{j(v,w,x,y);j(v,w,x,z);j(v,w,y,z);j(v,x,y,z);j(w,x,y,z)}
f=(v)=>(r=[],k(...v),r)

tests = [
  [[6,8],[1,10],[6,6],[5,9],[8,10]],
  [[3,8],[7,5],[6,9],[7,8],[5,1]],
  [[4,8],[1,9],[9,9],[10,2],[1,6]]
];

tests.forEach(
  (test,i)=>{
    console.log( "Test " + (i+1) );
    f(test).forEach(
      (x)=>console.log( "  " + x.map((e)=>"("+e[0]+","+e[1]+")").join(','))
    );
  }
);

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

मूल संस्करण का उपयोग करके और पहली दो पंक्तियों को बदलने के लिए सह-रैखिक बिंदुओं को भी संभाल सकते हैं:

t=(a,b,c)=>Math.sign((b[0]-a[0])*(b[1]-c[1])-(b[1]-a[1])*(b[0]-c[0]))
p=(a,b,c,d)=>[t(a,b,c),t(b,c,d),t(c,d,a),t(d,a,b)].filter(x=>x).reduce((p,c,i,a)=>p&c==a[0],1)
q=(a,m,n,o)=>[a[0],a[m],a[n],a[o]]
f=(a)=>{r=[];for(i=0;i<5;i++){b=a.slice();b.splice(i,1);r.push(q(b,1,2,3));r.push(q(b,1,3,2));r.push(q(b,2,1,3))}return r.filter((a)=>p(...a))}

हालाँकि, चूंकि उस मामले को विशेष रूप से प्रश्न में बाहर रखा गया है, फिर अतिरिक्त वर्ण आवश्यक नहीं हैं।

Answer 4

गणितज्ञ 105 96 बाइट्स

Select[#~Subsets~{4},f@#&]&(5) अंक की सूची से चयन करता है, 4 अंक के सबसेट जो संतुष्ट करते हैं f।

fसंतुष्ट हो जाता है जब एक सेट में प्रत्येक बिंदु, 4 अंक की, पर झूठ RegionBoundaryके ConvexHull4 अंक की।

f@p_:=Apply[And,RegionBoundary@ConvexHullMesh@p~RegionMember~#&/@p];
Select[#~Subsets~{4},f@#&]&

---

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

1. आइए {{6, 8}, {1, 10}, {6, 6}, {5, 9}, {8, 10}} के 5 उत्तल पतवारों (प्रत्येक 4 बिंदुओं के प्रत्येक) को देखें। ।

Select[#~Subsets~{4},f@#&[{{6, 8}, {1, 10}, {6, 6}, {5, 9}, {8, 10}}]

{{{6, 8}, {1, 10}, {6, 6}, {5, 9}}}

---

{{6, 8}, {1, 10}, {6, 6}, {5, 9}} एकमात्र उपाय है; चार बिंदुओं में से प्रत्येक उत्तल हल के एक शीर्ष के रूप में कार्य करता है (उसी 4 अंक का)।

---

{{6, 8}, {1, 10}, {6, 6}, {8, 10}} कोई समाधान नहीं है; उत्तल पतवार के केवल 3 कोने हैं। {6, 8} पतवार के भीतर है।

---

शेष उपसमूह भी समाधान नहीं हैं:

---

2. {{4, 8} {1, 9} {9, 9} {10, 2} {1, 6}} तीन समाधान है।

Select[#~Subsets~{4},f@#&[{{4, 8}, {1, 9}, {9, 9}, {10, 2}, {1, 6}}]

{
{{४,,}, {१, ९}, {१०, २}, {१, ६}},
{{४, {}, ९, ९}, {१०, २}, {१, ६} }},
{{1, 9}, {9, 9}, {10, 2}, {1, 6}}
}

---

* # {3, 8}, {7, 5}, {6, 9}, {7, 8}, {5, 1}} में 5 समाधान हैं।

Select[#~Subsets~{4},f@#&[{{3, 8}, {7, 5}, {6, 9}, {7, 8}, {5, 1}}]

{
{{3, 8}, {7, 5}, {6, 9}, {7, 8}},
{{3, 8}, {7, 5}, {6, 9}, {5, 1 }},
{{3, 8}, {7, 5}, {7, 8}, {5, 1}},
{{3, 8}, {6, 9}, {7, 8}, {5 , 1}},
{{7, 5}, {6, 9}, {7, 8}, {5, 1}}
}

ध्यान दें कि पाँच में से प्रत्येक बिंदु सभी बिंदुओं के उत्तल पतवार की सीमा पर स्थित है।

यदि किसी एक अंक को हटा दिया जाता है, तो शेष 4 अंक प्रत्येक घटे उत्तल पतवार के लंबवत होंगे।