Discussion :

[meriem1287]

es-que cet algorithme est correcte

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
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

[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

[Flodelarab]

Bonjour

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

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
30
31
32
33
34
35
36
37
38
39
40
41
13
13
12
14
8
4
12
8
8
10
15
2
7
16
16
19
9
18
15
7
(...)
8
1
5
2
6
8
5
19
14
6
13
16
18
17
1
14
9
19
4
5

Et le code :

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
$ 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

[tbc92]

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 :

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 :

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
 
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 :

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
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.