La même chose en plus concis

 Cliquez pour afficher

import itertools

solutions = set()
for A,B,C,D,E in itertools.permutations(range(10),5):
	z,t = (A*10+B)*10+C, D*10+E
	r,s = z+t,z-t
	if r>999 or s<0 or A != s//100 : continue
	F,G,H,I,J = r//100,(r//10)%10,r%10,(s//10)%10, s%10
	if len({A,B,C,D,E,F,G,H,I,J}) == 10:
		solutions.add((A,B,C,D,E,F,G,H,I,J,z,t,r,s))
		
		
print len(solutions)
for x in solutions:
	A,B,C,D,E,F,G,H,I,J,ABC,DE,r,s = x
	print "%s : %03d+%d = %03d et %03d-%d = %03d" % (x[:10],ABC,DE,r, ABC,DE,s)

et donc ?

Petit coup de pouce:
Dans la première addition il y a 2 retenues...

Bonjour dpi

 Cliquez pour afficher

5794162038 ?

>littleguy
Je sais que tu vas trouver.

 Cliquez pour afficher

Si on pose les opérations avec tes chiffres on obtient:
   579             579
+   41    et     - 41          
6203             568
Tu n'a que B=7   ton F= 6  est manifestement exagéré

> dpi

 Cliquez pour afficher

On n'a pas la même façon de compter...

> dpi

 Cliquez pour afficher

Pour moi 579+41=620 et 579-41=538, non ?
Ou alors j'ai mal interprété les données.

salut

à Ulmiere :

une petite question : dans

La condition dit : si r = ABC+DE a quatre chiffres, ou si s=ABC-DE a une signe négatif, ou encore si  A!=s//100, on passe à la permutation suivante, y'a rien à tirer de celle là.

(pour info a//b est la partie entière de a/b. Donc a//b**n shift le nombre a de n crans vers la droite en base b.)

Pour que la combinaison soit retenue on veut que s == AIJ. Donc les deux doivent avoir la même décomposition en base 10.
Donc s//100 == AIJ//100 = A,  (s//10)%10 == (AIJ//10)%10 = I et s%10 == AIJ%10 = J.
L'intérêt c'est de vérifier d'abord la condition sur A (un seul calcul), afin d'éviter de calculer F,G,H,I et J pour rien si elle n'est pas vérifiée.



La méthode de Horner est plus rapide pour évaluer des polynômes.
calculer demande n+1 + n + ... + 1 = (n+1)(n+2)/2 = O(n²) multiplications et n-1 = O(n) additions si on retient pas les puissances successives de X en mémoire.
calculer demande O(n) additions et O(n) multiplications.

Ici c'est un peu inutile car avec de si petits nombres, et vu comme Python est optimisé, on ne doit presque voir aucune différence, mais c'est une bonne pratique. Toutes les bonnes librairies bigint l'utilisent. Ca, Karatsuba, et les méthodes de multiplications du type FFT.



Enfin pour itertools, c'est avec numpy/sympy mon package préféré. Il te permet de générer en quelques frappes des permutations ou combinaisons de la taille que tu veux, avec ou sans répétition. Et ca renvoie un itérateur, donc aucune consommation de mémoire, tu génères les permutations dans l'ordre, au fur et à mesure.
Il sait faire plein de choses à très haute vitesse, et est propre

>littleguy

Et à tous.

Tu m'as fait découvrir une erreur dans mon énoncé (c'est l'âge) et donc je vais le  signaler à tous .

Une malencontreuse colonne cachée  m'a privé du F et à donc décalé l'énoncé:
Il aurait dû être:  
       ABC                   ABC
  +     DE      et       -   DE  
----------             ----------
= FGHI                   A  I  J

 Cliquez pour afficher

Si je ne m'abuse  dans l'ordre ABCDEFGHIJ  tu trouves  5794162038  et cela convient
parfaitement  à l'énoncé initial  
Tu comprends maintenant pourquoi je trouvais  F un peu gros....    

ok oui c'est bien ce que je pensais ...

c'est vrai que la méthode de Horner consomme moins d'opérations pour de "grands" polynomes

merci pour tout


une dernière chose : j'aime pas trop les "break" ou les "continue" ... n'est-il pas "plus naturel" d'écrire :

if r < 1000 and s > 0 and A == s//100 :
	F,G,H,I,J = r//100,(r//10)%10,r%10,(s//10)%10, s%10
	if len({A,B,C,D,E,F,G,H,I,J}) == 10:
		solutions.add((A,B,C,D,E,F,G,H,I,J,z,t,r,s))

      ABC                   ABC
+      DE      et    -      DE  
----------             ----------
   FGHI                    AI J

A = 9
F = 1
G = 0
D < B
B + D > 8
I et J ont même parité

...

Ce code fonctionnera aussi mais à mon avis sera plus lent. Dans un cas comme dans l'autre l'évaluation des booléens est paresseuse.
Seulement

if A==b1 and B==b2 and C==b3:
    blablabla

mov rax, qword[adresse_de_A]
cmp rax, qword[adressse_de_b1]
je .condition_vraie1
jmp .suite
.condition_vraie1
     mov rax, qword[adresse_de_B]
     cmp rax, qword[adressse_de_b2]
     je .condition_vraie2
     jmp .suite

     .condition_vraie2:
            ....
            .condition_vraie3:
                    ........
.suite:
      blablablabla

mov rax, qword[adresse_de_A]
cmp rax, qword[adressse_de_b1]
jnz .suite
mov rax, qword[adresse_de_B]
cmp rax, qword[adressse_de_b2]
jnz .suite
mov rax, qword[adresse_de_C]
cmp rax, qword[adressse_de_b3]
jnz .suite
      blablabla
.suite:
      blablablabla

ok d'accord ... je comprends l'idée mais là je te fais confiance sur le traitement interne : il y a une "chaîne" de "et condition" à traiter (on continue jusqu'à rencontrer une condition fausse) alors qu'avec des "or non condition" on passe immédiatement

c'est donc à nouveau un pb d'efficacité ...

merci pour tout

De rien

Enfin, il y a un certain temps c'était comme ça. Peut-être que maintenant c'est mieux optimisé (j'éspère !)

Autre traduction, en pseudo-code, pour clarifier, du code avec and

if condition1:
     if condition2:
           if condition3:
                     oui !!!!!
           else:
                 goto ici
     else:
         goto ici
else:
      goto ici

ici:
   non !!!!!!

if ncondition1:
     goto ici
if ncondition2:
     goto ici
if ncondition3:
     goto ici

oui!!!!!!!!!!!

ici:
    non !!!!!!!!!!!

>carpediem
Merci d'avoir répondu à la bonne version....

Tes approches sont bonnes ;

 Cliquez pour afficher

un petit coup de pouce :
B+D+1 =H+10   --->B+D= H+9  
dans la soustraction   B-D=I

merci Ulmiere  c'est plus clair ainsi :

effectivement avec des et on a une imbrication de conditions alors qu'avec des ou on a une liste de conditions ce qui effectivement devrait consommer moins de mémoire ...

merci pour tout

dpi : je n'ai donné que des évidences ... le reste nécessite un chouia d'effort supplémentaires (pour traduire l'ensemble des opérations) ... et des tests ...

et je n'ai pas envie de me "fatiguer" ... (j'ai des copies à corriger !!!)

Bonsoir,

Ne fatiguez pas vos neurones pour la deuxième version car 5 doit  être à la fois pair et impair !!!
Si on garde la première version littleguy a trouvé

   579                     579        ABCDEFGHI
+   41                    -  41         579416203
--------              --------
+620                   538      

Bonjour dpi

Ça me rassure, je ne m'en sortais pas avec la seconde mouture !

Bonsoir littleguy,

Je fignolerai la prochaine