जाँचें कि बिंदु त्रिभुज के अंदर है या नहीं

40

आपका लक्ष्य यह निर्धारित करना है कि दिए गए 2D बिंदु X त्रिभुज के क्षेत्र में A, B, C के साथ स्थित है या नहीं।

एक फ़ंक्शन लिखें जो परीक्षण बिंदु X और तीन त्रिभुज कोने के निर्देशांक में लेता है (इसलिए यह कुल 8 निर्देशांक है) और यह सत्य है कि यदि बिंदु उस त्रिकोण के अंदर स्थित है, और यदि यह बाहर स्थित है तो गलत है।

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

आपका कोड एक नामित फ़ंक्शन होना चाहिए। कोड स्निपेट स्वीकार नहीं किए जाएंगे।

सबसे कम पात्र जीतते हैं।

इनपुट:

निर्देशांक का प्रतिनिधित्व करने वाले आठ वास्तविक नंबर। संख्या सीमा में होगी (-1,1)।

सटीक इनपुट प्रारूप लचीला है। उदाहरण के लिए, आप आठ संख्याओं में ले सकते हैं, आठ संख्याओं की एक सूची, चार अंक की सूची जो कि एक टपल द्वारा दी गई है, 2 * 4 मैट्रिक्स, चार जटिल संख्याएँ, x- निर्देशांक और y- निर्देशांक की दो सूचियाँ, और इसी तरह।

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

कृपया अपना इनपुट प्रारूप बताएं।

आउटपुट:

या तो संबंधित बूलियन True/ False, संबंधित संख्या 1/ 0या आपकी भाषा में एनालॉग्स।

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

इनपुट को [X,A,B,C]चार ट्यूपल की सूची दी गई है , पहले परीक्षण बिंदु, फिर तीन त्रिभुज कोने। मैंने उन्हें उन लोगों में वर्गीकृत किया है, जिनका आउटपुट होना चाहिए Trueऔर जो होना चाहिए False।

True उदाहरणों:

[(-0.31961, -0.12646), (0.38478, 0.37419), (-0.30613, -0.59754), (-0.85548, 0.6633)]
[(-0.87427, -0.00831), (0.78829, 0.60409), (-0.90904, -0.13856), (-0.80685, 0.48468)]
[(0.28997, -0.03668), (-0.28362, 0.42831), (0.39332, -0.07474), (-0.48694, -0.10497)]
[(-0.07783, 0.04415), (-0.34355, -0.07161), (0.59105, -0.93145), (0.29402, 0.90334)]
[(0.36107, 0.05389), (0.27103, 0.47754), (-0.00341, -0.79472), (0.82549, -0.29028)]
[(-0.01655, -0.20437), (-0.36194, -0.90281), (-0.26515, -0.4172), (0.36181, 0.51683)]
[(-0.12198, -0.45897), (-0.35128, -0.85405), (0.84566, 0.99364), (0.13767, 0.78618)]
[(-0.03847, -0.81531), (-0.18704, -0.33282), (-0.95717, -0.6337), (0.10976, -0.88374)]
[(0.07904, -0.06245), (0.95181, -0.84223), (-0.75583, -0.34406), (0.16785, 0.87519)]
[(-0.33485, 0.53875), (-0.25173, 0.51317), (-0.62441, -0.90698), (-0.47925, 0.74832)]

False उदाहरणों:

[(-0.99103, 0.43842), (0.78128, -0.10985), (-0.84714, -0.20558), (-0.08925, -0.78608)]
[(0.15087, -0.56212), (-0.87374, -0.3787), (0.86403, 0.60374), (0.01392, 0.84362)]
[(0.1114, 0.66496), (-0.92633, 0.27408), (0.92439, 0.43692), (0.8298, -0.29647)]
[(0.87786, -0.8594), (-0.42283, -0.97999), (0.58659, -0.327), (-0.22656, 0.80896)]
[(0.43525, -0.8923), (0.86119, 0.78278), (-0.01348, 0.98093), (-0.56244, -0.75129)]
[(-0.73365, 0.28332), (0.63263, 0.17177), (-0.38398, -0.43497), (-0.31123, 0.73168)]
[(-0.57694, -0.87713), (-0.93622, 0.89397), (0.93117, 0.40775), (0.2323, -0.30718)]
[(0.91059, 0.75966), (0.60118, 0.73186), (0.32178, 0.88296), (-0.90087, -0.26367)]
[(0.3463, -0.89397), (0.99108, 0.13557), (0.50122, -0.8724), (0.43385, 0.00167)]
[(0.88121, 0.36469), (-0.29829, 0.21429), (0.31395, 0.2734), (0.43267, -0.78192)]
code-golf  geometry 
— XNOR
स्रोत
चरित्र की आपकी परिभाषा क्या है? Ascii? 7 बिट्स में एनकोडेबल? एक बाइट में? कोई यूनिकोड?
— 19गैस में isaacg
आपकी क्या सलाह है? पहले से ही समाधान हैं जो संपीड़ित कोड का उपयोग करते हैं।
— xnor
आमतौर पर, मेरा मानना ​​है कि बाइट्स का उपयोग गैर-असिस्की पात्रों के लिए किया जाता है, क्योंकि अन्यथा यूटीएफ -32 का लाभ असंभव है।
— 19गैस में 19
खैर, मैं अब वापस नहीं जा सकता; कोई भी यूनिकोड चरित्र एक चरित्र है। आप चाहें तो कंप्रेस करें।
— xnor

जवाबों:

19

जावास्क्रिप्ट / ईसीएमएस्क्रिप्ट 6, 161 159 158/152

जावास्क्रिप्ट:

function $(t,r,i,a,n,g,l,e){b=(-g*l+a*(-n+l)+i*(g-e)+n*e)/2;c=b<0?-1:1;d=(a*l-i*e+(e-a)*t+(i-l)*r)*c;f=(i*g-a*n+(a-g)*t+(n-i)*r)*c;return d>0&&f>0&&d+f<2*b*c}

ECMAScript 6 संस्करण (धन्यवाद m.buettner, 6 वर्ण बचाता है)

$=(t,r,i,a,n,g,l,e)=>{b=(-g*l+a*(-n+l)+i*(g-e)+n*e)/2;c=b<0?-1:1;d=(a*l-i*e+(e-a)*t+(i-l)*r)*c;f=(i*g-a*n+(a-g)*t+(n-i)*r)*c;return d>0&&f>0&&d+f<2*b*c}

इसे इस तरह से कॉल करें (रिटर्न trueया false):

$(pointX, pointY, v1X, v1Y, v2X, v2Y, v3X, v3Y);

इस उत्तर से कोड के आधार पर कुछ फैंसी बायरसेंट्रिक समन्वय गणित का उपयोग करता है । आपके पढ़ने के आनंद के लिए एक ungolfed संस्करण इस प्रकार है:

function $ (pointX, pointY, v1X, v1Y, v2X, v2Y, v3X, v3Y) {
  var A =  (-v2Y * v3X + v1Y * (-v2X + v3X) + v1X * (v2Y - v3Y) + v2X * v3Y) / 2;
  var sign = A < 0 ? -1 : 1;
  var s = (v1Y * v3X - v1X * v3Y + (v3Y - v1Y) * pointX + (v1X - v3X) * pointY) * sign;
  var t = (v1X * v2Y - v1Y * v2X + (v1Y - v2Y) * pointX + (v2X - v1X) * pointY) * sign;
  return s > 0 && t > 0 && s + t < 2 * A * sign;
}
— अब्राहम
स्रोत
12
+1, यदि केवल पैरामीटर नामों के लिए!
— मैट
आपको मेरे चरित्र-गिनती उपयोगकर्तास्क्रिप्ट को क्यों तोड़ना है ???
— किटकार्ने २२
@ kitcar2000 तुम्हारा क्या मतलब है?
— अब्राहम
नियम कहते हैं कि वर्णों की गणना की जाती है, बाइट्स नहीं। तो आप इसका इस्तेमाल कर सकते हैं: xem.github.io/obfuscatweet को 122 वर्णों में फिट करने के लिए
— xem
1
क्या मैंने गलती की है, या आप (a*(l-n)+i*(g-e)+n*e-g*l)इसके बजाय इस्तेमाल कर सकते थे (-g*l+a*(-n+l)+i*(g-e)+n*e)?
— ज़ाचरी
19

पायथन 2.7 128 127 117 110 109 103 99 99 95 94 91 90

मेरा पहला कोड-गोल्फ प्रयास!

कोड

f=lambda x,y,t:sum(a*y+c*b+d*x<d*a+c*y+b*x for i in(0,1,2)for a,b,c,d in[t[i-1]+t[i]])%3<1

इनपुट के रूप में लेता है (x, y, t) जहां (x, y) वह बिंदु है जिसे हम जाँच रहे हैं और t एक त्रिकोण t = ((X1, y1), (x2, y2), (x3, y3) है।

व्याख्या

मैं मेट्रिसेस के निर्धारकों की गणना कर रहा हूं

| 1 x1 y1 |      | 1 x2 y2 |      | 1 x3 y3 |
| 1 x2 y2 | ,    | 1 x3 y3 | ,    | 1 x1 y1 | .
| 1 x  y  |      | 1 x  y  |      | 1 x  y  |

ये निर्धारक त्रिकोण के किनारों से बिंदु (x, y) तक हस्ताक्षरित दूरियों का प्रतिनिधित्व करते हैं। यदि वे सभी एक ही संकेत हैं, तो बिंदु प्रत्येक पंक्ति के एक ही तरफ है और इस प्रकार त्रिभुज में समाहित है।

ऊपर दिए गए कोड में, a*y+c*b+d*x-d*a-c*y-b*xइन मैट्रिसेस में से एक का निर्धारक है।

मैं तथ्य यह है कि उपयोग कर रहा हूँ True+True+True==3और False+False+False==0अगर इन निर्धारकों सभी एक ही संकेत है निर्धारित करने के लिए।

मैं t[-1]इसके बजाय का उपयोग करके पायथन की नकारात्मक सूची सूचकांकों का उपयोग करता हूं t[(i+1)%3]।

धन्यवाद s%3<1की s in(0,3)जाँच करने के बजाय पीटर का उपयोग करने के लिए धन्यवाद अगर s 0 या 3 है!

Sagemath संस्करण

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

f=lambda p,t,o=[1]:sum([det(Matrix([o+t[i-1],o+t[i],o+p]))<0for i in 0,1,2])%3<1

कहाँ p=[x,y], औरt=[[x1,y1],[x2,y2],[x3,y3]]

— एलेक्स एल
स्रोत
1
s in (0,3)को छोटा किया जा सकता है s%3<1?
— पीटर टेलर
1
नकारात्मक सूचकांकों का उपयोग एक और बचाने के लिए किया जा सकता है: -1,0,1 ... t[i]+t[i+1]बराबर है0,1,2 ... t[i-1]+t[i]
— पीटर टेलर
@PeterTaylor बिलकुल सही! बहुत बुरा मैंने in -1,0,1इसे पढ़ने से पहले अंतरिक्ष को हटा दिया । वास्तव में आपका रास्ता अधिक पठनीय है इसलिए मैं इसे वैसे भी उपयोग करूँगा।
— एलेक्स एल
1
गोल्फ में आपका स्वागत है! sumयदि आप 0,1,2कोष्ठक में संलग्न करते हैं , तो आप अंतरिक्ष के स्थान पर एक वर्ण को अंकित करते हुए सूची बोध के लिए वर्ग कोष्ठक से छुटकारा पा सकते हैं । कारण यह है कि पायथन कार्यों में असंबद्ध समझ को पारित करने की अनुमति देता है, लेकिन नग्न टपल में कॉमा 1,2,3इसे भ्रमित करते हैं क्योंकि यह उन्हें अलग-अलग तर्कों के रूप में पार्स करने की कोशिश करता है।
— 22
16

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

f=Equal@@({#2,-#}&@@(#-#2).(x-#)>0&@@@Partition[x=#;#2,2,1,{1,1}])&

फ़ंक्शन दो तर्क, बिंदु Xऔर बिंदुओं की एक सूची लेता है {A,B,C}, जिन्हें क्रमशः #और #2क्रमशः संदर्भित किया जाता है। अगर आप कॉल करते हैं

f[X,{A,B,C}]

तो आप मिल जाएगा #के रूप में Xऔर #2के रूप में {A,B,C}। (ध्यान दें कि कोड के अंदर दो अन्य अनाम फ़ंक्शन हैं - #और #2उनके भीतर एक अलग अर्थ है।)

यहाँ फ़ंक्शन का स्पष्टीकरण है:

                                              x=#;#2            & (* Save X into a variable x, but evaluate to {A,B,C}. *)
                                    Partition[x=#;#2,2,1,{1,1}] & (* Get a cyclic list of pairs {{A,B},{B,C},{C,B}}. *)
       (                        &@@@Partition[x=#;#2,2,1,{1,1}])& (* Define an anonymous function and apply it to each 
                                                                     of the above pairs. The two elements are referred 
                                                                     to as # and #2. *)
       (          (#-#2)        &@@@Partition[x=#;#2,2,1,{1,1}])& (* Subtract the two points. For a pair of vertices 
                                                                     this yields a vector corresponding to the edge 
                                                                     between them. *)
        {#2,-#}&                                                  (* An anonymous function that takes two values, 
                                                                     reverses them, inverts the sign of one of them 
                                                                     and puts them into a list. *)
       ({#2,-#}&@@(#-#2)        &@@@Partition[x=#;#2,2,1,{1,1}])& (* Applied to the edge, this yields its normal. *)
       ({#2,-#}&@@(#-#2).(x-#)  &@@@Partition[x=#;#2,2,1,{1,1}])& (* Take the scalar product of that normal with a
                                                                     vector from a vertex to x. This is projection of 
                                                                     this vector onto that normal and hence the SIGNED
                                                                     distance of x from the edge. *)
       ({#2,-#}&@@(#-#2).(x-#)>0&@@@Partition[x=#;#2,2,1,{1,1}])& (* Check the sign of that distance, the exact mapping 
                                                                     between (left, right) and (True, False) is 
                                                                     irrelevant, as long as it's consistent. *)
Equal@@({#2,-#}&@@(#-#2).(x-#)>0&@@@Partition[x=#;#2,2,1,{1,1}])& (* Check if all signs are equal - that is, if point X 
                                                                     lies on the same side of all edges. This is 
                                                                     equivalent to check that the point is inside the 
                                                                     triangle. *)

ध्यान दें कि यह फ़ंक्शन वास्तव में किसी भी उत्तल n-gon के लिए काम करेगा, जब तक कि इसके वर्टीकल या दक्षिणावर्त क्रम में दिए गए हों।

— मार्टिन एंडर
स्रोत
यह जाँचने के लिए अधिक कुशल नहीं होगा कि क्या सभी संकेतों के बराबर होने पर दूरियों का उत्पाद सकारात्मक है? मैं गणितज्ञ नहीं हूं, लेकिन ऐसा लगता है कि यह आसान होना चाहिए।
— २०:०४ में isaacg
@ आइसाकग तीन शब्द हैं, इसलिए यदि वे सभी नकारात्मक हैं, तो उनका उत्पाद नकारात्मक है और यदि वे सभी सकारात्मक हैं, तो उनका उत्पाद सकारात्मक है। आपका दृष्टिकोण केवल तभी काम करता है जब दो संख्याओं के चिह्न बराबर हों।
— मार्टिन एंडर
उपयोग क्यों नहीं Det?
— एलेफल्फा
@alephalpha खैर, ज्यादातर संभावना है क्योंकि मैं इसके बारे में नहीं सोचा था। : पी ... मैं उस पर गौर करूंगा
— मार्टिन एंडर
@alephalpha Hm नहीं, मुझे कम पात्रों में तीन आवश्यक मैट्रिस बनाने के लिए अभी कोई रास्ता नहीं मिल रहा है।
— मार्टिन एंडर
7

CJam, 66 63 59 52 46 34 32 31 30 28 वर्ण

"Ă䒟损崙㩴ァ椟饃꿾藭鑭蘁"2G#b131b:c~

यूनिकोड स्ट्रिंग को बदलने के बाद, निम्न कोड ( 33 बाइट्स ) का मूल्यांकन किया जाता है:

{2*2/\f{f{+~@-@@-}~@@*@@*>})-!}:T

X [A B C]इनपुट के रूप में अपेक्षित है , जहां प्रत्येक बिंदु फॉर्म का है [double double]। आउटपुट 1 या 0 है।

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

एक बड़ा धन्यवाद 6 अक्षर (असम्पीडित कोड के 13 बाइट्स) को बचाने के लिए user23013 पर जाता है !

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

$ cat triangle.cjam
"Ă䒟损崙㩴ァ椟饃꿾藭鑭蘁"2G#b131b:c~

[
  [-0.31961 -0.12646] [ [0.38478 0.37419]   [-0.30613 -0.59754] [-0.85548 0.6633]   ] T
  [-0.87427 -0.00831] [ [0.78829 0.60409]   [-0.90904 -0.13856] [-0.80685 0.48468]  ] T
  [0.28997 -0.03668]  [ [-0.28362 0.42831]  [0.39332 -0.07474]  [-0.48694 -0.10497] ] T
  [-0.07783 0.04415]  [ [-0.34355 -0.07161] [0.59105 -0.93145]  [0.29402 0.90334]   ] T
  [0.36107 0.05389]   [ [0.27103 0.47754]   [-0.00341 -0.79472] [0.82549 -0.29028]  ] T
  [-0.01655 -0.20437] [ [-0.36194 -0.90281] [-0.26515 -0.4172]  [0.36181 0.51683]   ] T
  [-0.12198 -0.45897] [ [-0.35128 -0.85405] [0.84566 0.99364]   [0.13767 0.78618]   ] T
  [-0.03847 -0.81531] [ [-0.18704 -0.33282] [-0.95717 -0.6337]  [0.10976 -0.88374]  ] T
  [0.07904 -0.06245]  [ [0.95181 -0.84223]  [-0.75583 -0.34406] [0.16785 0.87519]   ] T
  [-0.33485 0.53875]  [ [-0.25173 0.51317]  [-0.62441 -0.90698] [-0.47925 0.74832]  ] T
  [-0.99103 0.43842]  [ [0.78128 -0.10985]  [-0.84714 -0.20558] [-0.08925 -0.78608] ] T
  [0.15087 -0.56212]  [ [-0.87374 -0.3787]  [0.86403 0.60374]   [0.01392 0.84362]   ] T
  [0.1114 0.66496]    [ [-0.92633 0.27408]  [0.92439 0.43692]   [0.8298 -0.29647]   ] T
  [0.87786 -0.8594]   [ [-0.42283 -0.97999] [0.58659 -0.327]    [-0.22656 0.80896]  ] T
  [0.43525 -0.8923]   [ [0.86119 0.78278]   [-0.01348 0.98093]  [-0.56244 -0.75129] ] T
  [-0.73365 0.28332]  [ [0.63263 0.17177]   [-0.38398 -0.43497] [-0.31123 0.73168]  ] T
  [-0.57694 -0.87713] [ [-0.93622 0.89397]  [0.93117 0.40775]   [0.2323 -0.30718]   ] T
  [0.91059 0.75966]   [ [0.60118 0.73186]   [0.32178 0.88296]   [-0.90087 -0.26367] ] T
  [0.3463 -0.89397]   [ [0.99108 0.13557]   [0.50122 -0.8724]   [0.43385 0.00167]   ] T
  [0.88121 0.36469]   [ [-0.29829 0.21429]  [0.31395 0.2734]    [0.43267 -0.78192]  ] T
]p;

$ cjam triangle.cjam
[1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0 0 0 0 0]
— डेनिस
स्रोत
यह एक नामित कार्य है?
— मार्टिन एंडर
@ m.buettner: क्रमबद्ध। आधिकारिक विकि : निम्नलिखित कहते हैं - एक कार्यक्रम अनुभाग द्वारा सीमांकित ब्लॉक {और }और एक इकाई के रूप में व्यवहार किया। सी / जावा में कोड ब्लॉक के समान, ब्लॉक को छोड़कर प्रथम श्रेणी की वस्तुएं हैं और उन्हें चर (इस प्रकार कार्यों को परिभाषित करना) को सौंपा जा सकता है।
— डेनिस
1
@xnor 1m<@m*X के 3 जोड़े और i+1त्रिकोण के अगले ( वें) शीर्ष को तैयार करता है । @-@@-वर्तमान ( iवें) शीर्ष को मूल में ले जाता है (और यदि यह नहीं था @-\@-, तो यह स्पष्ट नहीं है)। @@*@@*>क्रॉस उत्पाद, उर्फ ​​निर्धारक की जेड-अक्ष की गणना करता है, और 1यदि यह नकारात्मक है तो वापस आ जाता है। :+3%!रिटर्न कि क्या वे सभी समान हैं, अर्थात सभी 3 नकारात्मक या गैर-नकारात्मक हैं, जिसका अर्थ है कि किनारे के मामलों को छोड़कर सकारात्मक। मुझे लगता है कि सीजेएम को गोल्फ से पढ़ना ज्यादा चुनौतीपूर्ण है।
— jimmy23013
1
37 बाइट्स {[_1m<\]z\f{f{+~@-@@-}~@@*@@*>})-!}:T:। यूनिकोड सुरक्षा के लिए उपयोग करें 2m>या Wm<।
— jimmy23013
1
33 बाइट्स:{2*2/\f{f{+~@-@@-}~@@*@@*>})-!}:T
— jimmy23013
5

सी - 156 बाइट्स

इनपुट एक्स में 3 फ्लोट्स की सरणी है, वाई में 3 फ्लोट्स और टेस्ट पॉइंट के लिए अलग एक्स और वाई हैं। बोनस: सभी किनारे मामलों को संभालता है!

int f(float*X,float*Y,float x,float y){int i,j,c=0;for(i=0,j=2;i<3;j=i++)if(((Y[i]>y)!=(Y[j]>y))&&(x<(X[j]-X[i])*(y-Y[i])/(Y[j]-Y[i])+X[i]))c=!c;return c;}

PNPOLY से अनुकूलित।

i;j;c;f(float*X,float*Y,float x,float y){for(c=i=0,j=2;i<3;)c^=(Y[i]>y)-(Y[j]>y)&(x<(X[j]-X[i])*(y-Y[i])/(Y[j]-Y[i])+X[j=i++]);return c;}137 - जावास्क्रिप्ट में परीक्षण किया गया
— बीबीक्यू
@ कबी - यह एक वाक्यविन्यास त्रुटि का कारण बनता है।
— डेरेक 會 會
यह सिंटैक्स त्रुटि का कारण नहीं बनता है।
— bebe
4

पायथ 1.0.5 , 57 54 51

DgYb=Z0J'bWbK;bDiHNR*-'H'K-@N1@K1~Z>iYJiJY=JK)R!%Z3

फ़ंक्शन जी को परिभाषित करता है, जो दो इनपुट लेता है: परीक्षण बिंदु, और फिर त्रिकोण के कोने की सूची। आउटपुट Trueऔर False। नोट: इनपुट को नष्ट कर देता है, विशेष रूप से b, त्रिकोण के कोने की सूची।

इसे यहाँ आज़माएँ । अंतिम कुछ वर्ण, gvwvwअगली दो पंक्तियों पर परीक्षण मामले के साथ फ़ंक्शन को कॉल करते हैं।

इस एल्गोरिथ्म पर आधारित

स्पष्टीकरण:

DgYb                  Define g(Y,b):
=Z0                     Z=0
J'b                     J=b[0]              (No = is needed because j is special).
Wb                      While len(b)>0:     (While b:)
K;b                       K=b.pop()
DiHN                      Define i(H,N):    
R*-'H'K-@N1@K1              Return half of the linked equation.
~ZiYJiJY                  Z+=i(Y,J)>i(J,Y)
=JK                       J=K
)                       Wend
R!%Z3                   return not Z%3==0   (True iff Z == 0 or 3)

CJam - अजगर युद्ध पर क्रोध!

— isaacg
स्रोत
यह एक नामित कार्य होना चाहिए। क्या wSTDIN इनपुट ले रहा है?
— xnor
@ एक्सनोर ऊप्स, मुझे वर्णन का वह टुकड़ा याद आ गया। संपादित करेंगे।
— इसहाक
@xnor क्या फ़ंक्शंस हैं जो प्रिंट किए गए उत्तर की अनुमति देते हैं, या क्या उन्हें जवाब वापस करना चाहिए? वर्तमान में, यह उत्तर को प्रिंट करता है, लेकिन मैं इसे एक और चरित्र के लिए वापस कर सकता था।
— इसहाक
उत्तर लौटा दो।
— Xnor
क्या आप शायद Zखाली सेट के साथ काउंटर को बदलकर पात्रों को बचा सकते हैं Z|=, जो आप के साथ जमा करते हैं , फिर इसकी लंबाई का परीक्षण करें कि क्या केवल देखा गया है 0या नहीं 1? पाइथन में रणनीति अधिक लंबी हो गई, लेकिन शायद यह पायम प्राइमेटिव्स का उपयोग करने लायक है।
— xnor
4

J 64 45 (असाइनमेंट के बिना 42)

c=:*./@(>:&0)@({.(,(1-+/))@%.|:@}.)@(}:-"1{:)

कार्य एक कार्य होने के लिए आवश्यक नहीं है, इसलिए यह अनिश्चित है कि इसे गिनें या नहीं। लचीले इनपुट का लाभ उठाते हुए: मैं (1 + संख्या की संख्या) x (अंतरिक्ष की गतिशीलता) की एक सरणी रखना चाहता हूं।

यहां कुछ अतिरिक्त अंक स्कोर करने की उम्मीद ...: यह बात किसी प्लेन में त्रिकोण के ही नहीं, बल्कि 3 डी स्पेस और इसी तरह 3 साइड के पिरामिड के सिम्पलेक्स के किसी भी आयाम के लिए काम करती है। यह तब भी काम करता है जब सिम्प्लेक्स के कोने की संख्या (n + 1) से छोटी होती है, तो यह गणना करता है कि सिम्प्लेक्स पर बिंदु का प्रक्षेपण अंदर है या नहीं।

यह बेरेंट्रिक निर्देशांक में परिवर्तित हो जाता है , फिर नकारात्मक लोगों के लिए जांच करता है, यह इंगित करता है कि बिंदु बाहर है। बुरा मत मानिए J नकारात्मक के लिए _ का उपयोग करता है

NB. example in triangle
D =: 4 2 $ 1 1 0 0 3 0 0 2 NB. 4 rows , x first, then the vertices of the triangle

NB. subtract last vertex coordinates from the rest and drop reference node
n=: (}:-"1{:)

NB. preprocessed to barycentric coordinates
bar=: {. (, 1 - +/)@%. |:@}.

NB. all positive
ap =: *./@(>:&0)

insided =: ap@bar@n

inside D
1

दिए गए उदाहरणों पर एक रन:

   true =: 0 : 0
[(-0.31961, -0.12646), (0.38478, 0.37419), (-0.30613, -0.59754), (-0.85548, 0.6633)]
[(-0.87427, -0.00831), (0.78829, 0.60409), (-0.90904, -0.13856), (-0.80685, 0.48468)]
[(0.28997, -0.03668), (-0.28362, 0.42831), (0.39332, -0.07474), (-0.48694, -0.10497)]
[(-0.07783, 0.04415), (-0.34355, -0.07161), (0.59105, -0.93145), (0.29402, 0.90334)]
[(0.36107, 0.05389), (0.27103, 0.47754), (-0.00341, -0.79472), (0.82549, -0.29028)]
[(-0.01655, -0.20437), (-0.36194, -0.90281), (-0.26515, -0.4172), (0.36181, 0.51683)]
[(-0.12198, -0.45897), (-0.35128, -0.85405), (0.84566, 0.99364), (0.13767, 0.78618)]
[(-0.03847, -0.81531), (-0.18704, -0.33282), (-0.95717, -0.6337), (0.10976, -0.88374)]
[(0.07904, -0.06245), (0.95181, -0.84223), (-0.75583, -0.34406), (0.16785, 0.87519)]
[(-0.33485, 0.53875), (-0.25173, 0.51317), (-0.62441, -0.90698), (-0.47925, 0.74832)]
)

   false =: 0 : 0
[(-0.99103, 0.43842), (0.78128, -0.10985), (-0.84714, -0.20558), (-0.08925, -0.78608)]
[(0.15087, -0.56212), (-0.87374, -0.3787), (0.86403, 0.60374), (0.01392, 0.84362)]
[(0.1114, 0.66496), (-0.92633, 0.27408), (0.92439, 0.43692), (0.8298, -0.29647)]
[(0.87786, -0.8594), (-0.42283, -0.97999), (0.58659, -0.327), (-0.22656, 0.80896)]
[(0.43525, -0.8923), (0.86119, 0.78278), (-0.01348, 0.98093), (-0.56244, -0.75129)]
[(-0.73365, 0.28332), (0.63263, 0.17177), (-0.38398, -0.43497), (-0.31123, 0.73168)]
[(-0.57694, -0.87713), (-0.93622, 0.89397), (0.93117, 0.40775), (0.2323, -0.30718)]
[(0.91059, 0.75966), (0.60118, 0.73186), (0.32178, 0.88296), (-0.90087, -0.26367)]
[(0.3463, -0.89397), (0.99108, 0.13557), (0.50122, -0.8724), (0.43385, 0.00167)]
[(0.88121, 0.36469), (-0.29829, 0.21429), (0.31395, 0.2734), (0.43267, -0.78192)]
)
   NB. replace - by _ to avoid problems
   NB. cut up per row, drop the [ ] and convert to numbers
   $dat_t =: ((4 2 $ ".)@}:@}.;._2) (true='-')} true ,: '_'
10 4 2
   $dat_f =: ((4 2 $ ".)@}:@}.;._2) (false='-')}false,: '_'
10 4 2
   NB. this results in arrays with shape 10 4 2

   NB. for each 4 x 2 array (rank 2), do c for all true instances
   c=:*./@(>:&0)@({.(,(1-+/))@%.|:@}.)@(}:-"1{:)
   c"2 dat_t
1 1 1 1 1 1 1 1 1 1
   NB. the same for the false ones, demonstrating anonymous usage
   NB. still a function though (or verb in J parlance)
   *./@(>:&0)@({.(,(1-+/))@%.|:@}.)@(}:-"1{:)"2 dat_f
0 0 0 0 0 0 0 0 0 0
— jpjacobs
स्रोत
मैंने एक नामित फ़ंक्शन के लिए कहा, इसलिए असाइनमेंट वर्ण गणना करते हैं। बहुभुज के सामान्यीकरण के लिए कुछ बिंदु इस प्रकार हैं! ······
— XNOR
ठीक है, वास्तव में, मैं बहुभुज के लिए सामान्यीकरण नहीं करता हूं, लेकिन अधिकतम आयामों के साथ एन-आयामी सिम्प्लेक्स तक N+1। उदाहरण के लिए 3-डी स्पेस में 4 वर्टेक्स पिरामिड, या 4-डी स्पेस में 5 वर्टेक्स सिंप्लेक्स। वर्टिकल की संख्या इससे कम हो सकती है N+1, जिस स्थिति में एल्गोरिथ्म दिखता है कि हाइपरप्लेन पर ऑर्थोगोनल प्रोजेक्शन सिम्प्लेक्स सिंप्लेक्स के अंदर झूठ में रहता है या नहीं (जैसे 2-डी में 2 पॉइंट सिम्प्लेक्स लाइन पर प्रोजेक्ट किया जाएगा और जाँच की जाएगी क्या यह प्रक्षेपण अंतिम बिंदुओं के बीच है)
— jpjacobs
4

एचटीएमएल 5 + जेएस, 13 बी + 146 बी / 141 बी / 114 चार्ट

HTML:

<canvas id=C>

जेएस (146 बी):

// @params: t1x, t1y, t2x, t2y, t3x, t3y, pointx, pointy
function T(a,b,c,d,e,f,g,h){with(C.getContext("2d"))return beginPath(),moveTo(a,b),lineTo(c,d),lineTo(e,f),fill(),!!getImageData(g,h,1,1).data[3]}

या ईएस 6 (141 बी):

T=(a,b,c,d,e,f,g,h)=>{with(C.getContext("2d"))return beginPath(),moveTo(a,b),lineTo(c,d),lineTo(e,f),fill(),!!getImageData(g,h,1,1).data[3]}

या ईएस 6 यूनिकोड-ओब्सेस्ड (114 वर्ण):

eval(unescape(escape('𥀽𚁡𛁢𛁣𛁤𛁥𛁦𛁧𛁨𚐽🡻𭱩𭁨𚁃𛡧𩑴𠱯𫡴𩑸𭀨𘠲𩀢𚐩𬡥𭁵𬡮𘁢𩑧𪑮𤁡𭁨𚀩𛁭𫱶𩑔𫰨𨐬𨠩𛁬𪑮𩑔𫰨𨰬𩀩𛁬𪑮𩑔𫰨𩐬𩠩𛁦𪑬𫀨𚐬𘐡𩱥𭁉𫑡𩱥𡁡𭁡𚁧𛁨𛀱𛀱𚐮𩁡𭁡𦰳𧑽').replace(/uD./g,'')))

डेमो: http://jsfiddle.net/xH8mV/

यूनिकोड ऑबफसकेशन के साथ किया गया: http://xem.github.io/obfuscatweet/

— XEM
स्रोत
बिंदु के करीब होने पर यह सही परिणाम नहीं देता है: jsfiddle.net/L2B2A मेरा मानना ​​है कि ऐसा इसलिए है क्योंकि सभी इनपुट (-1,1) के बीच हैं, और आपका कोड केवल 4 पिक्सेल का परीक्षण कर रहा है मूल।
— डेरेक 會 會 k
यह सही है, उदाहरणों को फिट करने के लिए, मुझे [-1,1] के अंदर त्रिकोण को संभालने के लिए मूल और अपने कैनवास के पैमाने को बदलना चाहिए। लेकिन वे त्रिकोण इतने छोटे रास्ते क्यों हैं?
— xem
समस्या कहती है कि सभी xy -1 और 1 के बीच हैं। वास्तव में पता नहीं क्यों, लेकिन मेरा मानना ​​है कि आप हर इनपुट को 1e7 से गुणा कर सकते हैं (सटीक बनाए रखने के लिए) सही परिणाम प्राप्त कर सकते हैं: D
— Derek 會 x
एक चित्रमय समाधान, बहुत चालाक!
— xnor
3

पायथन (65)

लोगों को यह प्रतीत होता है कि वे सबमिट कर रहे हैं, इसलिए मैं अपने प्रश्न का अपना समाधान पोस्ट करूंगा।

f=lambda X,L:sum(((L[i-1]-X)/(L[i]-X)).imag>0for i in(0,1,2))%3<1

Xपरीक्षण बिंदुओं का प्रतिनिधित्व करने वाली जटिल संख्या है, और Lतीन बिंदुओं की एक सूची है, प्रत्येक एक जटिल संख्या है।

पहले, मैं कोड के एक कम गोल्फ वाले संस्करण की व्याख्या करूँगा;

def f(X,A,B,C):A-=X;B-=X;C-=X;return((A/B).imag>0)==((B/C).imag>0)==((C/A).imag>0)

हम अंक बदलाव A,B,C,Xताकि Xमूल में है, पायथन के अंतर्निहित जटिल गणित का लाभ लेने के। हमें यह जांचने की आवश्यकता है कि क्या मूल उत्तल हल में समाहित है A,B,C। यह लाइन सेगमेंट AB, BC, और AC के हमेशा एक ही तरफ (बाएं या दाएं) स्थित मूल के बराबर है।

एक सेगमेंट ABमें बाईं ओर मूल है अगर एक यात्रा ए से बी तक प्राप्त करने के लिए 180 डिग्री से कम वामावर्त, और दाईं ओर अन्यथा। अगर हम कोणों और इन बिंदुओं के अनुसार विचार करते हैं a, तो इसका मतलब है (0 से 360 डिग्री के कोण में कोण)। जटिल संख्या के रूप में, । इसके अलावा, वह ऊपरी आधे विमान में बिंदु के लिए, जिसे हम जांचते हैं ।bcb-a < 180 degreesangle(B/A)=angle(B)/angle(A)angle(x) < 180 degreesimag(x)>0

तो क्या मूल एबी के बाईं ओर स्थित है जैसा कि व्यक्त किया गया है (A/B).imag>0। यह जाँचना कि क्या ये सभी प्रत्येक चक्रीय जोड़ी के लिए समान हैं, A,B,Cहमें बताता है कि क्या त्रिभुज ABCमें मूल है।

अब, चलो पूरी तरह से गोल्फ कोड पर लौटते हैं

f=lambda X,L:sum(((L[i-1]-X)/(L[i]-X)).imag>0for i in(0,1,2))%3<1

हम में प्रत्येक चक्रीय जोड़ी उत्पन्न (A-X,B-X,C-X)=(L[0]-X,L[1]-X,L[2]-X), नकारात्मक अजगर सूची के चारों ओर लपेटकर सूचकांक (का लाभ लेने L[-1]= L[2])। यह जांचने के लिए कि बूल सभी हैं True( 1) या सभी False( 0), हम उन्हें जोड़ते हैं और 3 से विभाज्यता की जांच करते हैं, जैसा कि कई समाधानों ने किया था।

— XNOR
स्रोत
2

फोरट्रान - 232 218 195 174

खूनी भयानक। फ़ंक्शन इस आवश्यकता के कारण भयावह है कि डेटा इसे पारित किया गया है और हम इसे प्रीप्रोसेस नहीं कर सकते।

logical function L(x);real::x(8);p=x(1)-x(3);q=x(2)-x(4);r=x(5)-x(3);s=x(6)-x(4);t=x(7)-x(3);u=x(8)-x(4);L=ALL([p*(s-u)+q*(t-r)+r*u-t*s,p*u-q*t,q*r-p*s]>=r*u-t*s);endfunction

14 वर्णों की कमी इसलिए है क्योंकि मैं अपने टेस्ट रन से फ़ंक्शन नाम को भूल गया। आगे की कमी अंतर्निहित टाइपिंग और फ़ंक्शन का नाम बदलने के लिए भूल जाने के कारण है। अंक में एकल सरणी के रूप में पढ़ने के कारण अगले 20 अक्षर बंद हो गए। पूरा कार्यक्रम है

program inTriagle
   real, dimension(2) :: a,b,c,x
   do 
      print*,"Enter coordinates as x,a,b,c"
      read*,x,a,b,c
      if(all(x==0.0).and.all(a==0.0).and.all(b==0.0).and.all(c==0.0)) exit
      print*,"Is point in triangle: ",T(x,a,b,c)
   enddo
 contains!                       
   logical function L(x)
     real::x(8)
     p=x(1)-x(3);q=x(2)-x(4);r=x(5)-x(3)
     s=x(6)-x(4);t=x(7)-x(3);u=x(8)-x(4)
     L=ALL([p*(s-u)+q*(t-r)+r*u-t*s,p*u-q*t,q*r-p*s]>=r*u-t*s)
   endfunction
end program inTriagle
— काइल कानोस
स्रोत
1
आप फोरट्रान के अंतर्निहित टाइपिंग पर भरोसा करके और सभी 8 नंबरों वाले एकल इनपुट सरणी का उपयोग करके इसे थोड़ा कम कर सकते हैं: logical function T(x);real x(8);p=x(1)-x(3);q=x(2)-x(4);r=x(5)-x(3);s=x(6)-x(4);u=x(7)-x(3);v=x(8)-x(4);o=r*v-u*s;T=ALL([p*(s-v)+q*(u-r)+o,p*v-q*u,q*r-p*s]>=o);endमैंने सूची संचालन का उपयोग करके इसे और छोटा करने की कोशिश की है, लेकिन दुर्भाग्य से यह बहुत अच्छी तरह से काम नहीं किया।
— वेंटरो जूल
1
अधिक सामान्य सबटेक्शंस को समाप्त करके भी छोटा: logical function T(x);real x(8);p=x(1)-x(3);q=x(2)-x(4);r=x(5)-x(3);s=x(6)-x(4);u=x(7)-x(3);v=x(8)-x(4);a=r*v-u*s;b=p*v-q*u;d=q*r-p*s;T=ALL([a-b-d,b,d]>=a);endमुझे आशा है कि मैंने परिवर्तनों में कोई गलती नहीं की है! हालांकि ऐसा लगता है कि आपका मूल कोड सभी टेस्टकेस को पास नहीं करता है।
— वेंचरो
@ वेंटरो: मैं विश्वास नहीं कर सकता कि मैं निहित टाइपिंग का दुरुपयोग करना भूल गया :( आपकी मदद के लिए धन्यवाद!
— काइल कानोस
@Ventero: इसके अलावा, ऐसा लगता है कि मेरा जवाब त्रिकोण के उन्मुखीकरण पर निर्भर करता है। Trueओपी में पहला उदाहरण देता है Falseअगर मैं मूल अभिविन्यास के लिए देते समय स्वैप Bऔर Cमूल्यों को True।
— काइल कानोस
आह, वास्तव में, समस्या तब होती है जब (मेरी पिछली टिप्पणी से नोटेशन का फिर से उपयोग करते हुए) a < 0, जो प्रभावी रूप से आपके द्वारा परीक्षण की गई स्थिति को प्रभावित करता है। दुर्भाग्य से यह सब कुछ एक में लपेटकर तय नहीं किया जा सकता है abs, जैसा कि तब निहित स्थिति bऔर खो dजाने के समान संकेत होना a। इसे कुछ का उपयोग करके (फिर से, मेरी पिछली टिप्पणी से अंकन और पूर्व-परिभाषित चर का उपयोग करके) तय किया जा सकता है e=a-b-d;T=ALL([a*a-b*b,a*a-d*d,a*a-e*e,a*b,a*d,a*e]>=0)- जो शायद अधिक गोल्फ हो सकता है।
— वेंटरो
2

MATLAB: 9!

यहाँ लिखने के लिए मुझे बहुत कुछ नहीं

inpolygon

ऐसा कहा जा सकता है:

inpolygon(2/3, 2/3, [0 1 1], [0 0 1])

आउटपुट नाम के एक चर को सौंपा गया है ans

अगर मुझे वास्तव में एक फ़ंक्शन लिखना था, तो यह कुछ ऐसा हो सकता है, शायद अनुकूलित किया जा सकता है:

function y=f(a,b,c,d)
inpolygon(a,b,c,d)
— डेनिस जहरुद्दीन
स्रोत
2
एक फ़ंक्शन हैंडल का उपयोग करके कम किया जा सकता है:f=@(a,b,c,d)inpolygon(a,b,c,d)
— jpjacobs
2

C # 218 (149?)

using P=System.Drawing.PointF;
bool F(P[]p){for(int i=0;i<4;i++){p[i].X*=1e7f;p[i].Y*=1e7f;}P[]a=new P[3];Array.Copy(p,1,a,0,3);var g=new System.Drawing.Drawing2D.GraphicsPath();g.AddLines(a);return g.IsVisible(p[0]);}

संभवतः गणितीय पद्धति के रूप में चरित्र-कुशल नहीं है, लेकिन यह पुस्तकालयों का एक मजेदार उपयोग है। संयोग से, बल्कि धीमा भी।

इसके अलावा "संख्यात्मक स्थिरता या फ्लोटिंग-पॉइंट परिशुद्धता के बारे में चिंता न करें" का लाभ उठाएं। - दुर्भाग्य से, आंतरिक रूप से s GraphicsPathका उपयोग करता है int, इसलिए श्रेणी -1 <f <1 में एक मान केवल तीन संभावित मान हो सकता है। चूँकि तैरने के लिए केवल 7 अंको की सटीकता होती है, मैं सिर्फ 1e7 से गुणा करके उन्हें पूरी संख्या में बदल देता हूँ। हम्म, मुझे लगता है कि यह वास्तव में कोई सटीक नहीं खो रहा है । यह दूसरे तरीके से भी शोषक है: मैं शायद सटीकता की अनदेखी का फायदा उठा सकता था और सिर्फ "गलत" जवाब दिया।

यदि मुझे पुस्तकालयों के आयात की चरित्र लागत को अनदेखा करने की अनुमति है, तो 149 (बहुत कम से कम, System.Linqऔर System.Drawingअधिकांश WinForms परियोजनाओं पर मानक हैं, लेकिन System.Drawing.Drawing2Dथोड़ा खिंचाव हो सकता है):

bool G(PointF[]p){for(int i=0;i<4;i++){p[i].X*=1e7f;p[i].Y*=1e7f;}var g=new GraphicsPath();g.AddLines(p.Skip(1).ToArray());return g.IsVisible(p[0]);}

परीक्षण कार्यक्रम (हाँ, यह बदसूरत है):

using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using P=System.Drawing.PointF;
using System.Linq;

class Program
{
    static void Main(string[] args)
    {
        Program prog = new Program();
        foreach (string test in
@"[(-0.31961, -0.12646), (0.38478, 0.37419), (-0.30613, -0.59754), (-0.85548, 0.6633)]
[(-0.87427, -0.00831), (0.78829, 0.60409), (-0.90904, -0.13856), (-0.80685, 0.48468)]
[(0.28997, -0.03668), (-0.28362, 0.42831), (0.39332, -0.07474), (-0.48694, -0.10497)]
[(-0.07783, 0.04415), (-0.34355, -0.07161), (0.59105, -0.93145), (0.29402, 0.90334)]
[(0.36107, 0.05389), (0.27103, 0.47754), (-0.00341, -0.79472), (0.82549, -0.29028)]
[(-0.01655, -0.20437), (-0.36194, -0.90281), (-0.26515, -0.4172), (0.36181, 0.51683)]
[(-0.12198, -0.45897), (-0.35128, -0.85405), (0.84566, 0.99364), (0.13767, 0.78618)]
[(-0.03847, -0.81531), (-0.18704, -0.33282), (-0.95717, -0.6337), (0.10976, -0.88374)]
[(0.07904, -0.06245), (0.95181, -0.84223), (-0.75583, -0.34406), (0.16785, 0.87519)]
[(-0.33485, 0.53875), (-0.25173, 0.51317), (-0.62441, -0.90698), (-0.47925, 0.74832)]
[(-0.99103, 0.43842), (0.78128, -0.10985), (-0.84714, -0.20558), (-0.08925, -0.78608)]
[(0.15087, -0.56212), (-0.87374, -0.3787), (0.86403, 0.60374), (0.01392, 0.84362)]
[(0.1114, 0.66496), (-0.92633, 0.27408), (0.92439, 0.43692), (0.8298, -0.29647)]
[(0.87786, -0.8594), (-0.42283, -0.97999), (0.58659, -0.327), (-0.22656, 0.80896)]
[(0.43525, -0.8923), (0.86119, 0.78278), (-0.01348, 0.98093), (-0.56244, -0.75129)]
[(-0.73365, 0.28332), (0.63263, 0.17177), (-0.38398, -0.43497), (-0.31123, 0.73168)]
[(-0.57694, -0.87713), (-0.93622, 0.89397), (0.93117, 0.40775), (0.2323, -0.30718)]
[(0.91059, 0.75966), (0.60118, 0.73186), (0.32178, 0.88296), (-0.90087, -0.26367)]
[(0.3463, -0.89397), (0.99108, 0.13557), (0.50122, -0.8724), (0.43385, 0.00167)]
[(0.88121, 0.36469), (-0.29829, 0.21429), (0.31395, 0.2734), (0.43267, -0.78192)]".Split('\n'))
        {
            string t = test.Replace("[(", "").Replace(")]", "");
            string[] points = t.Split(new string[] { "), (" }, StringSplitOptions.None);

            string[] p = points[0].Split(',');
            P[] xabc = new P[4];

            for (int i = 0; i < 4; i++)
            {
                p = points[i].Split(',');
                xabc[i] = new F(float.Parse(p[0]), float.Parse(p[1]));
            }

            Console.WriteLine(test + "=>" + prog.F(xabc));
        }

        Console.ReadKey();
    }

    bool G(PointF[]p)
    {
        for(int i=0;i<4;i++){p[i].X*=1e7f;p[i].Y*=1e7f;}
        var g=new GraphicsPath();
        g.AddLines(p.Skip(1).ToArray());
        return g.IsVisible(p[0]);
    }

    bool F(P[]p)
    {
        for(int i=0;i<4;i++){p[i].X*=1e7f;p[i].Y*=1e7f;}
        var g=new System.Drawing.Drawing2D.GraphicsPath();
        g.AddLines(p.Skip(1).ToArray());
        return g.IsVisible(p[0]);
    }
}
— बॉब
स्रोत
प्यारा, काम करने के लिए ड्राइंग इंजन प्राप्त करना।
— xnor
2

हास्केल - 233 127

यहाँ वर्णित के रूप में क्रॉस उत्पादों का उपयोग करना :

h(a,b)(p,q)(r,s)(t,u)=z a b p q r s==z a b r s t u&&z a b r s t u==z a b t u p q where z j k l m n o =(o-m)*(j-l)+(l-n)*(k-m)>0

पिछले समाधान को बेरेंट्रिक निर्देशांक और इस स्टैक एक्सचेंज उत्तर में वर्णित सूत्रों का उपयोग करके लागू किया गया है :

g(p,q)(r,s)(t,u)(v,w)=
 let (j,k)=(p+(-r),q+(-s))
     (l,m)=(t+(-r),u+(-s))
     (n,o)=(v+(-r),w+(-s))
     d=l*o-n*m
     a=(j*(m-o)+k*(n-l)+l*o-n*m)/d
     b=(j*o-k*n)/d
     c=(k*l-j*m)/d
 in (0<=a&&a<1)&&(0<=b&&b<1)&&(0<=c&&c<1)

दोनों कार्य करते हैं gऔर hचार जोड़े लेते हैं, जिनमें से पहला समावेश के लिए परीक्षण किया जाना है और बाकी त्रिकोण के कोने के निर्देशांक हैं।

नमूना इनपुट के साथ परीक्षण करने के लिए:

let trueTestCases =
  [((-0.31961, -0.12646), (0.38478, 0.37419), (-0.30613, -0.59754), (-0.85548, 0.6633)),
   ((-0.87427, -0.00831), (0.78829, 0.60409), (-0.90904, -0.13856), (-0.80685, 0.48468)),
   ((0.28997, -0.03668), (-0.28362, 0.42831), (0.39332, -0.07474), (-0.48694, -0.10497)),
   ((-0.07783, 0.04415), (-0.34355, -0.07161), (0.59105, -0.93145), (0.29402, 0.90334)),
   ((0.36107, 0.05389), (0.27103, 0.47754), (-0.00341, -0.79472), (0.82549, -0.29028)),
   ((-0.01655, -0.20437), (-0.36194, -0.90281), (-0.26515, -0.4172), (0.36181, 0.51683)),
   ((-0.12198, -0.45897), (-0.35128, -0.85405), (0.84566, 0.99364), (0.13767, 0.78618)),
   ((-0.03847, -0.81531), (-0.18704, -0.33282), (-0.95717, -0.6337), (0.10976, -0.88374)),
   ((0.07904, -0.06245), (0.95181, -0.84223), (-0.75583, -0.34406), (0.16785, 0.87519)),
   ((-0.33485, 0.53875), (-0.25173, 0.51317), (-0.62441, -0.90698), (-0.47925, 0.74832))]

let falseTestCases =
  [((-0.99103, 0.43842), (0.78128, -0.10985), (-0.84714, -0.20558), (-0.08925, -0.78608)),
   ((0.15087, -0.56212), (-0.87374, -0.3787), (0.86403, 0.60374), (0.01392, 0.84362)),
   ((0.1114, 0.66496), (-0.92633, 0.27408), (0.92439, 0.43692), (0.8298, -0.29647)),
   ((0.87786, -0.8594), (-0.42283, -0.97999), (0.58659, -0.327), (-0.22656, 0.80896)),
   ((0.43525, -0.8923), (0.86119, 0.78278), (-0.01348, 0.98093), (-0.56244, -0.75129)),
   ((-0.73365, 0.28332), (0.63263, 0.17177), (-0.38398, -0.43497), (-0.31123, 0.73168)),
   ((-0.57694, -0.87713), (-0.93622, 0.89397), (0.93117, 0.40775), (0.2323, -0.30718)),
   ((0.91059, 0.75966), (0.60118, 0.73186), (0.32178, 0.88296), (-0.90087, -0.26367)),
   ((0.3463, -0.89397), (0.99108, 0.13557), (0.50122, -0.8724), (0.43385, 0.00167)),
   ((0.88121, 0.36469), (-0.29829, 0.21429), (0.31395, 0.2734), (0.43267, -0.78192))]

type Point = (Double, Double)

test :: [(Point, Point, Point, Point)] -> [Bool]
test testCases =
  map (\((px,py),(ax,ay),(bx,by),(cx,cy)) -> h (px,py) (ax,ay) (bx,by) (cx,cy)) testCases

test trueTestCases --> [True,True,True,True,True,True,True,True,True,True]
test falseTestCases --> [False,False,False,False,False,False,False,False,False,False]

अघोषित समाधान:

type Point = (Double, Double)

-- using cross products

triangulate' (a, b) (p, q) (r, s) (t, u) =
  (side a b p q r s == side a b r s t u) && (side a b r s t u == side a b t u p q)
  where side j k l m n o = (o - m) * (j - l) + (-n + l) * (k - m) >= 0

-- using barycentric coordinates

triangulate :: (Point, Point, Point, Point) -> Bool
triangulate ((px, py), (ax, ay), (bx, by), (cx, cy)) = 
  let (p'x, p'y) = (px + (-ax), py + (-ay))
      (b'x, b'y) = (bx + (-ax), by + (-ay))
      (c'x, c'y) = (cx + (-ax), cy + (-ay))
      d = b'x * c'y - c'x * b'y
      a = (p'x * (b'y - c'y) + p'y * (c'x - b'x) + b'x * c'y - c'x * b'y) / d
      b = (p'x * c'y - p'y * c'x) / d
      c = (p'y * b'x - p'x * b'y) / d
  in
      (0 <= a && a < 1) && (0 <= b && b < 1) && (0 <= c && c < 1)
— OI
स्रोत
2

जावास्क्रिप्ट (ईएस 6) 120

C=(p,q,i,j,k,l,m,n,
 z=j*(m-k)+i*(l-n)+k*n-l*m,
 s=(j*m-i*n+(n-j)*p+(i-m)*q)/z,
 t=(i*l-j*k+(j-l)*p+(k-i)*q)/z
)=>s>0&t>0&s+t<1

मेरे इस दूसरे प्रश्न के उत्तर से सीधे कॉपी किया गया

फायरफॉक्स / फायरबग कंसोल में टेस्ट

आउटपुट सभी 1s

;[
C(-0.31961, -0.12646, 0.38478, 0.37419, -0.30613, -0.59754, -0.85548, 0.6633),
C(-0.87427, -0.00831, 0.78829, 0.60409, -0.90904, -0.13856, -0.80685, 0.48468),
C(0.28997, -0.03668, -0.28362, 0.42831, 0.39332, -0.07474, -0.48694, -0.10497),
C(-0.07783, 0.04415, -0.34355, -0.07161, 0.59105, -0.93145, 0.29402, 0.90334),
C(0.36107, 0.05389, 0.27103, 0.47754, -0.00341, -0.79472, 0.82549, -0.29028),
C(-0.01655, -0.20437, -0.36194, -0.90281, -0.26515, -0.4172, 0.36181, 0.51683),
C(-0.12198, -0.45897, -0.35128, -0.85405, 0.84566, 0.99364, 0.13767, 0.78618),
C(-0.03847, -0.81531, -0.18704, -0.33282, -0.95717, -0.6337, 0.10976, -0.88374),
C(0.07904, -0.06245, 0.95181, -0.84223, -0.75583, -0.34406, 0.16785, 0.87519),
C(-0.33485, 0.53875, -0.25173, 0.51317, -0.62441, -0.90698, -0.47925, 0.74832)
]

आउटपुट सभी 0s

;[
C(-0.99103, 0.43842,0.78128, -0.10985,-0.84714, -0.20558,-0.08925, -0.78608),
C(0.15087, -0.56212,-0.87374, -0.3787,0.86403, 0.60374,0.01392, 0.84362),
C(0.1114, 0.66496,-0.92633, 0.27408,0.92439, 0.43692,0.8298, -0.29647),
C(0.87786, -0.8594,-0.42283, -0.97999,0.58659, -0.327,-0.22656, 0.80896),
C(0.43525, -0.8923,0.86119, 0.78278,-0.01348, 0.98093,-0.56244, -0.75129),
C(-0.73365, 0.28332,0.63263, 0.17177,-0.38398, -0.43497,-0.31123, 0.73168),
C(-0.57694, -0.87713,-0.93622, 0.89397,0.93117, 0.40775,0.2323, -0.30718),
C(0.91059, 0.75966,0.60118, 0.73186,0.32178, 0.88296,-0.90087, -0.26367),
C(0.3463, -0.89397,0.99108, 0.13557,0.50122, -0.8724,0.43385, 0.00167),
C(0.88121, 0.36469,-0.29829, 0.21429,0.31395, 0.2734,0.43267, -0.78192)
]
— edc65
स्रोत
2

स्माइलबासिक, 111 100 अक्षर

DEF T X,Y,A,B,C,D,E,F
Q=9e5GCLS
GTRI(A-X)*Q,Q*(B-Y),Q*(C-X),Q*(D-Y),Q*(E-X),Q*(F-Y)?!!GSPOIT(0,0)END

एक त्रिभुज खींचता है और बिंदु पर पिक्सेल का रंग जांचता है। त्रिकोण को 99999x तक बढ़ा दिया गया है और स्थानांतरित कर दिया गया है ताकि जांच का बिंदु तैयार होने से पहले (0,0) पर हो, सटीक में नुकसान को कम करने के लिए।

— 12Me21
स्रोत
2

इंटेल 8087 FPU विधानसभा, 222 220 बाइट्स

गणना करने के लिए केवल 8087 FPU हार्डवेयर का उपयोग करता है। यहाँ एक मैक्रो के रूप में असंबद्ध (इस मामले में भी अपवित्र) संस्करण है (आपको 220 हेक्स बाइट कोड को छोड़ देगा):

; calculate the area of of a triangle ABC using determinate
; input: coordinates (float), Ax,Ay,Bx,By,Cx,Cy
; output: area in ST
TAREA   MACRO   A1,A2,B1,B2,C1,C2
    FLD  A1
    FLD  B2
    FLD  C2
    FSUB        ; ST = By - Cy
    FMUL        ; ST = Ax * ( By - Cy )
    FLD  B1 
    FLD  C2
    FLD  A2
    FSUB        ; ST = Cy - Ay
    FMUL        ; ST = Bx * ( Cy - Ay )
    FLD  C1
    FLD  A2
    FLD  B2
    FSUB        ; Ay - By
    FMUL        ; Cx * ( Ay - By )
    FADD        ; Cx * ( Ay - By ) + Bx * ( Cy - Ay )
    FADD        ; Cx * ( Ay - By ) + Bx * ( Cy - Ay ) + Ax * ( By - Cy )
    FLD1        ; make a value of 2
    FADD ST,ST  ; ST = 2
    FDIV        ; divide by 2
    FABS        ; take abs value
        ENDM

; determine if point X is in triangle ABC
; input: points X, A, B, C
; output: ZF=1 if X in triangle, ZF=0 if X not in triangle
TXINABC     MACRO X1,X2,A1,A2,B1,B2,C1,C2

    TAREA  A1,A2,B1,B2,C1,C2    ; ST(3) = area of triangle ABC
    TAREA  X1,X2,B1,B2,C1,C2    ; ST(2) = area of triangle XBC
    TAREA  A1,A2,X1,X2,C1,C2    ; ST(1) = area of triangle AXC
    TAREA  A1,A2,B1,B2,X1,X2    ; ST(0) = area of triangle ABX

    FADD        ; add areas of triangles with point
    FADD        ; ST = ST + ST(1) + ST(2)
    FCOMPP      ; compare ST to ST(1) and pop results
    FWAIT       ; sync CPU/FPU
    FSTSW R     ; store result flags to R
    MOV  AX, R  ; move result to AX
    SAHF        ; store result into CPU flags for conditional check
        ENDM

व्याख्या

एबीसी त्रिकोण के क्षेत्र की गणना करने के लिए दृढ़ संकल्प का उपयोग करता है, और फिर एक्स बिंदु और एबीसी त्रिकोण के दो अन्य बिंदुओं के साथ गठित त्रिकोण। यदि त्रिभुज ABC का क्षेत्रफल त्रिभुज XBC + AXC + ABX के क्षेत्रों के योग के बराबर है, तो बिंदु त्रिभुज के भीतर है। परिणाम ZF के रूप में लौटाया जाता है।

इसमें साफ क्या है

सभी गणित और फ्लोटिंग पॉइंट ऑपरेशन हार्डवेयर में 80-बिट विस्तारित परिशुद्धता के साथ किए जाते हैं। अंतिम फ़्लोटिंग पॉइंट तुलना हार्डवेयर में भी की जाती है इसलिए यह बहुत सटीक होगी।

यह एक बार में 8087 के स्टैक रजिस्टर के सभी आठ का उपयोग करता है।

क्या इस बारे में काफी साफ नहीं है

जैसा कि त्रिकोण के बिंदुओं को गणना के दौरान कई बार सूत्रों में वापस प्लग किया जाना चाहिए, यह सही क्रम में एक समय में एक एफपीयू के स्टैक रजिस्टर में लोड करने के लिए स्मृति में प्रत्येक चर की आवश्यकता होती है। जबकि यह एक MACRO के रूप में एक फ़ंक्शन की तरह काफी आसानी से मॉडलिंग की जा सकती है, इसका मतलब है कि कोड को असेंबली में हर बार विस्तारित किया जाता है, जिससे अनावश्यक कोड बनाया जाता है। PROC में समान बार-बार कोड सेगमेंट को स्थानांतरित करके 41 बाइट्स बचाए गए थे। हालांकि यह कोड को कम पठनीय बनाता है, इसलिए उपरोक्त सूची इसके बिना है (यही कारण है कि इसे "अनगुल्ड" के रूप में लेबल किया गया है)।

टेस्ट

यहां आईबीएम डॉस का उपयोग कर एक परीक्षण कार्यक्रम दिखाया गया है:

TTEST   MACRO T
        LOCAL IS_IN_TRI

    TXINABC T,T+4*1,T+4*2,T+4*3,T+4*4,T+4*5,T+4*6,T+4*7
    MOV  DX, OFFSET TEQ     ; load true string by default 
    JZ   IS_IN_TRI          ; if ZF=1, it is in triangle, skip to display
    MOV  DX, OFFSET FEQ     ; otherwise ZF=0 means not in triangle, so load false string
IS_IN_TRI:
    MOV  AH, 9              ; DOS write string function
    INT  21H 
        ENDM

START:
    FINIT                   ; reset 8087

    TTEST   T0              ; true tests
    TTEST   T1
    TTEST   T2
    TTEST   T3
    TTEST   T4
    TTEST   T5
    TTEST   T6
    TTEST   T7
    TTEST   T8
    TTEST   T9

    TTEST   F0              ; false tests
    TTEST   F1
    TTEST   F2
    TTEST   F3
    TTEST   F4
    TTEST   F5
    TTEST   F6  
    TTEST   F7
    TTEST   F8  
    TTEST   F9

    RET         ; return to DOS

T0  DD  -0.31961, -0.12646, 0.38478, 0.37419, -0.30613, -0.59754, -0.85548, 0.6633
T1  DD  -0.87427, -0.00831, 0.78829, 0.60409, -0.90904, -0.13856, -0.80685, 0.48468
T2  DD  0.28997, -0.03668, -0.28362, 0.42831, 0.39332, -0.07474, -0.48694, -0.10497
T3  DD  -0.07783, 0.04415, -0.34355, -0.07161, 0.59105, -0.93145, 0.29402, 0.90334
T4  DD  0.36107, 0.05389, 0.27103, 0.47754, -0.00341, -0.79472, 0.82549, -0.29028
T5  DD  -0.01655, -0.20437, -0.36194, -0.90281, -0.26515, -0.4172, 0.36181, 0.51683
T6  DD  -0.12198, -0.45897, -0.35128, -0.85405, 0.84566, 0.99364, 0.13767, 0.78618
T7  DD  -0.03847, -0.81531, -0.18704, -0.33282, -0.95717, -0.6337, 0.10976, -0.88374
T8  DD  0.07904, -0.06245, 0.95181, -0.84223, -0.75583, -0.34406, 0.16785, 0.87519
T9  DD  -0.33485, 0.53875, -0.25173, 0.51317, -0.62441, -0.90698, -0.47925, 0.74832

F0  DD  -0.99103, 0.43842, 0.78128, -0.10985, -0.84714, -0.20558, -0.08925, -0.78608
F1  DD  0.15087, -0.56212, -0.87374, -0.3787, 0.86403, 0.60374, 0.01392, 0.84362
F2  DD  0.1114, 0.66496, -0.92633, 0.27408, 0.92439, 0.43692, 0.8298, -0.29647
F3  DD  0.87786, -0.8594, -0.42283, -0.97999, 0.58659, -0.327, -0.22656, 0.80896
F4  DD  0.43525, -0.8923, 0.86119, 0.78278, -0.01348, 0.98093, -0.56244, -0.75129
F5  DD  -0.73365, 0.28332, 0.63263, 0.17177, -0.38398, -0.43497, -0.31123, 0.73168
F6  DD  -0.57694, -0.87713, -0.93622, 0.89397, 0.93117, 0.40775, 0.2323, -0.30718
F7  DD  0.91059, 0.75966, 0.60118, 0.73186, 0.32178, 0.88296, -0.90087, -0.26367
F8  DD  0.3463, -0.89397, 0.99108, 0.13557, 0.50122, -0.8724, 0.43385, 0.00167
F9  DD  0.88121, 0.36469, -0.29829, 0.21429, 0.31395, 0.2734, 0.43267, -0.78192

TEQ DB 'In Triangle',0DH,0AH,'$'
FEQ DB 'Not In Triangle',0DH,0AH,'$'

उत्पादन

In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
Not In Triangle
— 640KB
स्रोत
1

C 414 (465 था)

golfed

#define D double 
int F(D ax,D ay,D bx,D by,D cx,D cy,D px,D py){int y=0;double J,K;D m=(ax-bx<0.001)?(by-ay)/(ax-bx):1000;D b=m*ax+ay;J=m*cx-cy+b;K=m*px-py+b;if(J*K>=0)y=1;return y;}D T[8],k;int i,n;void G(){while(i<8){scanf("%lf",&k);T[i++]=k;}n+=F(T[2],T[3],T[4],T[5],T[6],T[7],T[0],T[1]);n+=F(T[4],T[5],T[6],T[7],T[2],T[3],T[0],T[1]);n+=F(T[2],T[3],T[6],T[7],T[4],T[5],T[0],T[1]);printf(n==3?"True":"False");}

मूल फ़ंक्शन घोषणा स्पष्टीकरण के लिए जोड़ा गया

/**
* determine if points C & P are on same side of line AB
* return 1 if true, 0 otherwise
*/
int PointsSameSide(D ax,D ay,D bx,D by,D cx, D cy, D px, D py);

एक नामित फ़ंक्शन के रूप में फिर से लिखा गया: प्रत्येक पंक्ति में एक या सभी को एक पंक्ति में इनपुट के माध्यम से अलग किया गया।

#define D double
int F(D ax,D ay,D bx,D by,D cx, D cy, D px, D py)
{
int y=0;
double J,K;
D m = (ax-bx<0.001)?(by-ay)/(ax-bx):1000;
D b = m*ax+ay;
J=m*cx-cy+b;
K=m*px-py+b;
if(J*K>=0)y=1;
return y;
}
double T[8],k;
int i,n;
void G()
{
while(i<8){scanf("%lf",&k);T[i++]=k;}
n+=F(T[2],T[3],T[4],T[5],T[6],T[7],T[0],T[1]);
n+=F(T[4],T[5],T[6],T[7],T[2],T[3],T[0],T[1]);
n+=F(T[2],T[3],T[6],T[7],T[4],T[5],T[0],T[1]);
printf(n==3?"True":"False");
}
— bacchusbeale
स्रोत
3
आप नई बराबरी और अनावश्यक स्थानों से छुटकारा पाकर कुछ बाइट्स बचा सकते हैं। इसके अलावा, आपने इसे doubleफिर से परिभाषित किया है Dलेकिन आप अभी भी doubleकोड में उपयोग करते हैं।
— gronostaj
1

जावा, 149 अक्षर

g=Math.atan2(100*(d-y),(a-x));h=Math.atan2(100*(e-y),(b-x));i=Math.atan2(100*(f-y),(c-x));k=Math.round(Math.abs(g-h)+Math.abs(h-i)+Math.abs(i-g))==6;

भयानक विचार मुझे लिखना होगा "गणित।" हर बार। यह वास्तविक कार्यक्रम है:

package mathPackage;
public class InTriangle {
public static void main(String[] args) {
    boolean k;
    double a=-1,b=0,c=1,d=0,e=1,f=0,x=0,y=0.4;
    double g,h,i;
    g=Math.atan2(100*(d-y),(a-x));
    h=Math.atan2(100*(e-y),(b-x));
    i=Math.atan2(100*(f-y),(c-x));
    k=Math.round(Math.abs(g-h)+Math.abs(h-i)+Math.abs(i-g))==6;
    System.out.println(k);
    System.out.println(g);
    System.out.println(h);
    System.out.println(i);
    System.out.print(Math.abs(g-h)+Math.abs(h-i)+Math.abs(i-g));
}
}

जहाँ बिंदु का x है a, b, बिंदु b का x है, c के x के लिए c है, d का y है a, e का y है b, f का y है, और x और y का x है और बिंदु के वाई। बूलियन k यह निर्धारित करता है कि यह सच है या नहीं।

— colorado777
स्रोत
1
किसलिए हैं 100*?
— xnor
1

जावास्क्रिप्ट 125/198

यदि अंक 8 तर्कों में दिए गए हैं:

function d(x,y,a,b,c,d,e,f){function z(a,b,c,d){return(y-b)*(c-a)-(x-a)*(d-b)>0}return(z(a,b,c,d)+z(c,d,e,f)+z(e,f,a,b))%3<1}

यदि अंक 2-आयामी सरणी में प्रदान किए जाते हैं:

function c(s){return (z(s[1][0],s[1][1],s[2][0],s[2][1])+z(s[2][0],s[2][1],s[3][0],s[3][1])+z(s[3][0],s[3][1],s[1][0],s[1][1]))%3<1;function z(a,b,c,d){return (s[0][1]-b)*(c-a)-(s[0][0]-a)*(d-b)>0}}

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

(y-b)(c-a) - (x-a)(d-b)

जो बताता है कि रेखा किस तरफ है , ढलान की परिभाषा को पुनर्व्यवस्थित करने से लिया गया है:

            m = (y2-y1)/(x2-x1)
      (y2-y1) = m(x2-x1)
       (y-y1) = m(x-x1)     ,substituting point we are testing (x,y) to be the 2nd point
       (y-y1) = (x-x1)(y2-y1)/(x2-x1)  ,substitute back the original definition of m
(y-y1)(x2-x1) = (x-x1)(y2-y1)    <-- left side will be greater than the right side, if
                                     the point is on the left; otherwise, it's on the right
            0 = (y-b)(c-a)-(x-a)(d-b) ,where (a,b)=(x1,y1), (c,d)=(x2,y2)

यदि हम सभी 3 पक्षों का परीक्षण करते हैं, तो सभी 3 को कुछ संख्याओं को उसी संकेत के साथ प्राप्त करना चाहिए जब बिंदु त्रिकोण के अंदर हो क्योंकि हम त्रिकोण के चारों ओर परीक्षण कर रहे हैं। यदि बिंदु एक तरफ है, तो परीक्षण में से एक को वापस करना चाहिए।

jsFiddle परीक्षण कोड: http://jsfiddle.net/DerekL/zEzZU/

var l = [[-0.31961, -0.12646, 0.38478, 0.37419, -0.30613, -0.59754, -0.85548, 0.6633],[-0.87427, -0.00831, 0.78829, 0.60409, -0.90904, -0.13856, -0.80685, 0.48468],[0.28997, -0.03668, -0.28362, 0.42831, 0.39332, -0.07474, -0.48694, -0.10497],[-0.07783, 0.04415, -0.34355, -0.07161, 0.59105, -0.93145, 0.29402, 0.90334],[0.36107, 0.05389, 0.27103, 0.47754, -0.00341, -0.79472, 0.82549, -0.29028],[-0.01655, -0.20437, -0.36194, -0.90281, -0.26515, -0.4172, 0.36181, 0.51683],[-0.12198, -0.45897, -0.35128, -0.85405, 0.84566, 0.99364, 0.13767, 0.78618],[-0.03847, -0.81531, -0.18704, -0.33282, -0.95717, -0.6337, 0.10976, -0.88374],[0.07904, -0.06245, 0.95181, -0.84223, -0.75583, -0.34406, 0.16785, 0.87519],[-0.33485, 0.53875, -0.25173, 0.51317, -0.62441, -0.90698, -0.47925, 0.74832],
         [-0.99103, 0.43842, 0.78128, -0.10985, -0.84714, -0.20558, -0.08925, -0.78608],[0.15087, -0.56212, -0.87374, -0.3787, 0.86403, 0.60374, 0.01392, 0.84362],[0.1114, 0.66496, -0.92633, 0.27408, 0.92439, 0.43692, 0.8298, -0.29647],[0.87786, -0.8594, -0.42283, -0.97999, 0.58659, -0.327, -0.22656, 0.80896],[0.43525, -0.8923, 0.86119, 0.78278, -0.01348, 0.98093, -0.56244, -0.75129],[-0.73365, 0.28332, 0.63263, 0.17177, -0.38398, -0.43497, -0.31123, 0.73168],[-0.57694, -0.87713, -0.93622, 0.89397, 0.93117, 0.40775, 0.2323, -0.30718],[0.91059, 0.75966, 0.60118, 0.73186, 0.32178, 0.88296, -0.90087, -0.26367],[0.3463, -0.89397, 0.99108, 0.13557, 0.50122, -0.8724, 0.43385, 0.00167],[0.88121, 0.36469, -0.29829, 0.21429, 0.31395, 0.2734, 0.43267, -0.78192]];

function d(x,y,a,b,c,d,e,f){function z(a,b,c,d){return(y-b)*(c-a)-(x-a)*(d-b)>0}return(z(a,b,c,d)+z(c,d,e,f)+z(e,f,a,b))%3<1}

for(var i = 0; i < l.length; i++){
    console.log(d.apply(undefined,l[i]));    //10 true, 10 false
}

97 वर्ण (रिक्त स्थान या टैब की गिनती नहीं) यदि कॉफीस्क्रिप्ट में परिवर्तित की जाती है तो:

d=(x,y,a,b,c,d,e,f)->
    z=(a,b,c,d)->
        (y-b)*(c-a)-(x-a)*(d-b)>0
    (z(a,b,c,d)+z(c,d,e,f)+z(e,f,a,b))%3<1

115 अक्षर यदि ES6 में परिवर्तित हो जाएं:

d=(x,y,a,b,c,d,e,f)=>{z=(a,b,c,d)=>{return (y-b)*(c-a)-(x-a)*(d-b)>0};return(z(a,b,c,d)+z(c,d,e,f)+z(e,f,a,b))%3<1}
— डेरेक 朕 朕 朕
स्रोत
यह "फैंसी वेक्टर गणित" है जिसका मैं उपयोग कर रहा हूं: डी (फैंसी बेरेंट्रिक कॉर्डिनेट दृष्टिकोण कुछ अन्य लोगों ने हालांकि, लिया)। शीर्ष-वोट किए गए उत्तर की तरह, आप ES6 का उपयोग करके और जैसे कार्यों को परिभाषित करके कुछ बाइट्स बचा सकते हैं d=(x,y,...)=>{...}। आपके मामले में, आप कॉफीस्क्रिप्ट का उपयोग करके और भी अधिक बचत कर सकते हैं, जिसकी आवश्यकता नहीं है return: pastebin.com/RVFk1D5k ... और किसी भी मामले में आप <1इसके बजाय का उपयोग करके एक बाइट बचा सकते हैं ==0।
— मार्टिन एंडर
@ m.buettner: o मुझे लगा कि मेरे द्वारा उपयोग किए जाने वाले समीकरण का वैक्टर (साधारण बीजगणित से प्राप्त) से कोई लेना-देना नहीं है, लेकिन जाहिर है कि वे दोनों एक ही समीकरण का उत्पादन करते हैं। गणित अद्भुत है।
— डेरेक 會 會
1

आर, २३

MATLAB से प्रेरित ,

SDMTools::pnt.in.poly()

कहा जाता है कि SDMTools::pnt.in.poly(point,triangle)जहां pointलंबाई -2 वेक्टर है और triangleयह 3x2 मैट्रिक्स का वर्टिकल है। SDMTools CRAN पर उपलब्ध है।

— shadowtalker
स्रोत
1

गणितज्ञ, 38 वर्ण

RegionMember[Polygon[#[[1]]],#[[2]]] &

उदाहरण:

d = {{{0, 0}, {1, 0}, {.5, .7}}, {.5, .6}};

RegionMember[Polygon[#[[1]]], #[[2]]] & @ d

(* सच *)

— डेविड जी स्टॉर्क
स्रोत
यह रिक्त स्थान को वर्णों के रूप में गिनने के लिए मानक है, लेकिन संभवतया यहां आप उन्हें बिना किसी को तोड़े निकाल सकते हैं।
— xnor
1
इसके अलावा, आपको पूर्वनिर्धारित चर का उपयोग करने के बजाय इनपुट लेने और आउटपुट का उत्पादन करने की आवश्यकता है। आप कुछ गणितीय उत्तर खोज सकते हैं कि वे इसे कैसे देखते हैं।
— xnor
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.