एक बहुभुज में छेद की संख्या

Question

समस्या : एक जुड़े बहुभुज में छेद की संख्या की गणना करें। बहुभुज की कनेक्टिविटी को इस शर्त से गारंटी दी जाती है कि इनपुट त्रिकोण में प्रत्येक त्रिकोण दूसरे त्रिकोण के साथ कम से कम 1 पक्ष साझा करता है और त्रिकोण का केवल एक ऐसा जुड़ा हुआ सेट है।

इनपुट एक सूची है Lकी nविमान में अंक और एक सूची Tसे प्रविष्टियों के साथ 3-tuples के 0...n-1। Tटपल में प्रत्येक आइटम के लिए त्रिभुज में एक त्रिभुज (t_1,t_2,t_3)के तीन कोने (सूची से L) का प्रतिनिधित्व करता है । ध्यान दें कि यह 'बहुभुज त्रिभुज' के अर्थ में एक त्रिभुज है , क्योंकि इससे Tउस ओवरलैप में कभी भी दो त्रिकोण नहीं होंगे । एक अतिरिक्त शर्त यह है कि आपको इनपुट को सैनिटाइज नहीं करना पड़ेगा, Lऔर Tइसमें कोई दोहराव नहीं होगा।

उदाहरण 1 : यदि L = {{0,0},{1,0},{0,1},{1,2}}और T = {{0,1,2},{1,2,3}}फिर निर्दिष्ट बहुभुज में छेद संख्या 0 है।

उदाहरण 2 : यदि L = {{0,0},{1,0},{2,0},{2,1},{2,2},{1,2},{0,2},{0,1},{.5,.5},{1.5,.5},{1.5,1.5},{.5,1.5}}और T = {{5,6,11},{5,10,11},{4,5,10},{3,8,10},{2,3,9},{2,8,9},{1,2,8},{0,1,8},{0,8,11},{0,7,11},{6,7,11},{3,4,10}}फिर बहुभुज इनपुट का परिणाम 2 के आउटपुट में होना चाहिए।

कार्य सबसे छोटा प्रोग्राम (या फ़ंक्शन) लिखना है जो इनपुट के रूप में लेता है Lऔर Tछिद्रों की संख्या लौटाता है। 'विजेता' को कम से कम वर्ण गणना (1 जून की अंतिम समाप्ति तिथि) के साथ प्रवेश के रूप में मान्यता दी जाएगी।

नमूना इनपुट स्वरूपण (नोट 0 अनुक्रमणिका):

0,0
1,0
0,1
1,2
0,1,2
1,2,3    

Comments

"बहुभुज की कनेक्टिविटी इस शर्त से गारंटी दी जाती है कि इनपुट त्रिकोण में प्रत्येक त्रिकोण दूसरे त्रिकोण के साथ कम से कम 1 पक्ष साझा करता है।" -- नहीं। यह एक पर्याप्त स्थिति नहीं है। उदाहरण के लिए, ले लो T=1,2,3/1,2,4/5,6,7/5,6,8। प्रत्येक त्रिभुज दूसरे त्रिकोण के साथ बढ़त साझा करता है, लेकिन त्रिकोणासन काट दिया जाता है

— जॉन ड्वोरक

क्या हम मान सकते हैं कि इनपुट एक वैध आंशिक त्रिभुज का प्रतिनिधित्व करता है (कोई दो त्रिकोण ओवरलैप नहीं है और कोई त्रिकोण दो बार मौजूद नहीं है) और त्रिकोणासन जुड़ा हुआ है?

— जॉन ड्वोरक

ध्यान दें कि छिद्रों की संख्या आकृति का जीनस नहीं है। विमान का हर सबसेट 0. की एक जीनस है "एक जुड़ा हुआ है, orientable सतह के जीनस परिणामी कई गुना कट प्रतिपादन के बिना एक पूर्णांक को न काटने बंद सरल घटता साथ कलमों की अधिकतम संख्या का प्रतिनिधित्व करता है"

— जॉन ड्वोरक

क्या हम यह भी मान सकते हैं कि इनपुट बढ़त से जुड़ा हुआ है, यह संभव नहीं है कि डिस्कनेक्ट किए गए आकार को रेंडर करने के लिए बिंदुओं का एक सीमित सेट निकालना संभव नहीं है? (पूर्व: T=1,2,3/1,4,5कनेक्टेड है लेकिन एज-कनेक्टेड नहीं है)

— जॉन ड्वोरक

मुझे यकीन नहीं है कि अंतिम तिथियों के बारे में यह व्यवसाय हाल ही में क्यों शुरू हुआ है। आपको स्वीकृत उत्तर को बदलने की अनुमति है, इसलिए अंतिम तिथि निर्धारित करने की कोई आवश्यकता नहीं है। यह उचित है कि आप एक मानसिक विचार रखें, जिसका जवाब देने से पहले आप एक सप्ताह इंतजार करेंगे, ताकि लोगों को यह सोचकर डराया न जा सके कि पहला उत्तर अपराजेय है, लेकिन जब तक आप उस साइट पर सक्रिय हैं, आप चयनित उत्तर को बदल सकते हैं अगर कोई बेहतर पोस्ट करता है। प्रासंगिक मेटा चर्चाओं में meta.codegolf.stackexchange.com/q/542/194 और meta.codegolf.stackexchange.com/q/193/194

— पीटर टेलर

Answer 1

गोल्फस्क्रिप्ट (23 वर्ण)

~.{2*2/~}%{$}%.&,@@+,-)

GolfScript सरणी अंकन और उद्धृत (या अभिन्न) निर्देशांक का उपयोग कर इनपुट प्रारूप मानता है। उदाहरण के लिए

$ golfscript codegolf11738.gs <<<END
[["0" "0"] ["1" "0"] ["2" "0"] ["2" "1"] ["2" "2"] ["1" "2"] ["0" "2"] ["0" "1"] [".5" ".5"] ["1.5" ".5"] ["1.5" "1.5"] [".5" "1.5"]] [[5 6 11] [5 10 11] [4 5 10] [3 8 10] [2 3 9] [2 8 9] [1 2 8] [0 1 8] [0 8 11] [0 7 11] [6 7 11] [3 4 10]]
END
2

( ऑनलाइन आवेदन )

या

$ golfscript codegolf11738.gs <<<END
[[0 0] [1 0] [0 1] [1 2]] [[0 1 2] [1 2 3]]
END
0

( ऑनलाइन आवेदन )

Answer 2

पायथन, 71

निम्न प्रकार एक प्रोग्राम है ( फ़ंक्शन नहीं ) जो वांछित संख्या की गणना करता है।

len(set().union(*(map(frozenset,zip(t,t[1:]+t))for t in T)))-len(L+T)+1

उदाहरण का उपयोग:

>>> L = ((0,0),(1,0),(2,0),(2,1),(2,2),(1,2),(0,2),(0,1),(.5,.5),(1.5,.5),(1.5,1.5),(.5,1.5))
>>> T = ((5,6,11),(5,10,11),(4,5,10),(3,8,10),(2,3,9),(2,8,9),(1,2,8),(0,1,8),(0,8,11),(0,7,11),(6,7,11),(3,4,10))
>>> len(set().union(*(map(frozenset,zip(t,t[1:]+t))for t in T)))-len(L+T)+1
2

Comments

+1 स्पैट का उपयोग करने के लिए, छंटाई के बजाय फ्रोज़ेनसेट का उपयोग करते हुए, ज़िप (यह नहीं कह सकता कि मैंने इसे पहले कभी इस्तेमाल किया है, खुद को परिचित करने की आवश्यकता है।)

— काया

Answer 3

एपीएल, ३६

{1+(⍴⊃∪/{{⍵[⍋⍵]}¨,/3 2⍴⍵,⍵}¨⍵)-⍴⍺,⍵}

फ़ंक्शन Lइसके बाएं तर्क के Tरूप में और इसके दाईं ओर के रूप में लेता है ।

उदाहरण के लिए:

      L←(0 0)(1 0)(0 1)(1 2)
      T←(0 1 2)(1 2 3)
      L{1+(⍴⊃∪/{{⍵[⍋⍵]}¨,/3 2⍴⍵,⍵}¨⍵)-⍴⍺,⍵}T
0
      L←(0 0)(1 0)(2 0)(2 1)(2 2)(1 2)(0 2)(0 1)(.5 .5)(1.5 .5)(1.5 1.5)(.5 1.5)
      T←(5 6 11)(5 10 11)(4 5 10)(3 8 10)(2 3 9)(2 8 9)(1 2 8)(0 1 8)(0 8 11)(0 7 11)(6 7 11)(3 4 10)
      L{1+(⍴⊃∪/{{⍵[⍋⍵]}¨,/3 2⍴⍵,⍵}¨⍵)-⍴⍺,⍵}T
2

---

स्पष्टीकरण, दाएं से बाएं जाना:

• ⍴⍺,⍵दो इनपुट वैक्टर को सम्‍मिलित करता है और उनकी लंबाई लौटाता है ( V + F)
• अगले ब्लॉक के अंदर कदम रखना:
  • ¨⍵ सही तर्क के प्रत्येक तत्व के बाईं ओर फ़ंक्शन को लागू करता है और परिणाम देता है
  • ⍵,⍵ अपने साथ समाप्‍त सही तर्क देता है
  • 3 2⍴वेक्टर तर्क को तीन जोड़े में आकार देता है। इस मामले में यह पहले और दूसरे, तीसरे और पहले और वेक्टर के दूसरे और तीसरे आइटम के साथ जोड़ा जाता है।
  • ,/ वेक्टर तर्क को एक साथ जोड़ता है
  • ⍵[⍋⍵] सही तर्क दें
  • ∪/ किसी भी डुप्लिकेट को फ़िल्टर करता है
  • ⍴⊃ एक नेस्टेड स्केलर को वेक्टर में बदल देता है, और यह इसकी लंबाई लौटाता है।
  • संपूर्ण फ़ंक्शन आकार में किनारों की संख्या लौटाता है ( E)
• 1 आत्म-व्याख्यात्मक है (मुझे उम्मीद है ...)

पूरा फ़ंक्शन फिर लौटता है 1+E-(V+F), या 1-(F+V-E)।

Comments

बहुत सुंदर मेरे गोल्फस्क्रिप्ट समाधान क्या करता है। मुझे आश्चर्य है कि यह गोल्फस्क्रिप्ट से बहुत लंबा है।

— पीटर टेलर

@PeterTaylor मुझे आश्चर्य हुआ कि आपका गोल्फस्क्रिप्ट समाधान इतना छोटा था! (लेकिन फिर, यह है GolfScript)

— अस्थिरता

Answer 4

Mathematica, 93 (अभी तक गोल्फ नहीं)

f[l_, t_] :=  Max@MorphologicalComponents[Erosion[Graphics[
                                                        GraphicsComplex[l, Polygon[t + 1]]], 1]] - 1

(स्पष्टता के लिए जोड़े गए स्थान)

परिक्षण:

f[{{0, 0}, {1, 0}, {0, 1}, {1, 2}}, {{0, 1, 2}, {1, 2, 3}}]
(*
 -> 0
*)

{l, t} = {{{0, 0}, {1,   0}, {2,    0}, {2,     1}, {2,    2}, {1, 2}, {0, 2}, 
           {0, 1}, {.5, .5}, {1.5, .5}, {1.5, 1.5}, {.5, 1.5}}, 

           {{5, 6, 11}, {5, 10, 11}, {4, 5, 10}, {3, 8, 10}, {2, 3,  9}, 
            {2, 8,  9}, {1,  2,  8}, {0, 1,  8}, {0, 8, 11}, {0, 7, 11}, {6, 7, 11}, {3, 4, 10}}};
f[l, t]
 (*
  -> 2
 *)

Comments

क्या यह त्रिभुजों या छिद्रों पर कुछ न्यूनतम आकार (तर्क Erosion) पर निर्भर नहीं करता है ?

— जॉन ड्वोरक

@JDDvorak शायद मैं गलत हूं, लेकिन मुझे लगता है कि जब तक आप अनंत सटीक अंकगणित का उपयोग नहीं करते हैं, तब तक कोई भी समाधान तब तक काम करेगा जब तक आप एक निश्चित न्यूनतम आकार तक नहीं पहुंच जाते (आपको यह तय करना होगा कि तीन बिंदु गठबंधन किए गए हैं या नहीं)। यह सिर्फ इतना है कि इस तरह के समाधान में समस्या स्पष्ट रूप से बताई गई है।

— डॉ। बेलीज़ेरियस

यदि आप टोपोलॉजिकल दृष्टिकोण का उपयोग करते हैं, तो आपके पास नहीं है। यदि तीन बिंदु टकराते हैं तो आपको वहां एक शून्य-क्षेत्र त्रिकोण की आवश्यकता होती है - अन्यथा आपके पास एक छेद है।

— जॉन ड्वोरक

@belisarius। यहाँ जवाब है मुझे हमारे परिणामों के बीच विसंगति के बारे में वुल्फराम तकनीकी सहायता से मिला: "हैलो - आपके ईमेल के लिए धन्यवाद। मैंने पुष्टि की है कि आपका कोड मैक और विंडोज पर अलग-अलग परिणाम देता है। मुझे नहीं लगता कि यह इच्छित व्यवहार है, इसलिए मैंने इस मुद्दे पर हमारे डेवलपर्स के साथ एक रिपोर्ट दर्ज की है। मुझे इस मुद्दे पर हमारे द्वारा प्राप्त किसी भी उपयोगी जानकारी पर पास करना सुनिश्चित होगा। कृपया मुझे बताएं कि क्या आपके पास कोई और प्रश्न हैं। ... तकनीकी सहायता वोल्फ्राम रिसर्च , इंक "

— डेविड

@DavidCarraher "हां, मेरे पास और प्रश्न हैं: क्या आप मुझे प्रत्येक बग के लिए एक चेक भेजेंगे?"

— डॉ। बेलीजरियस

Answer 5

रूबी, 239 अक्षर (227 बॉडी)

def f t
e=t.flat_map{|x|x.permutation(2).to_a}.group_by{|x|x}.select{|_,x|x.one?}.keys
n=Hash[e]
(u,n=n,n.dup;e.map{|x|a,b=*x;n[a]=n[n[a]]=n[b]})until n==u
n.values.uniq.size+e.group_by(&:last).map{|_,x|x.size}.reduce(-1){|x,y|x+y/2-1}
end

ध्यान दें कि मैं केवल टोपोलॉजी पर विचार कर रहा हूं। मैं किसी भी तरह से शीर्ष पदों का उपयोग नहीं कर रहा हूं।

कॉल करने वाले (माथेमेटिका या JSON प्रारूप में T की अपेक्षा करते हैं):

input = gets.chomp
input.gsub! "{", "["
input.gsub! "}", "]"
f eval(input)

परीक्षा:

f [[0,1,2],[1,2,3]]
#=> 0
f [[5, 6, 11], [5, 10, 11], [4, 5, 10], [3, 8, 10], [2, 3, 9], [2, 8, 9], [1, 2, 8], [0, 1, 8], [0, 8, 11], [0, 7, 11], [6, 7, 11], [3, 4, 10]]
#=> 2
f [[1,2,3],[3,4,5],[5,6,1],[2,3,4],[4,5,6],[6,1,2]]
#=> 1

Comments

याय, एक यूलर चारित्रिक दृष्टिकोण। मैंने इसे अजगर में कैसे किया।

— काया

@Kaya। (कोलम्बस के अंडे देखें en.wikipedia.org/wiki/Egg_of_Columbus ) एक बार किसी ने आपके प्रश्न का उत्तर देने के लिए यूलरियन जवाब दिया है, तो इस बात की संभावना बढ़ जाती है कि दूसरे उसका अनुसरण करेंगे। मैं आपको आश्वस्त कर सकता हूं कि यह अपने आप में दृष्टिकोण की खोज करने के लिए कहीं अधिक चुनौतीपूर्ण और संतुष्टिदायक है, केवल बाद में पॉलीहेड्रा के साथ यूलर के काम के लिए संबंध बनाते हैं।

— डेविड

Answer 6

मैथमेटिका 76 73 72 67 62

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

ग्राफ में दो प्रकार के आंतरिक "त्रिकोण" थे: जो कि संभवतः एक चेहरा थे, अर्थात एक "भरा हुआ" त्रिभुज, और वे जहाँ नहीं थे। आंतरिक चेहरों की संख्या का किनारों या कोने से कोई संबंध नहीं था। इसका मतलब था कि पूरी तरह से "भरे हुए" ग्राफ़ में पोकिंग छेदों ने केवल चेहरे की संख्या कम कर दी। मैंने व्यवस्थित रूप से चेहरे, कोने और किनारों का ट्रैक रखते हुए, त्रिकोण के बीच भिन्नता के साथ खेला। आखिरकार मैंने महसूस किया कि छेदों की संख्या हमेशा 1 - # स्थान - # कोने + # बीज के बराबर होती थी। यह 1 शून्य से यूलर विशेषता निकला (जिसे मैं केवल नियमित पॉलीहेड्रा के संदर्भ में जानता था) (हालांकि किनारों की लंबाई का कोई महत्व नहीं था।

जब फंक्शंस और त्रिकोण इनपुट होते हैं, तो नीचे दी गई फ़ंक्शन छिद्रों की संख्या को लौटाता है। मेरे पहले सबमिशन के विपरीत, यह किसी इमेज के स्कैन पर निर्भर नहीं करता है। आप इसे 1 के रूप में सोच सकते हैं - यूलर की विशेषता, अर्थात 1 - (एफ + वी-ई) जहां = # Fस्थान, V= # कोने, E= # किनारों। फ़ंक्शन 1 - (F + V -E)वास्तविक चेहरों (त्रिकोण) और कोने को देखते हुए, छिद्रों की संख्या लौटाता है ।

यह आसानी से दिखाया जा सकता है कि परिसर के बाहर किसी भी त्रिकोण को हटाने से यूलर विशेषता पर कोई प्रभाव नहीं पड़ता है, चाहे वह अन्य त्रिकोणों के साथ एक या 2 पक्षों को साझा करे।

नोट: मूल सूत्रीकरण के vस्थान पर निचले मामले का उपयोग किया जाएगा L; अर्थात्, इसमें स्वयं वर्टिस होते हैं (V नहीं, वर्टिस की संख्या)

fTमूल सूत्रीकरण से उपयोग किया जाता है ; यही है, इसमें त्रिकोण शामिल हैं, जो वर्टेक्स इंडेक्स के आदेशित ट्रिपल के रूप में दर्शाए गए हैं।

कोड

z=Length;1-z@#2-z@#+z[Union@@(Sort/@{#|#2,#2|#3,#3|#}&@@@#2)]&

(प्रतिस्थापन नियम को समाप्त करके 5 वर्णों को बंद करने के लिए श्री जादूगर का धन्यवाद।)

---

उदाहरण 1

v = {{0, 0}, {1, 0}, {0, 1}, {1, 2}}; f = {{0, 1, 2}, {1, 2, 3}};

z=Length;1-z@#2-z@#+z[Union@@(Sort/@{#|#2,#2|#3,#3|#}&@@@#2)]&[v, f]

0

शून्य छेद।

---

उदाहरण 2

v = {{0, 0}, {1, 0}, {2, 0}, {2, 1}, {2, 2}, {1, 2}, {0, 2}, {0, 1}। , {.5, .5}, {1.5, .5}, {1.5, 1.5}, {.5, 1.5}}; f = {{5, 6, 11}, {5, 10, 11}, {4, 5, 10}, {3, 8, 10}, {2, 3, 9}, {2, 8, 9} , {1, 2, 8}, {0, 1, 8}, {0, 8, 11}, {0, 7, 11}, {6, 7, 11}, {3, 4, 10}};

z=Length;1-z@#2-z@#+z[Union@@(Sort/@{#|#2,#2|#3,#3|#}&@@@#2)]&[v, f]

2

इस प्रकार, 2 छेद उदाहरण 2 में हैं।

Comments

क्या आप मूल रूप से त्रिकोणीयकरण को तेज कर रहे हैं और उस छवि पर एक ग्राफिक्स लाइब्रेरी को डंप कर रहे हैं? यदि छेद बहुत छोटा है तो क्या यह विफल नहीं होता है?

— जॉन ड्वोरक

आपका दूसरा उदाहरण यहां 0 देता है (इसीलिए मैंने इसका उपयोग नहीं किया है MorphologicalEulerNumber[])। मम्मा 9.01, विन एक्सपी।

— डॉ। बेलीजरियस

मैं 9.0.1 का उपयोग कर रहा हूं, लेकिन मैक पर। क्या आप कह रहे हैं कि मैथेमेटिका विंडोज पर मेरा एक अलग जवाब देता है? यदि ऐसा है, तो यह एक बग (विंडोज एक्सपी संस्करण में) की तरह लगता है।

— डेविड

@DavidCarraher Yep: i.stack.imgur.com/LKcr1.png

— डॉ। बेलिसरियस

@ जान ड्वोरक। MorphologicalEulerNumberकभी-कभी एक छवि की आवश्यकता होती है; यह एक ग्राफिक्स ऑब्जेक्ट को स्वीकार करने से इनकार करता है। इन मामलों में, छेद का आकार और रिज़ॉल्यूशन महत्वपूर्ण है (देखें कोडगॉल्फ.स्टैकएक्सचेंज . com/questions/8706/… )। लेकिन यहां यह ग्राफिक्स ऑब्जेक्ट के साथ सीधे काम करता है, जिसमें स्पष्ट रूप से सभी कोने शामिल हैं। मैंने कल्पना की (या उम्मीद है) कि यह एक दृष्टिकोण का उपयोग करेगा जो छवि पर निर्भर नहीं था। काश मुझे पता होता कि इसने इस मुद्दे को हल करने का प्रयास कैसे किया। शायद फ़ंक्शन के लिए स्रोत कोड में कुछ स्पेलुनकिंग, चीजों को स्पष्ट करेंगे।

— डेविड

Answer 7

अजगर, १०th

मुझे महसूस हुआ कि जोड़े सीधे लेना from itertools import*टाइपिंग से कम था combinations()। फिर भी मैंने यह भी देखा कि मेरा समाधान इनपुट त्रिकोणीय चेहरों पर निर्भर करता है जिनके अनुरूप क्रम में सूचीबद्ध उनके कोने हैं। इसलिए चरित्र गणना में लाभ उतना बड़ा नहीं है।

f=lambda l,t:1-len(l+t)+len(set([tuple(sorted(m))for n in[[i[:2],i[1:],[i[0],i[2]]]for i in t]for m in n]))

अजगर, ११५

यूलर विशेषता दृष्टिकोण, itertools की क्रिया से बचने के लिए असंभव लगता है। मुझे आश्चर्य है कि अगर जोड़ियों के जोड़े बनाने के लिए अधिक प्रत्यक्ष तकनीक का उपयोग करना सस्ता होगा।

from itertools import*
f=lambda l,t:1-len(l+t)+len(set([m for n in[list(combinations(i,2)) for i in t]for m in n]))

उपयोग उदाहरण:

> f([[0,0],[1,0],[0,1],[1,2]],[[0,1,2],[1,2,3]])
> 0
> f([[0,0],[1,0],[2,0],[2,1],[2,2],[1,2],[0,2],[0,1],[.5,.5],[1.5,.5],[1.5,1.5],[.5,1.5]],[[5,6,11],[5,10,11],[4,5,10],[3,8,10],[2,3,9],[2,8,9],[1,2,8],[0,1,8],[0,8,11],[0,7,11],[6,7,11],[3,4,10]])
> 2