एक अपोलोनियन गैसकेट ड्रा करें

Question

तीन परस्पर स्पर्श रेखाओं को देखते हुए, हम हमेशा दो और वृत्त पा सकते हैं जो उन तीनों के स्पर्शरेखा हैं। इन दोनों को अपोलोनियन सर्कल कहा जाता है । ध्यान दें कि अपोलोनियन सर्कल में से एक वास्तव में तीन प्रारंभिक सर्कल के आसपास हो सकता है ।

तीन स्पर्शरेखा मंडलियों से शुरू होकर, हम एक अपोलोनियन गैसकेट नामक भग्न बना सकते हैं , निम्नलिखित प्रक्रिया द्वारा:

1. प्रारंभिक 3 मंडलियों को मूल मंडलियों को कॉल करें
2. अभिभावक मंडलियों के दो अपोलोनियन मंडलियों का पता लगाएं
3. प्रत्येक अपोलोनियन सर्कल के लिए:
   4. मूल जोड़े के तीन जोड़े में से प्रत्येक जोड़े के लिए:
      5. अपोलोनियन सर्कल और दो पैरेंट सर्कल को पेरेंट सर्कल के नए सेट को कॉल करें और चरण 2 से शुरू करें।

उदाहरण के लिए, समान आकार के वृत्तों के साथ, हम प्राप्त करते हैं:

^{छवि विकिपीडिया पर मिली}

हमें एक और बिटेशन की आवश्यकता है। यदि हमारे पास केंद्र (x, y) के साथ त्रिज्या r का एक घेरा है , तो हम इसे k = / 1 / r के रूप में वक्रता को परिभाषित कर सकते हैं । आमतौर पर k पॉजिटिव होगा, लेकिन हम नकारात्मक k का उपयोग उस सर्कल को दर्शाने के लिए कर सकते हैं जो गैसकेट में अन्य सभी सर्कल को घेरता है (अर्थात सभी स्पर्शक अंदर से उस सर्कल को स्पर्श करते हैं)। फिर हम संख्याओं के एक समूह के साथ एक वृत्त निर्दिष्ट कर सकते हैं: (k, x * k, y * k) ।

इस प्रश्न के उद्देश्य के लिए, हम सकारात्मक पूर्णांक k और परिमेय x और y मान लेंगे ।

ऐसे हलकों के लिए आगे के उदाहरण विकिपीडिया लेख में पाए जा सकते हैं ।

इस लेख में अभिन्न गास्केट के बारे में कुछ दिलचस्प चीजें भी हैं (हलकों के साथ अन्य मज़ेदार चीजें)।

चुनौती

आपको 4 सर्कल स्पेसिफिकेशन्स दिए जाएंगे , जिनमें से प्रत्येक जैसा दिखेगा (14, 28/35, -112/105)। आप किसी भी सूची प्रारूप और डिवीजन ऑपरेटर का उपयोग कर सकते हैं जो सुविधाजनक है, जैसे कि evalआप चाहें तो बस इनपुट कर सकते हैं । आप मान सकते हैं कि 4 सर्कल वास्तव में एक-दूसरे के स्पर्शरेखा हैं, और उनमें से पहले में नकारात्मक वक्रता है। इसका मतलब है कि आपको पहले से ही अन्य तीन के अपोलोनियन सर्कल दिए गए हैं। मान्य उदाहरण इनपुट की सूची के लिए, चुनौती के नीचे देखें।

एक प्रोग्राम या फ़ंक्शन लिखें, जो इस इनपुट को देखते हुए, एक अपोलोनियन गैसकेट खींचता है।

आप फ़ंक्शन तर्क, एआरजीवी या एसटीडीआईएन के माध्यम से इनपुट ले सकते हैं और या तो स्क्रीन पर फ्रैक्टल को प्रस्तुत कर सकते हैं या इसे अपनी पसंद के प्रारूप में एक छवि फ़ाइल में लिख सकते हैं।

यदि परिणामी छवि rasterised है, तो यह प्रत्येक तरफ कम से कम 400 पिक्सल होना चाहिए, जिसमें सबसे बड़ा सर्कल के आसपास 20% से कम पैडिंग है। जब आप उन सर्किलों तक पहुँचना बंद कर देते हैं, जिनकी त्रिज्या सबसे बड़े इनपुट सर्कल के 400 वें भाग से कम होती है, या ऐसे सर्कल जो पिक्सेल से छोटे होते हैं, जो भी पहले होता है।

आपको केवल सर्कल की रूपरेखाओं को आकर्षित करना चाहिए, न कि पूर्ण डिस्क, बल्कि पृष्ठभूमि और रेखाओं के रंग आपकी पसंद हैं। बाहरी मंडलियों के व्यास के 200 वें हिस्से की रूपरेखा व्यापक नहीं होनी चाहिए।

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

उदाहरण इनपुट

विकिपीडिया लेख से सभी इनपुट इनपुट निर्धारित प्रारूप में बदल दिए गए हैं:

[[-1, 0, 0], [2, 1, 0], [2, -1, 0], [3, 0, 2]]
[[-2, 0, 0], [3, 1/2, 0], [6, -2, 0], [7, -3/2, 2]]
[[-3, 0, 0], [4, 1/3, 0], [12, -3, 0], [13, -8/3, 2]]
[[-3, 0, 0], [5, 2/3, 0], [8, -4/3, -1], [8, -4/3, 1]]
[[-4, 0, 0], [5, 1/4, 0], [20, -4, 0], [21, -15/4, 2]]
[[-4, 0, 0], [8, 1, 0], [9, -3/4, -1], [9, -3/4, 1]]
[[-5, 0, 0], [6, 1/5, 0], [30, -5, 0], [31, -24/5, 2]]
[[-5, 0, 0], [7, 2/5, 0], [18, -12/5, -1], [18, -12/5, 1]]
[[-6, 0, 0], [7, 1/6, 0], [42, -6, 0], [43, -35/6, 2]]
[[-6, 0, 0], [10, 2/3, 0], [15, -3/2, 0], [19, -5/6, 2]]
[[-6, 0, 0], [11, 5/6, 0], [14, -16/15, -4/5], [15, -9/10, 6/5]]
[[-7, 0, 0], [8, 1/7, 0], [56, -7, 0], [57, -48/7, 2]]
[[-7, 0, 0], [9, 2/7, 0], [32, -24/7, -1], [32, -24/7, 1]]
[[-7, 0, 0], [12, 5/7, 0], [17, -48/35, -2/5], [20, -33/35, 8/5]]
[[-8, 0, 0], [9, 1/8, 0], [72, -8, 0], [73, -63/8, 2]]
[[-8, 0, 0], [12, 1/2, 0], [25, -15/8, -1], [25, -15/8, 1]]
[[-8, 0, 0], [13, 5/8, 0], [21, -63/40, -2/5], [24, -6/5, 8/5]]
[[-9, 0, 0], [10, 1/9, 0], [90, -9, 0], [91, -80/9, 2]]
[[-9, 0, 0], [11, 2/9, 0], [50, -40/9, -1], [50, -40/9, 1]]
[[-9, 0, 0], [14, 5/9, 0], [26, -77/45, -4/5], [27, -8/5, 6/5]]
[[-9, 0, 0], [18, 1, 0], [19, -8/9, -2/3], [22, -5/9, 4/3]]
[[-10, 0, 0], [11, 1/10, 0], [110, -10, 0], [111, -99/10, 2]]
[[-10, 0, 0], [14, 2/5, 0], [35, -5/2, 0], [39, -21/10, 2]]
[[-10, 0, 0], [18, 4/5, 0], [23, -6/5, -1/2], [27, -4/5, 3/2]]
[[-11, 0, 0], [12, 1/11, 0], [132, -11, 0], [133, -120/11, 2]]
[[-11, 0, 0], [13, 2/11, 0], [72, -60/11, -1], [72, -60/11, 1]]
[[-11, 0, 0], [16, 5/11, 0], [36, -117/55, -4/5], [37, -112/55, 6/5]]
[[-11, 0, 0], [21, 10/11, 0], [24, -56/55, -3/5], [28, -36/55, 7/5]]
[[-12, 0, 0], [13, 1/12, 0], [156, -12, 0], [157, -143/12, 2]]
[[-12, 0, 0], [16, 1/3, 0], [49, -35/12, -1], [49, -35/12, 1]]
[[-12, 0, 0], [17, 5/12, 0], [41, -143/60, -2/5], [44, -32/15, 8/5]]
[[-12, 0, 0], [21, 3/4, 0], [28, -4/3, 0], [37, -7/12, 2]]
[[-12, 0, 0], [21, 3/4, 0], [29, -5/4, -2/3], [32, -1, 4/3]]
[[-12, 0, 0], [25, 13/12, 0], [25, -119/156, -10/13], [28, -20/39, 16/13]]
[[-13, 0, 0], [14, 1/13, 0], [182, -13, 0], [183, -168/13, 2]]
[[-13, 0, 0], [15, 2/13, 0], [98, -84/13, -1], [98, -84/13, 1]]
[[-13, 0, 0], [18, 5/13, 0], [47, -168/65, -2/5], [50, -153/65, 8/5]]
[[-13, 0, 0], [23, 10/13, 0], [30, -84/65, -1/5], [38, -44/65, 9/5]]
[[-14, 0, 0], [15, 1/14, 0], [210, -14, 0], [211, -195/14, 2]]
[[-14, 0, 0], [18, 2/7, 0], [63, -7/2, 0], [67, -45/14, 2]]
[[-14, 0, 0], [19, 5/14, 0], [54, -96/35, -4/5], [55, -187/70, 6/5]]
[[-14, 0, 0], [22, 4/7, 0], [39, -12/7, -1/2], [43, -10/7, 3/2]]
[[-14, 0, 0], [27, 13/14, 0], [31, -171/182, -10/13], [34, -66/91, 16/13]]
[[-15, 0, 0], [16, 1/15, 0], [240, -15, 0], [241, -224/15, 2]]
[[-15, 0, 0], [17, 2/15, 0], [128, -112/15, -1], [128, -112/15, 1]]
[[-15, 0, 0], [24, 3/5, 0], [40, -5/3, 0], [49, -16/15, 2]]
[[-15, 0, 0], [24, 3/5, 0], [41, -8/5, -2/3], [44, -7/5, 4/3]]
[[-15, 0, 0], [28, 13/15, 0], [33, -72/65, -6/13], [40, -25/39, 20/13]]
[[-15, 0, 0], [32, 17/15, 0], [32, -161/255, -16/17], [33, -48/85, 18/17]]

Comments

आपके उदाहरण चित्रण में लगता है कि पहले ऑपरेशन के बाद केवल "अंदर" एपोलोनियन मंडलियां शामिल थीं।

— शुक्राणु

@ शेपर मुझे यकीन नहीं है कि आपका क्या मतलब है। पहले ऑपरेशन के बाद, दो एपोलोनियन सर्कल में से एक पहले से मौजूद है (मूल मूल सर्कल जो आपने वर्तमान पुनरावृत्ति के लिए नहीं चुना था) और आप केवल दूसरे समाधान की तलाश कर रहे हैं।

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

कोई बात नहीं, तुम सही हो, मैं गलत पढ़ रहा था।

— स्पर्स

Answer 1

GolfScript (289 बाइट्स वेक्टर / 237 बाइट्स रेखापुंज)

289 बाइट्स और एक उचित समय में निष्पादित:

'/'/n*','/']['*0,`1/*~1.$[]*(~-400*:&;{1+1=*}/:D;{{1+2<~D@*\/}%}%'<svg><g fill="none" stroke="red">'puts.{[[~@:b[D&*\abs]{@&*[b]+}2*]{'.0/'*'"#{
}"'n/*~}%'<circle r="
" cx="
" cy="
" />'n/\]zip puts}:|/[{.([.;]+}3*]{(:?zip{)\~++2*\-}%:c.|0=D&*<{?);[c]+[{([.;]+.}3*;]+}*.}do'</g></svg>'

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

इनपुट [[-2, 0, 0], [3, 1/2, 0], [6, -2, 0], [7, -3/2, 2]]को देखते हुए आउटपुट (इंकजेट के साथ पीएनजी में परिवर्तित) है

---

237 बाइट्स में और बहुत अधिक समय तक (मैं एक्सट्रपलेट करता हूं कि उपरोक्त समान समान आउटपुट का उत्पादन करने में एक सप्ताह से अधिक समय लगेगा, हालांकि एक-बिट ब्लैक एंड व्हाइट में):

'/'/n*','/']['*0,`1/*~1.$[]*(~-400*:&;{1+1=*}/:D;{{1+2<~D@*\/}%}%.[{.([.;]+}3*]{(:?[zip{)\~++2*\-}%:c]@+\0c=D&*<{?);[c]+[{([.;]+.}3*;]+}*.}do;:C;'P1 ''801 '2*.~:B*,{:P;C{:?[0=2/.D&*-.*\D&*+.*]{2,{P{B/}2$*B%400-?0=*\)?=&*-.*}/+<},,1=},!}/

आउटपुट newlines के बिना NetPBM प्रारूप है, इसलिए संभवतः कड़ाई से कल्पना का पालन नहीं करता है, हालांकि GIMP अभी भी इसे लोड करेगा। यदि सख्त अनुरूपता आवश्यक है, nतो अंतिम के बाद डालें !।

रेखांकन प्रत्येक वृत्त के विरुद्ध प्रत्येक पिक्सेल का परीक्षण करके होता है, इसलिए लिया गया समय पिक्सेल की संख्या में वृत्त की संख्या से बहुत अधिक रैखिक होता है। 10 के कारक द्वारा सब कुछ घटाकर,

'/'/n*','/']['*0,`1/*~1.$[]*(~-40*:&;{1+1=*}/:D;{{1+2<~D@*\/}%}%.[{.([.;]+}3*]{(:?[zip{)\~++2*\-}%:c]@+\0c=D&*<{?);[c]+[{([.;]+.}3*;]+}*.}do;:C;'P1 ''81 '2*.~:B*,{:P;C{:?[0=2/.D&*-.*\D&*+.*]{2,{P{B/}2$*B%40-?0=*\)?=&*-.*}/+<},,1=},!}/

10 मिनट में चलेगा और उत्पादन करेगा

(GIMP के साथ PNG में परिवर्तित)। 36 घंटों को देखते हुए इसने 401x401 का उत्पादन किया

Comments

मैंने कभी नहीं सोचा था कि आप गोल्फस्क्रिप्ट के साथ ग्राफिकल आउटपुट कर सकते हैं ...

— बीटा

Answer 2

जावास्क्रिप्ट ( 418 410 बाइट्स)

एक समारोह के रूप में लागू:

function A(s){P='<svg><g fill=none stroke=red transform=translate(400,400)>';Q=[];s=eval(s);S=-400*s[0][0];function d(c){P+='<circle r='+Math.abs(p=S/c[0])+' cx='+p*c[1]+' cy='+p*c[2]+' />'}for(c=4;c--;d(s[0]),s.push(s.shift()))Q.push(s.slice());for(;s=Q.shift();d(c)){c=[];for(i=4;i--;)c[i]=2*(s[0][i]+s[1][i]+s[2][i])-s[3][i];for(i=6;c[0]<S&&i;)Q.push([s[i--%3],s[i--%3],c,s[i%3]])}document.body.innerHTML=P}

ऑनलाइन डेमो (ध्यान दें: उन ब्राउज़रों में काम नहीं करता है जो एसवीजी युक्ति की आवश्यकताओं का सम्मान करने में असफल होते हैं, क्योंकि मैं उस बग के आसपास काम करने वाला थोड़ा लंबा संस्करण पेश करता हूं; ब्राउज़र एसवीजी को उदाहरण के लिए इंकसैप से कम सटीक रूप से प्रस्तुत कर सकते हैं, हालांकि Inkscape विशेषताओं के उद्धरण पर थोड़ा सख्त है)।

ध्यान दें कि 8 बाइट्स का उपयोग करके बचाया जा सकता है document.write, लेकिन यह गंभीर रूप से बोर्क्स jsFiddle।

Comments

आप शायद ES6 के साथ फ़ंक्शन को परिभाषित करके और अधिक सहेज सकते हैं, जैसे, S/c[0]एक चर में और फिर Math.absएक टर्नरी ऑपरेटर के साथ भी छुटकारा पाएं आदि

— Ingo Bürk

@ IngoBürk, अगर मैं ईएस 6 मार्ग पर जाने वाला था तो मैं इसके बजाय कॉफीस्क्रिप्ट में लिखूंगा।

— पीटर टेलर

मेजबान c99.nl का उपयोग करें। यह document.write की अनुमति देता है।

— xem

इसका उत्तर देखने के लिए अच्छा है :)

— मिकट

अस्थायी चर के लिए @ IngoBürk के सुझाव के साथ अपडेट किया गया। एलिमिनेट Math.absकरने से वास्तव में एक चरित्र पर खर्च होगा।

— पीटर टेलर

Answer 3

गणितज्ञ 289 वर्ण

Http://arxiv.org/pdf/math/0101066v1.pdf प्रमेय 2.2 (अत्यधिक अक्षम) के अनुसार बिलिनियर प्रणाली को हल करके ।

रिक्त स्थान की जरूरत नहीं है, अभी भी इसे गोल्फ:

w = {k, x, y};
d = IdentityMatrix;
j = Join;
p_~f~h_ := If[#[[-1, 1]] < 6! h,
    q = 2 d@4 - 1;
    m = #~j~{w};
    r = Complement[w /. NSolve[ And @@ j @@ 
                        MapThread[Equal, {Thread@m.q.m, 4 d@3 {0, 1, 1}}, 2], w], a];
    If[r != {},
     a~AppendTo~# & @@ r;
     Function[x, x~j~{#}~f~h & /@ r]@#]] & /@ p~Subsets~{3}; 
Graphics[Circle @@@ ({{##2}, 1}/# & @@@ (f[a = #, -Tr@#]; a))] &

इनपुट के साथ एक कम आकार का एनीमेशन {{-13, 0, 0}, {23, 10/13, 0}, {30, -84/65, -1/5}, {38, -44/65, 9/5}}

Comments

आप इनपुट कैसे लेते हैं?

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

@ मार्टिनबंटनर एक फ़ंक्शन तर्क के रूप में, @{{-1, 0, 0}, {2, 1, 0}, {2, -1, 0}, {3, 0, 2}}अंतिम पंक्ति में जोड़कर

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

@ मार्टिनबटनर यदि आप इसका परीक्षण करने जा रहे हैं तो 50/hइसके बजाय पहले प्रयास करें 400/h। आप तेजी से परिणाम प्राप्त करने जा रहे हैं। इसके अलावा, आप Dynamic@Length@aफंक्शन को अंजाम देने से पहले प्रवेश करके प्रगति की निगरानी कर सकते हैं

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

Instructions for testing this answer (with a reduced number of circles) without Mathematica installed: 1) इसे पास्टबिन से डाउनलोड करें और इसे * .CDF 2 के रूप में सेव करें) (एक छोटी फ़ाइल नहीं ) पर वुल्फराम रिसर्च से मुफ्त सीडीएफ पर्यावरण डाउनलोड और इंस्टॉल करें । का आनंद लें। मुझे बताएं कि क्या यह काम करता है! - नोट: कैलोरी धीमी हैं, ग्राफिक्स के आने का इंतजार करें।

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

"अत्यधिक अक्षम" टिप्पणी किसको संदर्भित करती है? क्या यह है कि (एनीमेशन को देखकर) आप स्पष्ट रूप से अधिकांश मंडलियों को कम से कम दो बार आकर्षित कर रहे हैं? मुझे लगता है कि जटिल डेसकार्टेस दृष्टिकोण स्वाभाविक रूप से उतना ही कुशल है जितना इसे प्राप्त होता है।

— पीटर टेलर

Answer 4

मेपल (960 बाइट्स)

मैंने अपोलोनियन गैसकेट को उत्पन्न करने के लिए डेसकार्टेस प्रमेय का उपयोग किया और फिर मैपल की साजिश रचने की प्रणाली का उपयोग किया। अगर मेरे पास समय है तो मैं इसे आगे बढ़ाना चाहता हूं और इसे पायथन में बदल सकता हूं (मेपल निश्चित रूप से भग्न के लिए सबसे अच्छा नहीं है)। यदि आप मेरा कोड चलाना चाहते हैं, तो यहां एक निशुल्क मेपल खिलाड़ी का लिंक दिया गया है ।

X,Y,Z,S,N:=abs,evalf,member,sqrt,numelems;
f:=proc(J)
    L:=map((x)->[x[1],(x[2]+x[3]*I)/x[1]+50*(1+I)/X(J[1][2])],J);
    R:=Vector([L]);
    T,r:=X(L[1][3]),L[1][4];
    A(L[1][5],L[2][6],L[3][7],L[1][8],L[2][9],L[3][10],R,T,r);
    A(L[1][11],L[2][12],L[4][13],L[1][14],L[2][15],L[4][16],R,T,r);
    A(L[1][17],L[3][18],L[4][19],L[1][20],L[3][21],L[4][22],R,T,r);
    A(L[2][23],L[3][24],L[4][25],L[2][26],L[3][27],L[4][28],R,T,r);
    plots[display](seq(plottools[circle]([Re(R[i][29]),Im(R[i][30])],X(1/R[i][31])),i=1..N(R))):
end proc:
A:=proc(a,b,c,i,j,k,R,E,F)
    K:=i+k+j+2*S(i*k+i*j+k*j);
    if K>400*E then
    return;
    end if;
    C:=(a*i+c*k+b*j+2*S(a*c*i*k+b*c*j*k+a*b*i*j))/K;
    C2:=(a*i+c*k+b*j-2*S(a*c*i*k+b*c*j*k+a*b*i*j))/K;
    if Y(X(C-F))<1/E and not Z([K,C],R) then
    R(N(R)+1):=[K,C];
    A(a,b,C,i,j,K,R,E,F);
    A(a,c,C,i,k,K,R,E,F);
    A(b,c,C,j,k,K,R,E,F);
    end if:    
    if Y(X(C2-F))<1/E and not Z([K,C2],R) then
    R(N(R)+1):=[K,C2];
    A(a,b,C2,i,j,K,R,E,F);
    A(a,c,C2,i,k,K,R,E,F);
    A(b,c,C2,j,k,K,R,E,F);
    end if: 
end proc:

कुछ सैंपल गैस्केट्स

f([[-1, 0, 0], [2, 1, 0], [2, -1, 0], [3, 0, 2]]);

f([[-9, 0, 0], [14, 5/9, 0], [26, -77/45, -4/5], [27, -8/5, 6/5]]);