En primer lugar ... Me gustaría desearles a todos una Feliz Navidad (lo siento si llego un día tarde a su zona horaria).

Para celebrar la ocasión, vamos a dibujar un copo de nieve. Debido a que el año es 201 5 y la Navidad es el día 2 5 (para una gran parte de las personas), dibujaremos un copo Penta . El pentaflake es un fractal simple compuesto de pentágonos. Aquí hay algunos ejemplos (tomados de aquí) :

Cada Pentaflake tiene un orden n. El Pentaflake de orden 0 es simplemente un pentágono. Para todas las demás órdenes n, un Pentaflake se compone de 5 Pentaflakes del orden anterior dispuestos alrededor de un sexto Pentaflake del orden anterior. Por ejemplo, un Pentaflake de orden 1 se compone de 5 pentágonos dispuestos alrededor de un pentágono central.

Entrada

El orden n. Esto puede darse de cualquier manera, excepto la de una variable predefinida.

Salida

Una imagen de la orden nPentaflake. Debe tener al menos 100 px de ancho y 100 px de largo. Puede guardarse en un archivo, mostrarse al usuario o enviarse a STDOUT. No se permite ninguna otra forma de salida. Todos los formatos de imagen existentes antes de este desafío están permitidos.

Victorioso

Como codegolf, la persona con el menor número de bytes gana.

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

Sin 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

Quinta iteración (ya tomó bastante tiempo renderizar).

Una ligera alteración del código (desafortunadamente más bytes) da como resultado esta belleza =)

Ah, y otro:

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

La última línea es una función que se puede aplicar a un número entero n.

Los nombres de las funciones de Mathematica son largos. Alguien debería codificarlos en entropía y crear un nuevo lenguaje a partir de él. :)

Cuando se aplica a 1:

Cuando se aplica a 2:

MATLAB, 235 233 217 bytes

Actualización: un montón de sugerencias de @flawr me ayudaron a perder 16 bytes. Como solo esto me permitió superar la solución de flawr , y que no habría encontrado el desafío sin la ayuda de flawr en primer lugar, considere esto como una presentación conjunta de nosotros :)

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

Esta es otra solución de MATLAB, esta basada en una filosofía de sistemas de funciones iteradas. Estaba principalmente interesado en desarrollar el algoritmo en sí, y no he jugado demasiado en la solución. Seguramente hay margen de mejora. (Contemplé el uso de una aproximación de punto fijo codificada para c, pero eso no sería bueno).

Versión sin golf:

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

Resultado para N=5(con un posterior axis equal offpara la belleza, pero espero que no cuente en bytes):

Mathematica, 124 bytes

Mathematica admite una nueva sintaxis Tabledesde la versión 10: Table[expr, n]que guarda otro byte. Table[expr, n]es equivalente a 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}])

El núcleo de esta función es usar números complejos para hacer transformaciones y luego convertirlas en puntos por ReIm.

Caso de prueba:

f[4]

Mathematica, 199 196 bytes

Borrando la respuesta de Peter Richter por un pelo, esta es la mía. Se apoya en gran medida en la funcionalidad gráfica, y menos en matemáticas y FP. La construcción integrada CirclePoints es nueva en 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

Editar: Gracias a DumpsterDoofus por 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

Utilizo una técnica similar a la respuesta de njpipeorgan (de hecho, robé su 2Pi I/5 == Pi.4Itruco), pero implementado como una función recursiva.

Ejemplo de uso (uso %para acceder a la función anónima que se generó en la última línea):

 %[5]