पिज्जा को अच्छी तरह से साझा करना

Question

दोस्तों के साथ पिज्जा साझा करने में कठिनाई यह है कि यह सुनिश्चित करना मुश्किल है कि हर किसी को अपने स्लाइस पर बराबर मात्रा में पेपरोनी मिले। तो, आपका काम यह तय करना है कि पिज्जा को काफी कैसे स्लाइस किया जाए ताकि हर कोई खुश रहे।

दिशा-निर्देश

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

• पिज्जा में केवल एक टॉपिंग है: पेपरोनी।
• आपके मित्र अपने स्लाइस के आकार के बारे में परवाह नहीं करते हैं, बस उन्हें किसी भी पेपरोनी से धोखा नहीं दिया जाता है।
• पिज्जा एक सर्कल है जो मूल पर (0, 0)और के त्रिज्या के1 साथ केंद्रित है ।
• पेपरोनिस सर्किल होते हैं जो कि इनपुट के अनुसार जहां भी कहते हैं केंद्रित होते हैं और जिनका दायरा होता है0.1
• एक पूर्णांक के रूप में इनपुट लें जो कि किए जाने वाले स्लाइस की संख्या का प्रतिनिधित्व करता है और आदेश-जोड़े की एक सूची है जो कार्टेशियन समन्वय प्रणाली पर पेपरोनिस के पदों का प्रतिनिधित्व करता है। (किसी भी उचित प्रारूप में)
• आउटपुट रेडियन में दिए गए कोणों की एक सूची होनी चाहिए जो पिज्जा ( रेंज में0 <= a < 2pi ) के लिए "कटौती" के पदों का प्रतिनिधित्व करती है । (किसी भी उचित प्रारूप में) (परिशुद्धता कम से कम होनी चाहिए +/- 1e-5।)
• आपके पास स्लाइस पर एक पेपरोनी के आंशिक टुकड़े हो सकते हैं (उदाहरण के लिए, यदि एक पिज्जा में एक पेपरोनी है और इसे 10 लोगों द्वारा साझा किया जाना है, तो पिज्जा को दस बार काट लें, सभी कटौती पेपरोनी के माध्यम से कटाई कर दें। लेकिन सुनिश्चित करें कि यह उचित है। !)
• कई पेपरोनिस के माध्यम से एक कट (टुकड़ा) का टुकड़ा हो सकता है।
• पेपेरोनिस ओवरलैप हो सकता है।

उदाहरण

इनपुट:

8 people, pepperonis: (0.4, 0.2), (-0.3, 0.1), (-0.022, -0.5), (0.3, -0.32)

संभव मान्य आउटपुट:

slices at:
0, 0.46365, 0.68916, 2.81984, 3.14159, 4.66842, 4.86957, 5.46554

यहाँ इस उदाहरण का एक दृश्य है (सभी को आधा पेपरोनी मिलता है):

और ज्यादा उदाहरण:

Input: 9 people, 1 pepperoni at: (0.03, 0.01)
Output: 0, 0.4065, 0.8222, 1.29988, 1.94749, 3.03869, 4.42503, 5.28428, 5.83985

Input: 5, (0.4, 0.3), (0.45, 0.43), (-0.5, -0.04)
Output: 0, 0.64751, 0.73928, 0.84206, 3.18997

स्कोरिंग

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

Comments

क्या सटीकता के लिए प्रस्तुतियाँ मान्य मानी जानी चाहिए?

— रेनबोल्ट

@Rainbolt मैं कहूँगा कि 4 या 5 दशमलव स्थान पर्याप्त होना चाहिए। आपकी क्या सलाह है? मुझे इसे प्रश्न में जोड़ना चाहिए।

— kukac67

मुझे यकीन नहीं है कि हर समस्या हल है। क्या होगा अगर वहाँ 7 स्लाइस और 3 पेपरोनी समान रूप से फैली हुई हैं?

— नाथन मेरिल

@NathanMerrill तब सभी को एक पेपरोनी के 3/7 मिलेंगे। :) (स्लाइस का आकार कोई फर्क नहीं पड़ता।)

— kukac67

पिज्जा टोपी का प्रयास विफल रहा। अगली बार एक आसान पूछें। ;)

— इल्मरी करोनें

Answer 1

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

f=(A=Pi.01Length@#2/#;l=m/.Solve[Norm[{a,b}-m{Cos@t,Sin@t}]==.1,m];k=(l/.{a->#,b->#2})&@@@#2;d=1.*^-5;For[Print[h=B=0];n=1,n<#,h+=d,(B+=If[Im@#<0,0,d(Max[#2,0]^2-Max[#,0]^2)/2])&@@@(k/.{t->h});If[B>A,n+=1;Print@h;B-=A]])&

Ungolfed:

f = (
   A = Pi .01 Length@#2/#;
   l = m /. Solve[Norm[{a, b} - m {Cos@t, Sin@t}] == .1, m];
   k = (l /. {a -> #, b -> #2}) & @@@ #2;
   d = 1.*^-5;
   For[Print[h = B = 0]; n = 1, n < #, h += d,
    (
      B += If[Im@# < 0, 0, d (Max[#2, 0]^2 - Max[#, 0]^2)/2]
    ) & @@@ (k /. {t -> h});
    If[B > A, n += 1; Print@h; B -= A]
   ]
) &

यह एक फ़ंक्शन को परिभाषित करता है जो पैरामीटर के रूप में लेता है स्लाइस की संख्या और पेपरोनी निर्देशांक के लिए जोड़े की सूची, जैसे

f[8, {{0.4, 0.2}, {-0.3, 0.1}, {-0.022, -0.5}, {0.3, -0.32}}]

यह स्लाइस को कंसोल पर प्रिंट कर देगा क्योंकि यह पिज्जा को ट्रेस करता है।

अधिकांश पिज्जा पर, यह काफी धीमा है, क्योंकि (आवश्यक परिशुद्धता प्राप्त करने के लिए) मैं 1e-5 के चरणों में 0 से 2 1 तक पेपरोनी क्षेत्र को एकीकृत कर रहा हूं। उचित समय में थोड़ा कम सटीक परिणाम प्राप्त करने के लिए, आप 1.*^-5अंत में बदल सकते हैं 1.*^-3।

यह काम किस प्रकार करता है

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

पेपरोनी क्षेत्र बह जाने के लिए, हम मूल से दो दूरी का उपयोग करने के लिए पेपरोनी के साथ लाइन को काटते हैं, जहां लाइन पेपरोनी के साथ मिलती है। चूँकि एक लाइन दोनों दिशाओं में अनंत तक फैली हुई है, इसलिए हमें इन दूरियों को गैर-नकारात्मक मूल्यों से जकड़ने की जरूरत है। यह दो समस्याओं को हल करता है:

• प्रत्येक पेपरोनी के साथ दो बार चौराहों की गिनती, एक बार सकारात्मक और एक बार नकारात्मक (जो वास्तव में 0 के समग्र क्षेत्र में निकलेगी)।
• केवल पेपरोनी के टुकड़ों की गिनती की जाती है जो मूल में शामिल होते हैं।

मैं कुछ आरेखों को बाद में शामिल करूंगा।

Comments

हां। यह मेरी हमले की योजना थी। कम से कम मैं अब आसानी से उदाहरण बना सकता हूं! : D

— kukac67

मैंने देखा कि आपका कार्यान्वयन कभी-कभी एक अतिरिक्त कोण का उत्पादन करता है जो उस पर कोई पेपरोनी के साथ एक अतिरिक्त टुकड़ा पैदा करेगा। : (साथ इनपुट उदाहरण के लिए [8, {{0.4, 0.2}, {-0.3, 0.1}, {-0.022, -0.5}, {0.3, -0.32}}])

— kukac67

@ kukac67 तय किया।

— मार्टिन एंडर