Tout d'abord ... je voudrais souhaiter à tous un Joyeux Noël (désolé si j'ai un jour de retard pour votre fuseau horaire).

Pour célébrer l'occasion, nous allons dessiner un flocon de neige. Parce que l'année est 201 5 et Noël est le 2 5 (pour une grande partie des personnes), nous allons dessiner un flocon Penta . Le Pentaflake est une simple fractale composée de pentagones. Voici quelques exemples (tirés d'ici) :

Chaque Pentaflake a un ordre n. Le Pentaflake d'ordre 0 est simplement un pentagone. Pour tous les autres ordres n, un Pentaflake est composé de 5 Pentaflakes de l'ordre précédent disposés autour d'un 6ème Pentaflake de l'ordre précédent. Par exemple, un Pentaflake d'ordre 1 est composé de 5 pentagones disposés autour d'un pentagone central.

Contribution

La commande n. Cela peut être donné de n'importe quelle manière sauf celle d'une variable prédéfinie.

Sortie

Une image de l'ordre nPentaflake. Doit avoir au moins 100 pixels de large et 100 pixels de long. Il peut être enregistré dans un fichier, affiché pour l'utilisateur ou édité STDOUT. Toute autre forme de sortie n'est pas autorisée. Tous les formats d'image existant avant ce défi sont autorisés.

Gagnant

En tant que codegolf, la personne avec le moins d'octets gagne.

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

Non golfé:

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

Cinquième itération (le rendu a déjà pris un certain temps).

Une légère altération du code (malheureusement plus d'octets) entraîne cette beauté =)

Oh, et un autre:

Mathematica, 200 octets

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],#]&

La dernière ligne est une fonction qui peut être appliquée à un entier n.

Les noms des fonctions Mathematica sont longs. Quelqu'un devrait les coder par entropie et en faire un nouveau langage. :)

Lorsqu'il est appliqué à 1:

Lorsqu'il est appliqué à 2:

MATLAB, 235 233 217 octets

Mise à jour: un tas de suggestions de @flawr m'a aidé à perdre 16 octets. Étant donné que cela m'a permis de battre la solution de flawr et que je n'aurais pas trouvé le défi sans l'aide de flawr en premier lieu, considérez cela comme une soumission conjointe de notre part :)

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');

Il s'agit d'une autre solution MATLAB, celle-ci basée sur une philosophie des systèmes de fonctions itératives. J'étais surtout intéressé par le développement de l'algorithme lui-même, et je n'ai pas trop joué sur la solution. Il y a sûrement matière à amélioration. (J'ai envisagé d'utiliser une approximation à virgule fixe codée en dur pour c, mais ce ne serait pas bien.)

Version non golfée:

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

Résultat pour N=5(avec un ultérieur axis equal offpour la beauté, mais j'espère que cela ne compte pas en octets):

Mathematica, 124 octets

Mathematica prend en charge une nouvelle syntaxe pour Tabledepuis la version 10 Table[expr, n]:, qui enregistre un autre octet. Table[expr, n]est équivalent à 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}])

Le cœur de cette fonction utilise des nombres complexes pour effectuer des transformations, puis les convertir en points par ReIm.

Cas de test:

f[4]

Mathematica, 199 196 octets

Bordant la réponse de Peter Richter par un cheveu, voici la mienne. Il s'appuie fortement sur la fonctionnalité graphique et moins sur les mathématiques et la FP. La fonction intégrée CirclePoints est nouvelle dans 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: Merci à DumpsterDoofus pour GoldenRatio

Mathematica, 130 octets

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

J'utilise une technique similaire à la réponse de njpipeorgan (en fait j'ai volé son 2Pi I/5 == Pi.4Itour), mais implémentée comme une fonction récursive.

Exemple d'utilisation (utilisation %pour accéder à la fonction anonyme qui a été sortie sur la dernière ligne):

 %[5]