Bonjour,

voilà les coordonnées,
tu te débrouilleras pour remplir les ou la variable(s) liste

1   VARIABLES
2    
3    
4    
5  
6   DEBUT_ALGORITHME
7     //1er rang
8     TRACER_SEGMENT (-8,0)->(-6,6)
9     TRACER_SEGMENT (-8,0)->(-6,0)
10    TRACER_SEGMENT (-8,0)->(-6,-6)
11    //2ème rang
12    TRACER_SEGMENT (-4,6)->(0,8)
13    TRACER_SEGMENT (-4,6)->(0,6)
14    TRACER_SEGMENT (-4,6)->(0,4)
15    //  
16    TRACER_SEGMENT (-4,0)->(0,2)
17    TRACER_SEGMENT (-4,0)->(0,0)
18    TRACER_SEGMENT (-4,0)->(0,-2)
19    //  
20    TRACER_SEGMENT (-4,-6)->(0,-4)
21    TRACER_SEGMENT (-4,-6)->(0,-6)
22    TRACER_SEGMENT (-4,-6)->(0,-8)
23    //3ème rang
24    TRACER_SEGMENT (2,8)->(8,8.7)
25    TRACER_SEGMENT (2,8)->(8,8)
26    TRACER_SEGMENT (2,8)->(8,7.3)
27    //  
28    TRACER_SEGMENT (2,6)->(8,6.7)
29    TRACER_SEGMENT (2,6)->(8,6)
30    TRACER_SEGMENT (2,6)->(8,5.3)
31    //  
32    TRACER_SEGMENT (2,4)->(8,4.7)
33    TRACER_SEGMENT (2,4)->(8,4)
34    TRACER_SEGMENT (2,4)->(8,3.3)
35    //  -----
36    TRACER_SEGMENT (2,2)->(8,2.7)
37    TRACER_SEGMENT (2,2)->(8,2)
38    TRACER_SEGMENT (2,2)->(8,1.3)
39    //  
40    TRACER_SEGMENT (2,0)->(8,0.7)
41    TRACER_SEGMENT (2,0)->(8,0)
42    TRACER_SEGMENT (2,0)->(8,-0.7)
43    //  
44    TRACER_SEGMENT (2,-2)->(8,-1.3)
45    TRACER_SEGMENT (2,-2)->(8,-2)
46    TRACER_SEGMENT (2,-2)->(8,-2.7)
47    //  -----
48    TRACER_SEGMENT (2,-4)->(8,-3.3)
49    TRACER_SEGMENT (2,-4)->(8,-4)
50    TRACER_SEGMENT (2,-4)->(8,-4.7)
51    //  
52    TRACER_SEGMENT (2,-6)->(8,-5.3)
53    TRACER_SEGMENT (2,-6)->(8,-6)
54    TRACER_SEGMENT (2,-6)->(8,-6.7)
55    //  
56    TRACER_SEGMENT (2,-8)->(8,-7.3)
57    TRACER_SEGMENT (2,-8)->(8,-8)
58    TRACER_SEGMENT (2,-8)->(8,-8.7)
59  FIN_ALGORITHME

Veuillez m'excuser, mais je préférerais plutôt avoir des explications. De plus, là, je ne comprends pas vraiment...
Je me doute que cela vous a pris beaucoup de temps (peut-être pas ^^'), mais j'aimerais comprendre comment faire, afin de pouvoir refaire un exercice du même genre seul, par exemple.
Je me rends compte que je ne vous ai pas encore remercier, alors merci d'avoir pris de votre temps pour faire ceci, et, encore une fois, veuillez m'excuser.

Bonjour
J'ai posté l'image de l'interpretation que j'avais de l'énoncé

On aura surement un problème de condition d'arrêt, il va falloir décider l'arbre aura combien d'étages. (variable rang par exemple, dans mon dessin, rang va de 0 à 3)

(Par contre je ne connais pas bien la syntaxe d'algobox, je vais rester évasif sur la syntaxe)

On va traiter ici une liste d'objets contenant 4 réels: x1, y1, x2 et y2 qui sont les coordonnées de M1 et M2, les extrémités d'un segment.


//On initialise le premier segment :exemple (0,0,0,10)
Liste = {(x1,y1,x2,y2)} //donc x1=x2, pour satisfaire le cas du premier segment vertical
entier rang_courant=0
Tant que rang_courant<rang faire
  Liste nouvelle_liste={}
  //pour chaque élément de la liste
  Pour i allant de 0 à taille de Liste
   Tracer segment correspondant à l'element i de la liste
   On affecte x1, x2, y1 et y2 à l'élément i de la liste
//PREMIER SEGMENT, au premier tiers
     nouveau_x1=x1+(x2-x1)/3;
     nouveau_y1=y1+(y2-y1)/3;
     //on a un problème pour savoir si on doit aller horizontalement ou verticalement, ca dépend de la parité du rang
     si rang_courant est pair alors
     //on va horizontalement, donc y1=y2
     nouveau_x2=nouveau_x1+(y2-y1)/3; //je suppose que le nouveau segment fait aussi le tiers de longueur du niveau supérieur
     nouveau_y2=nouveau_y1;
     sinon
    //on va verticalement, donc x1=x2
    nouveau_x2=nouveau_x1;    
    nouveau_y2=nouveau_y1+(x2-x1)/3;
    fin si
    Ajouter à la liste le segment (nouveau_x1,nouveau_y1,nouveau_x2,nouveau_y2)
//DEUXIEME SEGMENT, au deuxième tiers
    nouveau_x1=x1+2*(x2-x1)/3;
     nouveau_y1=y1+2*(y2-y1)/3;
     //on a un problème pour savoir si on doit aller horizontalement ou verticalement, ca dépend de la parité du rang
     si rang_courant est pair alors
     //on va horizontalement, donc y1=y2
     nouveau_x2=nouveau_x1+(y2-y1)/3; //je suppose que le nouveau segment fait aussi le tiers de longueur du niveau supérieur
     nouveau_y2=nouveau_y1;
     sinon
    //on va verticalement, donc x1=x2
    nouveau_x2=nouveau_x1;    
    nouveau_y2=nouveau_y1+(x2-x1)/3;
    fin si
    Ajouter à la liste le segment (nouveau_x1,nouveau_y1,nouveau_x2,nouveau_y2)
    
  Fin pour
rang_courant=rang_courant+1;
Fin Tant que

Merci, à vous de m'avoir répondu.
Cependant, j'ai essayé de rentrer votre programme et, au final, cela ne me trace que deux segments.
Je me demande si les listes sont vraiment utiles pour cet algorithme.

Bien que le délai imparti soit dépassé, j'aimerais bien en arriver à bout...
Si quelqu'un voit comment faire, je suis preneur, ou si quelqu'un arrive à m'expliquer les solutions précédemment données.
(J'espère que le double post ne dérange pas)

Tu n'as pas un schéma du résultat qui doit être obtenu? Car là, j'ai émis quelques hypothèses, mais ce serait bien d'être sûr de la forme finale voulue

Bonjour,

on peut bien entendu faire tout sans listes, mais c'est mieux avec. (en plus c'est demandé )
le premier problème est que Algobox ne connait que les listes de nombres.
ici il te faut une liste de segments. Un segment n'est pas un nombre mais un quadruplet de nombres (coordonnées origine et fin)

pratiquement le mieux est donc de gérer simultanément 4 listes
une liste pour Xdebut
une liste pour Ydebut
une liste Pour Xfin
une liste Pour Yfin

L'énoncé simplifie le problème puisque les nouveaux éléments sont ajoutés "à la fin" et pas au milieu de la liste.
Mais autre problème donc : quelle est la taille de la liste ?
Algobox ne permet pas de le savoir !
tu dois donc maintenir une variable qui indique le nombre de segments dans la liste disons la variable len

enfin il va falloir définir une condition d'arret
on aura donc l'architecture générale du programme :

Listes = 1 segment (le tronc) (X0, Y0, X1, Y1)
len = 1 // nombre total de segments dans la liste
i = 1 // rang du segment à traiter
tant que on continue
couper la branche liste[ i ] au tiers
len = len + 1 // on va ajouter une branche
générer une nouvelle branche dans liste[ len ]
couper la branche liste[ i ] au 2/3
len = len + 1 // on va ajouter une branche
générer une nouvelle branche dans liste[ len ]
i = i+1 // on passe à la branche suivante de la liste actuelle
fin tantque

affichage :
Pour chaque élement de la liste
tracer le segment.

il reste quelques "détails" à règler (hum)

la condition d'arrêt :
on peut s'arrêter au bout de N branches traitées (quand i > N)
ou bien au bout de N branches en tout dans l'arbre (quand len > N)
ou bien quand le nombre de "couches" est atteint :
au "niveau zéro" on n'a que le tronc : len = 1
au niveau 1 on a généré 2 nouvelles branches sur ce tronc len = 1 + 2 = 3
au niveau 2 on a généré 2 nouvelles branches sur chacune de ces deux nouvelles branches
donc len = 1 + 2 + 4 = 7
...
au niveau N on aura len = 1 + 2 + 4 + .. + 2^N = 2^N+1 - 1

Autre "détail" : la génération des coordonnées d'une nouvelle branche
les coordonnées du début de cette nouvelle branche sont faciles
((2Xdeb + Xfin)/3; (2Ydeb+ Yfin)/3) pour l'une
((Xdeb + 2Xfin)/3; (Ydeb+ 2Yfin)/3) pour l'autre
(barycentre des extrémités du segment précédent)
par contre les coordonnées de fin de la nouvelle branche sont un peu plus coton à cause de la "rotation" (au choix est il dit, pour faire simple à 90°)
il faut faire un peu de calcul vectoriel et de transformation de coordonnées.
Une rotation du vecteur (X; Y) de +90° donne un vecteur (-Y; X)
une rotation de -90° donne un vecteur (Y; -X)
un autre angle que 90° donne des formules avec des cosinus et sinus (formules/matrice de rotation)

ce qui donne les formules les plus générales (angle ) pour générer les deux nouvelles branches CD et EF à partir de AB :


simplifions donc avec = 90° (c'est assez)
la formule pour D donne
XD = XC + (YB - YA)/3
YD = YC - (XB - XA)/3

et pour F :
XF = XE - (YB - YA)/3
YF = YE + (XB - XA)/3

on a tout alors pour traduire notre algorithme sur Algobox.
y a plus qu'à...

et si on voulait des branches avec l'angle alpha quelconque c'est juste les formules pour les points D et F qui sont "un peu plus compliquées"
XD = XC + (XB - XA)cos()/3 + (YB - YA)sin()/3
YD = YC - (XB - XA)sin()/3 + (YB - YA)cos()/3
mais rien de bien méchant, on calcule les cos()/3 etc une fois pour toutes bien entendu dans u et v :
XD = XC + (XB - XA)*u + (YB - YA)*v
XD = XC - (XB - XA)*v + (YB - YA)*u

et
XF = XE + (XB - XA)*u - (YB - YA)*v
YF = YE + (XB - XA)*v + (YB - YA)*u

résultat Algobox :
***Algorithme lancé***
Entrer N : 4
31 branches seront générées
Entrer alpha : 60
***Algorithme terminé***
et la fenêtre graphique donne :


l'algo complet est "un peu long"
(j'affiche au fur et à mesure histoire de ne pas rajouter un deuxième balayage de la liste après coup pour afficher)

VARIABLES
  Xdeb EST_DU_TYPE LISTE
  Ydeb EST_DU_TYPE LISTE
  Xfin EST_DU_TYPE LISTE
  Yfin EST_DU_TYPE LISTE
  i EST_DU_TYPE NOMBRE
  len EST_DU_TYPE NOMBRE
  N EST_DU_TYPE NOMBRE
  alpha EST_DU_TYPE NOMBRE
  u EST_DU_TYPE NOMBRE
  v EST_DU_TYPE NOMBRE
  msg EST_DU_TYPE CHAINE
DEBUT_ALGORITHME
  len PREND_LA_VALEUR 1
  i PREND_LA_VALEUR 1
  // nombre de couches
  LIRE N
  // convertit en nombre de branches
  N PREND_LA_VALEUR pow(2,N+1)-1
  msg PREND_LA_VALEUR N+" branches seront générées"
  AFFICHER* msg
  // extrémités du tronc
  Xdeb[1] PREND_LA_VALEUR 0
  Ydeb[1] PREND_LA_VALEUR 0
  Xfin[1] PREND_LA_VALEUR 0
  Yfin[1] PREND_LA_VALEUR 100
  TRACER_SEGMENT_Vert (Xdeb[1],Ydeb[1])->(Xfin[1],Yfin[1])
  // angle des branches en degrés
  LIRE alpha
  u PREND_LA_VALEUR cos(Math.PI*alpha/180)/3
  v PREND_LA_VALEUR sin(Math.PI*alpha/180)/3
  TANT_QUE (len(Xfin[len],Yfin[len])
    // nouvelle branche au 2/3 à +alpha
    len PREND_LA_VALEUR len+1
    Xdeb[len] PREND_LA_VALEUR (Xdeb[i] + 2*Xfin[i])/3
    Ydeb[len] PREND_LA_VALEUR (Ydeb[i] + 2*Yfin[i])/3
    Xfin[len] PREND_LA_VALEUR Xdeb[len] + (Xfin[i] - Xdeb[i])*u - (Yfin[i] - Ydeb[i])*v
    Yfin[len] PREND_LA_VALEUR Ydeb[len]  + (Xfin[i] - Xdeb[i])*v + (Yfin[i] - Ydeb[i])*u
    TRACER_SEGMENT_Vert (Xdeb[len],Ydeb[len])->(Xfin[len],Yfin[len])
    // branche suivante de la liste, à scinder
    i PREND_LA_VALEUR i+1
    FIN_TANT_QUE
FIN_ALGORITHME

Bonjour Eric1,
J'aurais aimé un arbre avec des branches à 90° (comme celui de votre précédent post).
Merci de prendre la peine de me répondre.

Bonjour mathafou,
Vous êtes incroyable, merci beaucoup!