Schreiben Sie ein Programm oder eine Funktion, die eine positive ganze Zahl N aufnimmt und dieses Muster von Kreisen wiederherstellt, die so skaliert sind, dass sie zu einem N × N-Pixelbild passen:

Dieses Bild ist ein gültiges Ausgabebeispiel für N = 946.

Falls es nicht klar ist, haben alle kleinen hellblauen Kreise den gleichen Radius und werden auf die gleiche Weise in den vier dunkelblauen Kreisen positioniert. Die dunkelblauen Kreise haben den doppelten Radius und sind in ähnlicher Weise in dem großen hellblauen Kreis positioniert.

• Anstelle der beiden Blautöne können zwei beliebige visuell unterschiedliche Farben verwendet werden.

• Das Hintergrundquadrat muss farbig sein.

• Anti-Aliasing ist optional.

• Speichern Sie das Bild in einer Datei, zeigen Sie es an oder leiten Sie die Rohdaten an stdout.

• Jedes gängige Bilddateiformat ist zulässig.

Der kürzeste Code in Bytes gewinnt.

Brownie-Punkte, wenn Sie die rekursiven Aspekte dieses Kreismuster auf weitere Ebenen erweitern. (Unterscheiden Sie dies von Ihrem Herausforderungseintrag.)

CJam, 83 Bytes

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

Probieren Sie es online aus

CJam bietet keine dedizierten Bildausgabefunktionen. Mein Code generiert ein Bild in PBM ASCII. Zum Posten habe ich dieses Bild mit GIMP in ein PNG konvertiert.

Beachten Sie, dass keine Kreiszeichnungsfunktion oder ähnliches verwendet wurde. Das Bild wird pixelweise berechnet.

Höhere Grade der Unterteilung können leicht erzeugt werden, indem die Konstante 3um die Mitte des Codes erhöht wird .

Die Bilder der Grade 4 und 5 sehen folgendermaßen aus:

Die Gesamtsequenz des Codes ist:

1. Generieren Sie die Koordinaten aller Pixel, die auf den Bereich [-1.0, 1.0] normiert sind.
2. Schleife über alle Pixel.
3. Schleife über Unterteilungsgrade.
4. Überprüfen Sie für jede Unterteilung, ob sich das Pixel innerhalb / außerhalb befindet, und behalten Sie das Ergebnis bei. Die Skalierung / Verschiebung der Pixelkoordinaten in die Koordinatensysteme, die in einem der 4 Unterkreise zentriert sind. Wählen Sie diejenige aus, bei der die transformierten Koordinaten dem Zentrum am nächsten liegen.
5. Suchen Sie aus den binären Innen- / Außenergebnissen jedes Grades die erste 0, die dem ersten Grad entspricht, in dem sich das Pixel außerhalb befand, und bestimmen Sie mit Modulo 2 die Farbe des Pixels.

Erläuterung:

"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.

Python 2 + PIL, 262 Bytes

Dieser Ansatz bestimmt die Farbe jeder einzelnen Pixelkoordinate unter Verwendung einer rekursiven Funktion c. c(x,y,0)rendert einen Kreis; c(x,y,1)erzeugt einen Kreis mit vier ausgeschnittenen Kreisen; c(x,y,2)Rendert das Bild im OP. Alles was größer als 2 ist, bringt mir Brownie-Punkte.

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")

Nicht Golf Version:

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")

Bonus extra-rekursives Bild:

PostScript, 335 Bytes.

%!
/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

PostScript ist nicht nur ein Grafikdateiformat mit Vektor- und Bitmap-Funktionen, sondern eine objektbasierte Programmiersprache für Turing-complete. Der obige Code ist eine recht einfache Implementierung rekursiver Funktionen. Alle PostScript-Operatoren sind Funktionen, und es ist üblich, sie neu zu definieren, um den Code zu komprimieren. Beachten Sie, dass PostScript die umgekehrte polnische Notation verwendet (auch bekannt als Postfix-Notation) verwendet.

PostScript-Interpreter lesen im Allgemeinen Metadaten (wie Seitengröße und Titel) aus speziellen Kommentaren am Anfang der Datei. Natürlich habe ich alle wichtigen PostScript-Signaturkommentare %!aus meinem Eintrag entfernt, aber sie sollten in jedem Standard-PostScript-Interpreter, z. B. GhostScript oder Okular, weiterhin in Ordnung sein. Es kann auch das betrachtet wird unter Verwendung von Display - Dienstprogramm , das mit ImageMagick / GraphicsMagick kommt.

Beachten Sie, dass die Datei in einer neuen Zeile enden sollte (die ich in meine Byteanzahl aufgenommen habe), damit der Interpreter nicht verärgert wird.

Der Größenparameter Nfür diesen Code ist 512; Es wird durch 2 geteilt und zweimal dupliziert, um die Parameter für den ersten Aufruf der rekursiven Funktion zu erstellen f. Die Rekursion Tiefe beträgt 2, die unmittelbar vor dem gegeben wird fin 512 2 div dup dup 2 f. Um die Größe klein zu halten, erfolgt die Ausgabe in Schwarzweiß. Obwohl Sie eine angemessene nicht negative ganzzahlige Rekursionstiefe festlegen können, sieht diese Version nur mit gleichmäßigen Tiefen gut aus.

Dieses Bild ist eine Vektorgrafik und kann daher in jeder Auflösung ohne Pixelung angezeigt werden, abhängig von der Qualität und den Einstellungen des verwendeten PostScript-Interpreters / Druckers. (FWIW, PostScript verwendet kubische Bézier-Kurven zum Zeichnen von Kreisbögen, wobei genügend Splines verwendet werden, um sicherzustellen, dass der Fehler immer weniger als ein Pixel im Gerätebereich beträgt.) Um es mit dem ImageMagick- Display in angemessen hoher Qualität anzuzeigen , können Sie Folgendes tun:

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

Die gleichen Parameter eignen sich auch, wenn Sie ImageMagicks convertzum Konvertieren in ein anderes Format verwenden möchten . Hier ist zum Beispiel eine 640x640-Version des obigen PostScript-Codes, der in PNG konvertiert wurde:

Hier ist eine etwas größere Version, die RGB-Farben und ungerade Rekursionstiefen verarbeitet:

%!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

Außerdem können Sie den Größenparameter Nund die Rekursionstiefe dim oberen Bereich des Skripts festlegen .

%!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

Und hier ist die Ausgabe von depth == 4 im PNG-Format, die wiederum mit convert erstellt (und mit optipng optimiert ) wurde:

Python 2 + PIL, 361 Bytes

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")

Speichert das Bild in Schwarzweiß in der Datei c.png:

Ich generiere im Grunde genommen einen der halbgroßen Kreise im Bild J. Ich benutze mich dann als Maske, um die Form auf das Bild zu malen I, das den Hauptkreis hat.

Es könnte mit I.show()am Ende anstatt gekürzt werden I.save("c.png"), aber ich habe es in Python 2 nicht zum Laufen gebracht. Wenn jemand bestätigen kann, dass es in Python 2 funktioniert, werde ich das ändern.

Das folgende Programm erzeugt das Bild wie in der Frage (419 Bytes):

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")

SVG (1249 Zeichen)

Ja, viele Charaktere. Aber es ist statisch und rendert in jeder Größe, so dass es einen Bonus gibt.

<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>

Sichtbares Snippet:

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>

Mathematica 336 359 Bytes

Die Hauptgrafikobjekte sind Bereiche, die durch logische Kombinationen von Gleichungen definiert werden.

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}]

Java, 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();}}

Meist nur mit JavaFX experimentieren.

Bildschirmfoto:

Für Brownie-Punkte ändern Sie die 2im Code (d(n,2,0,0) ) eine andere Zahl.

Alte Version, 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();}}

Es hinterlässt einige unerwünschte Kanten, wie Sie in diesem Screenshot sehen können .

JavaScript (ES6), 279

Erstellen Sie rekursiv Leinwände und fügen Sie die untergeordnete Zeichenfläche viermal zur übergeordneten Zeichenfläche hinzu. In der unteren Ebene ist die Leinwand ein einzelner Kreis. Diese Zeichenfläche wird viermal auf eine übergeordnete Zeichenfläche gestempelt, und diese Zeichenfläche wird dann viermal auf die endgültige Master-Zeichenfläche gestempelt.

(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`)

Lauffähige Demo:

f = function (n) {var o = arguments.length <= 1 || arguments[1] === undefined ? 0 : arguments[1];return r = o - 2 && f(n / 2, o + 1), c = document.createElement("canvas"), X = c.getContext("2d"), d = function (x, y) {return X.drawImage(r, x, y || k), d;}, c.width = c.height = n, m = n / 2, k = n / 4, q = k * Math.sqrt(3), X.fillStyle = o % 2 || "red", X.arc(m, m, m, 0, 7),X.clip(),X.fill(), r && d(0)(m)(k, k - q)(k, k + q), o || (location = c.toDataURL("image/jpeg")), c;};f(400)

Mit Leerzeichen, Kommentaren und leicht ungolfed:

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
)

Dies kann leicht zu tieferen Rekursionsebenen führen, indem der Anfangswert o-2oder ein beliebiger größerer o-zWert geändert wird.

Beachten Sie, dass diese Übermittlung aufgrund der Verwendung von ES6-Funktionen und der Inkonsistenz in der Canvas-API für fillund clipArgumente nur in Firefox ausgeführt wird .