[DEBUTANT] resolution du pb de math vietnamien (bug)

Version imprimable

Bonjour,
j'esperais coder un truc vite fait sous python mais je me heurte a une non resolution du pb et je ne vois pas pourquoi

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
nb_equ=0
compte=0
for a in range(1,9):
    for b in range(1,9):
        for c in range(1,9):
            for d in range(1,9):
                for e in range(1,9):
                    for f in range(1,9):
                        for g in range(1,9):
                            for h in range(1,9):
                                for i in range(1,9):
                                    flag=0  
                                    tableau=[a,b,c,d,e,f,g,h,i]
                                    for nbr in tableau:
                                        compte=tableau.count(nbr)
                                        if compte>1:
                                            flag=1
                                    if flag==0:      
                                        equation=a+13*b/c+d+12*e-f-11+g*h/i-10;
                                        if equation==66:
                                            print(tableau)
                                            nb_equ+=1
print(nb_equ)

pouvez vous m'aidez, parceque je ne vois pas ce qui cloche

Qu'est-ce qui ne marche pas ?
Voici un code simplifié :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
nb_equ=0
compte=0
for a in range(1,9):
    for b in range(1,9):
 
        flag=0  
        tableau=[a,b]
        print(tableau)
        for nbr in tableau:
            compte=tableau.count(nbr)
            if compte>1:
                flag=1
        if flag==0:      
            equation=a+13*b;
            if equation==66:
                print(tableau)
                nb_equ+=1
print(nb_equ)

Salut,

Une autre approche:

Code:

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
 
# -*- coding: utf-8 -*-
 
import random
import time
 
numbers = list(range(1, 10))
 
def get_values():
    random.shuffle(numbers)
    return numbers
 
def compute(lv):
    base = (lv[0] + 13) * lv[1]
    if base % lv[2] <  0.000000000000001:
        base /= lv[2]
        base = ((base + lv[3] + 12) * lv[4] - lv[5] - 11 + lv[6]) * lv[7]
        if base % lv[8] <  0.000000000000001:
            if base / lv[8] == 76:
                return True
 
    return False
 
 
def pretty_print(lst):
    txt = "".join(["\n Solution:\n    %s + 13 * %s / %s + %s + 12 * %s",
                   " - %s - 11 + %s * %s / %s - 10 = 66\nNombre d'essais: %s",
                   "\nTemps total:     %s\n"])
    print(txt % tuple(lst))
 
def main():
    begin = time.clock()
    count = 1
    while 1:
        list_values = get_values()
        if compute(list_values):
            time_tot = time.clock() - begin
            list_values.extend([count, time_tot])
            pretty_print(list_values)
            break
        count += 1
 
main()

Tu remarqueras qu'il y a deux divisions dont il faudra s'assurer que le résultat soit entier, même si l'énoncé en ta possession ne dit rien de précis à ce sujet.

23/05/2015, 19h52
markham

Citation:

Qu'est-ce qui ne marche pas ?

pas de solution trouvé par mon prog , alors qu'il y'en a au moins une :

le pb en question :
http://www.slate.fr/story/101809/puzzle-maths-vietnam

pour resumé il faut résoudre l'equation : a+13*b/c+d+12*e-f-11+g*h/i-10=66

sachant que les inconnues : a,b,c,d,e,f,g,h,i

sont des chiffre (donc compris entre 1 et 9) tous différents (a≠b≠c≠d≠e≠f≠g≠h≠i)

Bonjour

Citation:

Envoyé par markham

pas de solution trouvé par mon prog , alors qu'il y'en a au moins une :

Il y en a très exactement 20...

Citation:

Envoyé par markham

pour resumé il faut résoudre l'equation : a+13*b/c+d+12*e-f-11+g*h/i-10=66

sachant que les inconnues : a,b,c,d,e,f,g,h,i

sont des chiffre (donc compris entre 1 et 9) tous différents (a≠b≠c≠d≠e≠f≠g≠h≠i)

Déjà le -10 final peut disparaitre. Ensuite ta suite de boucles est beaucoup beaucoup trop longue (générer 1 milliards de chiffres pour n'en garder que 363000 soit 0,04% !!!)
Ce qu'il faut faire, c'est créer un tableau de tes chiffres de 1 à 9 puis essayer toutes les permutations. Ca ne devrait pas prendre plus de quelques dizaines secondes. Ou à la rigueur, faire que la boucle 2 ne traite pas le chiffre en cours sur la boucle 1, que la boucle 3 ne traite aucun des deux chiffres des boucles 1 et 2 et etc. Ca ira quand-même beaucoup plus vite...

Voici un code sale (parce que j'avais pas envie de me casser la tête à écrire la fonction de permutation) qui exploite cette idée...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 #!/usr/bin/env python # -*- coding: utf-8 -*- tab=[0,] * 9 for tab[0] in xrange(1, 10): for tab[1] in xrange(1, 10): if tab[1] in tab[:1]: continue for tab[2] in xrange(1, 10): if tab[2] in tab[:2] or tab[1] % tab[2]: continue for tab[3] in xrange(1, 10): if tab[3] in tab[:3]: continue for tab[4] in xrange(1, 10): if tab[4] in tab[:4]: continue for tab[5] in xrange(1, 10): if tab[5] in tab[:5]: continue for tab[6] in xrange(1, 10): if tab[6] in tab[:6]: continue for tab[7] in xrange(1, 10): if tab[7] in tab[:7]: continue for tab[8] in xrange(1, 10): if tab[8] in tab[:8]: continue if (tab[6] * tab[7]) % tab[8]: continue if (tab[0] + 13 * tab[1] / tab[2] + tab[3] + 12 * tab[4] - tab[5] - 11 + tab[6] * tab[7] / tab[8]) == 76: print tab
Maintenant, je pense que le plaisir aurait été de trouver sans ce brute force. Par exemple le 13*b/c indique que fatalement b et c sont divisibles l'un par l'autre (puisque 13 est premier). Donc c ne peut valoir que 1, 2 3 ou 4...

tres bonne idée la permutation, j'ai finalement simplifié au max le prog ça donne ça :
Code:

1 2 3 4 5 6 7 8 9 10 import itertools nb_equ=0 for tableau in itertools.permutations([1,2,3,4,5,6,7,8,9]): equation=tableau[0]+13*tableau[1]/tableau[2]+tableau[3]+12*tableau[4]-tableau[5]-11+tableau[6]*tableau[7]/tableau[8]-10 if 13*tableau[1]%tableau[2]==0 and tableau[6]*tableau[7]%tableau[8]==0: if equation==66: print(tableau) nb_equ+=1 print(nb_equ)
(3, 2, 1, 5, 4, 7, 8, 9, 6)
(3, 2, 1, 5, 4, 7, 9, 8, 6)
(5, 2, 1, 3, 4, 7, 8, 9, 6)
(5, 2, 1, 3, 4, 7, 9, 8, 6)
(5, 3, 1, 7, 2, 6, 8, 9, 4)
(5, 3, 1, 7, 2, 6, 9, 8, 4)
(5, 4, 1, 9, 2, 7, 3, 8, 6)
(5, 4, 1, 9, 2, 7, 8, 3, 6)
(5, 9, 3, 6, 2, 1, 7, 8, 4)
(5, 9, 3, 6, 2, 1, 8, 7, 4)
(6, 3, 1, 9, 2, 5, 7, 8, 4)
(6, 3, 1, 9, 2, 5, 8, 7, 4)
(6, 9, 3, 5, 2, 1, 7, 8, 4)
(6, 9, 3, 5, 2, 1, 8, 7, 4)
(7, 3, 1, 5, 2, 6, 8, 9, 4)
(7, 3, 1, 5, 2, 6, 9, 8, 4)
(9, 3, 1, 6, 2, 5, 7, 8, 4)
(9, 3, 1, 6, 2, 5, 8, 7, 4)
(9, 4, 1, 5, 2, 7, 3, 8, 6)
(9, 4, 1, 5, 2, 7, 8, 3, 6)
20

24/05/2015, 11h05
Sve@r

Citation:

Envoyé par markham

j'ai finalement simplifié au max le prog

Au max ??? Mais tu calcules l'équation même dans le cas où les divisions sont impossibles (d'ailleurs le "*13" du test est inutile) !!!
Et décidément tu y tiens à ton "-10"...
24/05/2015, 11h14
VinsS

Sans forcer l'ordre des opérations aux moyen de parenthèses le résultat ne sera pas exact.

Regarde ma fonction compute()

Edit: Vérification faite, tous tes résultats sont faux.
24/05/2015, 11h43
Sve@r

Citation:

Envoyé par VinsS

Edit: Vérification faite, tous tes résultats sont faux.

Ben mon code (je connaissais pas la fonction permute() de itertools) donne les mêmes résultats... et au-moins le dernier est juste. 9+13*4/1+5+12*2-7-11+8*3/6-10 font bien 66. Je pense que les autres le sont aussi...

Citation:

Envoyé par VinsS

Sans forcer l'ordre des opérations aux moyen de parenthèses le résultat ne sera pas exact.

Lis bien l'énoncé...

Citation:

En ajoutant, multipliant, soustrayant et divisant au fur et à mesure (en suivant l’ordre des opérations –multiplications et divisions en priorité), on doit arriver à 66.

Il n'y a rien à forcer...
24/05/2015, 12h54
VinsS

Citation:

Envoyé par Sve@r

Lis bien l'énoncé...

Il n'y a rien à forcer...

Ce n'est pas l'énoncé exact.

Ce problème de calcul est donné comme un exercice de calcul simple destiné à des élèves de l'enseignement primaire vietnamien et où toutes les opérations se succèdent dans l'ordre donné.

La légende tendant à faire croire que les enfants vietnamiens sont tous des hyper matheux de naissance.

Voici un lien:

http://www.7sur7.be/7s7/fr/31482/Le-...1&utm_content=

Citation:

Envoyé par VinsS

http://www.7sur7.be/7s7/fr/31482/Le-...1&utm_content=

Aïe, là il y a un litige car dans cet autre lien http://www.slate.fr/story/101809/puzzle-maths-vietnam c'est bien précisé que les règles de priorité des opérateurs usuels doivent être suivies.

Toutefois, au premier abord et vu la population ciblée, j'avais effectivement eu l'impression que les calculs auraient dû tout de même se faire de façon linéaire (style a+13=r1, r1*b=r2, r2/c=r3 etc...) et j'ai été en fait surpris de voir que les instructions contredisaient cette impression. On peut alors admettre que la page citée est elle-même erronée et que c'est la tienne qui est correcte.

Ceci dit, ce n'est pas très grave - On n'a qu'à résoudre dans les deux configurations possibles...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#!/usr/bin/env python
# -*- coding: utf-8 -*-
 
import itertools
def crawler(lineaire):
	for tab in itertools.permutations([1,2,3,4,5,6,7,8,9]):    
		if tab[1] % tab[2] or (tab[6] * tab[7]) % tab[8]: continue
		if lineaire and ((((tab[0] + 13) * tab[1] / tab[2] + tab[3] + 12) * tab[4] - tab[5] - 11 + tab[6]) * tab[7] / tab[8]) == 76: yield tab, " lineaire"
		if not lineaire and tab[0] + 13 * tab[1] / tab[2] + tab[3] + 12 * tab[4] - tab[5] - 11 + tab[6] * tab[7] / tab[8] == 76: yield tab, " priorite"
# crawler()
 
for (i, t) in enumerate(crawler(True)):
	print i+1, t
for (i, t) in enumerate(crawler(False)):
	print i+1, t

Le résultat avec les calculs faits de façon linéaire

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
1 ((1, 4, 2, 8, 5, 7, 6, 3, 9), ' lineaire')
2 ((1, 8, 4, 7, 5, 2, 6, 3, 9), ' lineaire')
3 ((1, 8, 4, 7, 5, 3, 9, 2, 6), ' lineaire')
4 ((1, 8, 4, 9, 5, 7, 3, 2, 6), ' lineaire')
5 ((2, 6, 3, 5, 1, 7, 9, 8, 4), ' lineaire')
6 ((2, 6, 3, 9, 1, 7, 5, 8, 4), ' lineaire')
7 ((2, 8, 4, 5, 1, 7, 9, 6, 3), ' lineaire')
8 ((2, 8, 4, 9, 1, 7, 5, 6, 3), ' lineaire')
9 ((2, 9, 3, 6, 5, 7, 8, 1, 4), ' lineaire')
10 ((6, 9, 3, 2, 1, 7, 8, 5, 4), ' lineaire')
11 ((7, 2, 1, 8, 4, 5, 6, 3, 9), ' lineaire')
12 ((7, 3, 1, 9, 2, 5, 6, 4, 8), ' lineaire')
13 ((7, 4, 2, 5, 1, 3, 8, 9, 6), ' lineaire')
14 ((7, 4, 2, 8, 1, 9, 6, 5, 3), ' lineaire')
15 ((7, 8, 4, 2, 1, 6, 9, 5, 3), ' lineaire')
16 ((7, 8, 4, 9, 1, 5, 6, 3, 2), ' lineaire')
17 ((8, 5, 1, 4, 2, 7, 6, 3, 9), ' lineaire')
18 ((9, 6, 3, 7, 5, 1, 4, 2, 8), ' lineaire')
19 ((9, 8, 4, 2, 1, 7, 6, 5, 3), ' lineaire')

Le résultat avec les priorités des opérateurs respectées

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1 ((3, 2, 1, 5, 4, 7, 8, 9, 6), ' priorite')
2 ((3, 2, 1, 5, 4, 7, 9, 8, 6), ' priorite')
3 ((5, 2, 1, 3, 4, 7, 8, 9, 6), ' priorite')
4 ((5, 2, 1, 3, 4, 7, 9, 8, 6), ' priorite')
5 ((5, 3, 1, 7, 2, 6, 8, 9, 4), ' priorite')
6 ((5, 3, 1, 7, 2, 6, 9, 8, 4), ' priorite')
7 ((5, 4, 1, 9, 2, 7, 3, 8, 6), ' priorite')
8 ((5, 4, 1, 9, 2, 7, 8, 3, 6), ' priorite')
9 ((5, 9, 3, 6, 2, 1, 7, 8, 4), ' priorite')
10 ((5, 9, 3, 6, 2, 1, 8, 7, 4), ' priorite')
11 ((6, 3, 1, 9, 2, 5, 7, 8, 4), ' priorite')
12 ((6, 3, 1, 9, 2, 5, 8, 7, 4), ' priorite')
13 ((6, 9, 3, 5, 2, 1, 7, 8, 4), ' priorite')
14 ((6, 9, 3, 5, 2, 1, 8, 7, 4), ' priorite')
15 ((7, 3, 1, 5, 2, 6, 8, 9, 4), ' priorite')
16 ((7, 3, 1, 5, 2, 6, 9, 8, 4), ' priorite')
17 ((9, 3, 1, 6, 2, 5, 7, 8, 4), ' priorite')
18 ((9, 3, 1, 6, 2, 5, 8, 7, 4), ' priorite')
19 ((9, 4, 1, 5, 2, 7, 3, 8, 6), ' priorite')
20 ((9, 4, 1, 5, 2, 7, 8, 3, 6), ' priorite')

Accessoirement je ne vois pas en quoi cet exercice est sensé prouver quoi que ce soit. Il y a très peu de prises mathématiques pour l'aborder. A la limite on sait que (a+13) * b/c est une division euclidienne parfaite donc on peut restreindre c à quelques valeurs selon a et b (sans avoir à forcément tester les 9 cas possibles) mais ça ne mêne pas très loin...