Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2015-08-09T18:24:31+02:00Les derniers messages parus sur le forum de Zeste de Savoir.Challenge : Balancing words, message #689522015-08-09T18:24:31+02:00adri1/@adri1https://zestedesavoir.com/forums/sujet/3820/challenge-balancing-words/?page=1#p68952<blockquote>
<p>L'algorithme termine quand 1) gauche et droite ont même valeur (auquel cas c'est cool on a trouvé), 2) quand le curseur atteint la fin sans que gauche et droite soient égales.</p>
</blockquote>
<p>Tu peux plus simplement arrêter lorsque gauche est plus grande que droite. Pas besoin d'aller jusqu'au bout.</p>Challenge : Balancing words, message #689472015-08-09T17:51:54+02:00Idéophage/@Id%C3%A9ophagehttps://zestedesavoir.com/forums/sujet/3820/challenge-balancing-words/?page=1#p68947<p>@Algue-Rythme : on peut ne maintenir que la différence entre les poids à gauche et à droite. À chaque fois que l'on fait avancer le curseur, on enlève la somme des poids de toutes les lettres, <span>$s$</span>. Si la valeur initiale est <span>$k$</span>, on cherche <span>$i$</span> tel que <span>$k-is = 0$</span>. On peut voir cette solution sur reddit.</p>
<p>Une remarque sur ce que propose Berdes : c'est comme rechercher une valeur (0, la différence entre droite et gauche) dans un tableau 2d trié selon les deux coordonnées, sauf que l'on cherche la valeur sur la diagonale.</p>Challenge : Balancing words, message #689412015-08-09T14:38:16+02:00Algue-Rythme/@Algue-Rythmehttps://zestedesavoir.com/forums/sujet/3820/challenge-balancing-words/?page=1#p68941<blockquote>
<p>L'idée la plus intéressante est d'avoir deux curseurs (un à droite et un à gauche) et les poids associés.</p>
<p>Au début, tes curseurs sont sur les extrémités, par exemple sur <code>WRONGHEADED</code>, tu auras un curseur sur le <code>W</code> du début un un sur de <code>D</code> de la fin. Les poids initiaux sont nuls.</p>
<p>Ensuite, il faut faire avancer tes curseurs en mettant à jour les poids associés. On fait bien sûr avancer le curseur qui a le plus faible poids.</p>
<p>Tu as fini quand les deux curseurs sont sur la même lettre (la lettre central). Le mot est alors équilibré si les deux poids associés sont égaux. </p>
</blockquote>
<p>Malin ! J'ai une autre solution, mais elle est sûrement moins élégante, dans le doute je la poste quand même. </p>
<p>J'avais pensé à un unique curseur central, sur la lettre servant de balance, avec un poids à gauche (initialisé à 0), et un poids à droite initialisé à la valeur du mot correspondant à la première lettre comme pivot (valeur issu d'un pré-calcul). </p>
<p>Ensuite on ferait avancer le curseur central. On peut recalculer les valeurs <code>gauche</code> et <code>droite</code> de part et d'autre, mais on aurait alors du <span>$O(N^2)$</span>.<br>
Le mieux serait d'utiliser un tableau cumulatif (contenant les sommes partielles des indices des lettres), un en sens croissant, l'autre en sens décroissant, ça nous donnerait du <span>$O(N)$</span>.<br>
A chaque fois que le curseur avance on ajoute la valeur de la case courante du tableau cumulatif croissant à la variable <code>gauche</code> et on soustrait celle du tableau cumulatif décroissant à la variable <code>droite</code>.<br>
C'est une manière de se représenter le problème et de la comprendre. On peut gagner de l'espace mémoire, en constatant que chaque valeur du tableau cumulatif ne sera lue d'une fois, et donc qu'il est inutile de tout stocker à l'avance. On peut directement calculer la somme partielle "à la volée" avec 2 variables <code>cumulGauche</code> et <code>cumulDroite</code>. Une fois encore <code>cumulDroite</code> sera obtenue par soustractions successives de la somme totale, elle aussi obtenue par un précalcul.<br>
L'algorithme termine quand 1) <code>gauche</code>et <code>droite</code> ont même valeur (auquel cas c'est cool on a trouvé), 2) quand le curseur atteint la fin sans que <code>gauche</code>et <code>droite</code> soient égales. </p>Challenge : Balancing words, message #689342015-08-09T11:57:07+02:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/3820/challenge-balancing-words/?page=1#p68934<p>N'utilisant pas Ruby, je ne pourrais pas te donner d'indications au niveau de ton code. Mais si tu dis ne pas comprendre la logique derrière ton code, c'est certainement que tu n'as pas vraiment une idée précise de l'algorithme qui est à mettre en place. Face à ce genre d'exercices, si tu as des difficultés, essaies dans un premier temps d'écrire un algorithme en pseudo-langage. </p>
<p>Une fois que tu auras construit et testé ton algorithme, tu verras beaucoup plus clair. Tu n'auras plus qu'alors à l'implémenter en Ruby, étape par étape. Et si tu as correctement rédigé ton algorithme au préalable, ce ne sera qu'une partie de plaisir ! </p>
<p>Ce n'est qu'un détail, mais je pense qu'il peut quand même être relevé. Quand tu attribues chaque lettre à une valeur, tu n'as pas un moyen plus simple de procéder ? Encore une fois, n'utilisant pas Ruby, je ne sais pas ce qui se fait. Mais ça doit certainement exister.</p>
<p>Par exemple, avec Perl 6, ce serait tout simplement :</p>
<table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1</pre></div></td><td class="code"><div class="codehilite"><pre><span class="k">my</span> <span class="nv">@alphabet</span> <span class="o">=</span> <span class="s">'a'</span> <span class="o">...</span> <span class="s">'z'</span><span class="p">;</span>
</pre></div>
</td></tr></table>
<p>Il doit sûrement exister une syntaxe similaire en Ruby (?).</p>
<p>Edit : il existe en effet une syntaxe similaire en Ruby :</p>
<table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1</pre></div></td><td class="code"><div class="codehilite"><pre><span class="nb">puts</span> <span class="p">(</span><span class="s1">'a'</span><span class="o">..</span><span class="s1">'z'</span><span class="p">)</span><span class="o">.</span><span class="n">to_a</span><span class="p">;</span>
</pre></div>
</td></tr></table>Challenge : Balancing words, message #689232015-08-09T08:41:09+02:00Wizix/@Wizixhttps://zestedesavoir.com/forums/sujet/3820/challenge-balancing-words/?page=1#p68923<p>C'est assez complexe je trouve! <img alt=":D" src="/static/smileys/heureux.png"> </p>
<p>Bon, j'y arrive absolument pas, je ne comprend pas la logique derrière.. Voici ma fonction :</p>
<table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29</pre></div></td><td class="code"><div class="codehilite"><pre><span class="k">def</span> <span class="nf">balance_letter</span><span class="p">(</span><span class="n">word</span><span class="p">)</span>
<span class="n">left</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">right</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">i_left</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">i_right</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">reverse_word</span> <span class="o">=</span> <span class="n">word</span><span class="o">.</span><span class="n">reverse</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span>
<span class="n">word</span> <span class="o">=</span> <span class="n">word</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span>
<span class="kp">loop</span> <span class="k">do</span>
<span class="kp">loop</span> <span class="k">do</span>
<span class="n">left</span> <span class="o">+=</span> <span class="vg">$letters</span><span class="o">[</span><span class="n">word</span><span class="o">[</span><span class="n">i_left</span><span class="o">]]</span>
<span class="n">i_left</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">break</span> <span class="k">if</span> <span class="n">left</span> <span class="o">></span> <span class="n">right</span>
<span class="k">end</span>
<span class="kp">loop</span> <span class="k">do</span>
<span class="n">right</span> <span class="o">+=</span> <span class="vg">$letters</span><span class="o">[</span><span class="n">reverse_word</span><span class="o">[</span><span class="n">i_right</span><span class="o">]]</span>
<span class="n">i_right</span> <span class="o">+=</span> <span class="mi">1</span>
<span class="k">break</span> <span class="k">if</span> <span class="n">right</span> <span class="o">></span> <span class="n">left</span>
<span class="k">end</span>
<span class="k">break</span> <span class="k">if</span> <span class="n">i_left</span> <span class="o">>=</span> <span class="n">i_right</span>
<span class="k">end</span>
<span class="nb">puts</span> <span class="s2">"Côté gauche : </span><span class="si">#{</span><span class="n">left</span><span class="si">}</span><span class="s2">"</span>
<span class="nb">puts</span> <span class="s2">"Côté droit : </span><span class="si">#{</span><span class="n">right</span><span class="si">}</span><span class="s2">"</span>
<span class="k">end</span>
</pre></div>
</td></tr></table>
<p>Bon elle arrive à déterminer le poids de chaque côté, mais comment trouver la lettre du milieu ? Car si je fais une simple condition quand les deux poids sont égaux, le programme pourrait très bien s'arrêter avant… </p>
<p>Merci de ton aide, elle m'a mit sur la voie ! <img alt=":)" src="/static/smileys/smile.png"></p>
<p>EDIT : J'ai remarqué que j'avais oublié d'incrémenter mes curseurs. Maintenant ma fonction plante car elle dépasse la longueur des tableaux (celui des lettres du mot).</p>
<table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre>1
2
3
4
5
6
7</pre></div></td><td class="code"><div class="codehilite"><pre>balancing_word.rb:63:in `+': nil can't be coerced into Fixnum (TypeError)
from balancing_word.rb:63:in `block (2 levels) in balance_letter'
from balancing_word.rb:61:in `loop'
from balancing_word.rb:61:in `block in balance_letter'
from balancing_word.rb:53:in `loop'
from balancing_word.rb:53:in `balance_letter'
from balancing_word.rb:75:in `<main>'
</pre></div>
</td></tr></table>Challenge : Balancing words, message #689172015-08-09T00:07:42+02:00Berdes/@Berdeshttps://zestedesavoir.com/forums/sujet/3820/challenge-balancing-words/?page=1#p68917<p>L'idée la plus intéressante est d'avoir deux curseurs (un à droite et un à gauche) et les poids associés.</p>
<p>Au début, tes curseurs sont sur les extrémités, par exemple sur <code>WRONGHEADED</code>, tu auras un curseur sur le <code>W</code> du début un un sur de <code>D</code> de la fin. Les poids initiaux sont nuls.</p>
<p>Ensuite, il faut faire avancer tes curseurs en mettant à jour les poids associés. On fait bien sûr avancer le curseur qui a le plus faible poids.</p>
<p>Tu as fini quand les deux curseurs sont sur la même lettre (la lettre central). Le mot est alors équilibré si les deux poids associés sont égaux.</p>
<p>Je te laisse réfléchir sur la méthode qui doit permettre de mettre à jour les poids. Voici une petite aide si tu n'as pas du tout d'inspiration :</p>
<div class="spoiler">
<p>Le poids associé à un curseur doit être celui du côté associé au curseur (droite ou gauche) si celui-ci est la lettre centrale.</p>
</div>
<p>Edit : en regardant d'autres code, j'ai vu qu'il y avait d'autres solutions possibles. En revanche, en terme de complexité algorithmique, je ne pense pas que l'on puisse faire mieux que la première solution proposée.</p>Challenge : Balancing words, message #689082015-08-08T21:39:24+02:00Wizix/@Wizixhttps://zestedesavoir.com/forums/sujet/3820/challenge-balancing-words/?page=1#p68908<p>Bonjour,<br>
Je me suis mit au <em>dailyprogrammer</em> afin de m'améliorer en Ruby. Je suis actuellement sur le Challenge numéro 222 où le but est "d'équilibrer" un mot. Plus de détails <a href="http://www.reddit.com/r/dailyprogrammer/comments/3c9a9h/20150706_challenge_222_easy_balancing_words/">ici</a>. </p>
<p>Le truc, c'est que j'ai beau regarder les solutions des gens, je ne comprend pas comment faire pour trouver la lettre du milieu. Pourriez-vous m'expliquer ?</p>
<p>Voici où j'en suis dans mon code (oui, j'ai pas fait grand chose…) : </p>
<table class="codehilitetable"><tr><td class="linenos"><div class="linenodiv"><pre> 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43</pre></div></td><td class="code"><div class="codehilite"><pre><span class="c1">#!/usr/bin/env ruby</span>
<span class="c1"># encoding: utf-8</span>
<span class="c1"># Dailyprogrammer : Challenge #222 [Easy] Balancing Words</span>
<span class="c1"># http://www.reddit.com/r/dailyprogrammer/comments/3c9a9h/20150706_challenge_222_easy_balancing_words/</span>
<span class="vg">$letters</span> <span class="o">=</span> <span class="p">{</span><span class="s1">'a'</span> <span class="o">=></span> <span class="mi">1</span><span class="p">,</span>
<span class="s1">'b'</span> <span class="o">=></span> <span class="mi">2</span><span class="p">,</span>
<span class="s1">'c'</span> <span class="o">=></span> <span class="mi">3</span><span class="p">,</span>
<span class="s1">'d'</span> <span class="o">=></span> <span class="mi">4</span><span class="p">,</span>
<span class="s1">'e'</span> <span class="o">=></span> <span class="mi">5</span><span class="p">,</span>
<span class="s1">'f'</span> <span class="o">=></span> <span class="mi">6</span><span class="p">,</span>
<span class="s1">'g'</span> <span class="o">=></span> <span class="mi">7</span><span class="p">,</span>
<span class="s1">'h'</span> <span class="o">=></span> <span class="mi">8</span><span class="p">,</span>
<span class="s1">'i'</span> <span class="o">=></span> <span class="mi">9</span><span class="p">,</span>
<span class="s1">'j'</span> <span class="o">=></span> <span class="mi">10</span><span class="p">,</span>
<span class="s1">'k'</span> <span class="o">=></span> <span class="mi">11</span><span class="p">,</span>
<span class="s1">'l'</span> <span class="o">=></span> <span class="mi">12</span><span class="p">,</span>
<span class="s1">'m'</span> <span class="o">=></span> <span class="mi">13</span><span class="p">,</span>
<span class="s1">'n'</span> <span class="o">=></span> <span class="mi">14</span><span class="p">,</span>
<span class="s1">'o'</span> <span class="o">=></span> <span class="mi">15</span><span class="p">,</span>
<span class="s1">'p'</span> <span class="o">=></span> <span class="mi">16</span><span class="p">,</span>
<span class="s1">'q'</span> <span class="o">=></span> <span class="mi">17</span><span class="p">,</span>
<span class="s1">'r'</span> <span class="o">=></span> <span class="mi">18</span><span class="p">,</span>
<span class="s1">'s'</span> <span class="o">=></span> <span class="mi">19</span><span class="p">,</span>
<span class="s1">'t'</span> <span class="o">=></span> <span class="mi">20</span><span class="p">,</span>
<span class="s1">'u'</span> <span class="o">=></span> <span class="mi">21</span><span class="p">,</span>
<span class="s1">'v'</span> <span class="o">=></span> <span class="mi">22</span><span class="p">,</span>
<span class="s1">'w'</span> <span class="o">=></span> <span class="mi">23</span><span class="p">,</span>
<span class="s1">'x'</span> <span class="o">=></span> <span class="mi">24</span><span class="p">,</span>
<span class="s1">'y'</span> <span class="o">=></span> <span class="mi">25</span><span class="p">,</span>
<span class="s1">'z'</span> <span class="o">=></span> <span class="mi">26</span><span class="p">}</span>
<span class="k">def</span> <span class="nf">word_weight</span><span class="p">(</span><span class="n">word</span><span class="p">)</span>
<span class="n">weight</span> <span class="o">=</span> <span class="mi">0</span>
<span class="n">word</span><span class="o">.</span><span class="n">split</span><span class="p">(</span><span class="s1">''</span><span class="p">)</span><span class="o">.</span><span class="n">each</span> <span class="k">do</span> <span class="o">|</span><span class="n">letter</span><span class="o">|</span>
<span class="n">weight</span> <span class="o">+=</span> <span class="vg">$letters</span><span class="o">[</span><span class="n">letter</span><span class="o">]</span>
<span class="k">end</span>
<span class="n">weight</span>
<span class="k">end</span>
<span class="nb">puts</span> <span class="n">word_weight</span> <span class="s1">'stead'</span>
</pre></div>
</td></tr></table>
<p>Merci de votre aide!</p>