... c'est donc un défi de faire de moi un arbre.

Produisez un programme ou une fonction appelée arbre qui prend un seul argument entier, N et dessine un arbre de Pythagore N niveaux en profondeur, où le niveau 0 est juste le tronc.

Chaque jonction de l'arbre doit placer le sommet du triangle à un point aléatoire sur le périmètre (ce point doit être uniformément réparti sur au moins 5 points également espacés, ou uniformément sur tout le demi-cercle).

En option, votre arbre peut être en 3D, coloré ou éclairé en fonction de l'heure de la journée. Cependant, c'est du code-golf, donc le plus petit fichier gagne.

EDIT: Je vais fermer le concours et accepter la plus petite réponse quand elle aura une semaine

Mathematica, 246 234 221 caractères

g[n_,s_:1]:={p=RandomReal[q=Pi/2],r=##~Rotate~(o={0,0})&,t=Translate}~With~If[n<0,{},Join[#~t~{0,s}&/@(#~r~p&)/@g[n-1,s*Cos@p],t[#,s{Cos@p^2,1+Sin[2p]/2}]&/@(r[#,p-q]&)/@g[n-1,s*Sin@p],{Rectangle[o,o+s]}]]
f=Graphics@g@#&

Ce n'est certainement pas la manière la plus élégante / la plus courte de le faire.

Usage: f[8]

Et voici des exemples de sorties pour f[6]et f[10]respectivement.

Assez peu golfé:

g[n_, s_:1] := With[{p},
  r = Rotate;
  t = Translate;
  p = RandomReal[q = Pi/2];
  If[n < 0, {},
   Join[
    (t[#, {0, s}] &) /@ (r[#, p, {0, 0}] &) /@ g[n - 1, s*Cos[p]],
    (t[#, s {Cos[p]^2, 1 + Sin[2 p]/2}] &) /@ (r[#, p - q, {0, 0}] &) /@
       g[n - 1, s*Sin[p]],
    {Rectangle[{0, 0}, {s, s}]}
    ]
   ]
  ]
f = Graphics@g[#] &

CFDG, 134 caractères

Celui-ci n'est pas exactement valide, car vous ne pouvez pas limiter la profondeur de récursivité. Mais le problème appelle simplement une solution dans celui-ci . :)

startshape t
c(q)=cos(q/2)^2
d(q)=1+sin(q)/2
p=acos(-1)
shape t{w=rand(p)
SQUARE[x .5 .5]t[trans 0 1 c(w) d(w)]t[trans c(w) d(w) 1 1]}

Les résultats ressemblent à ceci

Pour 46 autres caractères ( 180 caractères au total), vous pouvez même le colorier en:

startshape t
c(q)=cos(q/2)^2
d(q)=1+sin(q)/2
p=acos(-1)
shape t{w=rand(p)
SQUARE[x .5 .5 h 25 sat 1 b .2]t[trans 0 1 c(w) d(w) b .08 .8 h 2.2]t[trans c(w) d(w) 1 1 b .08 .8 h 2.2]}

Postscript, 322 270

Edit: Il semble que realtimecela ne peut pas être utilisé comme une graine de générateur aléatoire appropriée. Par conséquent, nous utiliserons la variable d'environnement à cet effet et exécuterons le programme comme ça:

gs -c 20 $RANDOM -f tree.ps

ou

gswin32c -c 20 %RANDOM% -f tree.ps

Maintenant, nos arbres sont moins prévisibles. 14 octets sont ajoutés au nombre total. Autres modifications: 1) L'argument du programme est maintenant passé sur la ligne de commande. 2) Aucun compteur d'itération explicite - la taille de la pile sert à cet effet (l'angle de rotation de la branche gauche est stocké sur la pile, pour dessiner la branche droite, plus tard). 3) Il n'y a pas de variable nommée pour la profondeur requise - la taille de la pile est son décalage, sur la pile. Il est laissé là à la sortie, c'est-à-dire qu'il n'est pas consommé.

srand
250 99 translate
50 50 scale
/f{
    count
    dup index div dup 1 le{
        0 exch 0 setrgbcolor
        0 0 1 1 rectfill
        0 1 translate
        rand 5 mod 1 add 15 mul
        gsave
        dup rotate
        dup cos dup scale
        f
        grestore
        dup cos dup dup mul
        exch 2 index sin mul translate
        dup 90 sub rotate
        sin dup scale 1
        f
        pop
    }{pop}ifelse
}def
f

Je pense que c'est assez évident - l'état graphique est préparé et la fprocédure est appelée récursivement pour chaque niveau de profondeur consécutif, deux fois - pour les branches «gauche» et «droite». Travailler avec un rectangle de 1x1taille (voir l'échelle d'origine) évite de multiplier par la longueur du côté. L'angle de rotation de la branche gauche est randomisé - une des 5 divisions aléatoires également espacées est utilisée - je pense que cela empêche les cas laids possibles pour un caractère aléatoire uniforme.

Il peut être lent pour une profondeur requise supérieure à 20 environ.

Vient ensuite la version golfée, utilisant des jetons binaires encodés en ASCII (voir la réponse de luser droog du sujet lié). Notez cos, sin, randne peut pas utiliser cette notation.

/${{<920>dup 1 4 3 roll put cvx exec}forall}def srand 250 99<AD>$ 50 50<8B>$/f{count(8X68)$ 1 le{0(>)$ 0<9D>$ 0 0 1 1<80>$ 0 1<AD>$ rand 5 mod 1 add 15<~CecsG2u~>$ cos<388B>$ f(M8)$ cos(88l>)$ 2(X)$ sin<6CAD38>$ 90<A988>$ sin<388B>$ 1 f pop}{pop}(U)$}def f

.

/${{<920>dup 1 4 3 roll put cvx exec}forall}def
srand
250 99<AD>$
50 50<8B>$
/f{
count(8X68)$
1 le{
0(>)$ 0<9D>$
0 0 1 1<80>$
0 1<AD>$
rand 5 mod 1 add 15 
<~CecsG2u~>$
cos<388B>$ 
f
(M8)$
cos(88l>)$
2(X)$ sin<6CAD38>$
90<A988>$ sin<388B>$
1
f
pop
}{pop}(U)$
}def
f

Coffeescript 377B 352B

Je me sens sale en écrivant un coffeescript mais je ne trouve pas de package de dessin décent pour python3: - /

Q=(n)->X=(D=document).body.appendChild(C=D.createElement('Canvas')).getContext('2d');C.width=C.height=400;M=Math;T=[[175,400,50,i=0]];S=M.sin;C=M.cos;while [x,y,l,a]=T[i++]
 X.save();X.translate x,y;X.rotate -a;X.fillRect 0,-l,l,l;X.restore();T.push [e=x-l*S(a),f=y-l*C(a),g=l*C(b=M.random()*M.PI/2),d=a+b],[e+g*C(d),f-g*S(d),l*S(b),d-M.PI/2] if i<2**n

Javascript 393B 385B

Un peu plus joli en javascript et je suis beaucoup plus heureux avec la boucle for mais sans la [x, y, z] = une syntaxe que je ne peux pas faire assez courte pour battre coffeescript

function Q(n){X=(D=document).body.appendChild(C=D.createElement('Canvas')).getContext('2d');C.width=C.height=600;M=Math;T=[[275,400,50,i=0]];while(A=T[i++]){X.save();X.translate(x=A[0],y=A[1]);X.rotate(-(a=A[3]));X.fillRect(0,-(l=A[2]),l,l);X.restore();S=M.sin;C=M.cos;i<M.pow(2,n)&&T.push([e=x-l*S(a),f=y-l*C(a),g=l*C(b=M.random()*M.PI/2),d=a+b],[e+g*C(d),f-g*S(d),l*S(b),d-M.PI/2])}}

Je dois dire que je suis un peu fâché, c'est presque deux fois plus longtemps que la solution mathématique: - / voir en action: http://jsfiddle.net/FK2NX/3/