Zuallererst ... Ich möchte allen ein frohes Weihnachtsfest wünschen (sorry, wenn ich einen Tag zu spät für Ihre Zeitzone bin).

Um diesen Anlass zu feiern, werden wir eine Schneeflocke zeichnen. Da das Jahr 201 5 und Weihnachten 2 5 ist (für einen großen Teil der Personen), werden wir eine Penta- Flocke zeichnen . Das Pentaflake ist ein einfaches Fractal, das aus Pentagonen besteht. Hier einige Beispiele (von hier) :

Jeder Pentaflake hat eine Bestellung n. Die Pentaflake der Ordnung 0 ist einfach ein Fünfeck. Für alle anderen Bestellungen n setzt sich eine Pentaflake aus 5 Pentaflakes der vorherigen Bestellung zusammen, die um eine 6. Pentaflake der vorherigen Bestellung angeordnet sind. Zum Beispiel besteht ein Pentaflake der Ordnung 1 aus 5 Fünfecken, die um ein zentrales Fünfeck angeordnet sind.

Eingang

Die Bestellung n. Dies kann auf jede andere Weise als die einer vordefinierten Variablen angegeben werden.

Ausgabe

Ein Bild von der Bestellung nPentaflake. Muss mindestens 100px breit und 100px lang sein. Es kann in einer Datei gespeichert, dem Benutzer angezeigt oder an ausgegeben werden STDOUT. Jede andere Ausgabeform ist nicht zulässig. Alle Bildformate, die vor dieser Herausforderung existieren, sind zulässig.

Gewinnen

Als Codegolf gewinnt die Person mit der geringsten Anzahl von Bytes.

Matlab, 226

function P(M);function c(L,X,Y,O);hold on;F=.5+5^.5/2;a=2*pi*(1:5)/5;b=a(1)/2;C=F^(2*L);x=cos(a+O*b)/C;y=sin(a+O*b)/C;if L<M;c(L+1,X,Y,~O);for k=1:5;c(L+1,X+x(k),Y+y(k),O);end;else;fill(X+x*F, Y+y*F,'k');end;end;c(0,0,0,0);end

Ungolfed:

function P(M);                
function c(L,X,Y,O);          %recursive function
hold on;
F=.5+5^.5/2;                  %golden ratio
a=2*pi*(1:5)/5;               %full circle divided in 5 parts (angles)
b=a(1)/2;
C=F^(2*L);
x=cos(a+O*b)/C;               %calculate the relative position ofnext iteration
y=sin(a+O*b)/C;
if L<M;                       %current recursion (L) < Maximum (M)? recurse
    c(L+1,X,Y,~O);            %call recursion for inner pentagon
    for k=1:5;
        c(L+1,X+x(k),Y+y(k),O)%call recursion for the outer pentagons
    end; 
else;                         %draw
    fill(X+x*F, Y+y*F,'k');  
end;
end;
c(0,0,0,0);
end

Fünfte Iteration (das Rendern dauerte bereits eine Weile).

Eine geringfügige Änderung des Codes (leider mehr Bytes) führt zu dieser Schönheit =)

Oh, und noch einer:

Mathematica, 200 Bytes

a=RotationTransform
b=Range
r@k_:={Re[t=I^(4k/5)],Im@t}
R@k_:=a[Pi,(r@k+r[k+1])/2]
Graphics@Nest[GeometricTransformation[#,ScalingTransform[{1,1}(Sqrt@5-3)/2]@*#&/@Append[R/@b@5,a@0]]&,Polygon[r/@b@5],#]&

Die letzte Zeile ist eine Funktion, die auf eine ganze Zahl angewendet werden kann n.

Mathematica-Funktionsnamen sind lang. Jemand sollte sie entropiecodieren und daraus eine neue Sprache machen. :)

Bei Anwendung auf 1:

Bei Anwendung auf 2:

MATLAB, 235 233 217 Bytes

Update: Eine Reihe von Vorschlägen von @flawr hat mir geholfen, 16 Bytes zu verlieren. Da ich nur auf diese Weise die Lösung von flawr hätte übertreffen können und die Herausforderung ohne die Hilfe von flawr überhaupt nicht gefunden hätte, halten Sie dies für eine gemeinsame Einreichung von uns :)

N=input('');f=2*pi/5;c=1.5+5^.5/2;g=0:f:6;p=[cos(g);sin(g)];R=[p(:,2),[-p(2,2);p(1,2)]];for n=1:N,t=p;q=[];for l=0:4,q=[q R^l*[c-1+t(1,:);t(2,:)]/c];end,p=[q -t/c];end,p=reshape(p',5,[],2);fill(p(:,:,1),p(:,:,2),'k');

Dies ist eine weitere MATLAB-Lösung, die auf einer Philosophie iterierter Funktionssysteme basiert. Ich war hauptsächlich daran interessiert, den Algorithmus selbst zu entwickeln, und ich habe mich nicht zu sehr mit der Lösung befasst. Es gibt sicherlich Raum für Verbesserungen. (Ich habe darüber nachgedacht, eine hartcodierte Festkommanäherung für zu verwenden c, aber das wäre nicht schön.)

Ungolfed-Version:

N=input('');                                % read order from stdin

f=2*pi/5;                                   % angle of 5-fold rotation
c=1.5+5^.5/2;                               % scaling factor for contraction

g=0:f:6;
p=[cos(g);sin(g)];                          % starting pentagon, outer radius 1
R=[p(:,2),[-p(2,2);p(1,2)]];                % 2d rotation matrix with angle f

for n=1:N,                                  % iterate the points
    t=p;
    q=[];
    for l=0:4,
       q=[q R^l*[c-1+t(1,:);t(2,:)]/c];     % add contracted-rotated points
    end,
    p=[q -t/c];                             % add contracted middle block
end,

p=reshape(p',5,[],2);                 % reshape to 5x[]x2 matrix to separate pentagons
fill(p(:,:,1),p(:,:,2),'k');          % plot pentagons

Ergebnis für N=5(mit einem anschließenden axis equal offfür die Hübschheit, aber ich hoffe, dass das byteweise nicht zählt):

Mathematica, 124 Bytes

Mathematica unterstützt Tableseit Version 10: eine neue Syntax Table[expr, n], die ein weiteres Byte speichert. Table[expr, n]ist äquivalent zu Table[expr, {n}].

f@n_:=(p=E^Array[π.4I#&,5];Graphics@Map[Polygon,ReIm@Fold[{g,s}~Function~Join[.62(.62g#+#&/@s),{-.39g}],p,p~Table~n],{-3}])

Der Kern dieser Funktion besteht darin, komplexe Zahlen zu verwenden, um Transformationen durchzuführen und diese dann in Punkte umzuwandeln ReIm.

Testfall:

f[4]

Mathematica, 199 196 Bytes

Hier ist eine meiner eigenen Antworten, die Peter Richter um ein Haar verdrängt. Es stützt sich stark auf Grafikfunktionen und weniger auf Mathematik und FP. Die CirclePoints-Funktion ist neu in 10.1 .

c=CirclePoints;g=GeometricTransformation;
p@0=Polygon@c[{1,0},5];
p@n_:=GraphicsGroup@{
        p[n-1],
        g[
          p[n-1]~g~RotationTransform[Pi/5],
          TranslationTransform/@{GoldenRatio^(2n-1),n*Pi/5}~c~5
        ]
      };
f=Graphics@*p

Edit: Danke an DumpsterDoofus für GoldenRatio

Mathematica, 130 Bytes

r=Exp[Pi.4I Range@5]
p=1/GoldenRatio
f@0={r}
f@n_:=Join@@Outer[1##&,r,p(f[n-1]p+1),1]~Join~{-f[n-1]p^2}
Graphics@*Polygon@*ReIm@*f

Ich verwende eine ähnliche Technik wie die Antwort von njpipeorgan (tatsächlich habe ich seinen 2Pi I/5 == Pi.4ITrick gestohlen ), aber als rekursive Funktion implementiert.

Beispielverwendung ( %um auf die anonyme Funktion zuzugreifen, die in der letzten Zeile ausgegeben wurde):

 %[5]