Derniers messages sur Zeste de Savoirhttps://zestedesavoir.com/forums/2016-12-26T07:18:41+01:00Les derniers messages parus sur le forum de Zeste de Savoir.Le « Plus / Moins » le plus horrible du siècle !, message #1365052016-12-26T07:18:41+01:00Elried/@Elriedhttps://zestedesavoir.com/forums/sujet/3909/le-plus-moins-le-plus-horrible-du-siecle/?page=4#p136505<p>Voici une modeste contribution en C++ (ça doit être faisable en C en changeant les fonctions d’input et de random).</p>
<p>Le concept est simple, pourquoi faire soit même ce qu’un autre programme peut faire pour nous? Et si un programme pour générer un nombre aléatoire n’existe pas, créons le nous même… Bref, plutôt que de faire le travail lui même, ce programme code (littéralement) un autre programme qui le fera a sa place. C’est moche, c’est lent, mais ça marche (en tout cas sous Linux avec mon gcc 5.4).</p>
<p>Vous noterez les horribles appels a <code>system</code> et la communication qui se fait via les return de main a grand coup de <code>WEXITSTATUS</code>…</p>
<p>Sans plus attendre, le code :</p>
<div class="spoiler">
<div><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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="cp">#include</span> <span class="cpf"><fstream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><iostream></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><string></span><span class="cp"></span>
<span class="kt">int</span> <span class="nf">get_random_number</span><span class="p">(</span><span class="kt">int</span> <span class="n">min</span><span class="p">,</span> <span class="kt">int</span> <span class="n">max</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">ofstream</span> <span class="n">output</span><span class="p">(</span><span class="s">"get_random_number.cpp"</span><span class="p">);</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"#include<random></span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"int main(){</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"std::random_device rd;</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"std::mt19937 gen(rd());</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"std::uniform_int_distribution<> dis("</span> <span class="o"><<</span> <span class="n">min</span> <span class="o"><<</span> <span class="s">","</span> <span class="o"><<</span> <span class="n">max</span> <span class="o"><<</span> <span class="s">");</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"return dis(gen);</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"}"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">output</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="n">system</span><span class="p">(</span><span class="s">"g++ -std=c++11 -o random_gen get_random_number.cpp"</span><span class="p">);</span>
<span class="kt">int</span> <span class="n">ret_value</span> <span class="o">=</span> <span class="n">system</span><span class="p">(</span><span class="s">"./random_gen"</span><span class="p">);</span>
<span class="n">system</span><span class="p">(</span><span class="s">"rm ./random_gen"</span><span class="p">);</span>
<span class="n">system</span><span class="p">(</span><span class="s">"rm get_random_number.cpp"</span><span class="p">);</span>
<span class="k">return</span> <span class="n">WEXITSTATUS</span><span class="p">(</span><span class="n">ret_value</span><span class="p">);</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="nf">print_message</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="k">const</span> <span class="o">&</span><span class="n">message</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">std</span><span class="o">::</span><span class="n">ofstream</span> <span class="n">output</span><span class="p">(</span><span class="s">"print_message.cpp"</span><span class="p">);</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"#include<iostream></span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"int main(){</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"std::cout <<</span><span class="se">\"</span><span class="s">"</span> <span class="o"><<</span> <span class="n">message</span> <span class="o"><<</span> <span class="s">"</span><span class="se">\"</span><span class="s"><<std::endl;</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"return 0;</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"}"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">output</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="n">system</span><span class="p">(</span><span class="s">"g++ -std=c++11 -o print_message print_message.cpp"</span><span class="p">);</span>
<span class="kt">int</span> <span class="n">ret_value</span> <span class="o">=</span> <span class="n">system</span><span class="p">(</span><span class="s">"./print_message"</span><span class="p">);</span>
<span class="n">system</span><span class="p">(</span><span class="s">"rm ./print_message"</span><span class="p">);</span>
<span class="n">system</span><span class="p">(</span><span class="s">"rm print_message.cpp"</span><span class="p">);</span>
<span class="k">return</span> <span class="n">WEXITSTATUS</span><span class="p">(</span><span class="n">ret_value</span><span class="p">);</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="nf">get_user_input</span><span class="p">(</span><span class="n">std</span><span class="o">::</span><span class="n">string</span> <span class="k">const</span> <span class="o">&</span><span class="n">message</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">print_message</span><span class="p">(</span><span class="n">message</span><span class="p">);</span>
<span class="n">std</span><span class="o">::</span><span class="n">ofstream</span> <span class="n">output</span><span class="p">(</span><span class="s">"get_user_input.cpp"</span><span class="p">);</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"#include<iostream></span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"int main(){</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"int input = 0;</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"std::cin >> input;</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"return input;</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span>
<span class="n">output</span> <span class="o"><<</span> <span class="s">"}"</span> <span class="o"><<</span> <span class="n">std</span><span class="o">::</span><span class="n">endl</span><span class="p">;</span>
<span class="n">output</span><span class="p">.</span><span class="n">close</span><span class="p">();</span>
<span class="n">system</span><span class="p">(</span><span class="s">"g++ -std=c++11 -o user_input get_user_input.cpp"</span><span class="p">);</span>
<span class="kt">int</span> <span class="n">ret_value</span> <span class="o">=</span> <span class="n">system</span><span class="p">(</span><span class="s">"./user_input"</span><span class="p">);</span>
<span class="n">system</span><span class="p">(</span><span class="s">"rm ./user_input"</span><span class="p">);</span>
<span class="n">system</span><span class="p">(</span><span class="s">"rm get_user_input.cpp"</span><span class="p">);</span>
<span class="k">return</span> <span class="n">WEXITSTATUS</span><span class="p">(</span><span class="n">ret_value</span><span class="p">);</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">()</span>
<span class="p">{</span>
<span class="kt">bool</span> <span class="n">rejouer</span> <span class="o">=</span> <span class="nb">false</span><span class="p">;</span>
<span class="k">do</span>
<span class="p">{</span>
<span class="kt">int</span> <span class="n">number</span> <span class="o">=</span> <span class="n">get_random_number</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">100</span><span class="p">);</span>
<span class="n">print_message</span><span class="p">(</span><span class="s">"Devinez le nombre mystere (entre 0 et 100)"</span><span class="p">);</span>
<span class="kt">int</span> <span class="n">res</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">do</span>
<span class="p">{</span>
<span class="n">res</span> <span class="o">=</span> <span class="n">get_user_input</span><span class="p">(</span><span class="s">"Votre proposition?"</span><span class="p">);</span>
<span class="k">if</span><span class="p">(</span><span class="n">res</span> <span class="o">></span> <span class="n">number</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">print_message</span><span class="p">(</span><span class="s">"Un peu trop haut"</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">else</span> <span class="k">if</span><span class="p">(</span><span class="n">res</span> <span class="o"><</span> <span class="n">number</span><span class="p">)</span>
<span class="p">{</span>
<span class="n">print_message</span><span class="p">(</span><span class="s">"Un peu trop bas"</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">while</span><span class="p">(</span><span class="n">res</span> <span class="o">!=</span> <span class="n">number</span><span class="p">);</span>
<span class="n">print_message</span><span class="p">(</span><span class="s">"Bravo!"</span><span class="p">);</span>
<span class="n">rejouer</span> <span class="o">=</span> <span class="n">get_user_input</span><span class="p">(</span><span class="s">"Rejouer? (1 pour oui, autre chose pour non"</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">while</span><span class="p">(</span><span class="n">rejouer</span><span class="p">);</span>
<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
</td></tr></table></div>
</div>
<p>Ah oui, en plus du procédé douteux, le code a été fait a l’arrache et risque de faire preuve de mauvaises pratiques… Mais bon…</p>Le « Plus / Moins » le plus horrible du siècle !, message #1364842016-12-25T16:08:06+01:00anonyme/@anonymehttps://zestedesavoir.com/forums/sujet/3909/le-plus-moins-le-plus-horrible-du-siecle/?page=4#p136484<p>Hello,</p>
<p>Je déterre un peu, mais je viens de faire une version en Vala.</p>
<div class="spoiler">
<div><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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="kn">using</span> <span class="nn">GLib</span><span class="p">;</span>
<span class="cm">/* Textes du jeu</span>
<span class="cm">Plus</span>
<span class="cm">Moins</span>
<span class="cm">Gagné</span>
<span class="cm">*/</span>
<span class="kn">namespace</span> <span class="nn">PlusOuMoins</span> <span class="p">{</span>
<span class="kd">public</span> <span class="k">enum</span> <span class="n">Resultat</span> <span class="p">{</span>
<span class="n">PLUS</span><span class="p">,</span>
<span class="n">MOINS</span><span class="p">,</span>
<span class="n">GAGNE</span><span class="p">;</span>
<span class="kd">public</span> <span class="kt">string</span> <span class="n">foo</span> <span class="p">()</span> <span class="p">{</span>
<span class="kt">string</span> <span class="n">bar</span><span class="p">;</span>
<span class="kt">int</span> <span class="n">l</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="k">if</span> <span class="p">(</span><span class="k">this</span> <span class="o">==</span> <span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
<span class="n">l</span> <span class="o">=</span> <span class="mi">6</span><span class="p">;</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="k">this</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
<span class="n">l</span> <span class="o">=</span> <span class="mi">5</span><span class="p">;</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="n">l</span> <span class="o">=</span> <span class="mi">7</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">try</span> <span class="p">{</span>
<span class="n">FileUtils</span><span class="p">.</span><span class="n">get_contents</span> <span class="p">(</span><span class="s">"plusmoinsmoche.vala"</span><span class="p">,</span> <span class="k">out</span> <span class="n">bar</span><span class="p">);</span>
<span class="p">}</span> <span class="k">catch</span> <span class="p">{</span>
<span class="n">stdout</span><span class="p">.</span><span class="n">printf</span> <span class="p">(</span><span class="s">"Il faut les sources.</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
<span class="k">return</span> <span class="n">bar</span><span class="p">.</span><span class="n">split</span> <span class="p">(</span><span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">)[</span><span class="n">l</span> <span class="o">-</span> <span class="mi">1</span><span class="p">];</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">MsgManager</span> <span class="o">:</span> <span class="n">Object</span> <span class="p">{</span>
<span class="kd">public</span> <span class="kt">string</span> <span class="n">msg_0</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="k">default</span> <span class="o">=</span> <span class="s">"Bienvenue dans le jeu du plus ou du moins</span><span class="se">\n</span><span class="s">"</span><span class="p">;}</span>
<span class="kd">public</span> <span class="kt">string</span> <span class="n">msg_1</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="k">default</span> <span class="o">=</span> <span class="s">"Entre un nombre :</span><span class="se">\n</span><span class="s">"</span><span class="p">;</span> <span class="p">}</span>
<span class="kd">public</span> <span class="kt">string</span> <span class="n">msg_2</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="k">default</span> <span class="o">=</span> <span class="s">"Le nombre doit être compris entre 0 et 99 inclus"</span><span class="p">;</span> <span class="p">}</span>
<span class="kd">public</span> <span class="kt">string</span> <span class="n">msg_3</span> <span class="p">{</span> <span class="k">get</span><span class="p">;</span> <span class="k">set</span><span class="p">;</span> <span class="k">default</span> <span class="o">=</span> <span class="s">"GAGNÉ !!!!!"</span><span class="p">;</span> <span class="p">}</span>
<span class="kd">public</span> <span class="kt">uint8</span><span class="p">[]</span> <span class="n">get_msg</span> <span class="p">(</span><span class="kt">int</span> <span class="n">i</span><span class="p">)</span> <span class="p">{</span>
<span class="n">Value</span> <span class="n">v</span> <span class="o">=</span> <span class="n">Value</span> <span class="p">(</span><span class="k">typeof</span> <span class="p">(</span><span class="kt">string</span><span class="p">));</span>
<span class="n">get_property</span> <span class="p">(</span><span class="s">"msg-%s"</span><span class="p">.</span><span class="n">printf</span> <span class="p">(</span><span class="n">i</span><span class="p">.</span><span class="n">to_string</span> <span class="p">()),</span> <span class="kd">ref</span> <span class="n">v</span><span class="p">);</span>
<span class="k">return</span> <span class="n">v</span><span class="p">.</span><span class="n">get_string</span> <span class="p">().</span><span class="n">data</span><span class="p">;</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="kd">public</span> <span class="kd">class</span> <span class="nc">Jeu</span> <span class="o">:</span> <span class="n">Object</span> <span class="p">{</span>
<span class="n">Resultat</span> <span class="n">r</span><span class="p">;</span>
<span class="n">MsgManager</span> <span class="n">m</span> <span class="o">=</span> <span class="p">(</span><span class="n">Object</span><span class="p">.</span><span class="k">new</span> <span class="p">(</span><span class="k">typeof</span> <span class="p">(</span><span class="n">MsgManager</span><span class="p">))</span> <span class="k">as</span> <span class="n">MsgManager</span><span class="p">);</span>
<span class="kt">int</span> <span class="n">i</span> <span class="o">=</span> <span class="n">take_int</span> <span class="p">()()()()();</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="kt">void</span> <span class="n">main</span> <span class="p">()</span> <span class="p">{</span>
<span class="n">stdout</span><span class="p">.</span><span class="n">printf</span> <span class="p">((</span><span class="kt">string</span><span class="p">)(</span><span class="k">new</span> <span class="n">Jeu</span> <span class="p">().</span><span class="n">m</span><span class="p">.</span><span class="n">get_msg</span> <span class="p">(</span><span class="mi">0</span><span class="p">)));</span>
<span class="n">Jeu</span><span class="o">?</span> <span class="n">jeu</span> <span class="o">=</span> <span class="nb">null</span><span class="p">;</span>
<span class="p">(</span><span class="n">jeu</span> <span class="o">=</span> <span class="p">(</span><span class="n">Object</span><span class="p">.</span><span class="k">new</span> <span class="p">(</span><span class="k">typeof</span> <span class="p">(</span><span class="n">Jeu</span><span class="p">))</span> <span class="k">as</span> <span class="n">Jeu</span><span class="p">)).</span><span class="n">tour</span> <span class="p">(</span><span class="n">jeu</span><span class="p">.</span><span class="n">tour</span><span class="p">);</span>
<span class="n">Process</span><span class="p">.</span><span class="n">exit</span> <span class="p">((</span><span class="kt">int</span><span class="p">)(</span><span class="mi">42</span> <span class="o"><</span> <span class="p">(</span><span class="mi">42</span> <span class="o">*</span> <span class="mi">42</span><span class="p">)));</span>
<span class="p">}</span>
<span class="kd">public</span> <span class="kd">delegate</span> <span class="kt">void</span> <span class="n">Next</span> <span class="p">(</span><span class="kd">owned</span> <span class="n">Next</span> <span class="n">next</span><span class="p">);</span>
<span class="kd">public</span> <span class="kt">void</span> <span class="n">tour</span> <span class="p">(</span><span class="kd">owned</span> <span class="n">Next</span> <span class="n">next</span><span class="p">)</span> <span class="p">{</span>
<span class="kd">var</span> <span class="n">self</span> <span class="o">=</span> <span class="k">this</span><span class="p">;</span>
<span class="n">stdout</span><span class="p">.</span><span class="n">printf</span> <span class="p">((</span><span class="kt">string</span><span class="p">)</span><span class="n">self</span><span class="p">.</span><span class="n">m</span><span class="p">.</span><span class="n">get_msg</span> <span class="p">(</span><span class="mi">1</span><span class="p">));</span>
<span class="kt">int</span> <span class="n">c</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">stdin</span><span class="p">.</span><span class="n">read_line</span> <span class="p">().</span><span class="n">scanf</span> <span class="p">(</span><span class="s">"%d"</span><span class="p">,</span> <span class="kd">ref</span> <span class="n">c</span><span class="p">);</span>
<span class="kt">bool</span> <span class="n">m</span> <span class="o">=</span> <span class="n">c</span> <span class="o">></span> <span class="n">i</span><span class="p">,</span>
<span class="n">p</span> <span class="o">=</span> <span class="n">c</span> <span class="o"><</span> <span class="n">i</span><span class="p">,</span>
<span class="n">e</span> <span class="o">=</span> <span class="n">c</span> <span class="o">==</span> <span class="n">i</span><span class="p">,</span>
<span class="n">b</span> <span class="o">=</span> <span class="n">c</span> <span class="o"><</span> <span class="mi">0</span> <span class="o">||</span> <span class="n">c</span> <span class="o">></span> <span class="mi">99</span><span class="p">;</span>
<span class="k">if</span> <span class="p">(</span><span class="n">m</span><span class="p">)</span> <span class="p">{</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">Resultat</span><span class="p">.</span><span class="n">MOINS</span><span class="p">;</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">p</span><span class="p">)</span> <span class="p">{</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">Resultat</span><span class="p">.</span><span class="n">PLUS</span><span class="p">;</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">e</span><span class="p">)</span> <span class="p">{</span>
<span class="n">r</span> <span class="o">=</span> <span class="n">Resultat</span><span class="p">.</span><span class="n">GAGNE</span><span class="p">;</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">b</span><span class="p">)</span> <span class="p">{</span>
<span class="n">stdout</span><span class="p">.</span><span class="n">printf</span> <span class="p">((</span><span class="kt">string</span><span class="p">)</span><span class="n">self</span><span class="p">.</span><span class="n">m</span><span class="p">.</span><span class="n">get_msg</span> <span class="p">(</span><span class="mi">2</span><span class="p">));</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="k">if</span> <span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">foo</span> <span class="p">()</span> <span class="o">==</span> <span class="s">"Plus"</span><span class="p">)</span> <span class="p">{</span>
<span class="n">stdout</span><span class="p">.</span><span class="n">printf</span> <span class="p">(</span><span class="s">"%s"</span><span class="p">,</span> <span class="s">"C'est %s</span><span class="se">\n</span><span class="s">"</span><span class="p">.</span><span class="n">printf</span> <span class="p">(</span><span class="s">"plus !"</span><span class="p">));</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="k">if</span> <span class="p">(</span><span class="n">r</span><span class="p">.</span><span class="n">foo</span> <span class="p">()</span> <span class="o">==</span> <span class="s">"Moins"</span><span class="p">)</span> <span class="p">{</span>
<span class="kt">string</span> <span class="n">azerty</span> <span class="o">=</span> <span class="p">(</span><span class="kt">string</span><span class="p">)(</span><span class="k">new</span> <span class="kt">uint8</span><span class="p">[]</span> <span class="p">{</span> <span class="mi">109</span><span class="p">,</span> <span class="mi">111</span><span class="p">,</span> <span class="mi">105</span><span class="p">,</span> <span class="mi">110</span><span class="p">,</span> <span class="mi">115</span> <span class="p">});</span>
<span class="n">StringBuilder</span> <span class="n">w</span> <span class="o">=</span> <span class="k">new</span> <span class="n">StringBuilder</span> <span class="p">();</span>
<span class="n">w</span><span class="p">.</span><span class="n">append</span> <span class="p">(</span><span class="s">"C"</span><span class="p">);</span>
<span class="n">w</span><span class="p">.</span><span class="n">append</span> <span class="p">(</span><span class="s">"'"</span><span class="p">);</span>
<span class="n">w</span><span class="p">.</span><span class="n">append</span> <span class="p">(</span><span class="s">"est"</span><span class="p">);</span>
<span class="n">w</span><span class="p">.</span><span class="n">append</span> <span class="p">(</span><span class="s">" "</span><span class="p">);</span>
<span class="n">w</span><span class="p">.</span><span class="n">append</span> <span class="p">(</span><span class="n">azerty</span><span class="p">);</span>
<span class="n">stdout</span><span class="p">.</span><span class="n">printf</span> <span class="p">(</span><span class="s">"%s !</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="p">(</span><span class="kt">string</span><span class="p">)(((</span><span class="kt">string</span><span class="p">)(</span><span class="n">w</span><span class="p">.</span><span class="n">data</span><span class="p">)).</span><span class="n">data</span><span class="p">));</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="kt">string</span> <span class="n">baz</span> <span class="o">=</span> <span class="n">r</span><span class="p">.</span><span class="n">foo</span> <span class="p">();</span>
<span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="n">baz</span> <span class="o">==</span> <span class="s">"Gagné"</span><span class="p">)))))</span> <span class="p">{</span>
<span class="n">stdout</span><span class="p">.</span><span class="n">printf</span> <span class="p">(</span><span class="s">"%s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="p">(</span><span class="kt">string</span><span class="p">)(</span><span class="n">self</span><span class="p">.</span><span class="n">m</span><span class="p">.</span><span class="n">get_msg</span> <span class="p">(</span><span class="mi">3</span><span class="p">)));</span>
<span class="k">return</span><span class="p">;</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="n">stdout</span><span class="p">.</span><span class="n">printf</span> <span class="p">(</span><span class="s">"Lol, un bug"</span><span class="p">);</span>
<span class="n">Process</span><span class="p">.</span><span class="n">exit</span> <span class="p">(</span><span class="sc">'\0'</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="n">next</span> <span class="p">(</span><span class="n">self</span><span class="p">.</span><span class="n">tour</span><span class="p">);</span>
<span class="p">}</span>
<span class="kd">public</span> <span class="kd">static</span> <span class="n">Baz1</span> <span class="n">take_int</span> <span class="p">()</span> <span class="p">{</span>
<span class="k">return</span> <span class="p">()</span> <span class="o">=></span> <span class="p">{</span>
<span class="k">return</span> <span class="p">()</span> <span class="o">=></span> <span class="p">{</span>
<span class="k">return</span> <span class="p">()</span> <span class="o">=></span> <span class="p">{</span>
<span class="k">return</span> <span class="p">()</span> <span class="o">=></span> <span class="p">{</span>
<span class="kt">int</span> <span class="n">foo</span> <span class="o">=</span> <span class="n">Random</span><span class="p">.</span><span class="n">int_range</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">42</span><span class="p">);</span>
<span class="k">for</span> <span class="p">(</span><span class="kt">int</span> <span class="n">g</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="n">g</span> <span class="o"><</span> <span class="n">foo</span><span class="p">;</span> <span class="n">g</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
<span class="n">Random</span><span class="p">.</span><span class="n">set_seed</span> <span class="p">(</span><span class="n">Random</span><span class="p">.</span><span class="n">next_int</span> <span class="p">());</span>
<span class="p">}</span>
<span class="k">return</span> <span class="p">(</span><span class="kt">int</span><span class="p">)</span><span class="n">Random</span><span class="p">.</span><span class="n">int_range</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">99</span><span class="p">);</span>
<span class="p">};</span>
<span class="p">};</span>
<span class="p">};</span>
<span class="p">};</span>
<span class="p">}</span>
<span class="p">}</span>
<span class="p">[</span><span class="nd">CCode</span> <span class="p">(</span><span class="n">has_target</span> <span class="o">=</span> <span class="nb">false</span><span class="p">)]</span>
<span class="kd">public</span> <span class="kd">delegate</span> <span class="n">Baz2</span> <span class="n">Baz1</span> <span class="p">();</span>
<span class="p">[</span><span class="nd">CCode</span> <span class="p">(</span><span class="n">has_target</span> <span class="o">=</span> <span class="nb">false</span><span class="p">)]</span>
<span class="kd">public</span> <span class="kd">delegate</span> <span class="n">Baz3</span> <span class="n">Baz2</span> <span class="p">();</span>
<span class="p">[</span><span class="nd">CCode</span> <span class="p">(</span><span class="n">has_target</span> <span class="o">=</span> <span class="nb">false</span><span class="p">)]</span>
<span class="kd">public</span> <span class="kd">delegate</span> <span class="n">Baz4</span> <span class="n">Baz3</span> <span class="p">();</span>
<span class="p">[</span><span class="nd">CCode</span> <span class="p">(</span><span class="n">has_target</span> <span class="o">=</span> <span class="nb">false</span><span class="p">)]</span>
<span class="kd">public</span> <span class="kd">delegate</span> <span class="kt">int</span> <span class="n">Baz4</span> <span class="p">();</span>
<span class="p">}</span>
</pre></div>
</td></tr></table></div>
</div>
<p>Voici la liste des horreurs.</p>
<ul>
<li>Le <code>using</code> en haut du fichier ne sert strictement à rien, puisqu’il est de toute façon là par défaut ;</li>
<li>Je nomme mal mes variables ;</li>
<li>Pour créer des nouvelles instances d’objets j’utilise <code>Object.new (typeof (Foo)) as Foo</code>, alors qu’on fait normalement <code>new Foo</code> ;</li>
<li>J’utilise différents moyens pour stocker les chaînes de caractère de mon programme :<ul>
<li>J’ai une classe qui a des propriétés contenant certains textes, avec une méthode <code>get_msg</code> qui utilise de la réflexion pour récupérer la valeur de ces propriétés ;</li>
<li>Pour obtenir une version textuelle des valeurs de l’énumération <code>Resultat</code>, le programme lis son propre code source dans lequel il y a un commentaire avec les valeurs possibles ;</li>
</ul>
</li>
<li>Les namespace et la classe <code>Jeu</code> ne servent strictement à rien ;</li>
<li>La méthode pour obtenir un nombre aléatoire retourne un délégué qui retourne lui-même un délégué, qui retourne lui-même un délégué qui retourne un <code>int</code> (je crois). </li>
<li>Pour définir la <em>seed</em> du générateur de nombre aléatoire, j’utilise un nombre aléatoire de fois des nombres aléatoires ;</li>
<li>La méthode qui correspond à un tour de jeu s’appelle récursivement tant qu’on a pas gagné, grâce à un délégué qu’on lui passe en argument ;</li>
<li>Je crée un « alias » de <code>this</code> qui devient <code>self</code> dans la méthode <code>tour</code> ;</li>
<li>J’utilise <code>stdout.printf</code>, alors que <code>print</code> fait exactement la même chose ;</li>
<li>Je fais pas mal de petits trucs inutiles qui rendent le code compliqué pour rien, entre autres :<ul>
<li>J’utilise des <code>uint8[]</code> pour stocker du texte ;</li>
<li>Plutôt que de simplement écrire <code>0</code>, je converti une expression booléenne qui est toujours vraie (<code>42 < (42 * 42)</code>) en entier ;</li>
<li><code>!(!(!(!(baz == "Gagné"))))</code>.</li>
</ul>
</li>
<li>Je ne connais pas les <code>else if</code>, je mets d’autres <code>if/else</code> dans les <code>else</code> ;</li>
<li>Je crée une énumération <code>Resultat</code> qui ne sert à rien : une variable de ce type stocke bien le résultat (plus, moins ou gagné) d’un tour, mais je pourrais très bien m’en passer et utiliser directement les conditions à partir desquelles je donne justement une valeur à cette variable.</li>
<li>Et sûrement plein d’autres chose que j’ai oublié ;</li>
</ul>
<p>Bref, je me suis bien amusé ! <img alt=":D" src="/static/smileys/heureux.png"></p>
<p>Et en bonus, un code encore plus horrible, <a href="https://framagit.org/snippets/362">l’équivalent en C de mon programme</a> généré par le compilateur Vala.</p>Le « Plus / Moins » le plus horrible du siècle !, message #1121522016-05-27T21:37:44+02:00klafyvel/@klafyvelhttps://zestedesavoir.com/forums/sujet/3909/le-plus-moins-le-plus-horrible-du-siecle/?page=4#p112152<p>En brainfuck c'est trop facile de souligner les mauvaises pratiques : il suffit d'écrire un programme en brainfuck.</p>Le « Plus / Moins » le plus horrible du siècle !, message #1121472016-05-27T21:18:48+02:00SuperFola/@SuperFolahttps://zestedesavoir.com/forums/sujet/3909/le-plus-moins-le-plus-horrible-du-siecle/?page=4#p112147<p>Pas mal du tout <img alt=";)" src="/static/smileys/clin.png"></p>
<p>J'ai envie de refaire une participation, mais faut que je change de langage (brainfuck ? js ? php ? je me tâte) <img alt="^^" src="/static/smileys/hihi.png"></p>Le « Plus / Moins » le plus horrible du siècle !, message #1121162016-05-27T18:00:31+02:00Poliorcetics/@Poliorceticshttps://zestedesavoir.com/forums/sujet/3909/le-plus-moins-le-plus-horrible-du-siecle/?page=4#p112116<blockquote>
<p>Integer.Parse(Date.Now.Millisecond.ToString().Substring(1).ToString()).ToString() au lieu de simplement faire un rand de 0 à 99</p>
</blockquote>
<p>Celle ci m'a bien fait rire, bien joué !</p>Le « Plus / Moins » le plus horrible du siècle !, message #1120022016-05-26T15:19:57+02:00Niko300/@Niko300https://zestedesavoir.com/forums/sujet/3909/le-plus-moins-le-plus-horrible-du-siecle/?page=4#p112002<p>Bonjour je suis nouveau sur le forum et j'ai été conquis par l'idée à la fois drôle et pédagogique.
Voici mon code en VB.NET (langage pas encore proposé) :</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
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81</pre></div></td><td class="code"><div class="codehilite"><pre><span></span><span class="c">' Importation de System.Threading</span>
<span class="k">Imports</span> <span class="nn">System.Threading</span>
<span class="c">' Module 1</span>
<span class="k">Module</span> <span class="nn">Module1</span>
<span class="c">' Fonction principale</span>
<span class="k">Sub</span> <span class="nf">Main</span><span class="p">()</span>
<span class="c">' Déclaration de 2 variables :</span>
<span class="k">Static</span> <span class="n">N</span><span class="p">,</span> <span class="n">X</span>
<span class="c">' Affichage d'un titre accrocheur :</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"____,,,...----°°°° LE JE DU + OU DU MOIN (V1.37.896.21b) °°°°----...,,,____"</span><span class="p">)</span>
<span class="n">Thread</span><span class="p">.</span><span class="n">Sleep</span><span class="p">(</span><span class="mi">2800</span><span class="p">)</span>
<span class="n">Console</span><span class="p">.</span><span class="n">Clear</span><span class="p">()</span>
<span class="c">' Affichage d'un chargement, ça fait plus pro :</span>
<span class="k">For</span> <span class="n">i</span> <span class="o">=</span> <span class="mi">0</span> <span class="k">To</span> <span class="mi">100000</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"Chargemand d'kernel de l'aplicassion an cour : "</span> <span class="o">&</span> <span class="p">(</span><span class="n">i</span> <span class="o">/</span> <span class="mi">1000</span><span class="p">)</span> <span class="o">&</span> <span class="s">" %"</span><span class="p">)</span>
<span class="k">Select</span> <span class="k">Case</span> <span class="p">((</span><span class="n">i</span> <span class="ow">Mod</span> <span class="mi">3</span><span class="p">))</span>
<span class="k">Case</span> <span class="mi">0</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">" |"</span><span class="p">)</span>
<span class="k">Case</span> <span class="mi">1</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">" /"</span><span class="p">)</span>
<span class="k">Case</span> <span class="mi">2</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">" --"</span><span class="p">)</span>
<span class="k">End</span> <span class="k">Select</span>
<span class="n">Console</span><span class="p">.</span><span class="n">Clear</span><span class="p">()</span>
<span class="k">Next</span>
<span class="c">' RESTE DU CODE :</span>
<span class="n">Thread</span><span class="p">.</span><span class="n">Sleep</span><span class="p">(</span><span class="mi">1000</span><span class="p">)</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"========== LOADING KERNEL TERMINATED | Chargemand de l'interfasse grafik..."</span><span class="p">)</span>
<span class="n">Thread</span><span class="p">.</span><span class="n">Sleep</span><span class="p">(</span><span class="mi">2700</span><span class="p">)</span>
<span class="n">Console</span><span class="p">.</span><span class="n">Clear</span><span class="p">()</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"Tapée un nonbre de 0 a 99 !"</span><span class="p">)</span>
<span class="k">Static</span> <span class="n">D</span> <span class="o">=</span> <span class="kt">Integer</span><span class="p">.</span><span class="n">Parse</span><span class="p">(</span><span class="kt">Date</span><span class="p">.</span><span class="n">Now</span><span class="p">.</span><span class="n">Millisecond</span><span class="p">.</span><span class="n">ToString</span><span class="p">().</span><span class="n">Substring</span><span class="p">(</span><span class="mi">1</span><span class="p">).</span><span class="n">ToString</span><span class="p">()).</span><span class="n">ToString</span><span class="p">()</span>
<span class="n">X</span> <span class="o">=</span> <span class="n">D</span>
<span class="n">N</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span>
<span class="k">While</span> <span class="p">(</span><span class="n">AssignayValeure</span><span class="p">(</span><span class="n">N</span><span class="p">,</span> <span class="kt">Integer</span><span class="p">.</span><span class="n">Parse</span><span class="p">(</span><span class="n">Console</span><span class="p">.</span><span class="n">ReadLine</span><span class="p">()))</span> <span class="o"><></span> <span class="n">X</span><span class="p">)</span>
<span class="k">If</span> <span class="k">Not</span> <span class="n">N</span> <span class="o">>=</span> <span class="mi">0</span> <span class="ow">Or</span> <span class="k">Not</span> <span class="n">N</span> <span class="o"><=</span> <span class="mi">99</span> <span class="k">Then</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"Le nonbre tapez n'ai pa compris antres 0 ai 99, recommansser a tapait :"</span><span class="p">)</span>
<span class="k">Else</span>
<span class="n">Console</span><span class="p">.</span><span class="n">Clear</span><span class="p">()</span>
<span class="k">If</span> <span class="n">N</span> <span class="o"><</span> <span class="n">X</span> <span class="k">Then</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"Plu gran !"</span><span class="p">)</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"Tapée un nonbre de 0 a 99 !"</span><span class="p">)</span>
<span class="k">End</span> <span class="k">If</span>
<span class="k">If</span> <span class="n">N</span> <span class="o">></span> <span class="n">X</span> <span class="k">Then</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"Plu pti !"</span><span class="p">)</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"Tapée un nonbre de 0 a 99 !"</span><span class="p">)</span>
<span class="k">End</span> <span class="k">If</span>
<span class="k">End</span> <span class="k">If</span>
<span class="k">End</span> <span class="k">While</span>
<span class="n">Console</span><span class="p">.</span><span class="n">Clear</span><span class="p">()</span>
<span class="n">Console</span><span class="p">.</span><span class="n">WriteLine</span><span class="p">(</span><span class="s">"Braveaux ! sa va, c ganié !!!"</span><span class="p">)</span>
<span class="n">Console</span><span class="p">.</span><span class="n">ReadKey</span><span class="p">()</span>
<span class="k">End</span> <span class="k">Sub</span>
<span class="k">Public</span> <span class="k">Function</span> <span class="nf">AssignayValeure</span><span class="p">(</span><span class="k">ByRef</span> <span class="n">DESTINASSION</span> <span class="ow">As</span> <span class="kt">Object</span><span class="p">,</span> <span class="k">ByVal</span> <span class="n">VALUE</span> <span class="ow">As</span> <span class="kt">Object</span><span class="p">)</span> <span class="ow">As</span> <span class="kt">Object</span>
<span class="n">DESTINASSION</span> <span class="o">=</span> <span class="n">VALUE</span>
<span class="k">Return</span> <span class="n">DESTINASSION</span>
<span class="k">End</span> <span class="k">Function</span>
<span class="k">End</span> <span class="k">Module</span>
</pre></div>
</td></tr></table>
<p>N'hésitez pas à l'essayer, c'est une simple class en mode console.</p>
<p>Explications :</p>
<ul>
<li>
<p>Commentaires inutiles puis absence de commentaire</p>
</li>
<li>
<p>Déclaration en Static inutile car les variables ne doivent pas être accédées depuis une autre class</p>
</li>
<li>
<p>Non respect de la norme des nommages variables (écriture en majuscule)</p>
</li>
<li>
<p>Pas de typage</p>
</li>
<li>
<p>Splash screen avec des fioritures inutiles</p>
</li>
<li>
<p>Système de chargement fictif complètement gadget</p>
</li>
<li>
<p>Integer.Parse(Date.Now.Millisecond.ToString().Substring(1).ToString()).ToString() au lieu de simplement faire un rand de 0 à 99</p>
</li>
<li>
<p>Assignation dans le while (via une fonction)</p>
</li>
<li>
<p>Not N >= 0 Or Not N <= 99 au lieu de simplement N < 0 Or N > 99</p>
</li>
<li>
<p>Deux conditions sans utiliser le else, la deuxième est testée même si la première a été réussie </p>
</li>
<li>
<p>Pas de gestion des exceptions (Try/Catch) </p>
</li>
<li>
<p>Orthographe</p>
</li>
</ul>Le « Plus / Moins » le plus horrible du siècle !, message #1118532016-05-25T12:50:04+02:00Mohack/@Mohackhttps://zestedesavoir.com/forums/sujet/3909/le-plus-moins-le-plus-horrible-du-siecle/?page=4#p111853<p>L'<a href="https://zestedesavoir.com/forums/sujet/6137/creez-votre-galerie/">atelier CSS</a> ouvre ses portes ! Venez nombreux <img alt=":)" src="/static/smileys/smile.png"> !</p>Quelques question sur l'IA, message #977942016-02-07T16:12:57+01:00nohar/@noharhttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p97794<p>En fait je pense que n'importe qui faisant de l'IA se pose un beau jour la question, et continue d'en faire parce qu'il aime le fait d'y apporter des éléments de réponse, pas à pas, selon son interpretation personnelle de ses expériences.</p>Quelques question sur l'IA, message #977772016-02-07T12:09:29+01:00lombre33/@lombre33https://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p97777<p>Merci a tous de participer a ce super débat <img alt=";)" src="/static/smileys/clin.png"> </p>
<p>Pour ma part je suis en plein sur la lecteur du livre que vous m'avez conseiller !
Je le recommande donc a mon tour a ceux qui ne l'ont pas <img alt=";)" src="/static/smileys/clin.png"> des le premier chapitre il résumer presque tous ce débat <img alt="^^" src="/static/smileys/hihi.png"> et nous amène des termes plus générique ! ;D </p>
<p>Je pense qu'encore une fois(malgrès ce que vous font croire médias et politique c'est souvent le cas) rien n'est tout blanc ou tous noir. C'est a dire qu'il n'y a pas une bonne approche et une mauvaise approche mais simplement des moyens et surtout des objectifs différents mais qui au final se font plus du bien entre eux que du mal <img alt=";)" src="/static/smileys/clin.png"> </p>
<p>J'aspire aussi de plus en plus a être chercheur la dedans <img alt=":D" src="/static/smileys/heureux.png"> </p>
<p>Juste pour relancer un peu de bazar <img alt="^^" src="/static/smileys/hihi.png"> voilà une question que mon prof de lettre et com' nous a poser :
" Qu'es ce qui fait que le cerveaux agit et comprend" Genre depuis le début on essaye plus ou moins de définir la vie comme qqch de rationnel avec des formules mathématique, mais même si on y arrivait Comment expliquer que nous cerveaux INTERPRÈTE ça ? </p>
<p>c'est oufff la profondeur de cette question vous ne pensez pas ? (bon évidemment on a pas de réponse <img alt=";)" src="/static/smileys/clin.png"> mais c'est intéressant de lever un peu les yeux de la feuille de tmps en tmps pour ce genre de question existentielle)</p>Quelques question sur l'IA, message #975672016-02-05T13:07:11+01:00erios58/@erios58https://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p97567<p>Commencez par python pour développer une IA. Après tu pourra utiliser C++ et d'autres langages</p>Quelques question sur l'IA, message #967862016-02-01T13:19:52+01:00KFC/@KFChttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p96786<p>Notons par ailleurs que le recuit simule ne s'inspire pas de la biologie mais d'un processus utilise par l'Homme dans une activite sociale (a savoir en metallurgie). On est donc encore dans quelque chose de different puisque l'inspiration n'est pas la nature directement.</p>Quelques question sur l'IA, message #967592016-02-01T09:36:23+01:00nohar/@noharhttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p96759<p>Perso ce qui m'intéresse dans l'IA, ce sont plutôt les applications concrètes qu'on en a aujourd'hui, et pas seulement parce que j'ai le point de vue d'un ingénieur.</p>
<p>Étudier une application de l'IA <em>qui marche</em>, c'est se rendre compte de plusieurs choses :</p>
<ul>
<li>Il n'y a pas que le cerveau humain qui soit modélisé avec des résultats intéressants : certes aujourd'hui on nous rabat surtout les oreilles avec le Deep Learning qui repose sur les réseaux de neurones, mais à côté de ça il y a des tas d'autres approches, d'une part au machine learning (les algorithmes de boosting en sont un exemple), d'autres part en termes de modèles d'inspiration (rien qu'en optimisation, les algos génétiques ont été mentionnés, mais on peut aussi parler des colonies de fourmis ou du recuit simulé) ;</li>
<li>Le fait de chercher à quantifier les méthodes et leur efficacité face à une problématique concrète que l'on s'est donnée à résoudre fait tout autant avancer notre compréhension de l'intelligence que poursuivre l'effort pour atteindre l'IA forte. Il s'agit de prendre quelques pas de recul par rapport au modèle initial (disons le cerveau) et de ne réfléchir qu'en termes des propriétés du système qu'il nous a servi à modéliser. C'est comme ça qu'est né le Deep Learning ; un type s'est simplement demandé un beau jour ce que ça pouvait faire de créer un réseau de réseaux de neurones. Cette idée tient plus de l'adaptation de la topologie des réseaux IPv4 au perceptron qu'autre chose, et pourtant, les résultats obtenus sont assez peu surprenants, puisqu'on observe, en fait, des phénomènes similaires sur le cerveau humain depuis l'invention de l'IRM.</li>
</ul>
<p>Bref, cet aspect concret n'est pas à écarter sous prétexte qu'il est "pragmatique". Paradoxalement c'est grâce à cette approche pragmatique qu'on comprend de mieux en mieux le schmilblick aujourd'hui.</p>Quelques question sur l'IA, message #964062016-01-29T13:33:03+01:00Algue-Rythme/@Algue-Rythmehttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p96406<p>Notez que mon propos ne concerne que l'IA forte, c'est à dire la question de l'IA telle qu'elle est fantasmée. Ici je ne parle pas de l'IA en tant que domaine d’ingénierie. </p>
<p>L’enjeu de mon propos n'est d'ailleurs pas tant informatique que philosophique : il s'agit de déterminer, par des expériences de pensée, la nature de l'intelligence. Le fait qu'il soit question d'ordinateurs n'a qu'un vague rapport avec le sujet. Donc, que ce soit dit : ici je ne parle pas de l'IA au sens académique. Le débat porte sur autre chose. </p>
<p>Je n'affirme pas qu'il faille le même genre de structure biologique que les cerveaux pour les simuler. Je pense que pour effectuer une simulation les ordinateurs tels qu'on les connait aujourd'hui suffisent bien assez (en nature, après en performances de calculs je dis pas). </p>
<p>Pour ce qui est des <em>si</em>, j'ai du mal à comprendre ce qui te gène dedans victor.<br>
On ne peut pas réfléchir à de telles conceptions sans émettre des hypothèses.<br>
La question n'est pas de faire un bilan des connaissances présentes, je sais bien qu'à l'heure actuelle rien n'a avoir, en IA, avec ce qui pourrait ressembler - même vaguement - à un cerveau humain. </p>
<p>En ce qui me concerne ce débat me tient à cœur car je trouve ce domaine passionnant, et j'aspire à devenir chercheur dedans. Je pense qu'il y a un certains nombre d'idées à tirer du cerveau biologique.<br>
Je connais les traditionnels arguments "l'Homme a commencé à voler lorsqu'il a cessé d'imiter les oiseaux" et, comme le dit si bien Höd, on confie à l'IA des tâches qu'aucun cerveau biologique ne sait résoudre, et que par conséquent imiter un cerveau biologique n'a aucun intérêt. </p>
<p>Toutefois ce sont des arguments qui sont, à mon sens, peu convaincants. Le premier est une maxime empiriste. Sur d'autres domaines que l'aéronautique on pourrait tout aussi bien affirmer le contraire.<br>
Le 2nd est un argument utilitariste. Il n'est pas faux. Seulement, il ne m'intéresse pas car je n'ai pas de conception utilitariste de l'IA. C'est juste de la curiosité et le goût de comprendre la nature de l'intelligence. Je conçois avant tout l'ordinateur comme un moyen de simulation, pour tester un <em>modèle</em>. </p>
<p>Cela dissipe-t-il le quiproquo ? </p>Quelques question sur l'IA, message #963972016-01-29T11:55:25+01:00KFC/@KFChttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p96397<p>Pour appuyer un peu plus le fait que l'intelligence artificielle telle est qu'elle est reellement pratique se differencie largement de l'intelligence artificielle, un bon exemple est celui des algorithme evolutionnistes.</p>
<p>Les algorithmes genetiques sont a des annees lumieres de simplement mimer ou chercher a imiter nos connaissances sur la biologie. Au contraire, les algorithmes genetique s'insipirent librement de principes tres vagues et en partie faux par rapport a nos connaissances actuelles en biologie.</p>
<p>Pour autant, le but n'est certainement pas d'avoir des algorithmes intelligents au sens ou ils imiteraient parfaitement la nature et donneraient une impression d'intelligence. Non, leur seul but est de resoudre un probleme d'optimisation, c'est a dire, et aussi peu sexy que cela puisse-etre : minimiser (ou maximiser) une fonction <span>$f$</span> que l'on arrive pas a optimiser via des outils conventionnels.</p>
<p>Si demain on s'appercoit que Darwin etait un bouseux et que toute la theorie de l'evolution est une blague, on ne va pas pour autant abandonner les algorithmes genetiques ou les modifier pour les rendre conforme a nos nouvelles theories ; preuve que les deux domaines sont bien separes.</p>
<p>De fait, aujourd'hui, l'intelligence artificielle ce n'est <strong>pas</strong> de l'imitation de comportement humain. C'est meme tout le contraire : l'intelligence artificielle c'est en tres grande partie de la resolution de probleme d'optimisation que l'etre humain est incapable de resoudre !</p>Quelques question sur l'IA, message #963942016-01-29T11:19:58+01:00cepus/@cepushttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p96394<blockquote>
<p>Je suis pas d'accord avec toi victor.</p>
</blockquote>
<p>@Ricocotam, ce n'est pas que tu n'es pas d'accord avec moi, c'est que tu n'es pas d'accord avec des choses que je ne pense pas et que je n'ai pas dites.</p>
<blockquote>
<p>Déjà, pourquoi aurions nous besoin d'avoir le même genre de structure que les cerveaux biologique pour les simuler ?</p>
</blockquote>
<p>Effectivement, pourquoi ? Je veux bien que la personne qui prétend qu'il faut "le même genre de structure que les cerveaux biologique pour les simuler" nous explique son point de vue.</p>
<blockquote>
<p>Si il est possible de comprendre (pour un humain ou une machine) comment fonctionne un cerveau, il est possible de s'en inspirer pour l'adapter à la structure des ordinateurs (tels qu'on les connait aujourd'hui).</p>
</blockquote>
<p>Tu dis là ce que mes derniers posts disent en substance, oui. S'il est <em>possible</em> de <em>comprendre comment fonctionne le cerveau</em>, il est possible de s'en inspirer. Le problème étant qu'on <em>ne comprend pas comment fonctionne le cerveau</em> (cf. mes 3 derniers posts) et qu'on n'a aucune garantit sur notre <em>possibilité de comprendre</em> le fonctionnement du cerveau.</p>
<p>Et qu'avec si, on mettrait…</p>Quelques question sur l'IA, message #963872016-01-29T11:00:09+01:00Gabbro/@Gabbrohttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p96387<p>Heu… Les virus biologiques et informatiques n'ont pas grand chose en communs dans leur mode d'action. Donc pour la défense non plus.</p>
<p>On a tendance à se caler sur ce qu'on connait, ce qui n'est pas forcement un bien. Il y a deux siècle, on disait que l'homme était comme un automate, car on connaissait les automates. Et on cherchait à réaliser des automates <em>vivants</em>. On n'a pas réussi, et je doute très sincèrement que ce soit possible.</p>
<p>A-t-on une <strong>bonne</strong> raison de penser que le cerveau humain fonctionne comme un ordinateur, ou est-ce simplement qu'on réduit le cerveau humain à ce qu'on connait ?</p>Quelques question sur l'IA, message #963832016-01-29T10:51:57+01:00Ricocotam/@Ricocotamhttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p96383<p>Je suis pas d'accord avec toi victor. Déjà, pourquoi aurions nous besoin d'avoir le même genre de structure que les cerveaux biologique pour les simuler ? Si il est possible de comprendre (pour un humain ou une machine) comment fonctionne un cerveau, il est possible de s'en inspirer pour l'adapter à la structure des ordinateurs (tels qu'on les connait aujourd'hui).</p>
<p>Je vais te donner un exemple, qui a ses limites comme souvent, où le mimetisme ne servirait à rien sur un ordinateur. Parlons des virus et anti-virus. Les meilleurs anti-virus n'ont quasimment pas d'autre faille que l'utilisateur. Pourtant ils n'utilisent pas du tout le même système que les être vivants pour se défendre. Maintenant, serait-ce intelligent de faire un anti-virus basé sur les principes des êtres vivants ? Non je ne pense pas puisque leur seul faille vient de l'utilisateur. </p>
<p>Le mimétisme c'est bien, mais n'a pas toujours sa place. Donc émuler une intelligence ne nécessite pas forcément de comprendre parfaitement comment fonctionne un cerveau.</p>Quelques question sur l'IA, message #963652016-01-29T00:45:38+01:00cepus/@cepushttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p96365<blockquote>
<p>Ce qui <strong>n'invalide pas le fait que l'on puisse</strong> simuler une intelligence humaine ou animale, <strong>sous l'hypothèse que l'on dispose d'une</strong> compréhension <strong>suffisante</strong> des intelligences biologiques (et d'un modèle adapté pour les décrire) <strong>et d'un système</strong> informat<strong>ique apte à réaliser cette</strong> simulation. </p>
</blockquote>
<p>Absolument. Tout comme rien <strong>n'invalide le fait que l'on puisse</strong> mettre Paris en bouteille, <strong>sous l'hypothèse que l'on dispose d'une</strong> bouteille de taille <strong>suffisante</strong> <strong>et d'un système</strong> mécan<strong>ique apte à réaliser cette</strong> opération. (Ou sous l'hypothèse que Paris n'est en fait pas bien grand.)</p>Quelques question sur l'IA, message #963612016-01-28T23:34:27+01:00Algue-Rythme/@Algue-Rythmehttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=3#p96361<p>Ce qui n'invalide pas le fait que l'on puisse simuler une intelligence humaine ou animale, sous l'hypothèse que l'on dispose qu'une compréhension suffisante des intelligences biologiques (et d'un modèle adapté pour les décrire) et d'un système informatique apte à réaliser cette simulation. </p>Quelques question sur l'IA, message #963572016-01-28T23:20:52+01:00cepus/@cepushttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=2#p96357<figure><blockquote>
<blockquote>
<p>En fait, je me dis en général qu'un cerveau fonctionne de manière semblable à un ordinateur. </p>
</blockquote>
<p>C'est ce qu'essayent très fort de croire les gens qui veulent s'intéresser aux réseaux de neurone sans savoir ce qu'est l'IA. Ensuite, ils sont déçus.
</p>
</blockquote>
<figcaption><p><a href="http://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=2#p96355">Eusèbe</a></p></figcaption></figure><p>Oui, et surtout ça présuppose qu'on sait comment fonctionne le cerveau humain au moins aussi bien qu'on sait effectivement comment fonctionne un ordinateur. Ce qui est faux et donc invalide entièrement la proposition. </p>Quelques question sur l'IA, message #963552016-01-28T22:39:49+01:00Eusèbe/@Eus%C3%A8behttps://zestedesavoir.com/forums/sujet/5218/quelques-question-sur-lia/?page=2#p96355<blockquote>
<p>En fait, je me dis en général qu'un cerveau fonctionne de manière semblable à un ordinateur. </p>
</blockquote>
<p>C'est ce qu'essayent très fort de croire les gens qui veulent s'intéresser aux réseaux de neurone sans savoir ce qu'est l'IA. Ensuite, ils sont déçus. </p>