Discussion :

[Astartee]

- comment les deux solutions sont elles obtenues ?
par réflexion logique uniquement ?

Evidemment
Copier-coller du quizz dans une feuille Excel pour améliorer la lisibilité, puis déduction logique par élimination successive des impossibilités.
Le tout en ~2h devant le film du dimanche soir (donc pas super concentrée).

- comment faites vous pour déduire que, selon que la réponse 20 est A ou C ou D ou B ou E, alors il y a plusieurs, aucune ou une seule solution(s) ?

Eeeeeuh... Je ne vois pas comment expliquer ça plus clairement qu'en répétant la même chose
Si je choisis la réponse X pour la question 20, alors j'obtiens plusieurs combinaisons de réponses possibles pour les questions 1 à 19.
Si je choisis la réponse Z pour la question 20, alors je n'obtiens aucune combinaison de réponses possibles pour les questions 1 à 19.
La question 20 est censée avoir un sens en elle-même, on est censé pouvoir y répondre a priori, indépendemment des réponses aux questions 1 à 19. Donc, vu que l'auteur considère que le quizz a une solution unique, j'en déduis que la réponse à la question 20 n'est ni X ni Z.

- pourquoi faites vous si grand cas de la question 20 ?

Parce qu'on ne la comprend pas et que donc on ne sait pas comment y répondre (autrement que par la logique... ce qui demande plus de réflexion que pour les autres questions puisqu'elle n'est justement pas censée être résolue par la logique !).

Donc de donc, je ne vois pas pourquoi la réponse 20 est censée être fixée dès le départ.

Parce que c'est une "vraie" question qui est censée avoir une "vraie" réponse, unique et indépendante des autres questions.

[sixmillespieds]

Le test d'intelligence est une mesure instantanée pour un individu et peut dépendre ou être liés à beaucoup d'autres paramètres, tout comme la pression mesurée par le baromètre, qui est une mesure instantanée en un lieu précis et est liée d'une manière ou d'une autre à beaucoup d'autres paramètres dont principalement le vent et la température... De plus et de toute évidence, un baromètre ne mesure directement aucune des propositions. Dans tous les cas, on tombe sur la réponse E.

J'ai trouvé la même réponse que les autres: DADBEDDEDABADBADBABE ou en anglais: Dad bedded a bad bad babe

[Astartee]

ou en anglais: [...]

huhu

[eyquem]

Merci bien sixmillepieds d’avoir révélé la phrase que produit une solution.
Mais je pense que c’est une cerise sur le gâteau hors résolution.
Je reste médusé par le reste.

Le test d'intelligence est une mesure instantanée pour un individu et peut dépendre ou être liés à beaucoup d'autres paramètres,

Ah bon ? C’est sérieux ? On est censé savoir ça pour résoudre l’énigme ?
mesure instantanée : l’intelligence serait variable en fonction du moment de la journée, de l’année ?...
dépendre / être liée: quelle différence ?
paramètres: lesquels ? ils ont été établis quand ?

Le test d'intelligence est une mesure instantanée pour un individu et peut dépendre ou être liés à beaucoup d'autres paramètres, tout comme la pression mesurée par le baromètre, qui est une mesure instantanée en un lieu précis et est liée d'une manière ou d'une autre à beaucoup d'autres paramètres

le test = le mesureur.............intelligence=ce qui est mesuré
baromètre = le mesureur........mesure une pression : pas cité
Ce qui est cité, ce sont : température, vitesse du vent, etc = paramètres dont dépend la variable pression mesurée

Comme l'a bien expliqué Guulh, A : B :: C : D exprime une analogie.
Or on a mesureur:mesuré::mesureur:paramètres.
Il n’y a pas analogie terme à terme.

Dans tous les cas, on tombe sur la réponse E.

C'est hyper-ultra raccourci comme explication......


------------------------------------------------


Merci Astartee de m’avoir répondu.

Mais ça me laisse songeur.

- si on "fixe" cette réponse à /A/ alors on obtient plusieurs solutions possibles
- si on "fixe" cette réponse à C/D alors on n'obtient aucune solution possible
- si on "fixe" cette réponse à B/E alors on obtient une unique solution possible

Eeeeeuh... Je ne vois pas comment expliquer ça plus clairement qu'en répétant la même chose
Si je choisis la réponse X pour la question 20, alors j'obtiens plusieurs combinaisons de réponses possibles pour les questions 1 à 19.
Si je choisis la réponse Z pour la question 20, alors je n'obtiens aucune combinaison de réponses possibles pour les questions 1 à 19.

C’est en effet une répétition à l’identique qui ne m’apprend rien de plus.

Je ne vois pas comment expliquer ça plus clairement qu'en répétant la même chose

tiens donc; c'est original, comme concept....






En fait le problème m’a turlupiné parce qu’il est bizarrement tourné à cause de la façon dont la question 20 est montée en épingle alors qu’elle est spéciale par rapport aux autres.



- Premièrement, contrairement à toutes les autres questions, celle-ci ne fait pas référence à elle-même ou aux autres questions.

on est censé pouvoir y répondre a priori, indépendamment des réponses aux questions 1 à 19.

On est donc d’accord.




- Donc cette question ne participe pas du caractère “auto-référentiel“ du quiz. Après tout, pourquoi pas ?
Le probléme est secondement que si c'est le cas, il est logique de penser que la question 20 devrait avoir un sens en elle-même. Mais je la trouve insensée, il n’y a pas de réponse satisfaisante parmi celles proposées. La question est alors hors de la logique commune.

D’ailleurs:

Donc, si l'on ne comprend pas la question 20 et qu'on essaie d'y répondre par la logique uniquement,

Là aussi c’est un concept original: essayer de répondre à une question qu’on ne comprend pas.

Envoyé par eyquem
- pourquoi faites vous si grand cas de la question 20 ?

Parce qu'on ne la comprend pas et que donc on ne sait pas comment y répondre (autrement que par la logique... ce qui demande plus de réflexion que pour les autres questions puisqu'elle n'est justement pas censée être résolue par la logique !).

Là je n’y comprends toujours strictement rien.





- Bon, que la question 20 n’ait pas de sens, c’est peut être parce que l’auteur a voulu mettre une question à la Pierre Dac dans un problème dont la solution est à la Georges Perec (dad bedded etc). J’ai été assez peu sensible à cet humour non-sense, si ça en est...

Le problème est encore que l’inénarable Jim Propp se fend d’une allusion à la question 20 qui a l’air de se vouloir fine mais qui me reste hermétique:

I should mention that if you don't agree with me about the answer to #20, you will get a different solution to the puzzle than the one I had in mind. But I should also mention that if you don't agree with me about the answer to #20, you are just plain wrong. :-)

Et compte tenu de ce qu’il a aussi écrit juste avant, et de la discussion autour de cette question dans cette file, j’ai cru qu’il suffisait d’une astuce de raisonnement pour passer d’une hypothèse de réponse pour la 20 au nombre de combinaisons de réponses possibles.

le fait que l'auteur considère que la solution existe et est unique a son importance

Oui mais laquelle. Je ne voyais pas quoi tirer de cette information.








En fait, je n’avais rien compris (je dois manquer à la fois d’intelligence et d’humour...)

L’essentiel reste

Copier-coller du quizz dans une feuille Excel pour améliorer la lisibilité, puis déduction logique par élimination successive des impossibilités.
Le tout en ~2h devant le film du dimanche soir

Ça n’est pas l’éclair de génie qui conduit d’une hypothèse au nombre de combinaisons rapidement comme je croyais l’avoir compris.




Je ne comprends toujours pas ce que l’auteur a poursuivi comme but avec sa question 20 faussement sybilline et véritablement foireuse, le fait est que je continue de la trouver saugrenue, mais maintenant je m’en fous.

Merci pour vos explications.





----------------------------------------------


Mais le problème m’a intéressé et m’intéresse toujours parce qu’il m’a paru très difficile dès l’abord.
Il me semble qu’il y a tellement trop de réponses dépendantes les unes les autres et dans une imbrication embrouillée et en cascades éventuellement longues, que je n’ai pas imaginé pouvoir y arriver par la seule réflexion.

Je me suis donc rapidement posé la même question que Barsy, comme toute personne intéressée par la programmation, je pense:
comment arriver à formaliser l’énoncé pour faire un programme qui va livrer la solution ?
C’est pour ça que j’étais particulièrement intéressé de comprendre quelle méthode logique existait, d’après vos posts, sur laquelle fonder un tel programme.

Mais je crains maintenant qu’en fait de méthode, il ne s’agisse pas d’une méthode à cheminement sûr.
Je pense qu’il s’agit plutôt d’une façon d’avancer par essais-erreurs successifs, le temps de résolution dépendant pour une part des choix faits au hasard, ou à l’intuition, de telle ou telle réponse prise comme une hypothèse à tester pour une question donnée.

C’est une méthode qui réclame bien sûr plus d’intelligence que la brute-force que j’ai envisagée et dans laquelle je me suis lancée. Et moins de flemmardise aussi.

Je vous tire d’ailleurs mon chapeau pour avoir réussi à trouver la solution en 2 heures. Même en sachant qu’on peut résoudre ainsi, je n’ai pas le courage de me lancer là dedans.

Mais une telle méthode ne me satisfait pas bien non plus. Il y a trop d’humain dedans.
Est-ce qu’il existerait une méthode qui, pour dire les choses de façon courte, pourrait se mettre en équation, au moins partiellement ? C’est la question que je me pose, dans la perspective d’une mise en programme qui ne soit pas de la brute-force.



J’ai eu le courage de me lancer dans un tel programme de brute-force mais celui auquel j’ai abouti ne doit pas être correct. On m’a indiqué sur un autre forum que certaines de ses instructions sont contestables. Il ne me sort en tous cas pas la solution quand je me débrouille à le faire itérer de façon à atteindre rapidement les solutions que vous avez données.

Je ne sais pas si je vais continuer à m’intéressser à ce casse-tête énervant.

Merci encore.

[sixmillespieds]

As-tu un si bon score au test standard pour penser qu'il mesure réellement l'intelligence???

Allez pour le fun, après l'avoir résolu à la mano, voici un code qui trouve toutes les solutions:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
147
148
149
150
151
152
153
154
155
156
:- use_module(library(clpfd)).

count(E,L,N):-partition(=(E),L,Include,_),length(Include,N1),N #= N1.

quizz(Solution) :-

	Solution=[Q1,Q2,Q3,Q4,Q5,Q6,Q7,Q8,Q9,Q10,Q11,Q12,Q13,Q14,Q15,Q16,Q17,Q18,Q19,Q20],
	SolBegin=[Q1,Q2,Q3,Q4,Q5,Q6,Q7,Q8,Q9,Q10],
	SolEnd=[Q11,Q12,Q13,Q14,Q15,Q16,Q17,Q18,Q19,Q20],
	% N1=nb_of_A, N2a=nb_of_B[1..10], N2b=nb_of_B[11..20], N3=nb_of_C, N4=nb_of_D, N5=nb_of_E
	Counts=[N1,N2a,N2b,N3,N4,N5],
	Solution ins 1..5,
	Counts ins 0..20,

	N1 + N2a + N2b + N3 + N4 + N5 #= 20,

% A=1, B=2, C=3, D=4, E=5

% 1. the first question whose answer is B is question 1/1 2/2 3/3 4/4 5/5
	Q1 #= 1 #<==> Q1 #= 2,
	Q1 #= 2 #<==> Q1 #\= 2 #/\ Q2 #= 2,
	Q1 #= 3 #<==> Q1 #\= 2 #/\ Q2 #\= 2 #/\ Q3 #= 2,
	Q1 #= 4 #<==> Q1 #\= 2 #/\ Q2 #\= 2 #/\ Q3 #\= 2 #/\ Q4 #= 2,
	Q1 #= 5 #<==> Q1 #\= 2 #/\ Q2 #\= 2 #/\ Q3 #\= 2 #/\ Q4 #\= 2 #/\ Q5 #= 2,

% 2. The only two consecutive questions with identical answers are questions 1/ 6 and 7, 2/ 7 and 8, 3/ 8 and 9, 4/ 9 and 10, 5/ 10 and 11
	Q2 #= 1 #<==> Q6 #= Q7 #/\ Q7 #\= Q8 #/\ Q8 #\= Q9 #/\ Q9 #\= Q10 #/\ Q10 #\= Q11,
	Q2 #= 2 #<==> Q6 #\= Q7 #/\ Q7 #= Q8 #/\ Q8 #\= Q9 #/\ Q9 #\= Q10 #/\ Q10 #\= Q11,
	Q2 #= 3 #<==> Q6 #\= Q7 #/\ Q7 #\= Q8 #/\ Q8 #= Q9 #/\ Q9 #\= Q10 #/\ Q10 #\= Q11,
	Q2 #= 4 #<==> Q6 #\= Q7 #/\ Q7 #\= Q8 #/\ Q8 #\= Q9 #/\ Q9 #= Q10 #/\ Q10 #\= Q11,
	Q2 #= 5 #<==> Q6 #\= Q7 #/\ Q7 #\= Q8 #/\ Q8 #\= Q9 #/\ Q9 #\= Q10 #/\ Q10 #= Q11,

% 3. The number of questions with the answer E is 1/ 0, 2/ 1, 3/ 2, 4/ 3, 5/ 4
	Q3 #= 1 #<==> N5 #= 0,
	Q3 #= 2 #<==> N5 #= 1,
	Q3 #= 3 #<==> N5 #= 2,
	Q3 #= 4 #<==> N5 #= 3,
	Q3 #= 5 #<==> N5 #= 4,

% 4. The number of questions with the answer A is 1/ 4, 2/ 5, 3/ 6, 4/ 7, 5/ 8
	Q4 #= 1 #<==> N1 #= 4,
	Q4 #= 2 #<==> N1 #= 5,
	Q4 #= 3 #<==> N1 #= 6,
	Q4 #= 4 #<==> N1 #= 7,
	Q4 #= 5 #<==> N1 #= 8,

% 5. The answer to this question is the same as the answer to question 1/ 1, 2/ 2, 3/ 3, 4/ 4, 5/ 5
	Q5 #= 1 #<==> Q1 #= 1,
	Q5 #= 2 #<==> Q2 #= 2,
	Q5 #= 3 #<==> Q3 #= 3,
	Q5 #= 4 #<==> Q4 #= 4,
	Q5 #= 5 #<==> Q1 #\= 1 #/\ Q2 #\= 2 #/\ Q3 #\= 3 #/\ Q4 #\= 4,

% 6. The answer to question 17 is 1/ C, 2/ D, 3/ E, 4/ none of the above, 5/ all of the above
	Q6 #= 1 #<==> Q17 #= 3,
	Q6 #= 2 #<==> Q17 #= 4,
	Q6 #= 3 #<==> Q17 #= 5,
	Q6 #= 4 #<==> Q17 #\= 3 #/\ Q17 #\= 4 #/\ Q17 #\= 5,
	Q6 #= 5 #<==> Q17 #= 3 #/\ Q17 #= 4 #/\ Q17 #= 5,

% 7. Alphabetically, the answer to this question and the answer to the following question are 1/ 4 apart, 2/ 3 apart, 3/ 2 apart, 4/ 1 apart, 5/ the same
	Q7 #= 1 #<==> Q8 - Q7 #= 4,
	Q7 #= 2 #<==> Q8 - Q7 #= 3,
	Q7 #= 3 #<==> Q8 - Q7 #= 2 #\/ Q7 - Q8 #= 2,
	Q7 #= 4 #<==> Q8 - Q7 #= 1 #\/ Q7 - Q8 #= 1,
	Q7 #= 5 #<==> Q8 #= Q7,

% 8. The number of questions whose answers are vowels is 1/ 4, 2/ 5, 3/ 6, 4/ 7, 5/ 8
	Q8 #= 1 #<==> N1 + N5 #= 4,
	Q8 #= 2 #<==> N1 + N5 #= 5,
	Q8 #= 3 #<==> N1 + N5 #= 6,
	Q8 #= 4 #<==> N1 + N5 #= 7,
	Q8 #= 5 #<==> N1 + N5 #= 8,

% 9. The next question with the same answer as this one is question 1/ 10, 2/ 11, 3/ 12, 4/ 13, 5/ 14
	Q9 #= 1 #<==> Q10 #= Q9,
	Q9 #= 2 #<==> Q10 #\= 2 #/\ Q11 #= Q9,
	Q9 #= 3 #<==> Q10 #\= 3 #/\ Q11 #\= 3 #/\ Q12 #= Q9,
	Q9 #= 4 #<==> Q10 #\= 4 #/\ Q11 #\= 4 #/\ Q12 #\= 4 #/\ Q13 #= Q9,
	Q9 #= 5 #<==> Q10 #\= 5 #/\ Q11 #\= 5 #/\ Q12 #\= 5 #/\ Q13 #\= 5 #/\ Q14 #= Q9,

% 10. the answer to question 16 is 1/4, 2/1, 3/5, 4/2, 5/3
	Q10 #= 1 #<==> Q16 #= 4,
	Q10 #= 2 #<==> Q16 #= 1,
	Q10 #= 3 #<==> Q16 #= 5,
	Q10 #= 4 #<==> Q16 #= 2,
	Q10 #= 5 #<==> Q16 #= 3,

% 11. The number of questions preceding this one with the answer B is 1/ 0, 2/ 1, 3/ 2, 4/ 3, 5/ 4
	Q11 #= 1 #<==> N2a #= 0,
	Q11 #= 2 #<==> N2a #= 1,
	Q11 #= 3 #<==> N2a #= 2,
	Q11 #= 4 #<==> N2a #= 3,
	Q11 #= 5 #<==> N2a #= 4,

% 12. The number of questions whose answer is a consonant is 1/ an even number, 2/ an odd number, 3/ a perfect square, 4/ a prime, 5/ divisible by 5
	Q12 #= 1 #<==> (N2a + N2b + N3 + N4) mod 2 #= 0,
	Q12 #= 2 #<==> (N2a + N2b + N3 + N4) mod 2 #= 1,
	Q12 #= 4 #<==> (N2a + N2b + N3 + N4) #= 1 #\/ (N2a + N2b + N3 + N4) #= 4 #\/ (N2a + N2b + N3 + N4) #= 9 #\/ (N2a + N2b + N3 + N4) #= 16,
	Q12 #= 4 #<==> (N2a + N2b + N3 + N4) #= 2 #\/ (N2a + N2b + N3 + N4) #= 3 #\/ (N2a + N2b + N3 + N4) #= 5 #\/ (N2a + N2b + N3 + N4) #= 7 #\/ (N2a + N2b + N3 + N4) #= 11 #\/ (N2a + N2b + N3 + N4) #= 13 #\/ (N2a + N2b + N3 + N4) #= 17 #\/ (N2a + N2b + N3 + N4) #= 19,
	Q12 #= 5 #<==> (N2a + N2b + N3 + N4) mod 5 #= 0,

% 13. The only odd-numbered problem with answer A is 1/ 9, 2/ 11, 3/ 13, 4/ 15, 5/ 17
	Q13 #= 1 #<==> Q1 #\= 1 #/\ Q3 #\= 1 #/\ Q5 #\= 1 #/\ Q7 #\= 1 #/\ Q9 #= 1 #/\ Q11 #\= 1 #/\ Q13 #\= 1 #/\ Q15 #\= 1 #/\ Q17 #\= 1 #/\ Q19 #\= 1,
	Q13 #= 2 #<==> Q1 #\= 1 #/\ Q3 #\= 1 #/\ Q5 #\= 1 #/\ Q7 #\= 1 #/\ Q9 #\= 1 #/\ Q11 #= 1 #/\ Q13 #\= 1 #/\ Q15 #\= 1 #/\ Q17 #\= 1 #/\ Q19 #\= 1,
	Q13 #= 3 #<==> Q1 #\= 1 #/\ Q3 #\= 1 #/\ Q5 #\= 1 #/\ Q7 #\= 1 #/\ Q9 #\= 1 #/\ Q11 #\= 1 #/\ Q13 #= 1 #/\ Q15 #\= 1 #/\ Q17 #\= 1 #/\ Q19 #\= 1,
	Q13 #= 4 #<==> Q1 #\= 1 #/\ Q3 #\= 1 #/\ Q5 #\= 1 #/\ Q7 #\= 1 #/\ Q9 #\= 1 #/\ Q11 #\= 1 #/\ Q13 #\= 1 #/\ Q15 #= 1 #/\ Q17 #\= 1 #/\ Q19 #\= 1,
	Q13 #= 5 #<==> Q1 #\= 1 #/\ Q3 #\= 1 #/\ Q5 #\= 1 #/\ Q7 #\= 1 #/\ Q9 #\= 1 #/\ Q11 #\= 1 #/\ Q13 #\= 1 #/\ Q15 #\= 1 #/\ Q17 #= 1 #/\ Q19 #\= 1,

% 14. The number of questions with answer D is 1/ 6, 2/ 7, 3/ 8, 4/ 9, 5/ 10
	Q14 #= 1 #<==> N4 #= 6,
	Q14 #= 2 #<==> N4 #= 7,
	Q14 #= 3 #<==> N4 #= 8,
	Q14 #= 4 #<==> N4 #= 9,
	Q14 #= 5 #<==> N4 #= 10,

% 15. The answer to question 12 is 1/ A, 2/ B, 3/ C, 4/ D, 5/ E
	Q15 #= Q12,

% 16. the answer to question 10 is 1/4, 2/3, 3/2 ,4/1 ,5/5
	Q16 #= 1 #<==> Q10 #= 4,
	Q16 #= 2 #<==> Q10 #= 3,
	Q16 #= 3 #<==> Q10 #= 2,
	Q16 #= 4 #<==> Q10 #= 1,
	Q16 #= 5 #<==> Q10 #= 5,

% 17. The answer to question 6 is 1/ C, 2/ D, 3/ E, 4/ none of the above, 5/ all of the above
	Q17 #= 1 #<==> Q6 #= 3,
	Q17 #= 2 #<==> Q6 #= 4,
	Q17 #= 3 #<==> Q6 #= 5,
	Q17 #= 4 #<==> Q6 #\= 3 #/\ Q6 #\= 4 #/\ Q6 #\= 5,
	Q17 #= 5 #<==> Q6 #= 3 #/\ Q6 #= 4 #/\ Q6 #= 5,

% 18. The number of questions with answer A equals the number of questions with answer 1/ B, 2/ C, 3/ D, 4/ E, 5/ none of the above
	Q18 #= 1 #<==> N1 #= N2a + N2b,
	Q18 #= 2 #<==> N1 #= N3,
	Q18 #= 3 #<==> N1 #= N4,
	Q18 #= 4 #<==> N1 #= N5,
	Q18 #= 5 #<==> N1 #\=N2a + N2b #/\ N1 #\= N3 #/\ N1 #\= N4 #/\ N1 #\= N5,

% 19. The answer to this question is 1/ A, 2/ B, 3/ C, 4/ D, 5/ E

% 20. Standardized test : intelligence :: barometer : 1/ temperature (only), 2/ wind-velocity (only), 3/ latitude (only), 4/ longitude (only), 5/ all of the above 

	label(Counts),
	label(Solution),
	count(1,Solution,N1),
	count(2,SolBegin,N2a),
	count(2,SolEnd,N2b),
	count(3,Solution,N3),
	count(4,Solution,N4),
	count(5,Solution,N5)
	.

all_solutions:-quizz(N),maplist(plus(64),N,M),maplist(put_char,M).

Ce qui donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
?- all_solutions.
DADBEDDEDABADCADBEDA
true ;
DADBEDDEDABADBADBECA
true ;
DADBEDDEDABADBADBABE
true ;
DADBEDDEDABADBADBAEB
true ;
false.

(Edité pour corriger la règle 13...)

[tomlev]

Allez pour le fun, après l'avoir résolu à la mano, voici un code qui trouve toutes les solutions

Argh, c'est quoi ce langage monstrueux ?
Bien joué quand même

Par contre, t'es sûr de tes résultats ? D'après l'énoncé, la solution est unique si tu as la bonne réponse à la question 20 (donc tes solutions avec A comme dernière réponse doivent être fausses, puisqu'il y en a 2)

[sixmillespieds]

oui, les 6 sont valides si l'on considère ne pas connaitre la réponse à la question 20... Et je n'ai pas codé l'unicité: je voulais avoir toutes les solutions et ne surtout pas coder en dur la réponse à une question (ça aurait été de la triche!)...
A propos de la question 20, j'ai considéré que ça me prendrai moins de temps d'expliquer à eyquem pourquoi la réponse à cette question est E que de coder une IA capable d'y répondre!
Et il n'existe qu'une unique réponse si on considère que la réponse à la question 20 est E: Dad bedded a bad bad babe !

---
Après correction de la règle 13, il n'en reste que 4...

[sixmillespieds]

Bon puisqu'il y en a qui cherchent la petite bébête, en ajoutant ça à la fin du code précédent:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
print_solution(N):-maplist(plus(64),N,M),maplist(put_char,M),nl.

all_solutions(Solutions):-findall(A,quizz(A),Solutions).

mycompare(Element,RefElement):-Element==RefElement,!.
mycompare(Element,RefElement):-nth1(20,Element,End1),\+ nth1(20,RefElement,End1).

compare_q20(Reference,Element):-maplist(mycompare(Element),Reference).

keep_uniques(Solutions,Result):-include(compare_q20(Solutions),Solutions,Result).

print_all_unique_solutions:-all_solutions(Solutions),keep_uniques(Solutions,Result),maplist(print_solution,Result).

On obtient:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
?- print_all_unique_solutions.
DADBEDDEDABADBADBABE
DADBEDDEDABADBADBAEB
true.

(Edité après correction de la règle 13...)

[tomlev]

par contre t'as pas répondu à ma question : c'est quoi ce langage ?

[sixmillespieds]

Du prolog...

[tomlev]

Du prolog...

ah ok, je m'en doutais un peu... c'est vraiment imbitable comme truc
mais c'est vrai que c'est assez adapté à ce genre de problème

[sixmillespieds]

j'utilise le constraint logic programming sous SWI Prolog et c'est vrai qu'il ajoute pas mal de signes "cabalistiques"... mais si tu enlèves les #, ca pourrait presque se lire!

[Barsy]

Bon, je pense que ça n'est pas aussi efficace que le code en prolog ci-dessus, mais je me suis amusé à résoudre le quizz à l'aide d'un algorithme génétique :

Voici mes classes (en C#)

Gene.cs

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace AlgoGeneQuizz
{
    class Gene
    {
        private int valeur;
 
        public int Valeur
        {
            get { return this.valeur; }
            set { this.valeur = value; }
        }
 
        #region Constructeurs
 
        /// <summary>
        /// Défini un gène
        /// </summary>
        public Gene()
        {
            this.valeur = -1;
        }
 
        /// <summary>
        /// Défini un gène
        /// </summary>
        /// <param name="valeur">Valeur du gène</param>
        public Gene(int valeur)
        {
            this.valeur = valeur;
        }
 
        /// <summary>
        /// Défini un gène
        /// </summary>
        /// <param name="valeurAleatoire">Mettre à true pour obtenir une valeur aléatoire</param>
        public Gene(bool valeurAleatoire, Random random)
        {
            if (valeurAleatoire)
            {
                valeur = random.Next(5);
            }
            else
            {
                this.valeur = -1;
            }
        }
 
        #endregion
 
        #region Méthodes
 
        /// <summary>
        /// Retourne la lettre associé au gène
        /// </summary>
        /// <returns></returns>
        public string getLettre()
        {
            switch (this.valeur)
            {
                case 0:
                    return "A";
                case 1:
                    return "B";
                case 2:
                    return "C";
                case 3:
                    return "D";
                case 4:
                    return "E";
                default:
                    return "";
            }
        }
 
        /// <summary>
        /// Retourne vrai si le gène vaut A
        /// </summary>
        /// <returns></returns>
        public bool isA()
        {
            return (this.valeur == 0);
        }
 
        /// <summary>
        /// Retourne vrai si le gène vaut B
        /// </summary>
        /// <returns></returns>
        public bool isB()
        {
            return (this.valeur == 1);
        }
 
        /// <summary>
        /// Retourne vrai si le gène vaut C
        /// </summary>
        /// <returns></returns>
        public bool isC()
        {
            return (this.valeur == 2);
        }
 
        /// <summary>
        /// Retourne vrai si le gène vaut D
        /// </summary>
        /// <returns></returns>
        public bool isD()
        {
            return (this.valeur == 3);
        }
 
        /// <summary>
        /// Retourne vrai si le gène vaut E
        /// </summary>
        /// <returns></returns>
        public bool isE()
        {
            return (this.valeur == 4);
        }
 
        #endregion
 
        #region Methodes statiques
 
        /// <summary>
        /// Génère un génome à partir d'une chaine de caractères (Pratique pour tester)
        /// </summary>
        /// <param name="valeurs">chaine contenant le génome</param>
        /// <returns></returns>
        public static Gene[] getGenome(string valeurs)
        {
            Gene[] resultat = new Gene[valeurs.Length];
            valeurs = valeurs.ToLower();
 
            for (int i = 0; i < valeurs.Length; i++)
            {
                switch (valeurs[i])
                {
                    case 'a':
                        resultat[i] = new Gene(0);
                        break;
                    case 'b':
                        resultat[i] = new Gene(1);
                        break;
                    case 'c':
                        resultat[i] = new Gene(2);
                        break;
                    case 'd':
                        resultat[i] = new Gene(3);
                        break;
                    case 'e':
                        resultat[i] = new Gene(4);
                        break;
                    default:
                        resultat[i] = new Gene(-1);
                        break;
                }
            }
 
            return resultat;
        }
 
        #endregion
 
    }
}

Individu.cs

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
 
namespace AlgoGeneQuizz
{
    class Individu
    {
        // Constante
        const int NB_GENES = 20;
 
        /// <summary>
        /// Ensemble des gènes de l'individu
        /// </summary>
        private Gene[] genome = new Gene[NB_GENES];
        private int note = 0;
 
        public int Note
        {
            get { return note; }
        }
 
        internal Gene[] Genome
        {
            get { return genome; }
        }
 
        #region Constructeurs
 
        /// <summary>
        /// Défini un individu
        /// </summary>
        /// <param name="genes">Ensemble des gènes de l'individu</param>
        public Individu(Gene[] genome)
        {
            this.genome = genome;
        }
 
        /// <summary>
        /// Défini un individu
        /// </summary>
        public Individu()
        {
            for (int i = 0; i < genome.Length; i++)
            {
                genome[i] = new Gene();
            }
        }
 
        /// <summary>
        /// Défini un individu
        /// </summary>
        /// <param name="valeursAleatoires">Mettre à true pour avoir des valeurs aléatoires</param>
        public Individu(bool valeursAleatoires, Random random)
        {
            for (int i = 0; i < genome.Length; i++)
            {
                genome[i] = new Gene(valeursAleatoires, random);
            }
        }
 
        #endregion
 
        #region Méthodes
 
        /// <summary>
        /// Retourne la réponse correspondante au numéro de question
        /// </summary>
        /// <param name="numQuestion">numéro de question</param>
        /// <returns></returns>
        public Gene reponse(int numQuestion)
        {
            return genome[numQuestion - 1];
        }
 
        /// <summary>
        /// Retoure un string pour afficher le contenu de l'individu
        /// </summary>
        /// <returns></returns>
        public string affichage()
        {
            StringBuilder contenu = new StringBuilder();
 
            foreach (Gene gene in genome)
            {
                contenu.Append(gene.getLettre());
            }
 
            return contenu.ToString();
        }
 
        /// <summary>
        /// Attribut une valeur à un gène de l'individu
        /// </summary>
        /// <param name="idGene">ID du gène</param>
        /// <param name="valeur">Valeur à attribuer</param>
        public void setValeur(int idGene, int valeur)
        {
            this.genome[idGene].Valeur = valeur;
        }
 
        /// <summary>
        /// Génère un individu enfant à partir de deux autres individus
        /// </summary>
        /// <param name="conjoint">Individu conjoint</param>
        /// <returns></returns>
        public Individu enfant(Individu conjoint, Random random)
        {
            // génère une séparation
            int coupure = random.Next(this.genome.Length - 1);
 
            // Jusqu'à la séparation, prend les gènes du premier parent
            // Après la séparation, prend les gènes du second parent
            Gene[] nouveauGenome = new Gene[NB_GENES];
            for (int i = 0; i < NB_GENES; i++)
            {
                if (i < coupure)
                    nouveauGenome[i] = new Gene(this.genome[i].Valeur);
                else
                    nouveauGenome[i] = new Gene(conjoint.genome[i].Valeur);
            }
 
            Individu resultat = new Individu(nouveauGenome);
            return resultat;
        }
 
        /// <summary>
        /// Réalise une mutation de gène au sein de l'individu
        /// </summary>
        public void mutation(Random random)
        {
            // Défini si une mutation doit avoir lieu ou non
            int mutant = random.Next(10);
 
            int gene1 = random.Next(this.genome.Length - 1);
            int gene2 = random.Next(this.genome.Length - 1);
            int gene3 = random.Next(this.genome.Length - 1);
            int gene4 = random.Next(this.genome.Length - 1);
            int gene5 = random.Next(this.genome.Length - 1);
            int gene6 = random.Next(this.genome.Length - 1);
 
            // Mutation par inversion de gène
            if (mutant < 3)
            {
                int temp = this.genome[gene1].Valeur;
                this.genome[gene1] = new Gene(this.genome[gene2].Valeur);
                this.genome[gene2] = new Gene(temp);
                temp = this.genome[gene3].Valeur;
                this.genome[gene3] = new Gene(this.genome[gene4].Valeur);
                this.genome[gene4] = new Gene(temp);
                temp = this.genome[gene5].Valeur;
                this.genome[gene5] = new Gene(this.genome[gene6].Valeur);
                this.genome[gene6] = new Gene(temp);
            }
            // Mutation par génération de gène
            else if (mutant < 6)
            {
                this.genome[gene1] = new Gene(true, random);
                this.genome[gene2] = new Gene(true, random);
                this.genome[gene3] = new Gene(true, random);
                this.genome[gene4] = new Gene(true, random);
                this.genome[gene5] = new Gene(true, random);
                this.genome[gene6] = new Gene(true, random);
            }
            // Injection d'un nouvel individu pour rafraîchir la population
            else if (mutant == 6)
            {
                for (int i = 0; i < genome.Length; i++)
                {
                    genome[i] = new Gene(true, random);
                }
            }
        }
 
        /// <summary>
        /// Calcule la note de l'individu
        /// </summary>
        /// <returns></returns>
        public void calculNote()
        {
            int result = 0;
 
            // Vérifie que 2 valeurs se suivent
            bool[] reponsesEgales = new bool[genome.Length - 1];
            int nbReponsesEgales = 0;
            for (int i = 0; i < genome.Length - 1; i++)
            {
                reponsesEgales[i] = (genome[i].Valeur == genome[i + 1].Valeur);
                if (reponsesEgales[i])
                    nbReponsesEgales++;
            }
 
            // Nombre de réponses pour chaque lettres
            int nbRepA = 0;
            int nbRepB = 0;
            int nbRepC = 0;
            int nbRepD = 0;
            int nbRepE = 0;
            foreach (Gene gene in this.genome)
            {
                if (gene.isA())
                    nbRepA++;
                if (gene.isB())
                    nbRepB++;
                if (gene.isC())
                    nbRepC++;
                if (gene.isD())
                    nbRepD++;
                if (gene.isE())
                    nbRepE++;
            }
 
            // Nombre de réponse B avant la question 11
            int nbRepBAvant11 = 0;
            for (int i = 0; i < 10; i++)
            {
                if (genome[i].isB())
                    nbRepBAvant11++;
            }
 
            // Nombre de réponses A impaires
            int nbRepAImpair = 0;
            for (int i = 0; i < genome.Length; i += 2)
            {
                if (genome[i].isA())
                    nbRepAImpair++;
            }
 
            // Q1 : The first question whose answer is B is question
            // A
            if (this.reponse(1).isA() && this.reponse(1).isB())
                result++;
            // B
            if (this.reponse(1).isB() && this.reponse(2).isB())
                result++;
            // C
            if (this.reponse(1).isC() && this.reponse(3).isB())
                result++;
            //D
            if (this.reponse(1).isD() && this.reponse(4).isB())
                result++;
            //E
            if (this.reponse(1).isE() && this.reponse(5).isB())
                result++;
 
            // Q2 : The only two consecutive questions with identical answers are questions
            // A
            if (this.reponse(2).isA() && nbReponsesEgales == 1 && reponsesEgales[5])
                result++;
            // B
            if (this.reponse(2).isB() && nbReponsesEgales == 1 && reponsesEgales[6])
                result++;
            // C
            if (this.reponse(2).isC() && nbReponsesEgales == 1 && reponsesEgales[7])
                result++;
            // D
            if (this.reponse(2).isD() && nbReponsesEgales == 1 && reponsesEgales[8])
                result++;
            // E
            if (this.reponse(2).isE() && nbReponsesEgales == 1 && reponsesEgales[9])
                result++;
 
            // Q3 : The number of questions with the answer E is
            // A
            if (this.reponse(3).isA() && nbRepE == 0)
                result++;
            // B
            if (this.reponse(3).isB() && nbRepE == 1)
                result++;
            //C
            if (this.reponse(3).isC() && nbRepE == 2)
                result++;
            // D
            if (this.reponse(3).isD() && nbRepE == 3)
                result++;
            // E
            if (this.reponse(3).isE() && nbRepE == 4)
                result++;
 
            // Q4 : The number of questions with the answer A is
            // A
            if (this.reponse(4).isA() && nbRepA == 4)
                result++;
            // B
            if (this.reponse(4).isB() && nbRepA == 5)
                result++;
            //C
            if (this.reponse(4).isC() && nbRepA == 6)
                result++;
            // D
            if (this.reponse(4).isD() && nbRepA == 7)
                result++;
            // E
            if (this.reponse(4).isE() && nbRepA == 8)
                result++;
 
            // Q5 : The answer to this question is the same as the answer to question
            // A
            if (this.reponse(5).isA() && this.reponse(1).isA())
                result++;
            // B
            if (this.reponse(5).isB() && this.reponse(2).isB())
                result++;
            // C
            if (this.reponse(5).isC() && this.reponse(3).isC())
                result++;
            // D
            if (this.reponse(5).isD() && this.reponse(4).isD())
                result++;
            // E
            if (this.reponse(5).isE() && this.reponse(5).isE())
                result++;
 
            // Q6 : The answer to question 17 is
            // A
            if (this.reponse(6).isA() && this.reponse(17).isC())
                result++;
            // B
            if (this.reponse(6).isB() && this.reponse(17).isD())
                result++;
            // C
            if (this.reponse(6).isC() && this.reponse(17).isE())
                result++;
            // D
            if (this.reponse(6).isD() && !this.reponse(17).isC() && !this.reponse(17).isD() && !this.reponse(17).isE())
                result++;
            // E
            if (this.reponse(6).isE() && this.reponse(17).isC() && this.reponse(17).isD() && this.reponse(17).isE())
                result++;
 
            // Q7 : Alphabetically, the answer to this question and the answer to the following question are
            // A
            if (this.reponse(7).isA() && Math.Abs(this.reponse(7).Valeur - this.reponse(8).Valeur) == 4)
                result++;
            // B
            if (this.reponse(7).isB() && Math.Abs(this.reponse(7).Valeur - this.reponse(8).Valeur) == 3)
                result++;
            // C
            if (this.reponse(7).isC() && Math.Abs(this.reponse(7).Valeur - this.reponse(8).Valeur) == 2)
                result++;
            // D
            if (this.reponse(7).isD() && Math.Abs(this.reponse(7).Valeur - this.reponse(8).Valeur) == 1)
                result++;
            // E
            if (this.reponse(7).isE() && this.reponse(7).Valeur == this.reponse(8).Valeur)
                result++;
 
            // Q8 : The number of questions whose answers are vowels is
            // A
            if (this.reponse(8).isA() && nbRepA + nbRepE == 4)
                result++;
            // B
            if (this.reponse(8).isB() && nbRepA + nbRepE == 5)
                result++;
            // C
            if (this.reponse(8).isC() && nbRepA + nbRepE == 6)
                result++;
            // D
            if (this.reponse(8).isD() && nbRepA + nbRepE == 7)
                result++;
            // E
            if (this.reponse(8).isE() && nbRepA + nbRepE == 8)
                result++;
 
            // Q9 : The next question with the same answer as this one is question
            // A
            if (this.reponse(9).isA() && this.reponse(10).isA())
                result++;
            // B
            if (this.reponse(9).isB() && this.reponse(11).isB())
                result++;
            // C
            if (this.reponse(9).isC() && this.reponse(12).isC())
                result++;
            // D
            if (this.reponse(9).isD() && this.reponse(13).isD())
                result++;
            // E
            if (this.reponse(9).isE() && this.reponse(14).isE())
                result++;
 
            // Q10 : The answer to question 16 is
            // A
            if (this.reponse(10).isA() && this.reponse(16).isD())
                result++;
            // B
            if (this.reponse(10).isB() && this.reponse(16).isA())
                result++;
            // C
            if (this.reponse(10).isC() && this.reponse(16).isE())
                result++;
            // D
            if (this.reponse(10).isD() && this.reponse(16).isB())
                result++;
            // E
            if (this.reponse(10).isE() && this.reponse(16).isC())
                result++;
 
            // Q11 : The number of questions preceding this one with the answer B is
            // A
            if (this.reponse(11).isA() && nbRepBAvant11 == 0)
                result++;
            // B
            if (this.reponse(11).isB() && nbRepBAvant11 == 1)
                result++;
            // C
            if (this.reponse(11).isC() && nbRepBAvant11 == 2)
                result++;
            // D
            if (this.reponse(11).isD() && nbRepBAvant11 == 3)
                result++;
            // E
            if (this.reponse(11).isE() && nbRepBAvant11 == 4)
                result++;
 
            // Q12 : The number of questions whose answer is a consonant is
            // A
            if (this.reponse(12).isA() && (nbRepB + nbRepC + nbRepD) % 2 == 0)
                result++;
            // B
            if (this.reponse(12).isB() && (nbRepB + nbRepC + nbRepD) % 2 != 0)
                result++;
            // C
            if (this.reponse(12).isC() && Math.Sqrt(nbRepB + nbRepC + nbRepD) == Math.Floor(Math.Sqrt(nbRepB + nbRepC + nbRepD)))
                result++;
            // D
            if (this.reponse(12).isD() && isPrime(nbRepB + nbRepC + nbRepD))
                result++;
            // E
            if (this.reponse(12).isE() && (nbRepB + nbRepC + nbRepD) % 5 == 0)
                result++;
 
            // Q13 : The only odd-numbered problem with answer A is
            // A
            if (this.reponse(13).isA() && this.reponse(9).isA() && nbRepAImpair == 1)
                result++;
            // B
            if (this.reponse(13).isB() && this.reponse(11).isA() && nbRepAImpair == 1)
                result++;
            // C
            if (this.reponse(13).isC() && this.reponse(13).isA() && nbRepAImpair == 1)
                result++;
            // D
            if (this.reponse(13).isD() && this.reponse(15).isA() && nbRepAImpair == 1)
                result++;
            // E
            if (this.reponse(13).isE() && this.reponse(17).isA() && nbRepAImpair == 1)
                result++;
 
            // Q14 : The number of questions with answer D is
            // A
            if (this.reponse(14).isA() && nbRepD == 6)
                result++;
            // B
            if (this.reponse(14).isB() && nbRepD == 7)
                result++;
            // C
            if (this.reponse(14).isC() && nbRepD == 8)
                result++;
            // D
            if (this.reponse(14).isD() && nbRepD == 9)
                result++;
            // E
            if (this.reponse(14).isE() && nbRepD == 10)
                result++;
 
            // Q15 : The answer to question 12 is
            // A
            if (this.reponse(15).isA() && this.reponse(12).isA())
                result++;
            // B
            if (this.reponse(15).isB() && this.reponse(12).isB())
                result++;
            // C
            if (this.reponse(15).isC() && this.reponse(12).isC())
                result++;
            // D
            if (this.reponse(15).isD() && this.reponse(12).isD())
                result++;
            // E
            if (this.reponse(15).isE() && this.reponse(12).isE())
                result++;
 
            // Q16 : The answer to question 10 is
            // A
            if (this.reponse(16).isA() && this.reponse(10).isD())
                result++;
            // B
            if (this.reponse(16).isB() && this.reponse(10).isC())
                result++;
            // C
            if (this.reponse(16).isC() && this.reponse(10).isB())
                result++;
            // D
            if (this.reponse(16).isD() && this.reponse(10).isA())
                result++;
            // E
            if (this.reponse(16).isE() && this.reponse(10).isE())
                result++;
 
            // Q17 : The answer to question 6 is
            // A
            if (this.reponse(17).isA() && this.reponse(6).isC())
                result++;
            // B
            if (this.reponse(17).isB() && this.reponse(6).isD())
                result++;
            // C
            if (this.reponse(17).isC() && this.reponse(6).isE())
                result++;
            // D
            if (this.reponse(17).isD() && !this.reponse(6).isC() && !this.reponse(6).isD() && !this.reponse(6).isE())
                result++;
            // E
            if (this.reponse(17).isE() && this.reponse(6).isC() && this.reponse(6).isD() && this.reponse(6).isE())
                result++;
 
            // Q18 : The number of questions with answer A equals the number of questions with answer
            // A
            if (this.reponse(18).isA() && nbRepA == nbRepB)
                result++;
            // B
            if (this.reponse(18).isB() && nbRepA == nbRepC)
                result++;
            // C
            if (this.reponse(18).isC() && nbRepA == nbRepD)
                result++;
            // D
            if (this.reponse(18).isD() && nbRepA == nbRepE)
                result++;
            // E
            if (this.reponse(18).isE() && nbRepA != nbRepB && nbRepA != nbRepC && nbRepA != nbRepD && nbRepA != nbRepE)
                result++;
 
            // Q19 : The answer to this question is
            // A
            if (this.reponse(19).isA())
                result++;
            // B
            if (this.reponse(19).isB())
                result++;
            // C
            if (this.reponse(19).isC())
                result++;
            // D
            if (this.reponse(19).isD())
                result++;
            // E
            if (this.reponse(19).isE())
                result++;
 
            // Q20 : Standardized test : intelligence :: barometer :
            // A
            if (this.reponse(20).isA())
                result++;
            // B
            if (this.reponse(20).isB())
                result++;
            // C
            if (this.reponse(20).isC())
                result++;
            // D
            if (this.reponse(20).isD())
                result++;
            // E
            if (this.reponse(20).isE())
                result++;
 
            this.note = result;
        }
 
        #endregion
 
        #region Fonctions
 
        /// <summary>
        /// Teste qu'un nombre est premier
        /// </summary>
        /// <param name="valeur">Nombre à tester</param>
        /// <returns></returns>
        public static bool isPrime(int valeur)
        {
            if (valeur == 1)
                return false;
            if (valeur == 2)
                return true;
            if (valeur % 2 == 0)
                return false;
 
            for (int i = 3; (i * i) <= valeur; i += 2)
            {
                if (valeur % i == 0)
                {
                    return false;
                }
            }
            return true;
        }
 
        #endregion
 
    }
}

Program.cs

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

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
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;
 
namespace AlgoGeneQuizz
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("Début de l'application");
 
            // Permet de calculer le temps d'exécution de l'application
            DateTime dateDebut;
            dateDebut = DateTime.Now;
 
            // Constantes
            const int NB_INDIVIDU = 100;
            const int NB_IND_TOURNOIS = 5;
            const int NOTE_MAX = 20;
 
            // Variable aléatoire utilisée dans l'ensemble de l'application
            Random random = new Random();
            // Population courante
            Individu[] population = new Individu[NB_INDIVIDU];
            // Population tampon
            Individu[] tempPopulation = new Individu[NB_INDIVIDU];
            // Compteur du nombre d'itérations
            int cptIteration = 1;
            // Individu résultat
            Individu resultat = null;
 
            // Initialisation : Génération de NB_INDIVIDU individus aléatoirement
            for (int i = 0; i < NB_INDIVIDU; i++)
            {
                population[i] = new Individu(true, random);
                population[i].setValeur(19, 4); // Force la dernière valeur à E;
            }
 
            // Algorithme génétique
            while (true)
            {
                // Calcul des notes des individus de la population
                int noteMax = 0;
                foreach (Individu individu in population)
                {
                    individu.calculNote();
                    if (individu.Note == NOTE_MAX)
                    {
                        resultat = individu;
                        break;
                    }
                    if (individu.Note > noteMax)
                        noteMax = individu.Note;
                }
                Console.WriteLine("Iteration n°" + cptIteration + " - Note la plus haute : " + noteMax);
 
                // Si le résultat est trouvé, l'application s'arrête
                if (resultat != null)
                {
                    break;
                }
 
                // Sélection des parents par la méthode du tournois
                // 5 individus sont comparés et le meilleur des 5 devient parent
                int randParent = 0;
                int[] parents1 = new int[NB_INDIVIDU];
                int[] parents2 = new int[NB_INDIVIDU];
                for (int i = 0; i < NB_INDIVIDU; i++)
                {
                    for (int j = 0; j < NB_IND_TOURNOIS; j++)
                    {
                        // Parent 1
                        randParent = random.Next(NB_INDIVIDU);
                        if (population[randParent].Note > population[parents1[i]].Note)
                            parents1[i] = randParent;
                        // Parent 2
                        randParent = random.Next(NB_INDIVIDU);
                        if (population[randParent].Note > population[parents2[i]].Note)
                            parents2[i] = randParent;
                    }
                }
 
                // Génération de la nouvelle population
                for (int i = 0; i < NB_INDIVIDU; i++)
                {
                    // Fusion des parents
                    tempPopulation[i] = population[parents1[i]].enfant(population[parents2[i]], random);
 
                    // Calcule la nouvelle note avant mutation (au cas où)
                    tempPopulation[i].calculNote();
                    if (tempPopulation[i].Note == NOTE_MAX)
                    {
                        resultat = tempPopulation[i];
                        break;
                    }
 
                    // Mutation de l'enfant
                    tempPopulation[i].mutation(random);
                }
 
                // Si le résultat est trouvé, l'application s'arrête
                if (resultat != null)
                {
                    break;
                }
 
                // Copie de la population tampon dans la population courante
                for (int i = 0; i < NB_INDIVIDU; i++)
                {
                    population[i] = new Individu(tempPopulation[i].Genome);
                }
 
                // Incrémente l'itération
                cptIteration++;
            }
 
            Console.WriteLine("Iteration n°" + cptIteration + " - Le résultat est : " + resultat.affichage());
 
            // Affiche le temps d'exécution de l'application
            TimeSpan dureeExecution = DateTime.Now.Subtract(dateDebut);
            Console.WriteLine("Fin de l'application - Durée : " + dureeExecution.Hours + "h" + dureeExecution.Minutes + "m" + dureeExecution.Seconds + "s" + dureeExecution.Milliseconds + "ms");
            Console.Read(); // Met en pause
        }
    }
}

J'obtiens des temps de calcul allant de quelques secondes à moins de 2 minutes. C'est assez rapide sachant qu'il y a près de 19^26 réponses possibles (soit 1.76845342 × 10^33).

Pour simplifier, je bloque la réponse 20 à E. Le problème de l'algorithme génétique est qu'il ne pourra pas me dire si la réponse qu'il trouve est unique.