Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2023-02-27T15:29:24+01:00Les derniers messages parus sur le forum de Zeste de Savoir.Algorithme... en Lua, message #2493662023-02-27T15:29:24+01:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16838/algorithme-en-lua/?page=1#p249366<p>Hmm, tu réalises beaucoup d’opérations dans cette fonction, tu as d’une part la recherche des chunks elle-même, et tu as en plus une transformation non-triviale (dupliquée!) parce que tes chunks trimbalent des métadonnées.</p>
<p>Je serais toi, je garderais la fonction <code>get_chunks</code> telle que je l’ai écrite qui se contente de prendre un array et renvoyer la position et longueur des chunks, et <code>Pipe:getChunks</code> pourrait transformer le résultat de cette fonction pour ajouter les métadonnées. Ça t’évite de mélanger la logique de "chercher des chunks" avec celle qui consiste à "ajouter quelques métadonnées à chaque chunk". Cette dernière n’est alors plus dupliquée, et ton code gagne en lisibilité. Il est aussi plus facilement testable parce que tu peux écrire des tests pour chacune de ces deux logiques indépendamment.</p>Algorithme... en Lua, message #2493642023-02-27T15:08:27+01:00Tri-Opt/@Tri-Opthttps://zestedesavoir.com/forums/sujet/16838/algorithme-en-lua/?page=1#p249364<p>C’est en effet un bel algorithme ! J’aime beaucoup le fait que toutes les opérations (récupérer les sous-tableaux, calculer la position et la longueur, insérer le nouveau sous-tableau) sont réalisés en même temps. Cela rend le code bien plus propre et compréhensible. J’ai légèrement adapté celui-ci pour mon utilisation :</p>
<div class="hljs-code-div hljs-code-lua"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span><span data-count="29"></span></div><pre><code class="hljs language-lua"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">Pipe:getChunks</span><span class="hljs-params">()</span></span>
<span class="hljs-keyword">local</span> chunks = {}
<span class="hljs-keyword">local</span> currentIndex = <span class="hljs-literal">nil</span>
<span class="hljs-keyword">for</span> i, chunk <span class="hljs-keyword">in</span> <span class="hljs-built_in">ipairs</span>(<span class="hljs-built_in">self</span>.bitmap) <span class="hljs-keyword">do</span>
<span class="hljs-keyword">if</span> currentIndex <span class="hljs-keyword">and</span> chunk == <span class="hljs-number">0</span> <span class="hljs-keyword">then</span>
<span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(chunks, {
x = <span class="hljs-built_in">self</span>.x,
y = (currentIndex - <span class="hljs-number">1</span>) * <span class="hljs-built_in">self</span>.chunkHeight,
width = <span class="hljs-built_in">self</span>.width,
height = (i - currentIndex) * <span class="hljs-built_in">self</span>.chunkHeight
})
currentIndex = <span class="hljs-literal">nil</span>
<span class="hljs-keyword">elseif</span> (<span class="hljs-keyword">not</span> currentIndex) <span class="hljs-keyword">and</span> chunk == <span class="hljs-number">1</span> <span class="hljs-keyword">then</span>
currentIndex = i
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">if</span> currentIndex <span class="hljs-keyword">then</span>
<span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(chunks, {
x = <span class="hljs-built_in">self</span>.x,
y = (currentIndex - <span class="hljs-number">1</span>) * <span class="hljs-built_in">self</span>.chunkHeight,
width = <span class="hljs-built_in">self</span>.width,
height = (#<span class="hljs-built_in">self</span>.bitmap + <span class="hljs-number">1</span> - currentIndex) * <span class="hljs-built_in">self</span>.chunkHeight
})
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">return</span> chunks
<span class="hljs-keyword">end</span>
</code></pre></div>Algorithme... en Lua, message #2493312023-02-24T17:22:49+01:00adri1/@adri1https://zestedesavoir.com/forums/sujet/16838/algorithme-en-lua/?page=1#p249331<p>Salut,</p>
<p>Quelque chose de linéaire dans ce goût là serait beaucoup plus simple (et donc facile à écrire).</p>
<div class="hljs-code-div hljs-code-lua"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span></div><pre><code class="hljs language-lua"><span class="hljs-keyword">local</span> <span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">get_chunks</span><span class="hljs-params">(arr)</span></span>
<span class="hljs-keyword">local</span> chunks = {}
<span class="hljs-keyword">local</span> i0_current = <span class="hljs-literal">nil</span>
<span class="hljs-keyword">for</span> i, elt <span class="hljs-keyword">in</span> <span class="hljs-built_in">ipairs</span>(arr) <span class="hljs-keyword">do</span>
<span class="hljs-keyword">if</span> i0_current <span class="hljs-keyword">and</span> elt == <span class="hljs-number">0</span> <span class="hljs-keyword">then</span>
chunks[i0_current] = i - i0_current
i0_current = <span class="hljs-literal">nil</span>
<span class="hljs-keyword">elseif</span> (<span class="hljs-keyword">not</span> i0_current) <span class="hljs-keyword">and</span> elt == <span class="hljs-number">1</span> <span class="hljs-keyword">then</span>
i0_current = i
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">if</span> i0_current <span class="hljs-keyword">then</span>
chunks[i0_current] = #arr + <span class="hljs-number">1</span> - i0_current
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">return</span> chunks
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">for</span> k, v <span class="hljs-keyword">in</span> <span class="hljs-built_in">pairs</span>(get_chunks({ <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">1</span>, <span class="hljs-number">1</span>, <span class="hljs-number">0</span>, <span class="hljs-number">0</span>, <span class="hljs-number">1</span> })) <span class="hljs-keyword">do</span>
<span class="hljs-built_in">print</span>(k, v)
<span class="hljs-keyword">end</span>
</code></pre></div>
<p>Là je retourne <code>chunks</code> comme un mapping entre l’indice de départ et la longueur de chaque chunk, mais c’est facile à adapter au format que tu veux. Les indices commencent à <code>1</code> au lieu de <code>0</code> comme ton exemple suggère aussi, mais là encore c’est simple à adapter.</p>Algorithme... en Lua, message #2493262023-02-24T13:23:26+01:00Tri-Opt/@Tri-Opthttps://zestedesavoir.com/forums/sujet/16838/algorithme-en-lua/?page=1#p249326<p>Bonjour, j’essaye de m’améliorer en algorithmie et, alors que je réalise un petit jeu avec <a href="https://love2d.org/">LÖVE2D</a>, je suis confronté à l’exercice suivant :</p>
<p>Imaginez un tableau formé de <code>0</code> et de <code>1</code> (une bitmap à une dimension, techniquement) : <code>{1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1}</code>.</p>
<p>Comme vous pouvez le remarquer, en Lua, les tableaux utilisent des accolades, et non des crochets.</p>
<p>Je souhaiterais alors créer une fonction <code>getChunks()</code> (un <em>chunk</em> est un morceau de notre bitmap) :</p>
<ul>
<li>
<p>Récupérer les sous-tableaux formés de <code>1</code>, ici nous avons trois sous-tableaux : <code>{1, 1, 1}</code>, <code>{1, 1}</code> et <code>{1}</code></p>
</li>
<li>
<p>Retourner, pour chaque sous-tableau, un tableau comportant deux éléments :</p>
<ul>
<li>la position du premier élément du sous-tableau dans la bitmap ;</li>
<li>la longueur du sous-tableau.</li>
<li>dans notre exemple, on obtient : <code>{0, 3}</code>, <code>{7, 2}</code> et <code>{11, 1}</code>. C’est le <code>return</code> de notre fonction.</li>
</ul>
<p>Voici le code que j’ai écris :</p>
</li>
</ul>
<div class="hljs-code-div hljs-code-lua"><div class="hljs-line-numbers"><span data-count="1"></span><span data-count="2"></span><span data-count="3"></span><span data-count="4"></span><span data-count="5"></span><span data-count="6"></span><span data-count="7"></span><span data-count="8"></span><span data-count="9"></span><span data-count="10"></span><span data-count="11"></span><span data-count="12"></span><span data-count="13"></span><span data-count="14"></span><span data-count="15"></span><span data-count="16"></span><span data-count="17"></span><span data-count="18"></span><span data-count="19"></span><span data-count="20"></span><span data-count="21"></span><span data-count="22"></span><span data-count="23"></span><span data-count="24"></span><span data-count="25"></span><span data-count="26"></span><span data-count="27"></span><span data-count="28"></span></div><pre><code class="hljs language-lua"><span class="hljs-function"><span class="hljs-keyword">function</span> <span class="hljs-title">getChunks</span><span class="hljs-params">(bitmap)</span></span>
<span class="hljs-keyword">local</span> totalArr = {}
<span class="hljs-keyword">local</span> currentArr = {}
<span class="hljs-keyword">for</span> i, chunk <span class="hljs-keyword">in</span> <span class="hljs-built_in">ipairs</span>(bitmap) <span class="hljs-keyword">do</span>
<span class="hljs-keyword">if</span> chunk == <span class="hljs-number">1</span> <span class="hljs-keyword">then</span>
<span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(currentArr, i - <span class="hljs-number">1</span>) <span class="hljs-comment">-- en Lua, les indices des tableaux débutent par 1, et non par 0 !</span>
<span class="hljs-keyword">else</span>
<span class="hljs-keyword">if</span> currentArr ~= {} <span class="hljs-keyword">then</span>
<span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(totalArr, currentArr)
currentArr = {}
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">if</span> i == #bitmap <span class="hljs-keyword">then</span> <span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(totalArr, currentArr) <span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">local</span> chunks = {}
<span class="hljs-keyword">for</span> _, arr <span class="hljs-keyword">in</span> <span class="hljs-built_in">ipairs</span>(totalArr) <span class="hljs-keyword">do</span>
<span class="hljs-built_in">table</span>.<span class="hljs-built_in">insert</span>(chunks, {
pos = arr[<span class="hljs-number">1</span>]
length = #bitmap
})
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">return</span> chunks
<span class="hljs-keyword">end</span>
</code></pre></div>
<p>L’algorithme fonctionne pour les tableaux <code>{ 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 }</code> et <code>{ 1, 0, 1, 0, 1 }</code> mais pas pour <code>{1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1}</code>… <img src="/static/smileys/svg/pleure.svg" alt=":'(" class="smiley"> </p>
<p>De plus, comme vous avez pu le constater, le code est assez brutal et pas très subtil. Du coup, si vous avez une idée de comment écrire quelque chose de plus élégant (et de fonctionnel), je vous remercie d’avance.</p>Comment enfiler ses vêtements dans le bon ordre ?, message #2221402020-06-09T14:06:48+02:00Holosmos/@Holosmoshttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p222140<p>Bonjour,</p>
<p>La bêta du contenu « S’habiller dans le bon ordre grâce aux mathématiques » a été désactivée.</p>Comment enfiler ses vêtements dans le bon ordre ?, message #2203092020-05-06T03:07:53+02:00Looping/@Loopinghttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p220309<p>Sympa, ça me rappelle <a href="http://eljjdx.canalblog.com/archives/2014/02/23/29251687.html">cet article sur les noeuds de cravate. </a></p>Comment enfiler ses vêtements dans le bon ordre ?, message #2200632020-05-02T13:53:48+02:00Aabu/@Aabuhttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p220063<p>Bonjour les agrumes !</p>
<p>La bêta a été mise à jour et décante sa pulpe
à l’adresse suivante :</p>
<div class="align-center"><p> <a href="https://zestedesavoir.com/contenus/beta/3547/shabiller-dans-le-bon-ordre-grace-aux-mathematiques/">S’habiller dans le bon ordre grâce aux mathématiques</a> </p></div>
<p>Merci d’avance pour vos commentaires.</p>
<hr>
<p>J’ai fait quelques corrections, changements de vêtements et de nouvelles images plus abouties.</p>Comment enfiler ses vêtements dans le bon ordre ?, message #2200032020-05-01T13:17:35+02:00Aabu/@Aabuhttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p220003<p>Je pense que je ne vais pas en parler pour garder les choses simples, mais c’est vrai que c’est intéressant.</p>Comment enfiler ses vêtements dans le bon ordre ?, message #2200022020-05-01T13:15:09+02:00SpaceFox/@SpaceFoxhttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p220002<p>Au-delà de la blague, ça peut être un exemple pour montrer qu’un simple ajout d’une seule contrainte peut avoir des effets majeurs (connecter des graphes auparavant déconnectés, typiquement).</p>
<p>Je ne sais pas à quel point c’est dans le <em>scope</em> de ton tuto, mais c’est un problème d’optimisation assez classique en informatique : tu as deux composants qui fonctionnent très bien indépendamment, mais en les assemblant tu crées un couplage qui fait que ça explose, parce que tu ne tires pas <em>une</em> contrainte mais plein d’autres avec.</p>Comment enfiler ses vêtements dans le bon ordre ?, message #2200012020-05-01T13:11:57+02:00Aabu/@Aabuhttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p220001<blockquote>
<p>Note que si tu veux t’habiller de façon un peu formelle et donc rentrer ta chemise dans ton pantalon, il vaut mieux mettre la chemise avant la ceinture (et potentiellement avant le pantalon selon comment il est naturellement serré). Ça peut changer des trucs sur le graphe.</p>
</blockquote>
<p>Oui, mais je ne peux pas raisonnablement parler de toutes les manières de s’habiller. <img src="/static/smileys/heureux.png" alt=":D" class="smiley"> On peut aussi imaginer que les manteaux longs doivent toujours être mis en dernier.</p>Comment enfiler ses vêtements dans le bon ordre ?, message #2199992020-05-01T13:08:22+02:00SpaceFox/@SpaceFoxhttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p219999<p>Note que si tu veux t’habiller de façon un peu formelle et donc rentrer ta chemise dans ton pantalon, il vaut mieux mettre la chemise avant la ceinture (et potentiellement avant le pantalon selon comment il est naturellement serré). Ça peut changer des trucs sur le graphe.</p>Comment enfiler ses vêtements dans le bon ordre ?, message #2199952020-05-01T12:51:42+02:00Aabu/@Aabuhttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p219995<blockquote>
<p>Tout y est où tu as l’intention d’expliquer des outils de mesures/d’analyses ?</p>
</blockquote>
<p>Je suis pas sûr de comprendre. Tu penses à quoi en particulier ?</p>Comment enfiler ses vêtements dans le bon ordre ?, message #2199932020-05-01T12:19:19+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p219993<p><del>Ensuite, à la fin en contenu similaire, on pousse l’utilisateur vers une méthode d’ordonnancement de type MPM ou PERT</del></p>
<hr>
<p>Tout y est où tu as l’intention d’expliquer des outils de mesures/d’analyses ?</p>Comment enfiler ses vêtements dans le bon ordre ?, message #2199882020-05-01T11:00:23+02:00Aabu/@Aabuhttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p219988<p>Bonjour les agrumes !</p>
<p>La bêta a été mise à jour et décante sa pulpe
à l’adresse suivante :</p>
<div class="align-center"><p> <a href="https://zestedesavoir.com/contenus/beta/3547/shabiller-dans-le-bon-ordre-grace-aux-mathematiques/">S’habiller dans le bon ordre grâce aux mathématiques</a> </p></div>
<p>Merci d’avance pour vos commentaires.</p>
<hr>
<p>Merci pour tes remarques !</p>
<blockquote>
<ul>
<li>Peut-être donner un autre exemple de tri topologique puisque tu donnes exactement le même ordre (caleçon, pantalon, chaussettes, chaussures, chemise, veste, manteau) quand tu expliques ce qu’est un tri topologique et quand tu donnes l’algorithme pour le trouver. Expliquer que la solution n’est pas unique en quelque sorte.</li>
</ul>
</blockquote>
<p>Ok, j’ai rajouté un paragraphe.</p>
<blockquote>
<ul>
<li>Pourquoi simplifier le graphe ? C’est pas nécessaire pour l’algorithme si ?</li>
</ul>
</blockquote>
<p>Non, mais ça permet de parler de transitivité dans le graphe.</p>
<blockquote>
<ul>
<li>Peut-être dans l’algorithme de tri topologique indiquer pour 4 qu’on peut regarder seulement les sommets qui avaient une arrête qui pointait vers eux, voir reprendre le pseudo-code de l’algorithme de Kahn non ? Puis donner une intuition de la complexité de l’algo ?</li>
</ul>
</blockquote>
<p>Je préfère ne pas le faire, c’est trop subtil pour le niveau de l’article à mon avis.</p>
<figure><blockquote>
<ul>
<li>Peut-être ajouter tri topologique dans le titre, je sais pas si ça peut aider en terme de référencement par exemple (mais en tout cas c’est sûr que ça peut aider quand on recherche un tutoriel sur le tri topologique).</li>
</ul>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p219986">Jozifo</a></figcaption></figure>
<p>Bonne idée, j’ai changé le titre.</p>
<p><a href="/membres/voir/Melcore/" rel="nofollow" class="ping ping-link">@<span class="ping-username">Melcore</span></a> : tu vas être content.</p>Comment enfiler ses vêtements dans le bon ordre ?, message #2199862020-05-01T10:33:50+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p219986<p>Salut,</p>
<p>Mes remarques :</p>
<ul>
<li>
<p>Peut-être donner un autre exemple de tri topologique puisque tu donnes exactement le même ordre (caleçon, pantalon, chaussettes, chaussures, chemise, veste, manteau) quand tu expliques ce qu’est un tri topologique et quand tu donnes l’algorithme pour le trouver. Expliquer que la solution n’est pas unique en quelque sorte.</p>
</li>
<li>
<p>Pourquoi simplifier le graphe ? C’est pas nécessaire pour l’algorithme si ?</p>
</li>
<li>
<p>Peut-être dans l’algorithme de tri topologique indiquer pour 4 qu’on peut regarder seulement les sommets qui avaient une arrête qui pointait vers eux, voir reprendre le pseudo-code de l’algorithme de Kahn non ? Puis donner une intuition de la complexité de l’algo ?</p>
</li>
<li>
<p>Peut-être ajouter tri topologique dans le titre, je sais pas si ça peut aider en terme de référencement par exemple (mais en tout cas c’est sûr que ça peut aider quand on recherche un tutoriel sur le tri topologique).</p>
</li>
</ul>Comment enfiler ses vêtements dans le bon ordre ?, message #2199852020-05-01T09:24:45+02:00Aabu/@Aabuhttps://zestedesavoir.com/forums/sujet/14015/comment-enfiler-ses-vetements-dans-le-bon-ordre/?page=1#p219985<p>Tout le monde se secoue ! <img src="/static/smileys/heureux.png" alt=":D" class="smiley"></p>
<p>J’ai commencé (lundi 27 avril 2020 à 21h27) la rédaction d’un article au doux nom
de « Comment enfiler ses vêtements dans le bon ordre ? » et j’ai pour objectif de proposer en validation
un texte aux petits oignons. Je fais donc appel à votre bonté sans
limites pour dénicher le moindre pépin, que ce soit à propos
du fond ou de la forme. Vous pourrez consulter la bêta à votre guise à
l’adresse suivante :</p>
<div class="align-center"><p> <a href="https://zestedesavoir.com/contenus/beta/3547/comment-enfiler-ses-vetements-dans-le-bon-ordre/">À présent, c’est à vous !</a> </p></div>
<p>Merci !</p>
<hr>
<p>Article de vulgarisation mathématique portant sur les relations d’ordre, les graphes et le tri topologique, à l’aide de l’exemple des vêtements.</p>
<p>C’est assez avancé, donc tous types de retours sont les bienvenus !</p>Génération de données arborescentes avec une profondeur donnée, message #2142592020-01-22T08:34:25+01:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p214259<p>Salut,</p>
<p>Désolé pour le délai de réponse, je n’ai pas eu plus de temps que ça à reconsacrer à ce sujet.</p>
<p><a href="/membres/voir/Karnaj/" rel="nofollow" class="ping ping-link">@<span class="ping-username">Karnaj</span></a>, Effectivement il y a une relation de ce genre mais je ne suis pas sûr que ça me permette de trouver le x minimum pour D fixé.
Aussi comme dit ensuite, je ne pense finalement pas pouvoir faire quelque chose de ce x pour construire plus facilement mon arbre.</p>
<p><a href="/membres/voir/Berdes/" rel="nofollow" class="ping ping-link">@<span class="ping-username">Berdes</span></a>, En regardant de plus près la solution que tu proposes je remarque qu’elle s’axe sur des arbres binaires. Dans mon cas il n’y aurait pas nécessairement 2 enfants par nœud, le nombre d’enfant dépendant justement du nombre de nœuds voulu et de la profondeur.</p>
<p><a href="/membres/voir/fromvega/" rel="nofollow" class="ping ping-link">@<span class="ping-username">fromvega</span></a>, Merci, j’ai adapté le code vite-fait en Python et ça marche bien, bien plus performant que ma solution (environ 2000× plus rapide) !
J’ai encore quelques passes à faire dessus pour bien tout comprendre, mais c’est pile ce que je cherchais.</p>Génération de données arborescentes avec une profondeur donnée, message #2140082020-01-19T12:04:39+01:00fromvega/@fromvegahttps://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p214008<p>Salut,</p>
<p>Tu peux générer un arbre équilibré et de profondeur fixe en utilisant le nombre de fils maximum qu’un noeud peux avoir (le fameux x) et son corollaire le nombre de noeuds maximum dans un arbre de profondeur D.</p>
<p>J’ai fait un petit programme en Ruby (désolé je ne connais pas assez Python pour le faire de manière rapide). Il gère l’arbre de manière itérative, profondeur par profondeur en utilisant ces 2 variables (children_max et nodes_max dans ce programme).</p>
<p>A chaque itération le nombre de noeuds fils nécessaire est calculé en se basant sur le nombre de noeuds restant. Le nombre de groupes de noeuds fils comportant "children_max-1" noeuds et "children_max" noeuds est ensuite calculé, le nombre de noeuds correspondant est ensuite poussé dans l’arbre, représenté par un tableau donnant le parent de chaque noeud.</p>
<div class="hljs-code-div"><div class="hljs-line-numbers"><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span><span></span></div><pre><code class="hljs language-ruby"><span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">push_nodes</span><span class="hljs-params">(groups, children)</span></span>
groups.times <span class="hljs-keyword">do</span>
children.times <span class="hljs-keyword">do</span>
@tree.push(@parent_idx)
<span class="hljs-keyword">end</span>
@parent_idx += <span class="hljs-number">1</span>
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
<span class="hljs-function"><span class="hljs-keyword">def</span> <span class="hljs-title">fixed_depth_tree</span><span class="hljs-params">(depth, queued_nodes)</span></span>
<span class="hljs-comment"># Check arguments</span>
<span class="hljs-keyword">if</span> depth < <span class="hljs-number">1</span> <span class="hljs-params">||</span> depth > queued_nodes <span class="hljs-params">||</span> (depth == <span class="hljs-number">1</span> && queued_nodes > <span class="hljs-number">1</span>)
<span class="hljs-keyword">return</span>
<span class="hljs-keyword">end</span>
<span class="hljs-comment"># Compute maximum/minimum number of children per parent</span>
children_max = <span class="hljs-number">1</span>
nodes_max = depth
<span class="hljs-keyword">while</span> nodes_max < queued_nodes
children_max += <span class="hljs-number">1</span>
nodes_max = <span class="hljs-number">1</span>
children = children_max
(depth-<span class="hljs-number">1</span>).times <span class="hljs-keyword">do</span>
nodes_max += children
children *= children_max
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">end</span>
puts <span class="hljs-string">"ChildrenMax <span class="hljs-subst">#{children_max}</span>"</span>
children_min = children_max-<span class="hljs-number">1</span>
<span class="hljs-comment"># Generate tree</span>
@tree = Array.new.push(queued_nodes)
@parent_idx = <span class="hljs-number">0</span>
parent_nodes = <span class="hljs-number">1</span>
queued_nodes -= <span class="hljs-number">1</span>
nodes_max = (nodes_max-<span class="hljs-number">1</span>)/children_max
(depth-<span class="hljs-number">1</span>).times <span class="hljs-keyword">do</span>
child_nodes = queued_nodes/nodes_max
<span class="hljs-keyword">if</span> queued_nodes%nodes_max > <span class="hljs-number">0</span>
child_nodes += <span class="hljs-number">1</span>
<span class="hljs-keyword">end</span>
<span class="hljs-keyword">if</span> child_nodes < parent_nodes*children_min
child_nodes = parent_nodes*children_min
<span class="hljs-keyword">end</span>
groups_min = parent_nodes*children_max-child_nodes
groups_max = parent_nodes-groups_min
puts <span class="hljs-string">"GroupsMin <span class="hljs-subst">#{groups_min}</span> GroupsMax <span class="hljs-subst">#{groups_max}</span>"</span>
push_nodes(groups_min, children_min)
push_nodes(groups_max, children_max)
parent_nodes = child_nodes
queued_nodes -= parent_nodes
nodes_max = (nodes_max-<span class="hljs-number">1</span>)/children_max
<span class="hljs-keyword">end</span>
puts <span class="hljs-string">"Tree <span class="hljs-subst">#{@tree}</span>"</span>
<span class="hljs-keyword">end</span>
</code></pre></div>
<p>Le résultat est le suivant pour D=4 et N=20</p>
<div class="hljs-code-div"><div class="hljs-line-numbers"><span></span><span></span><span></span><span></span><span></span><span></span><span></span></div><pre><code class="hljs language-text"> ---- 0 ----
/ \
1 --- 2 -----
/ \ / | \
3 4 5 6 7
/ \ / \ / \ / | \ / | \
8 9 10 11 12 13 14 15 16 17 18 19
</code></pre></div>
<p>Les arbres générés "pencheront" légèrement vers la droite si tous les groupes de fils ne sont pas au maximum car ces groupes sont rajoutés en dernier. Il n’y a également que les noeuds au niveau le plus bas qui n’ont pas de fils.</p>
<p>En fait ce programme permet de créer une représentation "canonique" de l’arbre, caractérisé par les données suivantes (toujours pour D=4 et N=20)</p>
<div class="hljs-code-div"><div class="hljs-line-numbers"><span></span><span></span><span></span><span></span></div><pre><code class="hljs language-text">ChildrenMax 3
GroupsMin 1 GroupsMax 0
GroupsMin 1 GroupsMax 1
GroupsMin 3 GroupsMax 2
</code></pre></div>
<p>Je pense qu’il n’est pas vraiment nécessaire de générer l’arbre complet avec ce programme. On doit pouvoir déterminer le chemin pour accéder à un noeud quelconque en utilisant cette forme canonique, ce sera juste un peu plus compliqué j’essaierai de faire ça si j’ai un peu de temps.</p>
<p>Cela aurait l’avantage de pouvoir générer des arbres très grands facilement, la complexité dépendant alors de D et non plus de N.</p>
<p>EDIT: Le calcul de children_max pourrait être amélioré également, ici je l’incrémente à partir de 1 jusqu’à ce que la bonne valeur soit trouvée (>= N).</p>Génération de données arborescentes avec une profondeur donnée, message #2140022020-01-19T09:37:11+01:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p214002<figure><blockquote>
<p>Ok c’est plus clair ! Par contre on a toujours le droit de mettre des feuilles à profondeur quelconque ? Si oui, il y a encore une construction simple que tu vas probablement pas trouver satisfaisante : tu pars des noeuds <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><msub><mi>u</mi><mn>1</mn></msub><mo separator="true">,</mo><mo>…</mo><mo separator="true">,</mo><msub><mi>u</mi><mi>D</mi></msub></mrow><annotation encoding="application/x-tex">u_1, \ldots, u_D</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathdefault">u</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="minner">…</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathdefault">u</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32833099999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight" style="margin-right:0.02778em;">D</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span> de ta branche de gauche, et tu mets <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.03148em;">k</span></span></span></span></span> fils à <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><msub><mi>u</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">u_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">u</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span> pour <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>i</mi><mo>≤</mo><msub><mi>d</mi><mn>0</mn></msub></mrow><annotation encoding="application/x-tex">i\le d_0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.79549em;vertical-align:-0.13597em;"></span><span class="mord mathdefault">i</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span> et <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>k</mi><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">k+1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.77777em;vertical-align:-0.08333em;"></span><span class="mord mathdefault" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span></span> pour <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>i</mi><mo>></mo><msub><mi>d</mi><mn>0</mn></msub></mrow><annotation encoding="application/x-tex">i>d_0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69862em;vertical-align:-0.0391em;"></span><span class="mord mathdefault">i</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span>, et tous les autres sont des feuilles. <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.03148em;">k</span></span></span></span></span> et <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><msub><mi>d</mi><mn>0</mn></msub></mrow><annotation encoding="application/x-tex">d_0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span> s’expriment en termes de fonctions élémentaires de <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>D</mi></mrow><annotation encoding="application/x-tex">D</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">D</span></span></span></span></span> et <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>N</mi></mrow><annotation encoding="application/x-tex">N</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.10903em;">N</span></span></span></span></span>.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p213963">Lucas-84</a></figcaption></figure>
<p>J’ai du mal à visualiser ce que ça donnerait. Tu veux dire que seuls les nœuds de la branche de gauche auraient des enfants ?
Si c’est le cas je préférerais en effet que le nombre d’enfants par nœud soit plus équitablement réparti sur l’ensemble de l’arbre.</p>
<figure><blockquote>
<p>Et si c’est pas ce que tu veux, pourquoi dans ton premier exemple 7 n’est pas plutôt un fils de 9 ?</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p213963">Lucas-84</a></figcaption></figure>
<p>Mon algorithme actuel fonctionne ainsi, il construit l’arbre itérativement, en rajoutant chaque nœud <code>i</code> sur l’arbre généré pour <code>n=i-1</code>.
Donc au moment d’ajouter le nœud 7, il n’existe dans l’arbre que ceux de 0 à 6, et 5 est le nœud le plus bas dans l’arbre qui ne possède qu’un enfant, donc il est sélectionné comme parent.</p>
<figure><blockquote>
<p>Pour l’instant, je vois pas trop ce que tu comptes faire avec ton x (par ailleurs, il n’y a pas de formule directe pour retrouver x, mais l’espace des x intéressants est de taille <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mi>N</mi><mrow><mn>1</mn><mi mathvariant="normal">/</mi><mi>D</mi></mrow></msup></mrow><annotation encoding="application/x-tex">N^{1/D}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8879999999999999em;vertical-align:0em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.10903em;">N</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8879999999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span><span class="mord mtight">/</span><span class="mord mathdefault mtight" style="margin-right:0.02778em;">D</span></span></span></span></span></span></span></span></span></span></span></span></span>, donc avec une dichotomie ça prend <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>log</mi><mo></mo><mo>(</mo><mi>N</mi><mo>)</mo><mi mathvariant="normal">/</mi><mi>D</mi></mrow><annotation encoding="application/x-tex">\log(N)/D</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mop">lo<span style="margin-right:0.01389em;">g</span></span><span class="mopen">(</span><span class="mord mathdefault" style="margin-right:0.10903em;">N</span><span class="mclose">)</span><span class="mord">/</span><span class="mord mathdefault" style="margin-right:0.02778em;">D</span></span></span></span></span> de trouver le bon).</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p213963">Lucas-84</a></figcaption></figure>
<p>Je me dis qu’en connaissant <strong>x</strong> je pourrais simplement considérer que chaque nœud <strong>i</strong> a pour parent <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mo fence="true">⌊</mo><mfrac><mrow><mi>i</mi><mo>−</mo><mn>1</mn></mrow><mi>x</mi></mfrac><mo fence="true">⌋</mo></mrow><annotation encoding="application/x-tex">\left\lfloor \frac{i-1}{x} \right\rfloor</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.205674em;vertical-align:-0.35001em;"></span><span class="minner"><span class="mopen delimcenter" style="top:0em;"><span class="delimsizing size1">⌊</span></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.855664em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">x</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.394em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mathdefault mtight">i</span><span class="mbin mtight">−</span><span class="mord mtight">1</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose delimcenter" style="top:0em;"><span class="delimsizing size1">⌋</span></span></span></span></span></span></span> et que ce serait une manière comme une autre d’équilibrer (différente de mon algo actuel mais qui semble satisfaisante).</p>
<p>Edit : En fait en y repensant pas du tout, pour <code>D=4, N=5</code> ça partirait sur une structure à 2 enfants par nœud et ne me construirait un arbre qui n’aurait que 3 niveaux de profondeur alors que 4 auraient été possibles.<br>
Je vais en effet plutôt voir pour améliorer mon algo existant et éviter de trop me prendre la tête avec ça.</p>Génération de données arborescentes avec une profondeur donnée, message #2139632020-01-18T15:42:32+01:00Lucas-84/@Lucas-84https://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p213963<p>Ok c’est plus clair ! Par contre on a toujours le droit de mettre des feuilles à profondeur quelconque ? Si oui, il y a encore une construction simple que tu vas probablement pas trouver satisfaisante : tu pars des noeuds <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><msub><mi>u</mi><mn>1</mn></msub><mo separator="true">,</mo><mo>…</mo><mo separator="true">,</mo><msub><mi>u</mi><mi>D</mi></msub></mrow><annotation encoding="application/x-tex">u_1, \ldots, u_D</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.625em;vertical-align:-0.19444em;"></span><span class="mord"><span class="mord mathdefault">u</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">1</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="minner">…</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mpunct">,</span><span class="mspace" style="margin-right:0.16666666666666666em;"></span><span class="mord"><span class="mord mathdefault">u</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.32833099999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight" style="margin-right:0.02778em;">D</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span> de ta branche de gauche, et tu mets <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.03148em;">k</span></span></span></span></span> fils à <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><msub><mi>u</mi><mi>i</mi></msub></mrow><annotation encoding="application/x-tex">u_i</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.58056em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">u</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.31166399999999994em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">i</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span> pour <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>i</mi><mo>≤</mo><msub><mi>d</mi><mn>0</mn></msub></mrow><annotation encoding="application/x-tex">i\le d_0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.79549em;vertical-align:-0.13597em;"></span><span class="mord mathdefault">i</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">≤</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span> et <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>k</mi><mo>+</mo><mn>1</mn></mrow><annotation encoding="application/x-tex">k+1</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.77777em;vertical-align:-0.08333em;"></span><span class="mord mathdefault" style="margin-right:0.03148em;">k</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">+</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">1</span></span></span></span></span> pour <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>i</mi><mo>></mo><msub><mi>d</mi><mn>0</mn></msub></mrow><annotation encoding="application/x-tex">i>d_0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69862em;vertical-align:-0.0391em;"></span><span class="mord mathdefault">i</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span>, et tous les autres sont des feuilles. <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>k</mi></mrow><annotation encoding="application/x-tex">k</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.69444em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.03148em;">k</span></span></span></span></span> et <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><msub><mi>d</mi><mn>0</mn></msub></mrow><annotation encoding="application/x-tex">d_0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.84444em;vertical-align:-0.15em;"></span><span class="mord"><span class="mord mathdefault">d</span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.30110799999999993em;"><span style="top:-2.5500000000000003em;margin-left:0em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight">0</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.15em;"><span></span></span></span></span></span></span></span></span></span></span> s’expriment en termes de fonctions élémentaires de <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>D</mi></mrow><annotation encoding="application/x-tex">D</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">D</span></span></span></span></span> et <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>N</mi></mrow><annotation encoding="application/x-tex">N</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.10903em;">N</span></span></span></span></span>.</p>
<p>Et si c’est pas ce que tu veux, pourquoi dans ton premier exemple 7 n’est pas plutôt un fils de 9 ?</p>
<p>En tout cas, l’algo de ton premier message me paraît maintenant beaucoup plus naturel. Tu devrais le rendre linéaire en temps en stockant une pile pour chaque degré possible (dans la liste des priorités, c’est quand même avant de se débarrasser des pointeurs vers le parent). </p>
<hr>
<p>Pour l’instant, je vois pas trop ce que tu comptes faire avec ton x (par ailleurs, il n’y a pas de formule directe pour retrouver x, mais l’espace des x intéressants est de taille <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><msup><mi>N</mi><mrow><mn>1</mn><mi mathvariant="normal">/</mi><mi>D</mi></mrow></msup></mrow><annotation encoding="application/x-tex">N^{1/D}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.8879999999999999em;vertical-align:0em;"></span><span class="mord"><span class="mord mathdefault" style="margin-right:0.10903em;">N</span><span class="msupsub"><span class="vlist-t"><span class="vlist-r"><span class="vlist" style="height:0.8879999999999999em;"><span style="top:-3.063em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">1</span><span class="mord mtight">/</span><span class="mord mathdefault mtight" style="margin-right:0.02778em;">D</span></span></span></span></span></span></span></span></span></span></span></span></span>, donc avec une dichotomie ça prend <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>log</mi><mo></mo><mo>(</mo><mi>N</mi><mo>)</mo><mi mathvariant="normal">/</mi><mi>D</mi></mrow><annotation encoding="application/x-tex">\log(N)/D</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mop">lo<span style="margin-right:0.01389em;">g</span></span><span class="mopen">(</span><span class="mord mathdefault" style="margin-right:0.10903em;">N</span><span class="mclose">)</span><span class="mord">/</span><span class="mord mathdefault" style="margin-right:0.02778em;">D</span></span></span></span></span> de trouver le bon).</p>Génération de données arborescentes avec une profondeur donnée, message #2139532020-01-18T10:18:16+01:00entwanne/@entwannehttps://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p213953<figure><blockquote>
<p>EDIT : on a sûrement un truc du genre <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>D</mi><mo>=</mo><mo>⌊</mo><msub><mi>log</mi><mo></mo><mi>x</mi></msub><mo>(</mo><mo>(</mo><mi>x</mi><mo>−</mo><mn>1</mn><mo>)</mo><mi>N</mi><mo>)</mo><mo>⌋</mo></mrow><annotation encoding="application/x-tex">D = \lfloor \log_x ( (x - 1) N) \rfloor</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">D</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mopen">⌊</span><span class="mop"><span class="mop">lo<span style="margin-right:0.01389em;">g</span></span><span class="msupsub"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.057252em;"><span style="top:-2.4558600000000004em;margin-right:0.05em;"><span class="pstrut" style="height:2.7em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mathdefault mtight">x</span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.24414em;"><span></span></span></span></span></span></span><span class="mopen">(</span><span class="mopen">(</span><span class="mord mathdefault">x</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span><span class="mbin">−</span><span class="mspace" style="margin-right:0.2222222222222222em;"></span></span><span class="base"><span class="strut" style="height:1em;vertical-align:-0.25em;"></span><span class="mord">1</span><span class="mclose">)</span><span class="mord mathdefault" style="margin-right:0.10903em;">N</span><span class="mclose">)</span><span class="mclose">⌋</span></span></span></span></span>, ce qui permet de trouver <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>x</mi></mrow><annotation encoding="application/x-tex">x</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.43056em;vertical-align:0em;"></span><span class="mord mathdefault">x</span></span></span></span></span> en passant à l’exponentielle.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p213933">Karnaj</a></figcaption></figure>
<p>En effet, je vais voir ce que je peux en tirer, merci.
Une fois ce x obtenu je pense pouvoir me débrouiller pour la suite, oui.</p>
<figure><blockquote>
<p>Pour éviter les cas particuliers, il faut aussi corriger la profondeur demandé si elle est trop faible pour que l’arbre contienne assez de nœuds. Vu que l’on peut avoir <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mfrac><mrow><mo>(</mo><mi>D</mi><mo>+</mo><mn>1</mn><mo>)</mo><mo>(</mo><mi>D</mi><mo>+</mo><mn>2</mn><mo>)</mo></mrow><mn>2</mn></mfrac></mrow><annotation encoding="application/x-tex">\frac{(D+1)(D+2)}{2}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:1.355em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.01em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.485em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mopen mtight">(</span><span class="mord mathdefault mtight" style="margin-right:0.02778em;">D</span><span class="mbin mtight">+</span><span class="mord mtight">1</span><span class="mclose mtight">)</span><span class="mopen mtight">(</span><span class="mord mathdefault mtight" style="margin-right:0.02778em;">D</span><span class="mbin mtight">+</span><span class="mord mtight">2</span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span> nœuds dans un arbre de profondeur D (en utilisant <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>D</mi><mo>=</mo><mn>0</mn></mrow><annotation encoding="application/x-tex">D=0</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">D</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:0.64444em;vertical-align:0em;"></span><span class="mord">0</span></span></span></span></span> lorsque la racine est seule), si <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>N</mi><mo>></mo><mfrac><mrow><mo>(</mo><mi>D</mi><mo>+</mo><mn>1</mn><mo>)</mo><mo>(</mo><mi>D</mi><mo>+</mo><mn>2</mn><mo>)</mo></mrow><mn>2</mn></mfrac></mrow><annotation encoding="application/x-tex">N > \frac{(D+1)(D+2)}{2}</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.72243em;vertical-align:-0.0391em;"></span><span class="mord mathdefault" style="margin-right:0.10903em;">N</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">></span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1.355em;vertical-align:-0.345em;"></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.01em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.485em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mopen mtight">(</span><span class="mord mathdefault mtight" style="margin-right:0.02778em;">D</span><span class="mbin mtight">+</span><span class="mord mtight">1</span><span class="mclose mtight">)</span><span class="mopen mtight">(</span><span class="mord mathdefault mtight" style="margin-right:0.02778em;">D</span><span class="mbin mtight">+</span><span class="mord mtight">2</span><span class="mclose mtight">)</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span></span></span></span></span>, alors il faut augmenter <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>D</mi></mrow><annotation encoding="application/x-tex">D</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">D</span></span></span></span></span> pour avoir <span class="inlineMath"><span class="katex"><span class="katex-mathml"><math><semantics><mrow><mi>D</mi><mo>=</mo><mrow><mo fence="true">⌈</mo><mfrac><mrow><msqrt><mrow><mn>8</mn><mi>n</mi><mo>+</mo><mn>1</mn></mrow></msqrt><mo>−</mo><mn>3</mn></mrow><mn>2</mn></mfrac><mo fence="true">⌉</mo></mrow></mrow><annotation encoding="application/x-tex">D = \left\lceil\frac{\sqrt{8n + 1} - 3}{2}\right\rceil</annotation></semantics></math></span><span class="katex-html" aria-hidden="true"><span class="base"><span class="strut" style="height:0.68333em;vertical-align:0em;"></span><span class="mord mathdefault" style="margin-right:0.02778em;">D</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span><span class="mrel">=</span><span class="mspace" style="margin-right:0.2777777777777778em;"></span></span><span class="base"><span class="strut" style="height:1.80002em;vertical-align:-0.65002em;"></span><span class="minner"><span class="mopen delimcenter" style="top:0em;"><span class="delimsizing size2">⌈</span></span><span class="mord"><span class="mopen nulldelimiter"></span><span class="mfrac"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:1.038em;"><span style="top:-2.6550000000000002em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord mtight">2</span></span></span></span><span style="top:-3.23em;"><span class="pstrut" style="height:3em;"></span><span class="frac-line" style="border-bottom-width:0.04em;"></span></span><span style="top:-3.428174em;"><span class="pstrut" style="height:3em;"></span><span class="sizing reset-size6 size3 mtight"><span class="mord mtight"><span class="mord sqrt mtight"><span class="vlist-t vlist-t2"><span class="vlist-r"><span class="vlist" style="height:0.8711800000000001em;"><span class="svg-align" style="top:-3em;"><span class="pstrut" style="height:3em;"></span><span class="mord mtight" style="padding-left:0.833em;"><span class="mord mtight">8</span><span class="mord mathdefault mtight">n</span><span class="mbin mtight">+</span><span class="mord mtight">1</span></span></span><span style="top:-2.83118em;"><span class="pstrut" style="height:3em;"></span><span class="hide-tail mtight" style="min-width:0.853em;height:1.08em;"><svg width="400em" height="1.08em" viewBox="0 0 400000 1080" preserveAspectRatio="xMinYMin slice"><path d="M95,702c-2.7,0,-7.17,-2.7,-13.5,-8c-5.8,-5.3,-9.5,
-10,-9.5,-14c0,-2,0.3,-3.3,1,-4c1.3,-2.7,23.83,-20.7,67.5,-54c44.2,-33.3,65.8,
-50.3,66.5,-51c1.3,-1.3,3,-2,5,-2c4.7,0,8.7,3.3,12,10s173,378,173,378c0.7,0,
35.3,-71,104,-213c68.7,-142,137.5,-285,206.5,-429c69,-144,104.5,-217.7,106.5,
-221c5.3,-9.3,12,-14,20,-14H400000v40H845.2724s-225.272,467,-225.272,467
s-235,486,-235,486c-2.7,4.7,-9,7,-19,7c-6,0,-10,-1,-12,-3s-194,-422,-194,-422
s-65,47,-65,47z M834 80H400000v40H845z"></path></svg></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.16881999999999997em;"><span></span></span></span></span></span><span class="mbin mtight">−</span><span class="mord mtight">3</span></span></span></span></span><span class="vlist-s"></span></span><span class="vlist-r"><span class="vlist" style="height:0.345em;"><span></span></span></span></span></span><span class="mclose nulldelimiter"></span></span><span class="mclose delimcenter" style="top:0em;"><span class="delimsizing size2">⌉</span></span></span></span></span></span></span>.</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p213935">Berdes</a></figcaption></figure>
<p>Merci pour l’idée, j’essaierai ça aussi.</p>
<p>Par contre je ne comprends pas pourquoi il y aurait une limite sur le nombre de nœuds dans l’arbre (hors cas où D = 1 volontairement exclus). Le nombre d’enfants par nœud n’est pas limité.</p>
<figure><blockquote>
<p>Je comprends pas pourquoi vos algos sont aussi compliqués. Sans aucune condition supplémentaire, j’ai le droit de mettre une branche à gauche et de relier tous les autres noeuds à la racine, non ?</p>
<p>[…]</p>
<p>Voilà, j’ai un arbre à N noeuds de hauteur D !? Si il y a en plus une condition d’équilibrage, il faut préciser exactement ce qu’on veut (équilibrer les niveaux ? seulement les premiers ? le degré des noeuds ? etc.)</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p213938">Lucas-84</a></figcaption></figure>
<p>Merci pour ta réponse.
En effet je cherche à ce que l’arbre soit équilibré, qu’on ne commence pas à ajouter de 4<sup>ème</sup> enfant si tous les autres nœuds n’en ont pas déjà 3 par exemple (hors nœuds du D<sup>ème</sup> niveau qui n’auront jamais d’enfants).<br>
Mais il n’y aurait pas d’ordre particulier sur quels nœuds équilibrer en premier.</p>
<p>Il faudrait juste que pour <code>N=15, D=4</code> on ait un arbre de 4 niveaux où chaque parent a 2 enfants, pour <code>N=40, D=4</code> la même chose avec 3 enfants par parent, etc.<br>
Entre <code>N=16</code> et <code>N=39</code> (compris), on aurait des parents avec 2 enfants et d’autres avec 3, peu importe lesquels, mais jamais plus ni moins (et jamais plus de 4 niveaux).</p>
<figure><blockquote>
<p>Je comprends pas non plus pourquoi « l’empreinte mémoire » (qui est linéaire ici) est un problème si important. Si on fait des représentations en i/2 pour les tas, c’est parce que ça simplifie un peu le code, mais si tes arbres ne sont plus complets, c’est pas une optimisation rentable (à moins que tu travailles avec des données gigantesques, mais j’en doute fort vu le choix très peu optimal de représenter un noeud dans l’arbre par son chemin à la racine).</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p213938">Lucas-84</a></figcaption></figure>
<p>Ce n’est pas une contrainte forte mais ce serait pour moi un plus.
J’utilise ici le chemin pour illustrer (et pour le debug parce que c’est plus lisible), mais je n’ai en réalité besoin que de l’identifiant du parent.
Identifiant qui peut être numérique et donc ne pas nécessiter d’être stocké dans une liste (simplement recalculé à partir de l’identifiant de l’enfant).</p>
<figure><blockquote>
<p>Une question sans doute plus difficile : comment générer uniformément aléatoirement un arbre à N noeuds de hauteur D en minimisant le nombre de bits aléatoires utilisés ?</p>
</blockquote><figcaption><a href="https://zestedesavoir.com/forums/sujet/13507/generation-de-donnees-arborescentes-avec-une-profondeur-donnee/?page=1#p213938">Lucas-84</a></figcaption></figure>
<p>Je ne me suis pas intéressé ici à la génération aléatoire, ce sera peut-être une amélioration future. <img src="/static/smileys/heureux.png" alt=":D" class="smiley"></p>