त्रिकोणों की पहचान करना

Question

एक तस्वीर में त्रिकोणों की मात्रा की गणना करना एक ऐसा कार्य है जो आमतौर पर मस्तिष्क परीक्षणों में उपयोग किया जाता है। आपको एक चित्र दिया गया है जिसमें आकृतियों में त्रिकोण शामिल हैं। तब आपको चित्र में सभी संभावित त्रिकोण खोजने होंगे।

कार्य

आपको अपनी पसंद के एक प्रारूप में लाइनों की एक सूची दी गई है। फिर आपको उस में पाए जाने वाले त्रिकोणों की एक सूची तैयार करनी होगी

इनपुट

आपको लाइनों की एक सूची दी गई है, प्रत्येक चार पूर्णांक निर्देशांक (जैसे। x1 y1 x2 y2) द्वारा दिए गए हैं । आप इनपुट प्रारूप को चुन सकते हैं, जब तक कि यह स्पष्ट रूप से प्रलेखित है। उदाहरण:

0 4 8 1
0 4 9 5
8 1 9 5
2 8 0 4
9 5 2 8

[[0, 4, 8, 1], [0, 4, 9, 5], [8, 1, 9, 5], [2, 8, 0, 4], [9, 5, 2, 8]]

यहाँ छवि के समान इनपुट है:

एक और एक, चौराहों के साथ (अंतरिक्ष को बचाने के लिए केवल एक प्रारूप में):

[[2, 1, 5, 0], [2, 1, 2, 7], [5, 0, 6, 6], [5, 0, 2, 7], [6, 6, 2, 1], [2, 7, 6, 6]]

उत्पादन

आपको x1 y1 x2 y2 x3 y3इनपुट द्वारा निर्दिष्ट चित्र में, छह फ़्लोटिंग-पॉइंट निर्देशांक (जैसे। ) द्वारा दिए गए प्रत्येक त्रिकोण की सूची को आउटपुट करना होगा । ये पूर्णांक नहीं हो सकते हैं, क्योंकि लाइनें किसी भी बिंदु पर पार हो सकती हैं। आप आउटपुट प्रारूप चुन सकते हैं, जब तक कि यह स्पष्ट रूप से प्रलेखित है। उदाहरण इनपुट के लिए उदाहरण आउटपुट ऊपर:

0 4 8 1 9 5
0 4 9 5 2 8

[[0, 4, 8, 3, 9, 5], [0, 4, 9, 5, 2, 8]]

[[2, 1, 5, 0, 2, 7], [2, 1, 5, 0, 6, 6], [5, 0, 6, 6, 2, 7], [2, 1, 6, 6, 2, 7], [2, 1, 5, 0, 3.674, 3.093], [5, 0, 6, 6, 3.674, 3.093], [6, 6, 2, 7, 3.674, 3.093], [2, 7, 2, 1, 3.674, 3.093]]

आप ऐसा मान सकते हैं

• वहाँ कोई किनारे मामले नहीं हैं जहां एक रेखा एक चौराहे को पार करती है लेकिन किसी भी तरह की रेखाएं नहीं हैं, जैसे

  [[0, 9, 1, 8], [1, 8, 2, 9], [2, 9, 3, 8], [3, 8, 4, 9], [4, 9, 0, 9]]
  

• 179 डिग्री से अधिक कोण नहीं हैं, जैसे

  [[0, 0, 0, 1], [0, 1, 0, 2], [0, 2, 0, 0]]
  

नियम

• आप अपनी इच्छानुसार किसी भी भाषा का उपयोग कर सकते हैं।
• किसी भी बाहरी संसाधनों का उपयोग नहीं किया जाना चाहिए।
• मानक खामियां लागू होती हैं।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है।

Comments

क्या 3-चक्रों की पहचान करना पर्याप्त है या क्या हमें अधिक जटिल धार वाले मामलों को संभालना है? उदाहरण के लिए "पेंटागन" द्वारा परिभाषित [0,9],[1,8],[2,9],[3,8],[4,9]वास्तव में एक डब्ल्यू है जो शीर्ष पर खींची गई रेखा के साथ है। क्या यह कोई त्रिकोण या 2 त्रिकोण नहीं है?

— लेवल रिवर सेंट

@steveverrill मान लीजिए कि किनारे के मामलों को अनदेखा किया जा सकता है।

— पुरकाकूदरी

ठीक है। और [0,0],[1,0],[2,0],[1,2]180 डिग्री के कोण के साथ एक "चतुर्भुज"। कोई त्रिकोण या 1 त्रिकोण?

— लेवल रिवर सेंट

यह एक त्रिकोण नहीं होगा, लेकिन आप मान सकते हैं कि या तो नहीं आता है।

— पुरकाकूदरी

Answer 1

PostGIS, 162

मुझे लगता है कि यह नियमों का अनुपालन करता है, यह PostGIS के लिए एक क्वेरी है, जो PostgreSQL का एक विस्तार है। इनपुट को प्रत्येक पंक्ति के लिए निर्देशांक की तालिका माना जाता है जिसे एल कहा जाता है आउटपुट का गठन त्रिकोण के लिए बहुभुज परिभाषा के साथ पंक्तियों का एक सेट है।

SELECT ST_AsText(D)FROM(SELECT(ST_Dump(ST_Polygonize(B))).geom D FROM(SELECT ST_Union(ST_MakeLine(ST_Point(A,B),ST_Point(C,D)))B FROM L)A)B WHERE ST_NPoints(D)=4;

उपयोग में यह निम्न की तरह दिखता है

-- Create a table for the input
CREATE TABLE L (A INT, B INT, C INT,D INT);
INSERT INTO L VALUES(2, 1, 5, 0), (2, 1, 2, 7), (5, 0, 6, 6), (5, 0, 2, 7), (6, 6, 2, 1), (2, 7, 6, 6);

SELECT ST_AsText(D)FROM(SELECT(ST_Dump(ST_Polygonize(B))).geom D FROM(SELECT ST_Union(ST_MakeLine(ST_Point(A,B),ST_Point(C,D)))B FROM L)A)B WHERE ST_NPoints(D)=4;

-- Cleanup
DROP TABLE L;

आउटपुट इस प्रकार है

POLYGON((5 0,2 1,3.67441860465116 3.09302325581395,5 0))
POLYGON((6 6,5 0,3.67441860465116 3.09302325581395,6 6))
POLYGON((3.67441860465116 3.09302325581395,2 7,6 6,3.67441860465116 3.09302325581395))
POLYGON((2 7,3.67441860465116 3.09302325581395,2 1,2 7))

Answer 2

गणितज्ञ 915 395 401 405

अपडेट करें

यह प्रोग्रामिंग चुनौती पहले की तुलना में कहीं अधिक कठिन है।

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

उस सीमा के बावजूद, यह वर्तमान दृष्टिकोण के आधार पर तर्क को साझा करने के लायक हो सकता है।

---

इनपुट लाइन खंडों को क्षेत्रों के रूप में माना जाता है। यदि वे प्रतिच्छेद करते हैं, तो केन्द्रक चौराहे के निर्देशांक होंगे। हमें उन चौराहों को खत्म करने की आवश्यकता है जो लाइन सेगमेंट के कोने पर होते हैं। जिन पंक्तियों को प्रतिच्छेद नहीं किया जाता है, उनमें एक अनिश्चित सेंट्रोइड होगा।

प्रत्येक चौराहे बिंदु के लिए चार नए किनारे बनाए गए हैं। वे दो चौराहे लाइनों के चार कोने के लिए चौराहे बिंदु को जोड़ते हैं।

एक ग्राफ जैसे कि नीचे दायीं ओर पुराना और नया दोनों किनारों का उपयोग करके उत्पन्न होता है।

कोने संबंधित बिंदुओं के निर्देशांक हैं। चक्र, यानी, तीन छोरों के बंद छोरों को त्रिकोण प्रदान किया जाएगा, बशर्ते कि तीन कोने टकरा नहीं रहे हैं।

वर्तमान में हम यह देखने के लिए जांच करते हैं कि क्या किसी भी "त्रिकोण" में एक अनिश्चित क्षेत्र है। (किसी कारण से यह तीन कोलिनियर बिंदुओं के लिए 0 का क्षेत्र वापस नहीं करता है।)

---

एक सरल उदाहरण

नीचे (ए) समन्वित विमान में अंकित आकृति और (बी) दिए गए नोड्स के साथ-साथ चौराहे के नोड को दर्शाने वाला ग्राफ है {114/23, 314/69}। उत्तरार्द्ध में, संबंधित कार्टेशियन निर्देशांक पर कोने स्थित नहीं हैं।

ऐसा प्रतीत हो सकता है कि उनके बाएं हाथ की तुलना में दाहिनी आकृति में अधिक किनारे हैं। लेकिन याद रखें कि बाईं ओर ओवरलैपिंग ग्राफ किनारों हैं। प्रत्येक विकर्ण वास्तव में 3 ग्राफ किनारों से मेल खाता है!

---

    f@w_ :=(h@{a_, b_, c_, d_} := (r = RegionCentroid@RegionIntersection[Line@{a, b}, Line@{c, d}];
     {r <-> a, r <-> b, r <-> c, r <-> d});
      Cases[FindCycle[Graph[Union@Join[w /. {{a_, b_Integer}, {c_, d_}} :> {a, b} <-> {c, d},
      Cases[Flatten[h /@ Cases[{Length[Union@#] < 4, #} & /@ (FlattenAt[#, {{1}, {2}}] & /@ 
      Subsets[w, {2}]),{False, c_} :> c]], Except[{Indeterminate, _} <-> _]]]], {3}, 50],
      x_ /; NumericQ[RegionMeasure@Triangle[x[[All, 1]]]]][[All, All, 1]]//N//Grid)

नीचे प्रत्येक पंक्ति एक त्रिकोण है।

f[{{{2,8},{8,1}},{{0,4},{8,1}},{{0,4},{9,5}},{{8,1},{9,5}},{{2,8},{0,4}},{{9,5},{2,8}}}]

---

एक अधिक जटिल उदाहरण

f@{{{9, 5}, {0, -10}}, {{9, 5}, {0, 2}},  {{9, 5}, {2, -1}}, {{0, -10}, {2, -1}}, {{0, -10}, {-2, -1}}, {{-9, 5}, {0, -10}}, {{-9, 5}, {0, 2}}, {{-9, 5}, {-2, -1}}, {{0, 2}, {0, -10}}, {{-9, 5}, {2, -1}}, {{9, 5}, {-2, -1}}, {{-9, 5}, {9, 5}}}

यहाँ इनपुट निर्देशांक के अनुरूप ग्राफ है । कोने उनके अपेक्षित कार्टेशियन निर्देशांक पर हैं। (यदि आप गोल्फ कोड चलाते हैं तो यह वर्टेक्स लेबल और किनारों का सम्मान करते हुए कहीं और कोने को प्रदर्शित करेगा। पठनीयता के लिए, मैंने अतिरिक्त कोड के एक smattering का उपयोग करके वर्टेक्स निर्देशांक को असाइन किया है, समाधान के लिए आवश्यक नहीं है।)

---

यहाँ व्युत्पन्न ग्राफ है।
इसमें चौराहे का व्युत्पन्न बिंदु शामिल है (0,1/11), जहां कुछ इनपुट लाइनें क्रॉस होती हैं।

कोड में 19 त्रिकोण पाए गए। उनमें से नौ बिंदुओं (0,1/11)में से एक के रूप में है।

Comments

ठीक है। यह अब एक फंक्शन के रूप में है।

— डेविड एफएक्स

Answer 3

जावा, 1051 1004

(पूरी तरह से काम कर रहे कार्यक्रम)

मैंने सोचा कि यह न केवल कुछ कोड को गोल्फ के लिए एक अच्छी चुनौती है, बल्कि मुख्य रूप से गणितीय कार्यों को लिखने के लिए अभ्यास करना है।

और एक "बेसलाइन" बनाने के लिए मैंने जावा में यह एक बनाया * सभी को हँसना शुरू करने के लिए प्रतीक्षा करता है * ।

कोड

import java.util.*;class P{double x,y;static P l(double... i){double a=i[0],b=i[1],c=i[2],d=i[3],e=i[4],f=i[5],k,l,x=(k=i[7]-f)*(c-a)-(l=i[6]-e)*(d-b),n=(l*(b-f)-k*(a-e))/x,m=((c-a)*(b-f)-(d-b)*(a-e))/x;P p=new P();p.x=a+n*(c-a);p.y=b+n*(d-b);return(n>=0&n<=1&m>=0&m<=1&x!=0)?p:null;}public static void main(String[]p){Set<String>v=new HashSet();P q,w,e;Integer a,b,c,d,k,f,g,h,i,j,m,l,r,t,y,z;int[][]x=new int[l=p.length/4][4];for(c=0;c<l;c++){for(d=0;d<4;){x[c][d]=l.parseInt(p[c*4+d++]);}}z=x.length;for(r=0;r<z;r++){a=x[r][0];b=x[r][1];c=x[r][2];d=x[r][3];for(t=0;t<z;t++){if(t!=r){k=x[t][0];f=x[t][1];g=x[t][2];h=x[t][3];q=l(a,b,c,d,k,f,g,h);if(q!=null){for(y=0;y<z;y++){if(y!=r&y!=t){i=x[y][0];j=x[y][1];m=x[y][2];l=x[y][3];w=l(a,b,c,d,i,j,m,l);e=l(k,f,g,h,i,j,m,l);if(w!=null&&e!=null&&q.x!=e.x&q.y!=e.y&!v.contains(""+r+y+t)){v.add(""+r+t+y);v.add(""+r+y+t);v.add(""+t+r+y);v.add(""+t+y+r);v.add(""+y+r+t);v.add(""+y+t+r);System.out.printf("%s %s %s %s %s %s\n",q.x,q.y,w.x,w.y,e.x,e.y);}}}}}}}}}

---

इनपुट

अंतरिक्ष अलग पूर्णांक। 4 (X1, y1, x2, y2) के जोड़े में

2 1 5 0 2 1 2 7 5 0 6 6 5 0 2 7 6 6 2 1 2 7 6 6

---

आउटपुट (वास्तविक उत्पादन 3 दशमलव तक नहीं होता है)

प्रत्येक पंक्ति में एक त्रिभुज होता है। प्रत्येक पंक्ति में 2 (X1, y1, x2, y2, x3, y3) के जोड़े में अलग-अलग तैरने वाले बिंदु होते हैं। (नोट: त्रिभुज बनाने वाले 3 बिंदुओं का क्रम अपरिभाषित है।)

5.0 0.0 2.0 1.0 6.0 6.0
5.0 0.0 2.0 1.0 2.0 7.0
5.0 0.0 2.0 1.0 3.674 3.093
2.0 7.0 2.0 1.0 3.674 3.093
2.0 1.0 2.0 7.0 6.0 6.0
5.0 0.0 6.0 6.0 3.674 3.093
5.0 0.0 6.0 6.0 2.0 7.0
3.674 3.093 2.0 7.0 6.0 6.0

---

व्याख्या

मैंने दो नहीं-अनंत लाइनों के बीच चौराहे को खोजने के लिए एक विधि लिखना शुरू किया। परिणामी विधि एक जावा शैली के लिए एक बहुत छोटी (246) है। विधि इनपुट देने के बजाय 8 दोहरे या दो अंक (P) से बाहर होते हैं, मैं वर्णों को सुरक्षित मात्रा में सुरक्षित करने के लिए एक मनमाना पैरामीटर का उपयोग करता हूं। सरणी ऑपरेटर उपयोग को कम करने के लिए 2 से अधिक बार उपयोग किए जाने वाले प्रत्येक पैरामीटर को स्वयं के चर में रखा गया है।

static P l(double... i){double a=i[0],b=i[1],c=i[2],d=i[3],e=i[4],f=i[5],k,l,x=(k=i[7]-f)*(c-a)-(l=i[6]-e)*(d-b),n=(l*(b-f)-k*(a-e))/x,m=((c-a)*(b-f)-(d-b)*(a-e))/x;P p=new P();p.x=a+n*(c-a);p.y=b+n*(d-b);return(n>=0&n<=1&m>=0&m<=1&x!=0)?p:null;}

अधिक स्पष्टीकरण जोड़ा जाना चाहिए ... (यह उत्तर शायद और भी अधिक गोल्फ हो सकता है)

Answer 4

बीबीसी बेसिक

Http://www.bbcbasic.co.uk/bbcwin/bbcwin.html पर एमुलेटर

मैं 400 में नीचे गोल्फ के लिए यह उम्मीद कर रहा हूँ।

इनपुट आउटपुट

हर बार जब उपयोगकर्ता किसी नई लाइन में प्रवेश करता है, तो प्रोग्राम यह जांचता है कि क्या कोई नया त्रिकोण बनाया गया है, और उन्हें तुरंत आउटपुट करता है, नीचे देखें।

एक नई त्रिभुज बनाई जाती है जहाँ नई लाइन दो पूर्व-विद्यमान रेखाओं के साथ परस्पर जुड़ती है जो परस्पर अंतर्संबंध भी होती है (सिवाय एक बिंदु पर जब तीनों रेखाएँ एक दूसरे को काटती हैं, जो कि एक विशेष स्थिति होती है जिससे निपटा जाना होता है।)

कोड

मुख्य कार्यक्रम जितना सरल हो सकता है। अंत में फ़ंक्शन होता है, जो http://en.wikipedia.org/wiki/Line%E2%80%93line_intersection में सूत्र के अनुसार, चौराहों का पता लगाने का जटिल कार्य करता है।

यदि कोई चौराहा नहीं है और एक नॉनजरो फ्लोटिंग पॉइंट संख्या है, तो फ़ंक्शन शून्य हो जाता है। इसका एक साइड इफेक्ट भी है: चौराहे के निर्देशांक को स्ट्रिंग जेड $ में जोड़ा जाता है। इसके अतिरिक्त, बीबीसी में एक फ़ंक्शन के चर मुख्य कार्यक्रम के लिए दिखाई देते हैं, बशर्ते मुख्य कार्यक्रम में एक ही नाम का चर नहीं है (भले ही फ़ंक्शन समाप्त हो गया हो।)

इसलिए मुख्य कार्यक्रम में चर xऔर y, mऔर n, जो वर्तमान और पिछले चौराहों के निर्देशांक को संग्रहीत करते हैं, तक पहुंच है । इसका उपयोग यह पता लगाने के लिए किया जाता है कि क्या हमने वास्तव में एक त्रिभुज पाया है और न कि केवल एक बिंदु पर तीन रेखाएं।

  DIM a(99),b(99),c(99),d(99)                                                    :REM declare 4 arrays to hold the ata
  y=0                                                                            :REM x and y are only initialized
  x=0                                                                            :REM to avoid a no such varialbe error later
  FOR i=0 TO 99                                                                  :REM for each input line
    INPUT a(i),b(i),c(i),d(i)
    FOR j=0 TO i-1                                                               :REM iterate through all combinations of 2 previous lines
      FOR k=0 TO j-1
        z$=""                                                                    :REM clear z$, three function calls on next line will write the triangle (if found) to it
        IF i>j AND j>k AND FNf(i,j)*FNf(i,k)*FNf(j,k)<>0 IF x<>m OR y<>n PRINT z$:REM to avoid printing the same triangle twice, print only if j,k,i in lexicographic order. Also reject if x,y (3rd FNf call) and m,n (2nd FNf call) are the same: this means a point, not a triangle.
      NEXT
    NEXT
  NEXT

  DEF FNf(g,h)                                                                   :REM returns zero if no intersection found, otherwise a floating point value
  m=x                                                                            :REM backup previous x and y
  n=y                                                                            :REM to use in test for point versus triangle
  p=a(g)-c(g)
  q=b(g)-d(g)
  r=a(h)-c(h)
  s=b(h)-d(h)
  t=a(g)*d(g)-b(g)*c(g)
  u=a(h)*d(h)-b(h)*c(h)
  e=p*s-q*r                                                                      :REM following method in wikipedia, calculate denominator of expression
  IF e<>0 x=(t*r-u*p)/e : y=(t*s-u*q)/e: z$=z$+" "+STR$(x)+" "+STR$(y)           :REM if denominator not zero, calculate x and y and append a string copy to z$
  IF (a(g)-x)*(c(g)-x)>0 OR (b(g)-y)*(d(g)-x)>0 OR(a(h)-x)*(c(h)-x)>0 OR(b(h)-y)*(d(h)-y)>0 e=0
  =e          :REM return e                                                      :REM previous line sets e to zero if the intersection falls outside the line segment. This is detected when both are on the same side of the intersection, which yields a positive multiplication result.