Discussion :

[Sve@r]

Ce qui me surprend c'est que toutes vos solutions testent tous les nombres de 0 à 1000.

Je crois qu'on est tous partis dans l'idée plus ou moins consciente que le bouzin devait pouvoir chercher n'importe quelle correspondance et pas seulement le "15" de l'énoncé

Code python :

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

1
2
for i in range(69, 961):
    if not i % 3:

Ce qui me surprend c'est que tu génères des nombres que tu ne traites pas
for i in range(69, 961, 3)

Accessoirement, s'il faut tester une égalité avec 0, alors je conseillerais d'écrire le test intégral et non pas passer par "not" qui est plus associé à la notion de booléen. Déjà parce que cela est plus universel (aujourd'hui c'est 0, demain ça pourrait être 57) et correspond aux préconisations regroupées dans la pep 203 dont l'une d'elles dit précisément qu'explicite vaut mieux qu'implicite
if (i % 3) == 0 (et ça ne coûte pas vraiment plus cher )

Sinon inutile de construire une liste -->:

Code :

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

sum(int(n) for n in str(i))

Ah, il y en a au-moins un qui a lu ce que j'ai écrit sur le souci lié aux listes créées inutilement. Dommage qu'il n'ait pas lu jusqu'à la fin...=> sum(map(int, str(i)))

[MPython Alaplancha]

Ah, il y en a au-moins un qui a lu ce que j'ai écrit sur le souci lié aux listes créées inutilement. Dommage qu'il n'ait pas lu jusqu'à la fin...=> sum(map(int, str(i)))

Je t'ai lu jusqu'au bout... À vrai dire, je ne pensais pas à ton intervention, mais juste qu'utiliser une expression génératrice est plus efficace que de construire une liste.

[CosmoKnacki]

Basé sur des observations empiriques, pour aller directement au nombre suivant:

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
jump = 63 # saut d'une centaine à l'autre
jumpstep = -9 # variation de jump
item = 4  # nombre d'items par centaine
itemstep = 1  # variation d'item
 
x = 69
 
while x < 960:
    for i in range(item):
        print(x)
        x += 9
 
    if item == 10:
        itemstep = -itemstep
        jumpstep = -jumpstep
    else:
        jump += jumpstep
 
    item += itemstep
    x += jump

Dans une même centaine tous les résultats sont distants de 9.
Pour chaque nouvelle centaine, le nombre de résultats par centaine augmente de 1 et le saut d'une centaine à l'autre diminue de 9.
Si le nombre de résultats par centaine atteind 10, alors le nombre de résultats par centaine pour les centaines suivantes diminue de 1, et, le saut d'une centaine à l'autre augmentera de 9.

Malheureusement, comme je ne connais pas la "rêgle" précise qui sous-tend ces observations, difficile d'étendre l'algorithme au delà de 1000, (pour le passage d'un millier à l'autre le saut est augmenté de 36).

[Invité]

Slt !

Mouai l'optimisation est un peu futile non ?
En énumérant tous les nombres de 0 à 1000 mon PC met entre 0 et 1 msec pour sortir la liste des nombres concernés.

[Sve@r]

Basé sur des observations empiriques, pour aller directement au nombre suivant

Mouai l'optimisation est un peu futile non ?

Et aussi ça limite le programme à se cantonner au seul total 15 (tout à refaire si on veut le résultat 18).
Mais si tu t'es fait plaisir en écrivant ce code, c'est tout ce qui compte

[Invité]

Oki !

Sinon je ne sais pas si ça a été proposé mais pourquoi ne pas simplement écumer toutes les additions de 3 chiffres ?

Code :

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

1
2
3
4
5
6
7
8
>>> def toto(somme):
	liste = []
	for c in range(0,10):
		for d in range(0,10):
			u = somme-d-c
			if 0<= u <= 9:
				liste.append(int(str(c)+str(d)+str(u)))
	return liste

On peut probablement gratter quelques pouièmes de microsecondes ainsi :

Code :

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

1
2
3
4
5
6
7
8
9
10
def TOTO(somme):
	liste = []
	nb = 0
	for c in range(0,10):
		for d in range(min(9, max(0, somme-c-9)),10):
			nb+=1
			u = somme-d-c
			if 0<= u <= 9:
				liste.append(int(str(c)+str(d)+str(u)))
	return nb, len(liste), liste

Code :

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

1
2
>>> TOTO(15)
(79, 73, [69, 78, 87, 96, 159, 168, 177, 186, 195, 249, 258, 267, 276, 285, 294, 339, 348, 357, 366, 375, 384, 393, 429, 438, 447, 456, 465, 474, 483, 492, 519, 528, 537, 546, 555, 564, 573, 582, 591, 609, 618, 627, 636, 645, 654, 663, 672, 681, 690, 708, 717, 726, 735, 744, 753, 762, 771, 780, 807, 816, 825, 834, 843, 852, 861, 870, 906, 915, 924, 933, 942, 951, 960])

6 calculs en trop avec 15 au lieu de 26 calculs en trop sans cette petite optimisation... Niveau timing en réalité je pense qu'on ne gagne rien voire on perd ! ^^

[MPython Alaplancha]

Bonjour,

Oki !

Sinon je ne sais pas si ça a été proposé mais pourquoi ne pas simplement écumer toutes les additions de 3 chiffres ?

Code :

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

1
2
3
4
5
6
7
8
>>> def toto(somme):
	liste = []
	for c in range(0,10):
		for d in range(0,10):
			u = somme-d-c
			if 0<= u <= 9:
				liste.append(int(str(c)+str(d)+str(u)))
	return liste

On peut probablement gratter quelques pouièmes de microsecondes ainsi :

Ceci semble plus rapide:

Code :

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

1
2
3
def toto(somme):
	return [int(f"{c}{d}{somme-d-c}") for c, d in itertools.product(
            range(10), range(10)) if 0<= somme-d-c <= 9]