सर्कुलर ब्लूज़


21

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक N में लेता है और एक N × N पिक्सेल छवि को फिट करने के लिए स्केल किए गए मंडलियों के इस पैटर्न को फिर से बनाता है:

फैंसी सर्किल

यह छवि N = 946 के लिए एक मान्य आउटपुट उदाहरण है।

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

  • नीले रंग के दो रंगों के स्थान पर किसी भी दो अलग-अलग रंगों का उपयोग किया जा सकता है।

  • पृष्ठभूमि वर्ग को रंगीन करने की आवश्यकता है।

  • एंटी-अलियासिंग वैकल्पिक है।

  • छवि को एक फ़ाइल में सहेजें, इसे प्रदर्शित करें, या स्टडआउट के लिए कच्ची छवि डेटा को पाइप करें।

  • किसी भी सामान्य छवि फ़ाइल प्रारूप की अनुमति है।

बाइट्स में सबसे छोटा कोड जीतता है।

यदि आप इस सर्कल पैटर्न के पुनरावर्ती पहलुओं को आगे के स्तरों में बढ़ाते हैं तो ब्राउनी इंगित करता है। (इसे अपनी चुनौती प्रविष्टि से अलग रखें।)


"पृष्ठभूमि वर्ग को रंगीन होने की आवश्यकता है" से आपका क्या मतलब है? यदि पृष्ठभूमि में डिफ़ॉल्ट रूप से एक निश्चित रंग है, तो क्या मैं इसे स्पष्ट रूप से भरने के बिना 2 रंगों में से एक के रूप में उपयोग कर सकता हूं?
ad

मेरा मतलब है कि बीजी एक तीसरा अलग रंग नहीं हो सकता है
केल्विन के शौक

जवाबों:


5

सीजेएम, 83 बाइट्स

"P1"li___,.5f+2.@/f*1fm2m*{[3{_~mh1<[[VX][ZmqV]]_Wff*+@2f*f.+{~mh}$0=}*;0]0#2%}%]S*

इसे ऑनलाइन आज़माएं

CJam में समर्पित छवि आउटपुट कार्यक्षमता नहीं है। मेरा कोड PBM ASCII में एक छवि बनाता है। पोस्ट करने के लिए, मैंने GIMP का उपयोग करके उस छवि को PNG में बदल दिया।

ध्यान दें कि कोई सर्कल ड्राइंग कार्यक्षमता, या ऐसा कुछ भी नहीं, इसका उपयोग किया। छवि की गणना पिक्सेल द्वारा पिक्सेल की जाती है।

नमूना आउटपुट

उपखंड के उच्च डिग्री आसानी 3से कोड के मध्य के आसपास निरंतर वृद्धि करके बनाया जा सकता है ।

डिग्री 4 और 5 छवियां इस तरह दिखती हैं:

डिग्री 4डिग्री 5

कोड का समग्र अनुक्रम है:

  1. [-1.0, 1.0] सीमा तक सामान्यीकृत सभी पिक्सल के निर्देशांक बनाएं।
  2. सभी पिक्सेल पर लूप।
  3. उपखंड की डिग्री पर लूप।
  4. प्रत्येक उपखंड के लिए, जांचें कि क्या पिक्सेल अंदर / बाहर है, और परिणाम रखें। 4 उप-सर्कल में से एक पर केंद्रित समन्वय प्रणालियों के लिए पिक्सेल समन्वय को स्केल / ट्रांसलेट करता है। उस स्थान को चुनें जहां परिवर्तित निर्देशांक केंद्र के सबसे करीब हैं।
  5. प्रत्येक डिग्री के अंदर / बाहर के द्विआधारी से, पहले 0 को ढूंढें, पहले डिग्री के अनुरूप जहां पिक्सेल बाहर था, और पिक्सेल के रंग को निर्धारित करने के लिए इसके मोडुलो 2 को लें।

स्पष्टीकरण:

"P1"    Start of header for PBM ASCII file.
li      Get input n.
__      Two copies for the width/height of the image in the PBM header.
_,      Generate [0 .. n - 1].
.5f+    Add 0.5 to each list entry, since we want to test the pixel centers.
2.@/    Calculate 2.0 / n, which is the distance between two pixels.
f*      Multiply the unscaled pixel coordinates with the pixel distance.
        We now have coordinates in the range [0.0, 2.0].
1fm     Subtract one from each, giving coordinates in range [-1.0, 1.0].
2m*     Cartesian power to calculate all y/x pairs.
{       Start loop over all pixel coordinates.
  [       Start wrapping the inside/outside results for all degrees.
  3{      Start loop over degrees.
    _~mh    Calculate distance from center.
    1<      Compare with 1. This gives inside/outside result for degree.
    [       Start building list of centers for 4 sub-circles.
    [VX]    One is at [0 1]. Note that coordinate order is y/x.
    [ZmqV]  Next one is at [sqrt(3) 0].
    ]       Wrap these two...
    _       ... and copy them.
    Wff*    Mirror all coordinates by multiplying with -1.
    +       Concatenate, giving the centers of all 4 sub-circles.
    @       Get current coordinates to top.
    2f*     Multiply them by 2. Note that the coordinates need to be scaled up by
            a factor 2 to give a circle with half the radius when we test the distance
            to the origin against 1.0.
    f.+     Add the current coordinates to the centers of all 4 sub-circles.
            For each sub-circle, this puts the current coordinates in a coordinate
            space with the origin at the center, and with a radius of 1.0
    {~mh}$  Sort them by distance to the origin...
    0=      ... and take the first one. This picks the sub-circle which has its
            center closest to the current coordinates.
            We now have one coordinate pair, for the closest sub-circle, and are
            ready for the next loop iteration, which tests the next degree of the
            subdivision.
  }*      End loop over degrees.
  ;       Have remaining coordinate pair on stack, pop it.
  0       Add a sentinel for find operation before, so that a 0 is always found.
  ]       End wrapping the inside/outside results for all degrees.
  0#      Find the first 0 (outside) degree.
  2%      Modulo 2 to determine color.
}%      End loop over all pixel coordinates.
]       Wrap the pieces of the PBM header and the pixel list.
S*      Join them with spaces, to produce the necessary spaces for the header.

17

पायथन 2 + पीआईएल, 262 बाइट्स

यहाँ छवि विवरण दर्ज करें

यह दृष्टिकोण प्रत्येक व्यक्ति पिक्सेल के रंग को पुनरावर्ती फ़ंक्शन का उपयोग करके निर्धारित करता है cc(x,y,0)एक सर्कल प्रदान करता है; c(x,y,1)एक सर्कल का प्रतिपादन करता है जिसमें चार सर्कल काटे गए हैं; c(x,y,2)ओपी में छवि प्रदान करता है। 2 से बड़ा कुछ भी मुझे ब्राउनी पॉइंट देता है।

import PIL.Image as I
d=3**.5/2
c=lambda x,y,l=0:c(x,y)&~any(c((x+i)*2,(y+j)*2,l-1)for i,j in[(.5,0),(-.5,0),(0,d),(0,-d)])if l else x*x+y*y<1
z=input()
f=lambda s:2.*s/z-1
I.frombytes("L",(z,z),"".join(" ~"[c(f(i%z),f(i/z),2)]for i in range(z*z))).save("p.png")

गैर-गोल्फ संस्करण:

from PIL import Image
import math
def in_shape(x,y, level=0):
    d = math.sqrt(3)/2
    if level == 0:
        return x**2 + y**2 <= 1
    else:
        t = True
        for dx,dy in [(0.5, 0), (-0.5, 0), (0, d), (0,-d)]:
            if in_shape((x+dx)*2, (y+dy)*2, level-1):
                t = False
        return in_shape(x,y) and t

f = lambda s: ((2*s / float(size))-1)

size = input()
img = Image.new("RGB", (size, size))
pix = img.load()
for i in range(size):
    for j in range(size):
        if in_shape(f(i), f(j), 2):
            pix[i,j] = (0,0,0)
        else:
            pix[i,j] = (255,255,255)
img.save("output.png")

बोनस अतिरिक्त पुनरावर्ती छवि:

यहाँ छवि विवरण दर्ज करें


.save("p.png")केवल उपयोग के बजाय.show()
अल्बर्ट रेनशॉ

7

पोस्टस्क्रिप्ट, 335 बाइट्स।

%!
/D{def}def/B{bind D}D/E{exch}B/A{add}D/c{3 copy 3 -1 roll A E moveto 0 360 arc}B/f{5 dict begin/d E D/r E D/y E D/x E D gsave x y r c clip d 2 mod setgray x y r c fill d 0 gt{/h 3 sqrt 2 div r mul D/r r 2 div D/d d 1 sub D x r A y r d f x r sub y r d f x y h A r d f x y h sub r d f}if grestore end}B 512 2 div dup dup 2 f showpage

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

पोस्टस्क्रिप्ट दुभाषिए आमतौर पर फ़ाइल की शुरुआत में विशेष टिप्पणियों से मेटाडेटा (जैसे पृष्ठ आकार और शीर्षक) पढ़ते हैं; जाहिर है मैंने %!अपनी प्रविष्टि से सभी आवश्यक नंगे पोस्टस्क्रिप्ट हस्ताक्षर टिप्पणी को हटा दिया है , लेकिन यह अभी भी किसी भी मानक पोस्टस्क्रिप्ट दुभाषिया, जैसे घोस्टस्क्रिप्ट या ओकुलर में ठीक प्रदर्शित होना चाहिए। इसे ImageMagick / GraphicsMagick के साथ आने वाली डिस्प्ले यूटिलिटी का उपयोग करके भी देखा जा सकता है ।

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

Nइस कोड के लिए आकार पैरामीटर 512 है; पुनरावर्ती फ़ंक्शन के प्रारंभिक कॉल के लिए पैरामीटर बनाने के लिए इसे 2 से विभाजित किया गया है और दो बार डुप्लिकेट किया गया है f। पुनरावृत्ति की गहराई 2 है, जो अंदर से ठीक पहले दी fगई है 512 2 div dup dup 2 f। आकार छोटा रखने के लिए आउटपुट ब्लैक एंड व्हाइट है। यद्यपि आप किसी भी उचित गैर-नकारात्मक पूर्णांक पुनरावर्ती गहराई को सेट कर सकते हैं, यह संस्करण केवल गहराई के साथ भी अच्छा लगता है।

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

display -density 300 -geometry 512x512 -page 512x512

यदि आप ImageMagick का उपयोग करना चाहते हैं तो convertइसे अन्य स्वरूप में परिवर्तित करने के लिए समान पैरामीटर भी अच्छे हैं । उदाहरण के लिए, यहां उपरोक्त पोस्टस्क्रिप्ट कोड का 640x640 संस्करण PNG में परिवर्तित किया गया है:

640x640 बी एंड डब्ल्यू सर्कल भग्न


यहाँ थोड़ा बड़ा संस्करण है जो RGB रंग और विषम पुनरावृत्ति गहराई को संभालता है:

%!PS-Adobe-3.0
/D{def}def/N 512 D/d 2 D/B{bind D}D/E{exch}B/A{add}D/c{3 copy 3 -1 roll A E moveto 0 360 arc}B/k{2 mod 0 eq{.3 .6 .9}{0 .2 .5}ifelse setrgbcolor}B d 1 A k 0 0 N N rectfill/f{5 dict begin/d E D/r E D/y E D/x E D gsave x y r c clip d k x y r c fill d 0 gt{/h 3 sqrt 2 div r mul D/r r 2 div D/d d 1 sub D x r A y r d f x r sub y r d f x y h A r d f x y h sub r d f}if grestore end}B N 2 div dup dup d f showpage

यह आपको स्क्रिप्ट के शीर्ष के पास आकार पैरामीटर Nऔर पुनरावृत्ति की गहराई सेट करने की भी अनुमति देता है d

640x640 रंग चक्र भग्न, गहराई == 2


अंत में, यहां कोड का अधिक पठनीय रूप है। (दुर्भाग्य से, पोस्टस्क्रिप्ट के लिए यहां प्रयुक्त वाक्यविन्यास हाइलाइटिंग वांछित होने के लिए बहुत कुछ छोड़ देता है , लेकिन मुझे लगता है कि यह कुछ भी नहीं से बेहतर है ...)। स्मार्ट पोस्टस्क्रिप्ट दुभाषिए %%BoundingBox:विशेष टिप्पणी से पेज ज्यामिति पढ़ेंगे ।

%!PS-Adobe-3.0
%%BoundingBox: 0 0 640 640
%%Title: Circle fractal
%%Creator: PM 2Ring
%%Creationdate: (Oct 29 2015)
%%Pages: 1 1
%%EndComments

% for http://codegolf.stackexchange.com/questions/61989/circular-blues

% ----------------------------------------------------------------------

16 dict begin

%Total image width & height in points / pixels
/N 640 def

%Maximum recursion depth
/Depth 4 def

% ----------------------------------------------------------------------

%Draw a circle centred at (x,y), radius r. x y r circle -
/circle{
    3 copy      % x y r  x y r
    3 -1 roll   % x y r  y r x
    add exch    % x y r  x+r y
    moveto
    0 360 arc 
}bind def

% ----------------------------------------------------------------------

%Select 1st color if n is even, select 2nd color if n is odd. n color -
/color{
    2 mod 0 eq
    {.36 .6 .9}
    {0 .25 .5}
    ifelse
    setrgbcolor
}bind def

%Do background square
Depth 1 add color
0 0 N N rectfill

/Q 3 sqrt 2 div def

%Recursive circle pattern. x y r Depth cfrac -
/cfrac{
    5 dict begin
    /Depth exch def
    /r exch def
    /y exch def
    /x exch def

    gsave
    x y r circle clip
    Depth color
    x y r circle fill

    Depth 0 gt
    {
        /dy Q r mul def
        /r r 2 div def
        /Depth Depth 1 sub def 

        x r add y r Depth cfrac
        x r sub y r Depth cfrac
        x y dy add r Depth cfrac
        x y dy sub r Depth cfrac
    }if
    grestore
    end
}bind def

%Call it!
N 2 div dup dup Depth cfrac

showpage

% ----------------------------------------------------------------------

%%Trailer
end
%%EOF

और यहां पीएनजी प्रारूप में गहराई == 4 आउटपुट है, एक बार फिर कन्वर्ट (और ऑप्टिपिप के साथ अनुकूलित ) का उपयोग करके बनाया गया है :

640x640 रंग चक्र भग्न, गहराई == 4


6

पायथन 2 + पीआईएल, 361 बाइट्स

import PIL.Image as p,PIL.ImageDraw as d
W=input()
q=W/4
h=2*q
t=3*q
e=W/8
o=int(q*3**.5)
I,J=[p.new("1",(s,s),s>h)for s in[W,h]]
Q=lambda i,x,y,s=q,c=0:d.Draw(i).ellipse((x,y,x+s,y+s),fill=c)
Q(I,0,0,W)
Q(J,0,0,h,1)
[Q(J,k,e)for k in[0,q]]
[Q(J,e,e+k/2)for k in[-o,o]]
[I.paste(1,k,J)for k in[(0,q,h,t),(h,q,4*q,t),(q,q-o,t,t-o),(q,q+o,t,t+o)]]
I.save("c.png")

फ़ाइल में छवि को काले और सफेद रंग में सहेजता है c.png :

उदाहरण आउटपुट

मैं मूल रूप से छवि में आधे आकार के हलकों में से एक उत्पन्न करता हूं J। मैं तब छवि पर आकृति को चित्रित करने के लिए एक मुखौटा के रूप में उपयोग करता हूं I, जिसमें मुख्य सर्कल है।

इसका उपयोग करके इसे छोटा किया जा सकता है I.show() इसके बजाय अंत में है I.save("c.png"), लेकिन मैंने इसे पायथन 2 पर काम नहीं किया। अगर कोई पुष्टि कर सकता है कि यह पायथन 2 पर काम करता है तो मैं इसे बदल दूँगा।

निम्नलिखित कार्यक्रम प्रश्न में छवि उत्पन्न करता है (419 बाइट्स):

import PIL.Image as p,PIL.ImageDraw as d
W=int(input())
q=W/4
h=2*q
t=3*q
e=W/8
o=int(q*3**.5)
I,J=[p.new(["1","RGB"][s>h],(s,s),s>h and"rgb(13,55,125)")for s in[W,h]]
Q=lambda i,x,y,s=q,c=0:d.Draw(i).ellipse((x,y,x+s,y+s),fill=c)
Q(I,0,0,W,"rgb(97,140,224)")
Q(J,0,0,h,1)
[Q(J,k,e)for k in[0,q]]
[Q(J,e,e+k/2)for k in[-o,o]]
[I.paste("rgb(13,55,125)",k,J)for k in[(0,q,h,t),(h,q,4*q,t),(q,q-o,t,t-o),(q,q+o,t,t+o)]]
I.save("c.png")

-1 केल्विन की छवि के रूप में सुंदर नहीं;)
बीटा डेके

मैं इस बात की पुष्टि कर सकता हूं कि .show () काम करता है
अल्बर्ट रेनशॉ

ठीक है, धन्यवाद, मैं इसके बजाय का उपयोग करेंगे save
केविन

3

एसवीजी (1249 अक्षर)

हाँ, बहुत सारे पात्र। लेकिन यह स्थिर है और किसी भी आकार में प्रदान करता है, जिससे यह कुछ बोनस देता है।

<svg xmlns="http://www.w3.org/2000/svg"><path d="M15,33c-2.5,0-4.6,1.9-4.9,4.3c2.8,1.6,6.1,2.6,9.5,2.6c0.3-0.6,0.4-1.3,0.4-2C20,35.2,17.8,33,15,33zM15,7c2.8,0,5-2.2,5-5c0-0.7-0.1-1.4-0.4-2c-3.5,0.1-6.7,1-9.5,2.6C10.4,5.1,12.5,7,15,7zM25,33c-2.8,0-5,2.2-5,5c0,0.7,0.1,1.4,0.4,2c3.5-0.1,6.7-1,9.5-2.6C29.6,34.9,27.5,33,25,33zM25,7c2.5,0,4.6-1.9,4.9-4.3C27.1,1,23.9,0.1,20.4,0C20.1,0.6,20,1.3,20,2C20,4.7,22.2,7,25,7zM35,28.7C34.8,26,32.6,24,30,24s-4.8,2.1-5,4.7c-3-1.7-5-5-5-8.7c0,3.7-2,6.9-5,8.7C14.8,26,12.6,24,10,24S5.2,26,5,28.7c-3-1.7-5-5-5-8.7c0,7.4,4,13.9,10,17.3c0.1-1.2,0.4-2.4,0.8-3.4c0.9-1.9,2.3-3.5,4.1-4.5c0,0,0,0,0.1,0c0.2,2.6,2.3,4.7,5,4.7s4.8-2.1,5-4.7c0,0,0,0,0.1,0c1.8,1,3.2,2.6,4.1,4.5c0.5,1.1,0.8,2.2,0.8,3.4c6-3.5,10-9.9,10-17.3C40,23.7,38,26.9,35,28.7zM5,11.3c0.2,2.6,2.3,4.7,5,4.7s4.8-2.1,5-4.7c3,1.7,5,5,5,8.7c0-3.7,2-6.9,5-8.7c0.2,2.6,2.3,4.7,5,4.7s4.8-2.1,5-4.7c3,1.7,5,5,5,8.7c0-7.4-4-13.9-10-17.3c-0.1,1.2-0.4,2.4-0.8,3.4C28.3,8,26.8,9.6,25,10.6c0,0,0,0-0.1,0C24.8,8,22.6,6,20,6s-4.8,2.1-5,4.7c0,0,0,0-0.1,0c-1.8-1-3.2-2.6-4.1-4.5C10.4,5,10.1,3.9,10,2.6C4,6.1,0,12.6,0,20C0,16.3,2,13,5,11.3z"/><circle cx="15" cy="20" r="5"/><circle cx="5" cy="20" r="5"/><circle cx="35" cy="20" r="5"/><circle cx="25" cy="20" r="5"/></svg>

देखने योग्य स्निपेट:

svg { fill: #9FD7FF; background: #2176AA; }
<svg xmlns="http://www.w3.org/2000/svg" width="400" height="400" viewBox="0 0 40 40">
  <path d="M15,33c-2.5,0-4.6,1.9-4.9,4.3c2.8,1.6,6.1,2.6,9.5,2.6c0.3-0.6,0.4-1.3,0.4-2C20,35.2,17.8,33,15,33zM15,7c2.8,0,5-2.2,5-5c0-0.7-0.1-1.4-0.4-2c-3.5,0.1-6.7,1-9.5,2.6C10.4,5.1,12.5,7,15,7zM25,33c-2.8,0-5,2.2-5,5c0,0.7,0.1,1.4,0.4,2c3.5-0.1,6.7-1,9.5-2.6C29.6,34.9,27.5,33,25,33zM25,7c2.5,0,4.6-1.9,4.9-4.3C27.1,1,23.9,0.1,20.4,0C20.1,0.6,20,1.3,20,2C20,4.7,22.2,7,25,7zM35,28.7C34.8,26,32.6,24,30,24s-4.8,2.1-5,4.7c-3-1.7-5-5-5-8.7c0,3.7-2,6.9-5,8.7C14.8,26,12.6,24,10,24S5.2,26,5,28.7c-3-1.7-5-5-5-8.7c0,7.4,4,13.9,10,17.3c0.1-1.2,0.4-2.4,0.8-3.4c0.9-1.9,2.3-3.5,4.1-4.5c0,0,0,0,0.1,0c0.2,2.6,2.3,4.7,5,4.7s4.8-2.1,5-4.7c0,0,0,0,0.1,0c1.8,1,3.2,2.6,4.1,4.5c0.5,1.1,0.8,2.2,0.8,3.4c6-3.5,10-9.9,10-17.3C40,23.7,38,26.9,35,28.7zM5,11.3c0.2,2.6,2.3,4.7,5,4.7s4.8-2.1,5-4.7c3,1.7,5,5,5,8.7c0-3.7,2-6.9,5-8.7c0.2,2.6,2.3,4.7,5,4.7s4.8-2.1,5-4.7c3,1.7,5,5,5,8.7c0-7.4-4-13.9-10-17.3c-0.1,1.2-0.4,2.4-0.8,3.4C28.3,8,26.8,9.6,25,10.6c0,0,0,0-0.1,0C24.8,8,22.6,6,20,6s-4.8,2.1-5,4.7c0,0,0,0-0.1,0c-1.8-1-3.2-2.6-4.1-4.5C10.4,5,10.1,3.9,10,2.6C4,6.1,0,12.6,0,20C0,16.3,2,13,5,11.3z"/>
  <circle cx="15" cy="20" r="5"/>
  <circle cx="5" cy="20" r="5"/>
  <circle cx="35" cy="20" r="5"/>
  <circle cx="25" cy="20" r="5"/>
</svg>


ध्यान दें, जैसा कि मेगो ने कहा, एसवीजी एक प्रोग्रामिंग भाषा के रूप में अर्हता प्राप्त करने के लिए हमारे मानदंड को पूरा नहीं करता है । हालाँकि, ओपी इस जवाब को वैसे भी अनुमति देने का विकल्प चुन सकता है; यह उसके ऊपर है।
एलेक्स ए।

एसवीजी इस मामले में ठीक है।
केल्विन के शौक

आप 0अस्थायी बिंदु स्थिरांक में अग्रणी को छोड़ सकते हैं ? उदाहरण के लिए, 0.4द्वारा प्रतिस्थापित करें .4? अधिकांश भाषाओं में, यह मान्य है। और एसवीजी कल्पना का एक बहुत ही त्वरित रूप से पता चलता है कि यह संभवतः उनके साथ भी काम करना चाहिए।
रेटो कोराडी

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

2

गणितज्ञ 336 359 बाइट्स

प्रमुख ग्राफिक्स ऑब्जेक्ट समीकरणों के तार्किक संयोजनों के माध्यम से परिभाषित क्षेत्र हैं।

r=Red;i=ImplicitRegion;m=i[-2<x<2&&-2<y<2,{x,y}];n=Input[];
t[a_,b_,c_]:=i[(x+a)^2+(y+b)^2<=c,{x,y}];
a_~f~b_:={t[a,b,1],t[-.5+a,b,1/4],t[.5+a,b,1/4],t[a,b-.865,1/4],t[a,b+.865, 1/4]}
g@d_:=RegionIntersection[m,BooleanRegion[#1&&!#2&&!#3&&!#4&&!#5&,d]]
RegionPlot[{m,t[0,0,4],g@f[1,0],g@f[-1,0],g@f[0,1.75], 
g@f[0, -1.75]},ImageSize->n,PlotStyle->{r,Blue,r,r,r,r}]

पिक


1

जावा, 550

import javafx.application.*;import javafx.scene.*;import javafx.scene.layout.*;import javafx.scene.shape.*;import javafx.stage.*;public
class C extends Application{static long n;Shape d(float m,float k,float x,float y){float h=m/2;Shape
s=new Circle(x+h,y+h,h);return k>0?s.subtract(s,s.union(s.union(s.union(d(h,k-1,x,y+m/4),d(h,k-1,x+h,y+m/4)),d(h,k-1,x+m/4,y-m*.183f)),d(h,k-1,x+m/4,y+m*.683f))):s;}public
void start(Stage s){s.setScene(new Scene(new Pane(d(n,2,0,0))));s.show();}public
static void main(String[]a){n=Long.valueOf(a[0]);launch();}}

ज्यादातर सिर्फ JavaFX के साथ प्रयोग कर रहे हैं।

स्क्रीनशॉट:

स्क्रीनशॉट

ब्राउनी पॉइंट्स के लिए, 2कोड को ( d(n,2,0,0)) एक अलग संख्या में बदलें ।

पुराना संस्करण, 810

import javafx.application.*;import javafx.scene.*;import javafx.scene.canvas.*;import javafx.scene.effect.*;import javafx.scene.layout.*;import javafx.scene.paint.*;import javafx.stage.*;public
class C extends Application{static long n;Canvas c;GraphicsContext g;void
d(float m,float k,float x,float y){if(k>0){float
h=m/2;g.save();g.beginPath();g.arc(x+h,y+h,h,h,0,360);g.clip();g.fillRect(x,y,m,m);d(h,k-1,x,y+m/4);d(h,k-1,x+h,y+m/4);d(h,k-1,x+m/4,y-m*.183f);d(h,k-1,x+m/4,y+m*.683f);g.restore();}}public
void start(Stage s){c=new Canvas(n,n);g=c.getGraphicsContext2D();g.setGlobalBlendMode(BlendMode.DIFFERENCE);g.setFill(Color.TAN);g.fillRect(0,0,n,n);d(n,3,0,0);Pane
p=new Pane();p.getChildren().add(c);s.setScene(new Scene(p));s.show();}public
static void main(String[]a){n=Long.valueOf(a[0]);launch();}}

यह कुछ अवांछित किनारों को छोड़ देता है जैसा कि आप इस स्क्रीनशॉट में देख सकते हैं ।


0

जावास्क्रिप्ट (ईएस 6), 279

पुन: कैनवस बनाकर बच्चे के कैनवास को उसके मूल कैनवास से चार बार जोड़ सकते हैं। नीचे की परत पर, कैनवास एक एकल चक्र है; उस कैनवास पर चार बार मूल कैनवास पर मुहर लगती है, और फिर उस कैनवास पर अंतिम मास्टर कैनवास पर चार बार मुहर लगाई जाती है।

(n,o=0)=>(r=o-2&&f(n/2,o+1),c=document.createElement`canvas`,X=c.getContext`2d`,d=(x,Q)=>(X.drawImage(r,x,k+Q*k*Math.sqrt(3)),d),c.width=c.height=n,m=n/2,k=n/4,X.fillStyle=o%2||"red",X.fill(X.clip(X.arc(m,m,m,0,7))),r&&d(0,0)(m,0)(k,-1)(k,1),o?c:location=c.toDataURL`image/jpeg`)

छवि प्रस्तुत करना

चलने योग्य डेमो:

व्हॉट्सएप, टिप्पणियों और हल्के से

f=(n,o=0)=>(
    // recursively create another canvas if we're not at the deepest layer
    var r;
    if(o < 2) { r = f(n/2,o+1); }

    // create this canvas
    c=document.createElement("canvas"),
    c.width=c.height=n,
    X=c.getContext("2d"),

    // helpful postions
    m=n/2, k=n/4, q=k*Math.sqrt(3),

    // draw a circle and clip future draws within this circle
    // either fills red (the shortest color name) or a non-color that defaults to black
    X.fillStyle= o%2 || "red",
    X.arc(m,m,m,0,7),
    X.clip(),
    X.fill(),

    // define a chainable `drawImage` alias (the `d` function returns itself)
    d=(x,y)=>(X.drawImage(r,x,y),d)

    // if we have a recursive canvas, draw it four times by chaining `d`
    if(r) { d(0,k)(m,k)(k,k-q)(k,k+q); }

    // if this is the top-layer (o==0), show the final jpeg
    if(o == 0) { location = c.toDataURL("image/jpeg"); }

    // return this canvas, to be used recursively
    c
)

यह प्रारंभिक o-2या किसी भी बड़े o-zमूल्य को बदलकर आसानी से पुनरावृत्ति की गहरी परतों का उत्पादन कर सकता है ।

ध्यान दें कि यह प्रस्तुत करने के लिए फ़ायरफ़ॉक्स में केवल ES6 सुविधाओं और असंगतता के कारण कैनवास एपीआई में तर्क fillऔर clipतर्कों के कारण होगा।

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.