plus grand consecutifs

Bonjour
je voudrai savoir comment je peux afficher le k nombre consectifs de x ayant le plus grand produit
par exemple plusgrandconsecutifs([2,3,5,1,6],3)
ici je cherche le 3 valeurs consecutifs qui forme un grand nombre, doit renvoiyer [5,1,6]

volia ma solution
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 def exo7(liste,n): i=0 maxt=[0] maxi=1 pdt=1 for j in xrange(len(liste)): k=j pdt=1 print j while(i<n): pdt=pdt*liste[j] j=j+1 i=i+1 if pdt>=maxi: maxi=pdt while len(maxt)!=0: maxt.pop() maxt.append(liste[k]) i=i+1 j=k i=0 print maxt plusgrandconsecutifs([2,3,5,1,6],3)
pourrez vous m'aidez s'il vous plais
merci

dans l'exemple, [2,3,5] marche aussi non ?

Citation:

Envoyé par josmiley

dans l'exemple, [2,3,5] marche aussi non ?

oui ca marche,mais le probleme dans l 'exemple que j ai donné

Bonjour,

Essaie ça (Python 2.7):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def  plusgrandconsecutifs(L, n):
     pmax = 0 # sauvegarde du produit maxi
     ipmax = -1 # sauvegarde de son indice
     for i in range(0, len(L)-n+1):
         # calcul du produit
         p = 1
         for j in range(i, i+n):
             p *= L[j]
         # affichage de vérification (à supprimer après mise au point)
         print i, L[i:i+n], p
         # voir si le nouveau produit est plus grand que le précédent
         if p>pmax:
            # oui => on sauvegarde
            pmax = p
            ipmax = i
     # on retourne le résultat
     return ipmax, L[ipmax:ipmax+n], pmax
 
L = [20,3,5,1,60,4,9]
n = 3
i, L2, p = plusgrandconsecutifs(L, n)
print u"Résultat:", i, L2, p

Ce qui affiche:

Code:

1
2
3
4
5
6
0 [20, 3, 5] 300
1 [3, 5, 1] 15
2 [5, 1, 60] 300
3 [1, 60, 4] 240
4 [60, 4, 9] 2160
Résultat: 4 [60, 4, 9] 2160

Salut,

Une autre proposition:

Code:

1
2
3
4
5
6
7
8
9
10
11
 
L = [20,3,5,1,60,4,9]
n = 3
d = {}
for idx, num in enumerate(L[:-(n-1)]):
    d[idx] = sum(L[idx:idx+3])
 
kv = [(k, v) for k, v in d.iteritems()]
pgc = sorted(kv, key=lambda kv: kv[1])[-1]
val = L[pgc[0]:pgc[0]+3]
print 'Le plus grand consécutif est %s = %s' %(val, sum(val))

Code:

1
2
def exo7(seq,n):
    return max((reduce(lambda x,y: x*y,seq[i:i+n]),seq[i:i+n]) for i in range(len(seq)-n+1))[1]

Citation:
Envoyé par VinsS
Salut,

Une autre proposition:
Code:

1 2 3 4 5 6 7 8 9 10 11 L = [20,3,5,1,60,4,9] n = 3 d = {} for idx, num in enumerate(L[:-(n-1)]): d[idx] = sum(L[idx:idx+3]) kv = [(k, v) for k, v in d.iteritems()] pgc = sorted(kv, key=lambda kv: kv[1])[-1] val = L[pgc[0]:pgc[0]+3] print 'Le plus grand consécutif est %s = %s' %(val, sum(val))
je prefere python 3 et surtout j'aime bien quelqu"un qui m 'aide a trouver les bugs dans mon programme merci

Citation:

Envoyé par tyrtamos

Bonjour,

Essaie ça (Python 2.7):

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
def  plusgrandconsecutifs(L, n):
     pmax = 0 # sauvegarde du produit maxi
     ipmax = -1 # sauvegarde de son indice
     for i in range(0, len(L)-n+1):
         # calcul du produit
         p = 1
         for j in range(i, i+n):
             p *= L[j]
         # affichage de vérification (à supprimer après mise au point)
         print i, L[i:i+n], p
         # voir si le nouveau produit est plus grand que le précédent
         if p>pmax:
            # oui => on sauvegarde
            pmax = p
            ipmax = i
     # on retourne le résultat
     return ipmax, L[ipmax:ipmax+n], pmax
 
L = [20,3,5,1,60,4,9]
n = 3
i, L2, p = plusgrandconsecutifs(L, n)
print u"Résultat:", i, L2, p

Ce qui affiche:

Code:

1
2
3
4
5
6
0 [20, 3, 5] 300
1 [3, 5, 1] 15
2 [5, 1, 60] 300
3 [1, 60, 4] 240
4 [60, 4, 9] 2160
Résultat: 4 [60, 4, 9] 2160

vous avez changez completement le code que j'ai mis, en plus vous avez testez que la liste qui contient 3 valeurs qui marche avec le code que j'ai mis

Bonjour à vous aussi,

Citation:

Envoyé par pythonprog

vous avez changez completement le code que j'ai mis

Vous avez demandé une solution, et pas une critique de votre code.

Citation:

Envoyé par pythonprog

, en plus vous avez testez que la liste qui contient 3 valeurs qui marche avec le code que j'ai mis

???

Mon code marche quelque soit la liste et quelque soit le nombre de facteurs à multiplier. Par exemple:

L = [20,3,5,1,60,4,9,12,25,8,4,50]
n = 5

0 [20, 3, 5, 1, 60] 18000
1 [3, 5, 1, 60, 4] 3600
2 [5, 1, 60, 4, 9] 10800
3 [1, 60, 4, 9, 12] 25920
4 [60, 4, 9, 12, 25] 648000
5 [4, 9, 12, 25, 8] 86400
6 [9, 12, 25, 8, 4] 86400
7 [12, 25, 8, 4, 50] 480000

Résultat: 4 [60, 4, 9, 12, 25] 648000

Et vous avez d'autres propositions.

Citation:

Envoyé par pythonprog

vous avez changez completement le code que j'ai mis, en plus vous avez testez que la liste qui contient 3 valeurs qui marche avec le code que j'ai mis

Les constructions comme:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 def exo7(liste,n): i=0 ... for j in xrange(len(liste)): k=j ... while(i<n): pdt=pdt*liste[j] j=j+1 #....... i=i+1 #...... .... i=i+1 j=k i=0
sont des horreurs: difficile a lire, comprendre et a mettre au point.
N’espérez pas qu'on passe du temps a comprendre pourquoi ça ne fonctionne pas.
- W

Citation:

Envoyé par pythonprog

je prefere python 3

Suffit de remplacer iteritems par items et d'ajouter des parenthèses au print

Citation:

Envoyé par pythonprog

... et surtout j'aime bien quelqu"un qui m 'aide a trouver les bugs dans mon programme merci

Wiztricks vient de répondre.

Citation:

vous avez changez completement le code que j'ai mis

Votre solution ne suit pas les "traditions" du monde Python, vous semblez suivre plutôt une tradition Pascalienne ou c-ienne. Ceux qui vous ont répondu sont des spécialistes Python qui suivent leurs "traditions", ne serait-ce que par économie de temps (je vous rappelle quand même qu'il y a surtout des professionnels ici, par définition de ce forum). Il est vrai cependant que certaines constructions de Python sont un peu déroutantes au début.

Quand on apprend un langage, il faut aussi apprendre sa philosophie et ses traditions, ça fait partie du lot.

Votre code ne suit pas une indentation irréprochable, pourtant indispensable en Python (un des fondements du langage). On comprend mal le rôle de chacune de vos variables, tellement il y en a... D'ailleurs vous-même faites des confusions (rôle de i et de j)

Votre code avec quelques remarques
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 def exo7(liste,n): i=0 maxt=[0] maxi=1 # pdt=1 affectation inutile for j in range(len(liste)): # range suffit en Python k=j pdt=1 #print j pas d'affichage dans les calculs par principe while(i<n): pdt = pdt * liste[j] # Eviter les lourdeur syntaxiques j=j+1 # j étant contrôlé par le for plus haut, il est préférable de ne pas le modifier ici i=i+1 if pdt>=maxi: maxi=pdt while len(maxt)!=0: maxt.pop() maxt.append(liste[k]) # et k, il n'est pas incrémenté. i=i+1 # à quoi sert-ce ? vous affecter à 0 en bas... j=k i=0 print maxt
Pour votre problème, il faut former la liste de tous les produits de n termes consécutifs à partir d'une liste de M termes (il y a M-2 produit à calculer, de 0 à M-3), l'indice de chaque produit étant celui du premier des N termes de chaque sous-suite.

Votre code en un peu plus simple:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 def exo7mieux(liste,n): maxi=1 maxt = [] for j in range(len(liste)-n+1): # range suffit en Python 3 # produit des n termes de la sous-liste de rang j pdt=1 for i in range(n): pdt *= liste[j+i] # j non modifié # est-ce le nouveau max ? if pdt >= maxi: maxi = pdt # reprendre la sous-liste à l'origine du produit maxt = liste[j:j+n] # utilise le slices, concept élémentaire de Python return maxt
Une autre solution, proche du texte de ma solution et qui retourne toutes les sous-suites :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 def toto(L,N): # liste des produits de N termes # pourrait être écrit de manière plus compacte P = [] for i in range(len(L)-N+1): # produit de rang i prod = 1 for term in L[i:i+N]: # sous-listes de N termes à partir du rang i prod *= term P.append(prod) # Obtenir la valeur maximale des produits obtenus m = max(P) # Liste de sous-listes de longueur N dont le produit est égale au maximum # définit une liste en compréhension, il faut lire la doc pour comprendre. # facile à transformer en boucle for return [L[i:i+N] for i in range(len(P)) if P[i] == m]
Enfin, un contrôle entre la longueur de la liste et n, qui ne doit pas être trop grand, ne serait pas mal du tout.

Bonjour,

+1 pour e-ric et Wiztrick,

Si vous demandez un minimum d'investissement dans votre code, il faudra en montrer aussi en commentant votre code.

Ça aurait été sympatique de

1) Donner les problèmes rencontrés dans votre code
2) Les erreurs de l'interpréteur

Et en prime faire une demande explicite sur ce que vous souhaitez vraiment, et pas juste un énoncé.

Bonne continuation...

Edit :

En prime ma solution, pas de raison que je ne m'amuse pas aussi, non mais...
Code:

1 2 3 4 5 6 7 8 >>> from functools import reduce >>> from operator import mul >>> l = [12, 5, 7, 9, 2, 5, 8] >>> res = list(map(lambda x: reduce(mul, x), [l[i:i+3] for i in range(len(l)-2)])) [420, 315, 126, 90, 80] >>> ind = res.index(max(res)) >>> l[ind:ind+3] [12, 5, 7]

Citation:

Envoyé par e-ric

Votre solution ne suit pas les "traditions" du monde Python, vous semblez suivre plutôt une tradition Pascalienne ou c-ienne. Ceux qui vous ont répondu sont des spécialistes Python qui suivent leurs "traditions",

C'est pas une question de tradition, juste de traduction d'une idée d'algo. qu'on a pris le temps de faire fonctionner sur le papier (ou dans sa tete) avant d'essayer de le "coder". Et si on ne retrouve pas dans le code le semblant d'algo. qu'on prétend réaliser, pas la peine d'essayer de le faire marcher.

C'est difficile mais "coder" est une forme de "rendu" de ses idées.
Imaginez l’écrivain qui jette pour la n-ieme fois son brouillon parce qu'il ne retrouve pas ce qu'il veut dire dans le "rendu" papier qu'il a pondu.
Il jette et il recommence.

Avec Python, l'algo "papier" peut s’écrire en Python
Pourquoi ne pas commencer par écrire:
Code:

1 2 3 4 5 6 7 def func(L, n): max_p = 0 for ix, s in sequence(L, n): p = produit(s) if p >= max_p: max_s, max_p, max_ix = s, p, ix return max_s, max_p, max_ix
Une partie de la complexité a été poussée dans les fonctions "sequence" et "produit". Ce faisant, les détails de leur réalisation n'encombrent pas l'algo: il est assez simple pour être sur de ce que ça fait ou pas.

Votre option (et celle de Tyrtamos) a été de réaliser ces fonctions "inline" en utilisant les propriétés des séquences.
C'est "assez bon" car c'est assez light pour rester "lisible".

Cela "ferme" les différentes possibilités de les adapter a différents cas, limite le polymorphisme de la construction....
Est aussi exclue la possibilité de les réaliser avec le pas grand chose que connaît le débutant Python sur les séquences et qu'il pourra enrichir plus tard.

- W

J'ai parlé de tradition à défaut de mieux car la façon initiale de résoudre le problème est très proche d'une solution réalisée en Pascal, bien que fausse.
Précision: Je viens du monde Pascal.

Code:

C'est difficile mais "coder" est une forme de "rendu" de ses idées.

ça c'est vrai, c'est aussi pour cela qu'il n'est pas très utile de rédiger un algo dans un langage spécial sauf peut-être en respectant la notation mathématique. Un langage de programmation propose une grammaire formelle et "opérationnelle" tout à fait adaptée à la description d'un algo.

Citation:

Est aussi exclue la possibilité de les réaliser avec le pas grand chose que connaît le débutant Python sur les séquences et qu'il pourra enrichir plus tard.

Ok pour les fonctions lambda et autres joyeusetés mais j'ai pris soin de proposer une solution abordable, je pense que les listes en compréhension et les slices sont faciles à comprendre, non ?

Citation:

Cela "ferme" les différentes possibilités de les adapter a différents cas, limite le polymorphisme de la construction....

Certes, certes mais je doute que cela soit une contrainte pour notre débutant.

Citation:

Envoyé par e-ric

Ok pour les fonctions lambda et autres joyeusetés mais j'ai pris soin de proposer une solution abordable, je pense que les listes en compréhension et les slices sont faciles à comprendre, non ?

Je complétais en disant surtout que cela empêche leur réalisation avec ce qu'on connaît.
Par exemple, on peut très bien realiser ca (pas teste) avec:
Code:

1 2 3 4 5 6 7 8 9 def sequence(L, n): sequences = [] for ix in range(len(L)): if (ix + n) > len(L): break s = [] for iy in range(n): s.append(L[ix+iy] sequences.append(s) return sequences
L'horrible est dans une "feuille".
Elle réalise un petit bout qui peut être mis au point sans devoir casser autre chose et sans changer la "structure" de l'algo. - l'important -

Apprendre a programmer, c'est arriver a maîtriser cette mécanique top-down qui organise le brouillon-nage "bottom-up". Ce sont des automatismes qui s'installent (ou pas). C'est votre cerveau que vous être en train de re-cabler pour qu'il soit plus "agile".

Python la dedans n'est qu'un outil pour réaliser cet apprentissage.
C'est cette connaissance qu'on pourra réutiliser dans d'autres domaines et pour débuter rapidement avec d'autres langages..

- W

Mais que fait pythonprog ? On ne l'entend plus depuis un jour.