छोटा चांडलर उदास है। उसे खुश करने के लिए एक बादल खींचें

Question

छोटा चांडलर उदास है। उसे खुश करने के लिए एक बादल खींचें।
ध्यान दें: एक बादल ड्राइंग वास्तव में उसे खुश नहीं होगा।

एक सर्कल को 3-ट्यूपल के रूप में परिभाषित किया जा सकता है (x,y,r)जहां xएक कार्टेशियन प्लेन पर सर्कल की x स्थिति है, एक कारटेसियन प्लेन पर सर्कल yकी y स्थिति है, और rसर्कल का त्रिज्या है। xऔर yनकारात्मक हो सकता है। rहमेशा सकारात्मक है। इनपुट अलग-अलग 3-ट्यूपल्स के रूप में हलकों की एक सूची है। उदाहरण के लिए:

3,1,1 3,2,1.5 1,2,0.7 0.9,1.2,1.2 1,0,0.8

इसका 3,1,1मतलब है " 3,11 त्रिज्या के 3,2,1.5साथ केंद्र बिंदु के साथ एक चक्र । इसका मतलब है" 3,21.5 त्रिज्या के साथ केंद्र बिंदु के साथ एक चक्र ।

यदि हम एक ग्राफ पर इनपुट के इन सभी हलकों को आकर्षित करते हैं, तो यह इस तरह दिखता है (मैंने केवल स्पष्टता के लिए ग्रिड लाइनें और लेबल शामिल किए हैं; उनकी आवश्यकता नहीं है):

ध्यान दें कि सभी मंडल कैसे एकजुट होते हैं । यही है, वे सभी एक साथ ऐसे ओवरलैप किए गए हैं कि यह एक बड़े समूह को बनाता है, जो बाकी हिस्सों से अलग किए गए मंडलियों के किसी भी छोटे समूह के बिना है। इनपुट सामंजस्यपूर्ण होने की गारंटी है।

मान लीजिए कि अब हम एक रेखा खींचते हैं, जो इन मंडलियों द्वारा बनाई गई "सीमा" के चारों ओर घूमती है, बिना किसी अन्य रेखा के। यह सभी हलकों द्वारा गठित सिल्हूट की सीमा को खींचने जैसा होगा। परिणामी बादल कुछ इस तरह दिखेगा:

तो इस बादल का निर्माण केवल एक आकृति के परिणामस्वरूप होने वाले इनपुट में हलकों के चापों को जोड़कर किया गया है। दूसरे शब्दों में, क्लाउड केवल उन आर्क को आरेखित करके बनता है जो दूसरे सर्कल में नहीं हैं। आपका कार्यक्रम ऊपर वर्णित रूप में इनपुट में ले जाएगा, और एक छवि आउटपुट करेगा जो परिणामस्वरूप क्लाउड प्रदर्शित करता है। क्लाउड का समग्र आकार सही होना चाहिए, लेकिन स्केल, रंग, रेखा मोटाई और यह कैसे दिखता है, यह आपके ऊपर है। ध्यान दें कि बादल दिखाई देना चाहिए, इसलिए आप कुछ खींच नहीं सकते जैसे "यह कार्यक्रम एक सफेद पृष्ठभूमि पर एक सफेद बादल खींचता है", "यह कार्यक्रम एक छोटे से छोटे पैमाने पर एक बादल खींचता है", "यह कार्यक्रम 0 के साथ एक बादल खींचता है लाइन मोटाई ", आदि यह भी ध्यान दें कि सीमा का रंग भरण या पृष्ठभूमि के रंग से अलग होना चाहिए।

एक और उदाहरण। इनपुट:

1,4,2 5,2,1 3,1,1 3.5,2,1.2 3,3,0.7 1,2,0.7

आउटपुट:

यदि बादल में "छेद" है, तो आपको छेद को भी आकर्षित करना चाहिए। इनपुट:

0,5,4 3,4,4 4,3,4 5,0,4 4,-3,4 3,-4,4 0,-5,4 -3,-4,4 -4,-3,4 -5,0,4 -4,3,4 -3,4,4 

आउटपुट:

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

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

Comments

उद्देश्यपरक मानदंड (और पहला पैराग्राफ) के साथ ग्राफिकल-आउटपुट प्रश्न के लिए +1।

— डेनिस

आप कैसे बता सकते हैं कि हम एक रेखा खींचते हैं और बाद में मिटा देते हैं? क्या रेंडरिंग ने आंतरिक बिटमैप्स पर लाइनों को ठीक कहा है? यदि नहीं, तो एक वेक्टर और बिटमैप प्रतिनिधित्व के बीच सीमा कहां है? यदि हाँ, तो हमें प्राथमिक कैनवास के साथ ऐसा करने की अनुमति क्यों दें (जिसे हम जानते हैं कि यह डबल-बफर है, ताकि उपयोगकर्ता हमारी अस्थायी लाइनें नहीं देख सके)?

— जॉन ड्वोरक

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

— अबिन्ते

क्लाउड से बट ( chrome.google.com/webstore/detail/cloud-to-butt-plus/… ) पर यह प्रश्न बिल्कुल उल्लसित है।

— Erty Seidohl

@SomeKittens मैंने इसे "यदि बादल में" छेद "है, तो खो दिया है, आपको छेद भी खींचना चाहिए।"

— एरी सीडोहल

Answer 1

गणितज्ञ 177 126 121 119

डिस्क क्षेत्र द्वारा हल: गणितज्ञ का दृष्टिकोण

तर्क करना है

• क्षेत्र 1 (आर 1), मंडलियां (उनके अंदरूनी के बिना) बनाएं;
• क्षेत्र 2 (R2), डिस्क बनाएं (सर्कल सीमाओं के बिना)।
• क्षेत्र 3 (R3 = R1-R2) बनाएँ।
-

यह ठीक नीचे दिए गए दृष्टिकोण है। इसने 3 आंकड़े ऊपर दिए।

input = "3,1,1 3,2,1.5 1,2,0.7 0.9,1.2,1.2 1,0,0.8";
circles = ((x - #)^2 + (y - #2)^2 == #3^2) & @@@ 
     ToExpression[#~StringSplit~","] &@(StringSplit@input);
R1 = ImplicitRegion[Or @@ circles, {x, y}];
r1 = RegionPlot[R1, PlotLabel -> "R1: circles containing borders", 
   AspectRatio -> 1, PlotRange -> {{-1, 5}, {-1, 5}}];

innerDisks = ((x - #)^2 + (y - #2)^2 < #3^2) & @@@ 
     ToExpression[#~StringSplit~","] &@(StringSplit@input);
R2 = ImplicitRegion[Or @@ innerDisks, {x, y}];
r2 = RegionPlot[R2, PlotLabel -> "R2: disks within circle borders", 
   AspectRatio -> 1, PlotRange -> {{-1, 5}, {-1, 5}}];
R3 = RegionDifference[R1, R2]
r3 = RegionPlot[R3, PlotLabel -> "R3 = R1-R2", AspectRatio -> 1, 
   PlotRange -> {{-1, 5}, {-1, 5}}];
GraphicsGrid[{{r1, r2, r3}}, ImageSize -> 600]

निहित क्षेत्र # 1 मंडलियों का संघ है। निहित क्षेत्र # 2 मंडलियों के भीतर स्थित डिस्क का संघ है। उनका अंतर सीमा है।

रीजनल डिफरेंस [इम्प्लिट रीजन]
(- 3 + x) ^ 2 + (-1 + y) ^ 2 == 1 || (-3 + x) ^ 2 + (-2 + y) ^ 2 == 2.25 || (-1 + x) ^ 2 + (-2 + y) ^ 2 == 0.49 || (-0.9 + x) ^ 2 + (-1.2 + y) ^ 2 == 1.44 || (-1 + x) ^ 2 + y ^ 2 == 0.64, {x, y}],
ImplicitRegion [(- 3 + x) ^ 2 + (-1 + y) ^ 2 <1 || (-3 + x) ^ 2 + (-2 + y) ^ 2 <2.25 || (-1 + x) ^ 2 + (-2 + y) ^ 2 <0.49 || (-0.9 + x) ^ 2 + (-1.2 + y) ^ 2 <1.44 || (-1 + x) ^ 2 + y ^ 2 <0.64, {x, y}]]

---

डिस्क क्षेत्र द्वारा हल: इंजीनियर का दृष्टिकोण (119 वर्ण)

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

s = StringSplit;RegionBoundary@DiscretizeRegion[RegionUnion[Disk[{#, #2}, #3] &@@@
ToExpression[#~s~","] &@(s@InputString[])]]

"3,1,1 3,2,1.5 1,2,0.7 0.9,1.2,1.2 1,0,0.8"

क्षेत्र की सीमा विवेकाधीन है।

---

एडिटिंग डिटेक्टिंग एड्स द्वारा: फोटोग्राफर का दृष्टिकोण - 121 वर्ण

यह डिस्क को काले रंग में खींचता है, छवि को रेखापुंज करता है, किनारों का पता लगाता है, और काले और सफेद रंग में बदल जाता है।

s=StringSplit;ColorNegate@EdgeDetect@Rasterize@Graphics[Disk[{#,#2},#3]&@@@
((ToExpression/@s[#,","])&/@s[InputString[]])]

Comments

5 बाइट्स शेव की गईं:RegionBoundary@DiscretizeRegion@RegionUnion[{#,#2}~Disk~#3&@@@ToExpression[#~s~","]&@s@InputString[s=StringSplit]]

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

s=StringSplitसंकेत के अंदर संभावित रूप से ? फिर से आगे बढ़ने की कोशिश करें, फिर भी आपके वर्तमान संस्करण से छोटा होना चाहिए।

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

Answer 2

टी-एससी 235 234 229 212 171 73 बाइट्स

यह SQL सर्वर 2012+ में स्थानिक कार्यक्षमता का उपयोग करता है। जब यह SSMS (SQL Server Management Studio) में चलाया जाता है, तो एक स्थानिक परिणाम फलक उत्पन्न करता है। इनपुट वैरिएबल @i से है। अगर इनपुट एक टेबल से लिया जा सकता है तो मैं इसे और कम कर सकता हूं।

चूंकि अब टेबल इनपुट की अनुमति है।

SELECT Geometry::UnionAggregate(Geometry::Point(X,Y,0).STBuffer(R))FROM A

मैंने पिछले समाधान को नीचे छोड़ दिया है।

DECLARE @ VARCHAR(999)='WITH a AS(SELECT *FROM(VALUES('+REPLACE(@i,' ','),(')+'))A(X,Y,R))SELECT Geometry::UnionAggregate(Geometry::Point(X,Y,0).STBuffer(R))FROM a'EXEC(@)

संपादित करें : आवारा अंतरिक्ष, अधिशेष को हटा दें और सबक्वेरी में

171: CTE और @ के साथ @ के साथ प्रतिस्थापित तालिका निर्माण।

डायनेमिक SQL का टूटना

DECLARE @i VARCHAR(100) = '1,4,2 5,2,1 3,1,1 3.5,2,1.2 3,3,0.7 1,2,0.7' -- Input
DECLARE @ VARCHAR(999) = '
WITH a AS(                                       --CTE to produce rows of x,y,r 
    SELECT *FROM(VALUES('+
        REPLACE(@i,' ','),(')                    --Format @i to a value set
        +'))A(X,Y,R)
)
SELECT Geometry::UnionAggregate(                 --Aggregate Buffered Points
    Geometry::Point(X,Y,0).STBuffer(R)           --Create point and buffer
    )               
FROM a                                           --from the table variable
'
EXEC(@)                                          --Execute Dynamic sql

Comments

मुझे यह कहते हुए एक त्रुटि हो रही है'A' has fewer columns than were specified in the column list

— जेसन फाफॉन

@JesanFafon सुनिश्चित करें कि आपका इनपुट चर @i सही ढंग से सेट है। DECLARE @i VARCHAR(100) = '1,4,2 5,2,1 3,1,1 3.5,2,1.2 3,3,0.7 1,2,0.7'। दुर्भाग्य से मैं उस पल का परीक्षण नहीं कर सकता और SQLfiddle 2012 के लिए अच्छी तरह से नहीं खेल रहा है।

— मिकी

SQL ज्यामिति कार्यों के साथ अच्छा काम। खुशखबरी! पहले से मौजूद तालिका द्वारा इनपुट को अब स्पष्ट रूप से अनुमति दी गई है । टेबल निर्माण और जनसंख्या को बाइट काउंट में शामिल करने की आवश्यकता नहीं है।

— ब्राडकास

मैंने कुछ पात्रों को गढ़ा। लिंक एक परिणाम नहीं देता है। लेकिन यह ms-sql सर्वर प्रबंधन स्टूडियो में काम करता है। स्क्रिप्ट यहां है , आनंद लें। इसे बेझिझक इस्तेमाल करें

— t-clausen.dk

@ t-clausen.dk उस के लिए धन्यवाद, लेकिन जब से मैं इसे अपडेट करने जा रहा हूं, मैं इसे अनुमत टेबल इनपुट में बदल दूंगा। मैं इस एक को वापस करने के लिए नहीं जा रहा था, लेकिन ...

— मिक

Answer 3

गणितज्ञ, 175 158 149 बाइट्स

s=StringSplit;l=ToExpression[#~s~","]&@s@InputString[];RegionPlot[Or@@(Norm@{x-#,y-#2}<#3&@@@l),{x,m=Min@(k={{##}-#3,{##}+#3}&@@@l),M=Max@k},{y,m,M}]

मुझे सैंडबॉक्स में चर्चा से याद है कि यह दृष्टिकोण वैध माना जाता था, लेकिन मुझे पूरी तरह से यकीन नहीं है कि यह नियमों के नए शब्दों के साथ कैसे बैठता है, इसलिए @ लिलाक, मुझे बताएं कि क्या आपको लगता है कि यह नियमों का उल्लंघन करता है।

मूल रूप से, मैं एक तार्किक स्थिति बना रहा हूं जो क्लाउड के अंदर सभी बिंदुओं के लिए सही है और इसके बाहर सभी बिंदुओं के लिए गलत है। मैं उसे खिला रहा हूं, RegionPlotजो तब सभी बिंदुओं के क्षेत्र को प्रस्तुत करता है जहां अभिव्यक्ति के Trueसाथ-साथ उसके चारों ओर एक रूपरेखा भी है।

Ungolfed:

s = StringSplit;
l = ToExpression[#~s~","] &@s@InputString[];
RegionPlot[
 Or @@ (Norm@{x - #, y - #2} < #3 & @@@ l), 
 {x, m = Min@(k = {{##} - #3, {##} + #3} & @@@ l), M = Max@k},
 {y, m, M}
]

Comments

ImplicitRegionस्वचालित रूप से साजिश रचने के लिए उचित x और y मान पाता है। 122 वर्ण:s = StringSplit; RegionPlot@ ImplicitRegion[ Or @@ (((x - #)^2 + (y - #2)^2 < #3^2) & @@@ (ToExpression[#~s~","] &@(s@InputString[]))), {x, y}]

— डेविड सीपी

@DavidCarraher दुर्भाग्य से, यह छवि के पहलू अनुपात को विकृत करता है। (उन सभी क्षेत्रों के कार्यों को जानकर अच्छा लगा - हालांकि आपके द्वारा उपयोग किए गए - मैंने केवल RegionPlotअब तक देखा है।)

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

आपने शायद पहले ही नोट कर लिया ,AspectRatio-> 1है कि कोड को 149 बाइट्स में वापस लाता है, ठीक उसी जगह जहां यह अब खड़ा है।

— डेविड सीपी

क्या यह मुझे या इस छवि को मार्विन द पैरानॉयड एंड्रॉइड जैसा दिखता है?

— पक्कोगोमेज़ २४'१४

Answer 4

पायथन 3.3 ( 183 177 164 160 बाइट्स)

B=list(map(eval,input().split()))
print("".join(" ## "[sum(any(r*r>(x-d%80/4+10)**2+(y+d//80/4-10)**2for
x,y,r in B)for d in[i,i+1,i+80])]for i in range(6400)))

इसके लिए 80 कैरेक्टर वाइड कंसोल की आवश्यकता होती है, जो मुझे पता है कि विंडोज में डिफ़ॉल्ट है। यह सबसे अच्छा काम करता है अगर आपके कंसोल में एक वर्ग फ़ॉन्ट है। यहाँ कुछ परीक्षण इनपुट के कुछ अंश दिए गए हैं।

मूल:

           ########
          ##       #
         ##         #
     #####          #
    ##   #          #
   ##               #
  ##                #
 ##                 #
 #                  #
 #                 ##
  #               ##
  #       ##      #
   #      # #    ##
   #      #  #####
   #      #
    #    ##
     #  ##
      ###

एक और:

    ########
  ###       ##
 ##           #
 #            #
##             #
#              #
#              #
#              #
#              #
#               ##
#                 #
 #                 ##
 #                   ######
  #                        #
   ##      ###             #
     #    ## #             #
     #    #  #             #
      #  ## ##             #
       ###  #             ##
            #       #######
            #      ##
            #      #
             #    ##
              #####

छेद:

                              ############
                            ###           ##
                          ###               ##
                         ##                   #
                  ########                     #######
                ###                                   ##
              ###                                       ##
             ##                                           #
            ##                                             #
           ##                                               #
          ##                                                 #
         ##                                                   #
        ##                                                     #
       ##                                                       #
      ##                                                         #
      #                                                          #
     ##                                                           #
     #                                                            #
    ##                                                             #
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
   ##                                                               #
  ##                                                                 #
  #                                                                  #
 ##                                                                   #
 #                                                                    #
##                                                                     #
#                                 ####                                 #
#                                ##   #                                #
#                               ##     #                               #
#                              ##       #                              #
#                              #        #                              #
#                              #        #                              #
#                               #      ##                              #
#                                #    ##                               #
#                                 #  ##                                #
#                                  ###                                 #
 #                                                                    ##
 #                                                                    #
  #                                                                  ##
  #                                                                  #
   #                                                                ##
    #                                                              ##
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
    #                                                              #
     #                                                            ##
     #                                                            #
      #                                                          ##
      #                                                          #
       #                                                        ##
        #                                                      ##
         #                                                    ##
          #                                                  ##
           #                                                ##
            #                                              ##
             #                                            ##
              #                                          ##
               ##                                      ###
                 ##                                  ###
                   #######                    ########
                          #                  ##
                           ##              ###
                             ##          ###
                               ###########

Comments

मैं प्यार करता हूँ कि यह केवल आस्की कला समाधान है।

— vmrob

कोई आयात नहीं ... प्रभावशाली!

— रिचर्ड ग्रीन

Answer 5

पायथन - 253 249 215 199

इस भयानक लिए एक विज्ञापन है सुडौल पुस्तकालय, जिसका ज्यामिति संचालन समाधान हलकों (= बफ़र अंक) ओवरलैपिंग के मिलन की रूपरेखा (रों) बनाकर सीधा लिख दिया:

from pylab import*
from shapely.geometry import*
c=Point()
for s in raw_input().split():
 x,y,r=eval(s)
 c=c.union(Point(x,y).buffer(r))
plot(*c.exterior.xy)
for i in c.interiors:
 plot(*i.xy)
show()

आउटपुट:

संपादित करें (ओं):

• 249: sys.argv[1:]द्वारा raw_input().split()बचाया, बचतimport sys
• 215: हटाए गए k={'color':'k'}लक्जरी, savefigद्वारा प्रतिस्थापितshow
• 199: map(float,s.split(','))द्वारा प्रतिस्थापितeval(s)

Answer 6

अजगर - 535

import math as m
import matplotlib.pyplot as l
c = "3,1,1 3,2,1.5 1,2,0.7 0.9,1.2,1.2 1,0,0.8"
a = [[float(y) for y in x.split(",")] for x in c.split(" ")]
for a2 in a:
    for x in xrange(0,200):
        q=x*m.pi/100.0
        p=(a2[0]+m.sin(q)*a2[2], a2[1]+m.cos(q)*a2[2])
        cc = []
        for z in a:            
            if z != a2:               
                if ((z[0] - p[0]) ** 2 + (z[1] - p[1]) ** 2 ) < (z[2] ** 2) :
                    cc.append(z)
        if not cc: 
            l.scatter(p[0],p[1])
l.show()

Comments

यह नीचे गिराए जाने की बहुत अधिक संभावना है, उदाहरण के लिए, अनपेक्षित from math import*रिक्त स्थान को हटाकर, केवल एक-अक्षर चर नामों का उपयोग करके, सूची बोध का उपयोग करके (जैसे, cc=[z for z in a if z!=a2 and (z[0]…)])। इसके अलावा पायथन में गोल्फ के लिए युक्तियों पर एक नज़र डालें ।

— 15

आप इसके बजाय एक अक्षर वाले चर नाम का उपयोग करके कुछ पात्रों को बचा सकते हैं a2।

— प्रोग्राम फॉक्स

धन्यवाद rzl ... मैं शायद आज रात गोल्फ शुरू कर दूंगा (अन्य चीजें अभी करने के लिए लेकिन जमीन में हिस्सेदारी रखना चाहता था)

— रिचर्ड ग्रीन

हाँ @ProgramFOX ... यह एक ऐसा संस्करण था जो काम करता था और जिसे मैं डिबग कर सकता था .. यह आज रात को कम हो जाएगा ...

— रिचर्ड ग्रीन

@JamesWilliams यदि आप बैटन लेना चाहते हैं ... कृपया करें .. मैं कोड की सुरक्षा नहीं कर रहा हूँ !! इसे अपनी प्रविष्टि के रूप में जोड़ने के लिए बेझिझक (जब तक आप मूल को श्रेय देते हैं!)

— रिचर्ड ग्रीन

Answer 7

अजगर - 296 249 231 223 212

from pylab import*
a=map(eval,raw_input().split())
for x,y,r in a:
 for i in range(200):
  q=i*pi/100;p=x+r*sin(q);t=y+r*cos(q);[z for z in a if z!=(x,y,r)and(z[0]-p)**2+(z[1]-t)**2<z[2]**2]or scatter(p,t)
show()

मूल समाधान के लिए क्रेडिट @ रिचार्ड-ग्रीन (अनुमति दी गई थी) जाता है, मैंने अभी इसे थोड़ा नीचे गिराया है।

Comments

अच्छा है कि मेरा वोट मिलता है ...

— रिचर्ड ग्रीन

आप pylabइसके बजाय आयात करके कुछ और बचत करने में सक्षम हो सकते हैं matplotlib.pyplot।

— ओजदो

@odjo वर्तमान में मोबाइल पर, अगर मैंने उपयोग किया तो from pylab import *क्या मैं अभी भी कॉल कर सकूंगा show()और scatter()बिना किसी संदर्भ के?

— जेम्स विलियम्स

@ जेम्सवेल्स ने पुष्टि की! पाइलैब एक नेमस्पेस प्रदूषक है, जिसमें कई MATLAB जैसे कार्य शामिल हैं :-)

— ojdo

आप का उपयोग करके यह छोटा कर सकते हैं [eval(i)for i in raw_input().split()]अजगर के रूप में evalबदल जाता है 1,2,3एक टपल में। तुम भी निश्चित रूप [x,y,r]से एक को बदलना होगा (x,y,r)।

— केएसएबी

Answer 8

जावास्क्रिप्ट (E6) + HTML 322

JSFiddle

प्रत्येक वृत्त लगभग 100 छोटे चापों में विभाजित होता है, और प्रत्येक चाप को खींचा जाता है यदि उसका मध्य बिंदु किसी अन्य मंडल के अंदर नहीं है।

<canvas id='c'/>
<script>
t=c.getContext("2d"),z=99,c.width=c.height=400,
l=prompt().split(' ').map(c=>c.split(',').map(v=>40*v)),
l.map(c=>{
  for(i=z;--i+z;)
    s=4/z,r=c[2],x=c[0]+r*Math.cos(a=i*s),y=c[1]+r*Math.sin(a),
    t.beginPath(),
    l.some(q=>c!=q&(d=x-q[0],e=y-q[1],d*d+e*e<q[2]*q[2]))||t.arc(z+c[0],z+c[1],r,a-s,a+s),
    t.stroke()
})
</script>

Answer 9

पायथन 274 बाइट्स

यह स्टडिन से इनपुट लेता है और डिस्प्ले पर हर पॉइंट को चेक करता है, पिक्सल को एक-एक करके ड्रॉ करता है। बिल्कुल कुशल नहीं है लेकिन यह सभी नियमों का पालन करता है।

c=[eval(s)for s in raw_input().split()]
import pygame
S=pygame.display.set_mode((500,500))
S.fill([255]*3)
for p in((x,y)for x in range(500)for y in range(500)if 0<min((((x-250)/25.-a)**2+((y-250)/25.-b)**2)**.5-r for(a,b,r)in c)<.1):S.set_at(p,[0]*3)
pygame.display.update()

ध्यान दें कि ड्राइंग प्रदर्शित होते ही pygame डिस्प्ले समाप्त हो जाएगी, मुझे यकीन नहीं था कि मुझे इसे अपने उत्तर के हिस्से के रूप में शामिल करना चाहिए, लेकिन यह देखने के लिए कि आप raw_inputअंत में इसे फेंक सकते हैं या थोड़ा लूप जोड़ सकते हैं यदि आप प्रतिक्रिया न करने और इस तरह के बारे में शिकायत करने से ओएस को रोकना चाहते हैं:

alive = True
while alive:
    pygame.display.update()
    for e in pygame.event.get():
        if e.type == pygame.QUIT:
            alive = False

उदाहरण चित्र:

1,4,2 5,2,1 3,1,1 3.5,2,1.2 3,3,0.7, 1,2,0.7

0,5,4 3,4,4 4,3,4 5,0,4 4,-3,4 3,-4,4 0,-5,4 -3,-4,4 -4,-3,4 -5,0,4 -4,3,4 -3,4,4

Comments

@ edc65 मुझे पूरा यकीन नहीं है कि आपका क्या मतलब है। यह जो ठीक करता है वह किसी भी पिक्सेल में भरता है जो कि सर्कल के बाहर 0 और 0.1 यूनिट (0 और 2.5 पिक्सेल के बीच) के बीच होता है। क्या आप कह रहे हैं कि इसे गणितीय रूप से आकर्षित करने के लिए सही आर्क्स ढूंढना चाहिए? प्रश्न को पढ़ने से ऐसा नहीं लगा कि यह मेरे लिए प्रतिबंध था।

— केएसएबी

Answer 10

पर्ल - 430

@e=map{[map{int($_*32)}split',']}(split' ',<>);for$g(@e){for(0..3){($a[$_]>($q=$$g[$_&1]+(($_>>1)*2-1)*$$g[2]))^($_>>1)&&($a[$_]=$q)}}for(2,3){$a[$_]-=$a[$_-2]-1}for(@e){($x,$y,$r)=@$_;$x-=$a[0];$y-=$a[1];for$k($x-$r..$x+$r){for$l($y-$r..$y+$r){$i=(int(sqrt(($x-$k)**2+($y-$l)**2)+0.5)<=>$r)-1;$f[$l][$k]=($j=$f[$l][$k])<-1||$i<-1?-2:$i||$j;}}}print"P1
$a[2] $a[3]
".join("
",map{join' ',map{$_+1?0:1}@$_,('0')x($a[2]-@$_)}@f)."
"

एक pbm फ़ाइल को stdout में लिखता है।

परीक्षण छवि (png में परिवर्तित):