fréquence dans un tableau

**netchou** · 29/10/2010, 16h32

bonjour
j'ai un souci. J'ai un tableau de note( entieres de 0 à20) j'ai également notes[1..500] : entiers // contient une succession de notes comprises entre 0 et20.
Taille: entier // qui est le nb de lignes remplies dans le tableau .

On me demande d'écrire l'algo qui permet d'afficher pour chaque note possible (donc de 0 à 20) la fréquence d'apparition de cette note dans le tableau notes (qui n'est pas trié et ne doit pas l'être).
Comment faire ?

Merci

**prgasp77** · 29/10/2010, 17h34

Bonjour,
la méthode la plus simple est d'initialiser un tableau t de 21 entiers à zéro. On parcours le tableau des 500 notes une fois, et pour chaque note n on incrémente l'entier t[n].

Une fois fini, la fréquence de la note n est l'entier t[n] ou t[n]/500 selon le sens que l'on donne à fréquence.

Cordialement,

**netchou** · 29/10/2010, 17h37

merci , mais si tu peux développer...

**prgasp77** · 29/10/2010, 18h16

L'étape suivante est l'implémentation, je ne peux pas vraiment développer ... Si un point ou du vocabulaire te semble confus n'hésite pas à poser des questions, mais je ne ferai pas l'exercice à ta place

**netchou** · 29/10/2010, 19h40

ok c'est normal: que penses tu de ma solution:
Lexique :
• notes (tableau [1..500] d'entier, saisi)) : tableau contenant les entiers saisis
• valeurs (tableau [0..20] d'entier, saisi) tableau contenant les valeurs des notes.
• taille (fonction) résultat entier : fonction qui retourne le nombre effectif
• i, n (entier, calculé) : compteurs d’itération, indices

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Début 
    // initialisation du tableau valeurs
    Valeurs[n] ←0
    // incrémentation de valeurs
    Pour n de 0 à taille (valeur) Faire 
        Si notes[i] = n Alors
            valeurs[n] ←valeurs [n] +1 
        FinSi
    FinPour	
    Si valeur[n] <>0 Alors	
        Afficher ("fréquence=",  valeurs[n]/ taille (notes)) 
    FinSi
Fin

**prgasp77** · 30/10/2010, 05h19

Envoyé par netchou

ok c'est normal: que penses tu de ma solution:
Lexique :
• notes (tableau [1..500] d'entier, saisi)) : tableau contenant les entiers saisis
• valeurs (tableau [0..20] d'entier, saisi) tableau contenant les valeurs des notes.
• taille (fonction) résultat entier : fonction qui retourne le nombre effectif
• i, n (entier, calculé) : compteurs d’itération, indices

Ton lexique me semble approprié.

Valeurs[n] ←0

Ici, tu dois bien comprendre qu'il faut initialiser à zéro chacune des 21 valeurs de ton tableau. Une boucle for serait donc tout à fait adaptée (pour i = 0..21, Valeurs[i]<--0)

Pour n de 0 à taille(valeur) Faire
Si notes[i] = n Alors
valeurs[n] ←valeurs [n] +1
FinSi
FinPour

Non, il faut boucler sur tes notes, donc pour i = 1..500(=taille(notes)), il faut incrémenter Valeurs[notes[i]]

Si valeur[n] <>0 Alors
Afficher ("fréquence=", valeurs[n]/ taille (notes))
FinSi

Le "Si" est ici inutile. Étant donné que tu ne divises pas par Valeurs[n], le fait que cet entier soit nul n'est pas un cas particulier. Ainsi, la fréquence de la note n est le réel Valeur[n]/taille(notes).

Cordialement,

**netchou** · 30/10/2010, 11h14

c'est pas mieux ?
Lexique :
• notes (tableau [1..500] d'entier, saisi)) : tableau contenant les notes saisies
• taille (fonction) résultat entier : fonction qui retourne le nombre effectif
• nbOcc (entier, calculé): nb d'occurrence dans le tableau notes
• i, n (entier, calculé) : compteurs d’itération, indices

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
 
Début 
    // initialisation du tableau valeurs
    nbOcc ←0
    // Incrémentation de valeurs
    Pour n de 0 à taille (notes)
        Pour i de 0 à 20 Faire 
            Si notes[i] = n Alors
                nbOcc←nbOcc+1
                valeurs [notes[i]] ←valeurs [n] +1 
            FinSi
        FinPour 
    FinPour 
    Afficher ("fréquence=", valeurs [notes[i]]/ taille (notes)) 
Fin

**prgasp77** · 30/10/2010, 16h44

Bonjour,
il y a toujours quelques soucis avec ton algo :
Ici "Si notes[i] = n Alors" une petite erreur : tu as confondu i et n ^^
Ta variable nbOcc ne te sert à rien : tu la modifies puis tu ne la lis pas
Tu lis 21 fois chaque note du tableau, ce qui est inutile.

Je te conseille de reprendre mon premier message, et de faire l'exercice "de tête" ou sur papier avec un petit nombre de notes (disons 5). Tu devrais alors comprendre tes erreurs.

Sinon, essaie d'utiliser les balises [code] afin de formater ton algo, Pseudocode passe derrière toi à chaque fois pour mettre ton texte en forme.

Bon courage.

**ToTo13** · 30/10/2010, 17h33

Juste pour la petite histoire, c'est exactement le principe des histogrammes en analyses d'images.

**netchou** · 31/10/2010, 11h18

Bonjour,

Voici ma correction, merci de m'indiquer si il y a encore des erreurs.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
[Algorithme]:
    Pour n de [0..20] Faire 
        valeurs[n] <-- 0
    Fin Pour
    Pour i de 0 à taille(notes) faire
        Si notes[i] <--n Alors
            valeurs[n] <-- valeurs[n]+1
        FinSi
    Fin Pour
    Afficher (" La fréquence =  ", ((valeurs[n]/taille(notes))*100, "  %")
Fin

**netchou** · 31/10/2010, 11h36

Merci de m'excuser de mes erreurs, qui paraissent pour certains inadmissibles.
Mais je débute et j'essai de me former à l'informatique. En autodidacte.
A+

**prgasp77** · 31/10/2010, 12h19

On commence à s'approcher de quelque chose de correct, je dirais même plus, on en est à une ligne !! Celle-ci : "Si notes[i] <--n Alors"

Que signifie cette ligne ? Si l'affectation de notes[i] par n fonctionne ? Mais que vaut n ? il a été défini dans le cadre de la boucle précédente, et la variable n'a plus de raison d'être.
Tu t'obstines à vouloir tester la valeur de ta i-ième note, mais cela n'est pas nécessaire, quelqu'elle soit, tu dois incrémenter valeurs[notes[i]].

Je pense que ce double indexage te pose problème, par principe. Je vais essayer de te fournir un exemple. Nous avons les notes suivantes (pour simpllifier, disons qu'elles vont de 1 à 6, comme en Allemagne) :
notes = {1,6,2,3,5,6,6}
On initialise notre tableau nous servant à compter
valeurs = {0,0,0,0,0,0} (on commence à compter à 1 pour l'exemple toujours)

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
21
22
23
24
25
26
27
28
29
 
On commence :
i=0
notes[i]=1
valeurs[notes[i]]=valeurs[1], on l'incrémente ---> valeurs = {1,0,0,0,0,0}
---
i=1
notes[i]=6
valeurs[notes[i]]=valeurs[6] --> valeurs = {1,0,0,0,0,1}
---
i=2
notes[i]=2
valeurs[notes[i]]=valeurs[2] --> valeurs = {1,1,0,0,0,1}
---
i=3
notes[i]=3
valeurs[notes[i]]=valeurs[3] --> valeurs = {1,1,1,0,0,1}
---
i=4
notes[i]=5
valeurs[notes[i]]=valeurs[5] --> valeurs = {1,1,1,0,1,1}
---
i=5
notes[i]=6
valeurs[notes[i]]=valeurs[6] --> valeurs = {1,1,1,0,1,2}
---
i=5
notes[i]=6
valeurs[notes[i]]=valeurs[6] --> valeurs = {1,1,1,0,1,3}

On s'est contenté d'incrémenter pour chaque i l'entier valeurs[notes[i]] car notes[i] représente l'index dans le tableaux valeurs (le nombre d'occurences de la note n est valeurs[n] et la i-ième note est notes[i], donc le nombre d'occurences de la i-ème note est valeurs[notes[i]]).

J'espère ne pas en avoir trop fait

, mais pense à entourer ton code par [code] et [_/code] (sans l'underscore) afin de le formater.

**netchou** · 31/10/2010, 14h25

Si j'ai bien compris ce devrait donner celà !

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
[Algorithme]:
    Pour n de [0..20] Faire 
        valeurs[n] <-- 0
    Fin Pour
    Pour i de 0 à taille(notes) faire
        Si notes[i] <--n Alors
            valeurs[notes[i]] <-- valeurs[n]
            notes[i]<--notes[i]+1  
      FinSi
    Fin Pour
    Afficher (" La fréquence =  ", ((valeurs[n]/taille(notes))*100, "  %")
Fin

Es-tu d'accord ?

Merci pour ton développement, tu n'as pas été trop loin!!!

**netchou** · 31/10/2010, 14h38

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Début
Pour n de 0 à 20 Faire
valeurs[n] ← 0
Fin Pour
Pour i de 0 à taille (notes) Faire
	Si notes[i] ← n Alors
		valeurs[notes[i]] ←valeurs[n]
		notes[i] ←notes[i] +1
                          Somme← valeurs[n]+n
	FinSi
Fin Pour
Afficher ("La fréquence =", ((valeurs [n] / Somme)*100, "  %")
Fin

J'ai rajouté Somme car pour calculer la fréquence normalement c'est le nombre de fois qu'apparait le même chiffre divisé par la somme de tous les chiffres.
je crois que c'est plus fonctionnel.
Donc j'incrémente le tableau notes.

**prgasp77** · 31/10/2010, 17h10

Tu étais bien plus proche de la solution dans ton message #11.
N'oublie pas qu'une variable définie dans le cadre d'une boucle n'a pas vraiment de sens en dehors. Ainsi, tu utilises n dans ta boucle d'initialisation du tableau valeurs ; puis tu réutilises cette variable, que représente-t-elle ?

Tu t'obstines à vouloir tester la valeur de notes[i], mais encore une fois quelque soit sa valeur, on en fait la même chose. Demande toi comment tu ferais pour résoudre ce problème sans ordinateur. Pour ma part, je prendrais une feuille, je ferais 21 cases sur lesquelles je noterais le numéro correspondant (0 à 20) et à chaque fois que je lirais une note, j'ajouterais un petit bâton dans la case appropriée. C'est exactement l'algorithme que tu dois écrire, la feuille représente le tableau que tu as appelé valeurs, et ajouter un bâton revient à incrémenter un entier du tableau (incrémenter signifie ajouter 1).

L'initialisation du tableau valeurs est correcte. Ne pas y toucher.

Ensuite, ne plus réutiliser la variable n qui n'as plus aucun sens une fois sorti de cette boucle.

Enfin, pour chaque note notes[i] (donc pour i allant de 0 à taille(notes)), incrémenter valeurs[notes[i]] et FIN !
Il ne te reste plus qu'à afficher les différentes fréquences, mais ça on y reviendra après.

Encore un effort, et pour chaque instruction, tente de comprendre ce qu'elle implique et représente.

**netchou** · 31/10/2010, 19h34

Bon je remplace notes[i] par valeurs[notes[i]]!

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
Début
Pour n de 0 à 20 Faire
valeurs[n] ← 0
Fin Pour
Pour i de 0 à taille (notes) Faire
	Si notes[i]  ← i Alors
           	valeurs[notes[i]]←valeurs[notes[i]] +1
             FinSi
Fin Pour
 Pour n de 0 à 20 Faire
 Somme← n+n
 valeurs[n]<-valeurs[n]+1
 Afficher ("La fréquence de ", n, " = " ,((valeurs [n] / Somme)*100, "  %")
  Fin Pour
Fin

OK a chaque fois je refais l'algorithme à la main!

**netchou** · 01/11/2010, 19h46

bonsoir,

Code :

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

1
2
Pour i de 0 à taille (notes) Faire
	Si notes[i]  ← valeurs[n] Alors

est-ce que cela n'est pas plus logique par rapport à ton message avec algo en exemple.

**Jean Dumoncel** · 01/11/2010, 20h15

Bonjour,

Envoyé par netchou

Bon je remplace notes[i] par valeurs[notes[i]]!

Code :

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

1
2
3
4
5
6
7
8
9
Début
Pour n de 0 à 20 Faire
valeurs[n] ← 0
Fin Pour
Pour i de 0 à taille (notes) Faire
	Si notes[i]  ← i Alors
           	valeurs[notes[i]]←valeurs[notes[i]] +1
             FinSi
Fin Pour

Les lignes en rouges sont inutiles et fausses, il faut les supprimer. Selon toi, à quoi servait ces lignes??

Envoyé par netchou

Code :

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

1
2
3
4
5
6
7
 
 Pour n de 0 à 20 Faire
 Somme← n+n
 valeurs[n]<-valeurs[n]+1
 Afficher ("La fréquence de ", n, " = " ,((valeurs [n] / Somme)*100, "  %")
  Fin Pour
Fin

Pourquoi ajoutes-tu 1 à chaque valeur de ton tableau? A moins que tu aies une bonne raison,, il faut supprimer cette ligne...
Pour la fréquence, pourquoi divises-tu par 2*n??
On obtient la fréquence en divisant le nombre d'apparition d'une valeur par le nombre total d'éléments (ici ce nombre total d'éléments est "taille (notes)").

**Mat.M** · 01/11/2010, 20h35

Salut une autre solution c'est de trier en ordre croissant ( ou bien décroissant ) le tableau notes[1..500].
Puis par exemple tu peux tout simplement voir à quelle fréquence apparait les nombres 0,1,2 etc
Par exemple tu vas compter tant que la note==0, puis tant que la note==1, ainsi de suite..
Avec C++ et STL pour programmer cela,ça se fait en quelques minutes

**netchou** · 02/11/2010, 09h13

Bonjour,
Suite à tes remarques:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Début
Pour n de 0 à 20 Faire
valeurs[n] ← 0
Fin Pour
 
Pour i de 0 à taille (notes) Faire
valeurs[notes[i]]←valeurs[notes[i]] +1
Fin Pour
 
 Afficher ("La fréquence de ", n, " = " ,((valeurs [n] / taille(notes))*100), "  %")
  Fin

Si j'ai bien compris le code s'écrit de cette façon !

fréquence dans un tableau

Algorithmes et structures de données

Discussions similaires

Partager

Partager