J'ai 5 exercices à faire, tous concerne les listes. J'en ait fait l'équivalent de 4 sur 5. Mais dans deux de ces exercices, je n'arrive pas à traiter de la seconde question. Alors, voilà la consigne du premier exercice:
Écrire le programme qui construit et renvoie la liste [4, 2, 4, 2, 4, ...] de longueur n. Puis celui qui construit et renvoie la liste [0, 1, 2, 0, 1, 2, 0, ...] à nouveau de longueur n.
Voici ce que j'ai fait:
def Liste3(n):
L = [4] * n
i = 1
while i < n :
L[i] = 2
i += 2
return L
def Liste4(n):
L = [0] * n
i = 1
while i < n :
L[i] = 1
i += 2
while i < n :
L[i] = 2
i += 2
return L
J'ai testé le premier programme, il marche mais je bloque pour la liste [0,1,2....0,1,2]
Voici le second exercice:
a) Écrire un programme NombreOccurrences(L, x) qui détermine le nombre de fois où x apparaît dans la liste L. Ce nombre p eut être nul. b) En déduire un programme Mode(L) qui renvoie la valeur de L ayant le plus grand nombre d'occurrences (où l'une d'elles en cas d'égalité)
Voici mes réponses: a)
def NombreOccurences(L, x):
compteur = 0
for i in L :
if i == x:
compteur = compteur + 1
return compteur
Merci de colorer votre code à l'aide du bouton Code
Les forums d'Openclassrooms disposent d'une fonctionnalité permettant de colorer et mettre en forme les codes source afin de les rendre plus lisibles et faciles à manipuler par les intervenants. Pour cela, il faut utiliser le bouton de l'éditeur, choisir un des langages proposés et coller votre code dans la zone prévue. Si vous utilisez l'éditeur de messages en mode Markdown, il faut utiliser les balises <pre class="brush: python;">Votre code ici</pre>.
Merci de modifier votre message d'origine en fonction.
Pour prendre ton exo avec t=[0, 1, 2], c'est très simple, la valeur que tu vas placer dans ta liste finale à l'indice i dépend uniquement du reste de i modulo la longueur de ta petite liste t. Si tu n'utilises pas de liste t, il te suffit d'écrire une suite de if/elif en fonction du reste. A l'inverse de ce que tu as écrit, il n'y a aucune boucle imbriquée, il est clair que l'on peut réaliser l'opération en une seule traversée.
Par ailleurs, tu utilises à tort des boucles while ou lieu de boucle for, cf. ICI pour les inconvénients.
Enfin, l'exercice peut se faire sans aucune boucle apparente mais avec des slices:
Et vous avez une idées du programme pour la dernière question ?
Vous appelez votre fonction NombreOccurences sur chaque x de la liste et vous prenez le max (et vous mémorisez la valeur de x pour laquelle le max courant est atteint).
# Fonction qui construit et renvoie la liste [4, 2, 4, 2, 4, ...] de longueur n
def Liste_42(n):
motif = [4, 2]
result = motif * (n // len(motif)) + motif[:(n % len(motif))]
return result
# Fonction qui construit et renvoie la liste [0, 1, 2, 0, 1, 2, 0, ...] de longueur n
def Liste_012(n):
motif = [0, 1, 2]
result = motif * (n // len(motif)) + motif[:(n % len(motif))]
return result
# Écrire un programme NombreOccurrences(L, x) qui détermine le nombre de fois où x apparaît dans la liste L. Ce nombre p eut être nul.
def NombreOccurrences(L, x):
return sum([1 for elem in L if elem == x])
# En déduire un programme Mode(L) qui renvoie la valeur de L ayant le plus grand nombre d'occurrences (où l'une d'elles en cas d'égalité)
def Mode(L):
dico = {x: NombreOccurrences(L, x) for x in set(L)}
couples_maxi = ([k for k, v in dico.items() if v == max(dico.values())], max(dico.values()))
return f"{couples_maxi[0]}"[1:-1] + " --> " + f"{couples_maxi[1]}x."
As-tu appris les compréhensions? liste1 = [4-2*(i%2) for i in range(n)] liste2 = [i%3 for i in range(n)] count = sum(1 for i in liste if i==x) maximum = max(sum(1 for i in liste if i==x) for x in liste) Dans le dernier cas, on peut remplacer sum(...) par une fonction si on a une
edit:
en fait on obtient la fréquence maximum, ce n'est pas ce qu'on demandait.
La variante de PB68 serait mieux ....
ou encore:
l=[1,2,3,4,4] k, v = sorted([(i, sum(1 for x in l if x==i)) for i,v in enumerate(l)], key=lambda t: t[1])[-1] print(f"{k} apparait {v} fois")
- Edité par PierrotLeFou 5 octobre 2021 à 19:43:27
Le Tout est souvent plus grand que la somme de ses parties.
Tes deux premières fonctions sont exactement le code que j'avais proposé plus haut . Tu aurais pu écrire une fonction prenant la liste à répéter en paramètre.
PB68 a écrit:
# Écrire un programme NombreOccurrences(L, x) qui détermine le nombre de fois où x apparaît dans la liste L. Ce nombre p eut être nul.
def NombreOccurrences(L, x):
return sum([1 for elem in L if elem == x])
Dans ce genre d'exo, c'est un code trop sophistiqué que tu proposes là. Il est attendu que l'élève fasse un parcours de liste avec un compteur. Parce que sinon, autant utiliser list.count qui est exactement faite pour ça.
PB68 a écrit:
Bonjour.
Voici les réponses que j'aurais fournies :
# Écrire un programme NombreOccurrences(L, x) qui détermine le nombre de fois où x apparaît dans la liste L. Ce nombre p eut être nul.
def NombreOccurrences(L, x):
return sum([1 for elem in L if elem == x])
# En déduire un programme Mode(L) qui renvoie la valeur de L ayant le plus grand nombre d'occurrences (où l'une d'elles en cas d'égalité)
def Mode(L):
dico = {x: NombreOccurrences(L, x) for x in set(L)}
couples_maxi = ([k for k, v in dico.items() if v == max(dico.values())], max(dico.values()))
return f"{couples_maxi[0]}"[1:-1] + " --> " + f"{couples_maxi[1]}x."
Le problème est que cette question est une invitation à mal faire : il est assez maladroit si le but est de déterminer une occurrence la plus fréquente d'appeler autant de fois qu'il y a d'éléments la fonction du calcul du nombre d'occurrences. La complexité devient quadratique au lieu de linéaire et, au passage, ton code aggrave la complexité. La bonne méthode pour faire cela est juste de faire une boucle for avec un compteur et de ne pas appeler la fonction NombreOccurrences. Ou d'utiliser Counter du module collections.
Au passage, tu pouvais écrire un code de complexité équivalente mais en une simple ligne :
def NombreOccurrences(L, x):
return sum([1 for elem in L if elem == x])
L=[50, 40, 20, 40, 80, 50, 20, 20, 40, 70, 40, 20]
z=max((NombreOccurrences(L, x),x) for x in L)[1]
print(z)
ou encore (peut-être plus pythonique mais l'algo reste quadratique)
def NombreOccurrences(L, x):
return sum([1 for elem in L if elem == x])
L=[50, 40, 20, 40, 80, 50, 20, 20, 40, 70, 40, 20]
z=max(L, key=lambda x:NombreOccurrences(L, x))
print(z)
@ PascalOrtiz : C'est un de mes défauts, j'ai tendance à utiliser un bazooka pour tuer une mouche. Effectivement, pour les 2 premiers exercices, c'est même du plaggia (n'ayons pas peur des mots !!!) ; ceci dit, je suis content d'avoir eu une bonne idée.
Ouf! On ne m'a pas écorché au passage. Moi aussi j'ai utilisé du mégatonnes pour tuer ta mouche. Voici quelque chose de linéaire. - L=[1, 3, 2, 3, 5, 3, 1, 5] dico={} for i in L: dico[i] = dico.get(i, 0) + 1 vmax = -1 for k,v in dico.items(): if vmax < v: vmax = v kmax = k
if vmax >= 0:
print(f"la valeur {kmax} se retrouve {vmax} fois.")
- Edité par PierrotLeFou 6 octobre 2021 à 1:47:52
Le Tout est souvent plus grand que la somme de ses parties.
Effectivement mais ce n'est pas vraiment optimal : si t est de longueur 100 et que n=2000 alors on va générer 200000 éléments alors qu'on en a besoin que de 2000.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Découverte Python Doc Tkinter Les chaînes de caractères
Découverte Python Doc Tkinter Les chaînes de caractères
Découverte Python Doc Tkinter Les chaînes de caractères
PB68
Le Tout est souvent plus grand que la somme de ses parties.
Découverte Python Doc Tkinter Les chaînes de caractères
PB68
Le Tout est souvent plus grand que la somme de ses parties.
Python c'est bon, mangez-en.
Découverte Python Doc Tkinter Les chaînes de caractères