जे, 40 39 34 बाइट्स
3 :'(o.1)<(>./-<./)12 o.y*+{.y'@:-
एक अनाम डियाडिक फंक्शन, एक बिंदु, पी , इसके तर्कों में से एक के रूप में, और अंक की एक सूची, पी , अन्य तर्क के रूप में (यह कोई फर्क नहीं पड़ता कि कौन सा तर्क है), और वापस आ रहा है , 0या 1यदि पी बाहर है या क्रमशः पी के उत्तल पतवार के अंदर । बिंदु p , और P में बिंदुओं को जटिल संख्याओं के रूप में लिया जाता है।
उदाहरण
is_inside =: 3 :'(o.1)<(>./-<./)12 o.y*+{.y'@:-
0.5j0.5 is_inside 0j0 0j1 1j0 1j1
1
1.5j0.5 is_inside 0j0 0j1 1j0 1j1
0
या ...
पायथन 2, फ़ंक्शन, 121 103, पूरा कार्यक्रम, 162
पायथन 3, 149 बाइट्स
import sys,cmath as C
p,q,*P=[complex(*eval(l.replace(*";,")))for l in sys.stdin]
A=[C.phase((r-p)/(q-p+(q==p)))for r in P]
print(max(A)-min(A)>C.pi)
मूल पोस्ट के रूप में एक ही प्रारूप में, STDIN के माध्यम से इनपुट लेता है, और एक बूलियन मूल्य प्रिंट करता है जो यह दर्शाता है कि पी पी के उत्तल पतवार में है या नहीं
व्याख्या
कार्यक्रम परीक्षण अधिकतम और न्यूनतम (हस्ताक्षरित) के बीच का अंतर किसी भी बिंदु के बीच कोण है कि क्या आर में पी , पी , और एक निश्चित मनमाना बिंदु क्ष में पी (हम सिर्फ में पहला बिंदु का उपयोग पी ), 180 से भी कम है °। दूसरे शब्दों में, यह परीक्षण करता है कि क्या पी के सभी बिंदु 180 ° या उससे कम के कोण में निहित हैं, पी के आसपास ।
पी के उत्तल पतवार में है पी यदि और केवल यदि इस हालत झूठी है।
ध्यान दें कि ऊपर हालत कह रही है कि के बराबर है: कुछ और बाइट्स की लागत में, हम एक ऐसी ही विधि है कि हमारे पास स्पष्ट रूप से कैलकुलेट कोण की आवश्यकता नहीं है का उपयोग कर सकते पी के उत्तल पतवार के बाहर है पी यदि और केवल यदि वहां मौजूद एक लाइन एल के माध्यम से पी , में सभी बिंदुओं ऐसा है कि पी के एक ही तरफ हैं एल । यदि ऐसी कोई रेखा मौजूद है, तो P में बिंदुओं में से एक (या अधिक) के लिए घटना है ऐसी रेखा भी है (हम L को घुमा सकते हैं जब तक कि यह P में से किसी एक बिंदु को नहीं छूता है ।)
To (अस्थायी रूप से) इस लाइन को ढूंढें, हम शुरुआत करते हैं l को p के माध्यम से रेखा बनाते हैं और P में पहला बिंदु । हम फिर पी में बाकी बिंदुओं पर पुनरावृति करते हैं ; यदि अंकों में से एक l के बाईं ओर है (हम कुछ दिशात्मकता मान लेते हैं, तो बाएं या दाएं वास्तव में कोई फर्क नहीं पड़ता,) हम l को p और उस बिंदु से गुजरने वाली लाइन से प्रतिस्थापित करते हैं , और जारी रखते हैं। पी के सभी पर चलने के बाद , यदि (और केवल अगर) पी उत्तल पतवार के बाहर है, तो पी में सभी बिंदु एल के दाईं ओर (या) होना चाहिए । हम जांच करते हैं कि पी में बिंदुओं पर दूसरे पास का उपयोग करना।
पायथन 2, 172 बाइट्स
import sys
P=[eval(l.replace(*";,"))for l in sys.stdin]
x,y=P.pop(0)
C=lambda(a,b),(c,d):(a-x)*(d-y)-(b-y)*(c-x)>0
l=reduce(lambda*x:x[C(*x)],P)
print any(C(l,q)for q in P)
वैकल्पिक रूप से, एक ही पास में एक ही काम करने के लिए , P में , किसी भी दो बिंदुओं, q और r के बीच एक बोध होने दें , जैसे कि q , r के बाईं ओर है यदि q बाईं ओर है पी और आर से होकर गुजरने वाली रेखा । ध्यान दें कि करने के लिए-बायां-की को एक आदेश संबंध है पी यदि और केवल यदि सभी बिंदुओं पी कुछ लाइन के माध्यम से गुजर के एक ही तरफ हैं पी कि है, अगर, पी के उत्तल पतवार के बाहर है पी । ऊपर वर्णित प्रक्रिया पी में न्यूनतम बिंदु पाता हैइस आदेश को पी ।, " पी में सबसे बाईं ओर" बिंदु । दो पास करने के बजाय, हम अधिकतम (यानी, "सबसे दाएं" बिंदु), और साथ ही न्यूनतम पा सकते हैं, पी में अंक एक ही पास में एक ही आदेश देते हैं, और सत्यापित करते हैं कि न्यूनतम बाईं ओर है अधिकतम, यानी, प्रभावी रूप से, कि-के-बाएँ-से-सकर्मक है।
यह अच्छी तरह से काम करेगा अगर पी के उत्तल पतवार के बाहर है पी , जिस स्थिति में करने के लिए-बाएं की वास्तव में एक आदेश संबंध है, लेकिन जब टूट सकता है पी (उदाहरण के लिए उत्तल पतवार के अंदर है, यह पता लगाने की कोशिश क्या होगा यदि हम इस एल्गोरिथ्म को चलाते हैं, जहां P में अंक एक नियमित पेंटागन के कोने हैं, काउंटर-क्लॉकवाइज चल रहा है, और p इसका केंद्र है।) समायोजित करने के लिए, हम एल्गोरिथ्म को थोड़ा बदल देते हैं: हम P में एक बिंदु q का चयन करते हैं , और बिसेक्ट करते हैं। पी रेखा के साथ के माध्यम से गुजर पी और क्यू (यानी, हम विभाजन पी के आसपास क्षwrt-to-left-to-the।) अब हमारे पास एक "बाएँ भाग" और P का एक "दाएँ भाग" है , प्रत्येक में एक समतल सम्मिलित है, ताकि बाएँ-से-बाएँ प्रत्येक पर एक ऑर्डर रिलेशन हो; हम बाएं हिस्से का न्यूनतम भाग, और दाएं भाग का अधिकतम भाग, और ऊपर वर्णित अनुसार उनकी तुलना करते हैं। बेशक, हमें P को शारीरिक रूप से द्विभाजित करने की आवश्यकता नहीं है , हम बस P में प्रत्येक बिंदु को वर्गीकृत कर सकते हैं क्योंकि हम एक पास में न्यूनतम और अधिकतम की तलाश करते हैं।
पायथन 2, 194 बाइट्स
import sys
P=[eval(l.replace(*";,"))for l in sys.stdin]
x,y=P.pop(0)
C=lambda(a,b),(c,d):(a-x)*(d-y)-(b-y)*(c-x)>0
l=r=P[0]
for q in P:
if C(P[0],q):l=q*C(l,q)or l
elif C(q,r):r=q
print C(l,r)