Problème en algorithme de calcul de fréquence

Version imprimable

es-que cet algorithme est correcte

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
Algorithme Calcul-Fréquences1 ;
entrée : un tableau T[1..n] d’entiers ;
sortie : le nombre d’occurrences de chaque élément du tableau ;
const	n=500 ;
var	i, j, fréquence : entier ;
trouve : booléen ;
début
pour	i := 1 à n faire
   début	j :=1 ;
   trouve := faux ;
   tant que (j<i) et (non trouve) faire
      si T[i] = T[j] alors trouve := vrai
      sinon j := j+1 ;
      si (non trouve) alors début fréquence := 1 ;
      pour j := i+1 à n faire
         si T[i] = T[j] alors fréquence := fréquence + 1 ;
         écrire (‘fréquence de’ T[i] ‘=’ fréquence) ;
      fin
   fin	
fin

17/01/2023, 19h46
Mat.M

Pourquoi utiliser des booléens ? Le but de l'exercice c'est de savoir par exemple combien il y a de 3 ou 10 dans le tableau ?
Déjà il faudrait savoir quel est la limite d'une variable de type entier et quelle valeur max peut prendre chaque élément du tableau.
D'après l'énoncé rien n'est indiqué.
Sinon l'algorithme est simple, parcourir la totalité du tableau et prendre chaque élément
Démarrer une deuxième boucle qui va de 0 à une limite et que l'on incrémente et si la valeur est trouvée il faut l'incrémenter.
Une chose importante c'est de mettre le nombre d'occurrence dans un autre tableau

Bonjour :coucou:

Avec un tableau associatif, c'est direct. Soit un fichier de 100 nombres entre 0 et 19 :

Code:

Et le code :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
$ awk '{tab[$1]++} END{for (i in tab) print i,"est présent en quantité",tab[i]}' fichier.txt 
0 est présent en quantité 3
1 est présent en quantité 2
2 est présent en quantité 8
4 est présent en quantité 8
5 est présent en quantité 5
6 est présent en quantité 7
7 est présent en quantité 6
8 est présent en quantité 7
9 est présent en quantité 7
10 est présent en quantité 6
11 est présent en quantité 1
12 est présent en quantité 4
13 est présent en quantité 5
14 est présent en quantité 5
15 est présent en quantité 5
16 est présent en quantité 7
17 est présent en quantité 4
18 est présent en quantité 4
19 est présent en quantité 6

On peut considérer que les tableaux associatifs sont 'interdits' dans le cadre de cet exercice, pour que l'exercice ait un peu d'intérêt.

Dans ta tête, tu as défini un plan de travail, puis tu as traduit ce plan de travail, sous forme d'algorithme. Et tu as posté l'algorithme. J'essaie de remonter le fil, et de trouver ton plan de travail, et je pense y être parvenu :

Citation:

Tu regardes toutes les valeurs du tableau.
Pour chaque valeur, tu cherches si cette valeur est nouvelle (c'est la première fois qu'on rencontre cette valeur)
Si oui , tu vas faire un traitement pour compter combien de fois elle apparaît en tout dans le tableau
Si la valeur était déjà apparue, tu ne fais rien.

Ok, c'est un bon plan.
Mais la réalisation n'est pas bonne.

Je recopie ton algorithme en ajoutant 1 tout petit commentaire :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 Algorithme Calcul-Fréquences1 ; entrée : un tableau T[1..n] d’entiers ; sortie : le nombre d’occurrences de chaque élément du tableau ; const n=500 ; var i, j, fréquence : entier ; trouve : booléen ; début pour i := 1 à n faire début j :=1 ; trouve := faux ; tant que (j<i) et (non trouve) faire si T[i] = T[j] alors trouve := vrai sinon j := j+1 ; si (non trouve) alors début fréquence := 1 ; pour j := i+1 à n faire si T[i] = T[j] alors fréquence := fréquence + 1 ; écrire (‘fréquence de’ T[i] ‘=’ fréquence) ; fin -- fin pour j = i+1 à n fin fin
Le fait de mettre derrière chaque mot clé FIN un commentaire pour rappeler quelle est la boucle ou le bloc d'instruction qu'on ferme, ça rend le truc beaucoup plus lisible.
En particulier, tu as à un moment : Si (non trouvé) ALORS ; Ok Si (non trouvé), alors on va exécuter un certain traitement ; c'est quoi le traitement qu'on va exécuter, c'est quelle instruction, ou quel groupe d'instructions ?
Tu as une boucle pour j=i+1 a n ... donc si n=100et i=20, on va exécuter 80 fois (ou 81... peu importe) les 2 instructions entre le pour et le Fin.
En particulier, on va exécuter l'instruction ECRIRE() 80 fois, avec le même T(i), mais la fréquence qui va monter (ou pas) à chaque affichage. Ce qu'on veut, c'est uniquement écrire le résultat à la fin, quand on a fini le comptage pour cette valeur T(i).
On doit avoir une boucle qui fait le comptage. Et quand on a fini le comptage ( après la boucle donc), on affiche le résultat du comptage.
Ici, c'est une erreur 'simple' sur le fonctionnement des boucles.
Cette erreur (exactement la même, mais beaucoup plus vicieuse), tu l'as faite une autre fois dans ton algorithme.

Voici un début de correction :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 Algorithme Calcul-Fréquences1 ; entrée : un tableau T[1..n] d’entiers ; sortie : le nombre d’occurrences de chaque élément du tableau ; const n=500 ; var i, j, fréquence : entier ; trouve : booléen ; début Pour i = 1 a n // Pour chaque ligne i du tableau // A-t-on déjà vu la valeur T(i) Ici, il va falloir ajouter un traitement qui détermine si on a déjà traité cette valeur Si deja-vue alors Ecrire ( "on ne fait rien, on a déjà traité", T(i) ) sinon Faire un traitement qui compte combien de fois T(i) apparaît dans le tableau (une boucle, certainement) écrire (‘fréquence de’ T[i] ‘=’ fréquence) ; fin // Fin du Si déjà-vue ... sinon fin // Fin de la boucle pour i=1 a n
Normalement, quand tu écris un algorithme, ou un programme, tu écris d'abord un truc comme ça, avec les grandes étapes du programmes. Puis tu t'attaques aux parties laissées en suspens. On n'écrit pas les lignes les unes après les autres, de la première ligne à la dernière. On écrit le squelette, puis on revient sur chaque étape.