Probleme de boucle sur nombre d'occurences d'une lettre dans un mot

**mabeille77** · 21/11/2014, 14h00

Help!

Je m'arrache les cheveux sur un exercice ou je dois trouver le nombre d'occurrences de chaque lettre dans un mot.
Exemple: tester --> t2 e2 s1 r1

j'en suis à là:

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
#include <stdio.h>
#include <string.h>
main()
{
/*VARIABLES*/
char MOT[101]="",CHAR[100]="";
int NBCHAR[100]={0},compteur,compteur2;
 
printf("Saisissez un mot en majuscules (max 100 caractères): ");
scanf("%s",MOT);
 
compteur=0;
 
while (compteur<=strlen(MOT))/*analyse du mot complet*/
    {
 
    CHAR[compteur]=MOT[compteur];/*attribution de la lettre a tester*/
    NBCHAR[compteur]=0;/*initialisation du nombre d'occurences*/
 
    for (compteur2=0;compteur2<strlen(MOT);compteur2++) /*Pour chaque lettre du mot*/
        {
        if (CHAR[compteur]==MOT[compteur2]) /*si la lettre est presente*/
            NBCHAR[compteur]=NBCHAR[compteur]+1;/*on ajoute +1 au nombre de fois ou elle est presente*/
        }
 
    compteur=compteur+1;/*on passe a le lettre suivante*/
 
    }
 
for (compteur=0;compteur<(strlen(CHAR));compteur++)
    {
    printf("\n%c%d",CHAR[compteur],NBCHAR[compteur]);
    }
}

Le resultat donné est t2 e2 s1 t2 e2 r1

le décompte est correct mais j'aimerais vraiment avoir comme resultat t2 e2 s1 r1...

quelqu'un peut il m'éclairer?

**Médinoc** · 21/11/2014, 14h04

Pourquoi des variables en majuscules? Pourquoi une chaîne de caractères nommée CHAR?
On dirait que tu fais exprès de rendre ton code plus difficile à comprendre en défiant les conventions établies...

De plus, l'organisation des données en "tableaux parallèles" peut avantageusement être remplacée par une structure.
Et ton code est monolithique. Tu devrais le séparer en fonction, ne serait-ce qu'une pour trouver le bon indice pour le compteur d'une lettre donnée, et une pour incrémenter le compteur (qui utiliserait la première), etc.

**mabeille77** · 21/11/2014, 14h09

Envoyé par Médinoc

Pourquoi des variables en majuscules? Pourquoi une chaîne de caractères nommée CHAR?
On dirait que tu fais exprès de rendre ton code plus difficile à comprendre en défiant les conventions établies...

je débute

mettre mes tableaux en majuscule me paraissait plus simple pour moi, en tout cas pour commencer

. Et pour l'instant je fais avec ce qu'on m'a appris (je suis en formation)

mais bon, mon problème n'est pas là, j'aimerais dans ma dernière boucle d'affichage n'afficher qu'une seule fois les caractères concernés, comme donné dans l'exemple...

**Médinoc** · 21/11/2014, 14h29

Le problème, c'est que tu mets la lettre plusieurs fois dans ton buffer de comptage.

Tu dois faire un buffer de comptage correct, et décomposer ton code en fonctions élémentaires dédiées à une tâche et une seule, et il devient beaucoup plus facile de s'y retrouver.

Voici un exemple concret:

Code C :

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
#include <stdio.h>
#include <string.h>
 
/*On centralise la taille max du mot*/
#define TAILLE_MAX 100
 
/*On regroupe le char et son nombre d'occurrences*/
struct charEtCompteur
{
	char c;
	int nbOccur;
};
 
/*On fait une fonction pour trouver la bonne structure*/
struct charEtCompteur* Trouve(struct charEtCompteur tableau[], size_t nombreCharsComptes, char c)
{
	size_t indexCh;
	for(indexCh=0 ; indexCh < nombreCharsComptes ; indexCh++)
	{
		if(tableau[indexCh].c == c)
			return &( tableau[indexCh] );
	}
	return NULL;
}
 
/*On fait une fonction pour ajouter une occurrence
(elle prend un pointeur vers nombreCharsComptes car elle doit pouvoir le modifier)*/
void Ajoute(struct charEtCompteur tableau[], size_t* pNombreCharsComptes, char c)
{
	struct charEtCompteur* pObj;
	pObj = Trouve(tableau, *pNombreCharsComptes, c);
	if(pObj == NULL)
	{
		/*Ajoute une nouvelle entree dans le tableau*/
		pObj = &tableau[ *pNombreCharsComptes ];
		pObj->c = c;
		pObj->nbOccur = 0;
		(*pNombreCharsComptes)++;
	}
	/*Ici, pObj n'est jamais nul*/
	pObj->nbOccur++;
}
 
/*On fait une fonction pour l'affichage*/
void Affiche(const struct charEtCompteur tableau[], size_t nombreCharsComptes)
{
	size_t indexCh;
	for(indexCh=0 ; indexCh < nombreCharsComptes ; indexCh++)
	{
		if(indexCh != 0)
			printf(" ");
		printf("%c%d", tableau[indexCh].c, tableau[indexCh].nbOccur);
	}
}
 
int main(void)
{
	struct charEtCompteur charsComptes[TAILLE_MAX] = {{0}};
	size_t nombreCharsComptes = 0;
	char mot[TAILLE_MAX+1] = "";
	size_t index;
 
	printf("Saisissez un mot (max %d caractères): ", TAILLE_MAX);
	fgets(mot, TAILLE_MAX+1, stdin);
 
	for(index=0 ; mot[index] != '\0' ; index++) /*analyse du mot complet*/
	{
		char c = mot[index];
		/*Saute le \n retourné par fgets*/
		if(c == '\n')
			continue;
 
		Ajoute(charsComptes, &nombreCharsComptes, c);
	}
	Affiche(charsComptes, nombreCharsComptes);
}

**mabeille77** · 21/11/2014, 14h31

bon en effet déjà mon CHAR[100] ne sert a rien:

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
#include <stdio.h>
#include <string.h>
main()
{
/*VARIABLES*/
char MOT[101]="",lettre;
int NBCHAR[100]={0},compteur,compteur2;
 
printf("Saisissez un mot en majuscules (max 100 caractères): ");
scanf("%s",MOT);
 
compteur=0;
 
while (compteur<=strlen(MOT))/*analyse du mot complet*/
    {
 
    lettre=MOT[compteur];/*attribution de la lettre a tester*/
    NBCHAR[compteur]=0;/*initialisation du nombre d'occurences*/
 
    for (compteur2=0;compteur2<strlen(MOT);compteur2++) /*Pour chaque lettre du mot*/
        {
        if (lettre==MOT[compteur2]) /*si la lettre est presente*/
            NBCHAR[compteur]=NBCHAR[compteur]+1;/*on ajoute +1 au nombre de fois ou elle est presente*/
 
 
        }
 
 
    printf("\n%c%d",lettre,NBCHAR[compteur]);
    compteur=compteur+1;/*on passe a le lettre suivante*/
 
 
    }
 
 
}

@Medinoc,
Merci mais pour l'instant je n'ai pas vu encore les structures et fonction. J'en suis qu'au début de ma formation donc j'ai vu les bases, les chaines, tableaux et c'est tout... on n'est pas encore au chapitre des pointeurs... :s

Si je sors ça à ma formatrice ça va ch.....er

Je sais que votre solution est bien plus propre que ce que j'essaie de faire mais vraiment je ne peux pas utiliser des choses que je n'ai pas encore vu (en plus sincèrement pour l'instant j'y comprends pas grand chose à votre code):p

Je pense que là mon problème est surtout algorithmique...

**Médinoc** · 21/11/2014, 16h29

Le gros problème, c'est que le réflexe "découper le code en fonctions" est infaisable sans pointeurs dès qu'une fonction doit modifier quelque chose, et donc je me retrouve un peu perdu.

Enfin sinon, plutôt que d'ajouter des couples { caractère, compteur } à une liste, tu peux faire un histogramme sur toutes les valeurs possibles:

Code C :

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
char mot[100] = "";
int histogramme[128] = {0};
int indexMot, indexHist;
 
fgets(mot, 100, stdin);
 
for(indexMot=0 ; mot[indexMot] != '\0' ; indexMot++)
{
	char c = mot[indexMot];
	if(c >= 0 && c < 128)
		histogramme[c]++;
}
 
/*Note: Les caractères en-dessous de 32 ne sont pas affichables*/
for(indexHist=32 ; indexHist < 128 ; indexHist++)
{
	if(histogramme[indexHist] != 0)
	{
		char c = (char)indexHist;
		printf(" %c%d", c, histogramme[indexHist]);
	}
}

Je trouve que c'est beaucoup plus simple vu que tu n'as pas à trouver la place d'un caractère dans l'histogramme: Sa place, c'est sa valeur.

**mabeille77** · 21/11/2014, 19h56

@Medinoc, merci beaucoup pour ton aide. En effet ta solution est plus simple et me parait plus accessible.

MAIS, tu utilises dans ton code des fonctions que je n'ai pas encore vu en cours, donc pas le droit de les utiliser... (genre fgets) et ce meme si ta solution m'a paru accessible.

Finalement ma formatrice m'a mis sur la voie et voici ce que ca donne:

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
#include <stdio.h>
#include <string.h>
main()
{
char MOT[101]="",LETTRE[100]="";
int NBCHAR[100]={0},compteur,compteur2,trouve,i,k;
 
printf("Saisissez un mot en majuscules (max 100 caractères): ");
scanf("%s",MOT);
 
compteur=0;
while (compteur<=strlen(MOT))/*analyse du mot complet*/
    {
 
    LETTRE[compteur]=MOT[compteur];/*attribution de la lettre a tester*/
    NBCHAR[compteur]=0;/*initialisation du nombre d'occurences*/
 
    for (compteur2=0;compteur2<strlen(MOT);compteur2++) /*Pour chaque lettre du mot*/
        {
        if (LETTRE[compteur]==MOT[compteur2]) /*si la lettre est presente*/
            NBCHAR[compteur]=NBCHAR[compteur]+1;/*on ajoute +1 au nombre de fois ou elle est presente*/
        }
    compteur=compteur+1;/*on passe a le lettre suivante*/
    }
 
/*J'ai un peu honte de ne pas avoir trouve cette suite tout seul...*/
for (compteur=0;compteur<(strlen(LETTRE));compteur++)
    {
    trouve=0;
        /*c'est a ce niveau que je bloquais, je n'ai pas pensé a faire compteur2<compteur...!!!"*/
        for (compteur2=0;compteur2<compteur;compteur2++)
            {
            if( LETTRE[compteur2]==LETTRE[compteur])
                trouve=1;
            }
    if (trouve==0)
        printf("\n%c%d",LETTRE[compteur],NBCHAR[compteur]);
    }
}

J'avais bien tenté d'imbriquer un for dans ma derniere boucle d'affichage mais je n'avais pas les bons arguments...

**Médinoc** · 21/11/2014, 20h54

Il faut vraiment que les profs arrêtent d'enseigner scanf("%s", str); aux débutants.

Enfin bon, si ton code marche...

**mabeille77** · 22/11/2014, 00h40

Envoyé par Médinoc

Il faut vraiment que les profs arrêtent d'enseigner scanf("%s", str); aux débutants.

Enfin bon, si ton code marche...

Pourquoi?

En même temps ce n'est que le début (ça fait une semaine que je suis en formation), on va surement bientôt en venir à des méthodes plus efficaces (prochain chapitre: les fonctions).

**Médinoc** · 22/11/2014, 01h09

Ce n'est pas sécurisé (il faut mettre la taille dans la chaîne de format pour que ça le soit).

**mabeille77** · 22/11/2014, 14h33

Envoyé par Médinoc

Ce n'est pas sécurisé (il faut mettre la taille dans la chaîne de format pour que ça le soit).

C'est noté

Merci pour ton aide Medinoc. je passe cette conversation en résolu

**Sve@r** · 22/11/2014, 16h28

Bonjour

Envoyé par mabeille77

Code c :

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

    for (compteur2=0;compteur2<strlen(MOT);compteur2++) /*Pour chaque lettre du mot*/

Attention à l'optimisation: le strlen() sera appelé à chaque itération de ta boucle. Pour l'instant ce n'est pas grave mais un jour il te faudra y penser et essayer de l'éviter...

Envoyé par Médinoc

Il faut vraiment que les profs arrêtent d'enseigner scanf("%s", str); aux débutants.

Désolé, mais c'est un gros problème dans l'apprentissage du C: comment enseigner une méthode de saisie permettant les premiers TP à des étudiants ne connaissant ni le pointeur, ni les problèmes de la saisie sécurisée et ayant à ce niveau d'autres soucis pour pouvoir s'y intéresser. Sans compter que les profs n'étant pas des "professionnels" de l'informatique ni même entourés d'autres "professionnels" avec qui ils peuvent discuter et échanger leurs expériences, eux-mêmes n'ont pas forcément les connaissances de ces dangers et de la façon de les éviter...

**mabeille77** · 23/11/2014, 04h40

Merci pour le conseil. Il vaut mieux dans ce cas que je stocke le résultat de strlen une bonne fois pour toute dans une variable au début du programme et que je bosse après dessus.

Sinon pour revenir a l'exercice en lui même, j'ai trouve une solution qui me parait bien plus propre:

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <stdio.h>
#include <string.h>
 
main()
{
char MOT[101]="",temp;
int compteur,compteur2,index,occur;
 
printf("Saisissez un mot (max 100 caractères): ");/*affichage*/
scanf("%s",MOT);/*saisie*/
 
/*vu que je vais comparer des caracteres, je ne veux pas de loupé dans la conversion ASCII*/
for (compteur=0;compteur<=strlen(MOT);compteur++)/*donc une boucle pour conversion en majuscule*/
    {
    MOT[compteur]=toupper(MOT[compteur]);/*conversion en majuscule*/
    }
 
printf("\nLe mot %s contient:\n",MOT);/*J'affiche le mot saisi avant de remanipuler toute le tableau*/
 
/*Un petit tri par selection :-)*/
for (compteur=0;compteur<strlen(MOT);compteur++)/*on boucle sur le tableau*/
    {
    index=compteur;/*l'index sera ma position de l'element comparé*/
    for (compteur2=compteur+1;compteur2<strlen(MOT);compteur2++)
        {/*je recherche l'index de l'element le plus petit*/
        if (MOT[compteur2]<MOT[index])
            {/*si je le trouve, la position de ma case devient mon nouvel index*/
            index=compteur2;
            }
        }
    temp=MOT[compteur];       /*et hop j'echange les positions entre la case en cours de lecture et la case index*/
    MOT[compteur]=MOT[index]; /*echange*/
    MOT[index]=temp;          /*fin de l'echange*/
    }/*fin du tri*/
 
compteur=0;
while (compteur<strlen(MOT))/*Boucle pour la lecture du tableau*/
    {
    if (MOT[compteur]!=MOT[compteur+1])/*Si la case du tableau en cours est differente de la suivante*/
        {
        occur=1;/*une seule occurrence*/
        printf("\n  %d  fois la lettre   %c",occur,MOT[compteur]);/*donc j'affiche*/
        compteur++;/*et j'alimente mon compteur*/
        }
    else /*sinon*/
        {
        occur=1;/*je sais deja que j'ai au moins une occurence*/
        while (MOT[compteur]==MOT[compteur+1])/*donc tant que la case en cours est egale a la suivante*/
            {
            occur=occur+1;/*j'incremente mon nombre d'occurrences dans cette boucle*/
            compteur++;/*et mon compteur pour passer a la case suivante*/
            }
        printf("\n  %d  fois la lettre   %c",occur,MOT[compteur]);/*a la fin de ma boucle, j'affiche*/
        compteur++;/*je passe a la case suivante*/
        occur=0;/*je reinitialise mon nombre d'occurrence*/
        }
    }
}

Qu'en pensez vous?

Quant a l'utilisation de scanf("%s"), je pense qu'on va vite finir par apprendre autre chose. J'imagine qu'elle nous a donné cette façon de faire car elle permet surtout la saisie d'autres types de données et qu'elle ne veut pas "bruler" les étapes. Cette formation a vraiment l'air d'être de qualité et notre formatrice est bien une professionnelle de l'informatique

Mais comme tu dis, comment enseigner une méthode de saisie plus adaptée alors qu'on en est à la première semaine de formation...

**Sve@r** · 23/11/2014, 11h17

4h40 ton post !!!???!!! Au-moins tu es motivée !!!

Envoyé par mabeille77

Il vaut mieux dans ce cas que je stocke le resultat de strlen une bonne fois pour toute dans une variable au debut du programme et que je bosse apres dessus.

Au début de la boucle suffira (et non "au début du programme" parce que la chaine peut changer entre temps). Mais sinon il y a une autre méthode basée sur le fait qu'une chaine se termine toujours par un '\0'. C'est un des fondements du C et t'as tout à fait le droit de l'utiliser toi-aussi comme point de repère
Ainsi ton for (compteur=0;compteur<=strlen(MOT);compteur++) pourra être remplacé par for (compteur=0; MOT[compteur] != '\0'; compteur++). C'est d'ailleurs comme ça que fait strlen() pour savoir où se termine la chaine pour renvoyer son nombre de caractères...

Ainsi tu fais l'économie d'une variable (car toute variable est une source d'erreur possible). Et plus tard tu pourras même appliquer ce principe aux tableaux que toi tu créeras en leur rajoutant ce qu'on nomme une "sentinelle" c'est à dire une valeur "spéciale" permettant de marquer la fin du tableau (ce qui t'évitera de devoir stocker leur taille).

Envoyé par mabeille77

Sinon pour revenir a l'exercice en lui meme, j'ai trouve une solution qui me parait bien plus propre:
...
Qu'en pensez vous?

Aïe Aïe Aïe...
Non, question programmation c'est super (sauf qu'il ne faut pas oublier que déclarer main() de type int). C'est juste que pour éliminer une complexité dans la recherche, tu as rajouté une complexité en amont: ton tri. Et question économies c'est kif kif. Si encore tu devais faire 2, 3, 5, 10 traitements analogues sur ta chaine alors oui ton tri initial aurait une petite justification puisqu'ensuite les traitements en seraient facilités. Mais là tu perds l'information (si j'écris une lettre commençant par "bonjour monsieur" et que je l'imprime, j'apprécierai mal de voir ressortir "beijnnooorruus" sur mon papier !!!) et ton code n'ira pas plus vite que le premier.
Mais question algo c'est bien. Tu es à l'aise et tu as compris les principes de réflexion et c'est ce qui compte. Le reste ce n'est que de l'expérience

**mabeille77** · 24/11/2014, 10h02

Merci Sve@r

J'y ai pensé au fait de perdre le mot d'origine, mais dans le cadre de l'exercice je me disais que ce n'etait pas important :p

En effet je suis bien motivé mais je viens de me faire taper sur les doigts par la formatrice :p consigne: me reposer! sinon je ne vais pas tenir jusqu'a la fin prevue en juillet :p

Bon allez, on attaque le chapitre sur les fonctions, je sens que ca va me plaire

Probleme de boucle sur nombre d'occurences d'une lettre dans un mot

C

Discussions similaires

Partager

Partager