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);
}

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

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

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

C

Vue hybride

Discussions similaires

Partager

Partager