Discussion :

[michall]

salut
qui a une idee pour ecrire une fonction quie retourne le caractere le plus utilisé dans une chaine de caractere
moi je fait ça mais probleme!!:

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
char nbappar(char b[z])
{
char y,mo;
int i,ap,max=0;
for(y='A';y<='Z';y++)
{ap=0;
	for(i=0;i<z;i++)
		if (y==b[i])
		 ap++;
		 if (max<ap)
			  {max=ap;
			  mo=y;}
}
return mo;
}

[SofEvans]

Bonjour,

moi je fait ça mais probleme!!:

Decrivez le probleme un peu mieux.

En l'occurence, a vu de nez, je dirai ceci :

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
char nbappar(char b[z])
{
char y,mo;
int i,ap,max=0;
for(y='A';y<='Z';y++)
{ap=0;
	for(i=0;i<z;i++)
		if (y==b[i])
		 ap++;
		 if (max<ap)
			  {max=ap;
			  mo=y;}
}
return mo;
}

"z undeclared", non ?


J'ai une idée pour faire ca :

Tu fais un tableau de 26 case. La case 0 represente "a" ou "A", la case 1 "b" ou "B" ...
Tu initialise le tableau a 0, puis tu parcours une unique fois ta chaine avec strlen et non z, car ce n'est pas comme ca que ca marche.

Puis, une fois que cela est fini, tu parcours le tableau de 26 case afin de determiner quel est la case, et donc la lettre ayant le plus grand nombre. Si tu veux differencier minuscule/majuscule, il faut faire un tableau de 52 case ou deux tableau de 26 case ou ... ( a toi de voir).

[michall]

mais pourquoi le tableau de 26...!!!!
il y a for(y=A.....
esemple:
si b=ABNDHDNKBBBVFJBBFKJDBBBBBBB
alors return 'B'

[Médinoc]

Là, on a l'histoire du compromis entre vitesse et mémoire.

• Avec un tableau de 256 entiers, on peut compter les occurrences de chaque caractère possible, en une seule fois, puis chercher le plus grand, le tout en temps linéaire (méthode conseillée par SofEvans).
• Sans, on doit parcourir la chaîne pour chaque caractère à tester, ce qui donne un temps quadratique (méthode que tu sembles avoir proposée, mais mal écrite).

[SofEvans]

Je me suis certainement mal expliqué :

Le tableau de 26 case represente les lettre de l'alphabet. Tu parcours ta chaine, et pour chaque lettre tu incremente la bonne case de 1. Ensuite, tu parcours ton tableau de 26 case pour determiner le plus grand.

@Medinoc, ton doigt a dérapé ? 256 entier ?

[Médinoc]

@SofEvans: Non, mon doigt n'a pas dérapé: Quitte à faire un tableau pour les caractères d'une chaîne, autant accepter toutes les valeurs possibles. Une variante en fait, mais ça reste plus proche de ta méthode que de celle de michall.

[SofEvans]

@Medinoc

Ah daccord, tu refais tout le code ASCII ? Pourquoi pas. Comme tu le dis, tant qu'a faire


Apparement, sa chaine n'etant que des majuscules, un tabeau de 26 case suffirait. Il faudrait neamoins faire attention au segfault le jour ou il y aura un caractere autre qu'une majuscule

[ok.Idriss]

Bonsoir.

Une idée toute bête qui fonctionne :

Dans une fonction qui retourne un char :
- déclarer une chaîne alphabet ("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
- déclarer un tableau d'entiers de 26 cases toutes initialisées à 0
- comparer chacun des caractères de la chaine de départ avec chacun des caractère de la chaîne et incrémenter la case du tableau correspondant à l'indice de la chaîne alphabet lors d'une équivalence
- trier le tableau dans l'ordre décroissant et trier la chaîne alphabet suivant l'ordre des indices du tableau
- retourner alphabet[0]

Si vous ne comprenez pas (c'est peut être pas évident à expliquer), voici 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
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
# include <stdio.h>
 
char retourChar (char*);
 
int main (void)
{
    char chaine [] = "ABNDHNKBBBVFJBBFKJDBBBBBBB"; /* chaine à l'entrée */
    char lettre;
    lettre = retourChar (chaine);
    printf ("La lettre la plus courrante est : %c\n", lettre);
    return 0;
}
 
char retourChar (char chaine[])
{
    char lettre;
    char alphabet [] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; /* alphabet */
    int tampon, i, j, tab[26];
    for (i=0 ; i<26 ; i++) /* initialisation à 0 de l'ensemble du tableau */
        tab[i]=0;
    i=0;
    while (chaine[i] != '\0')
    {
        for (j=0 ; j<26 ; j++)
        {
            if (chaine[i] == alphabet[j])
                tab[j] ++;
        }
        i++;
    }
    for (i=0 ; i<26 ; i++) /* tri à bulle */
    {
        for (j=(i+1) ; j<26 ; j++)
        {
            if (tab[j] >= tab[i])
            {
                tampon=tab[i];
                tab[i]=tab[j];
                tab[j]=tampon;
 
                lettre=alphabet[i]; /* on fait la même chose avec la chaîne ... les éléments de tab correspondant aux lettres de l'alphabet par leur indice */
                alphabet[i]=alphabet[j];
                alphabet[j]=lettre;
            }
        }
    }
    return alphabet[0]; /* La première lettre de la chaine alphabet sera la plus courrante grâce au tri à bulle */
}

Cependant, si l'ont a plusieurs lettres (et pas qu'une seule) qui sont plus courantes que les autres, c'est la dernière lettre dans l'ordre de l'alphabet qui est retenu.

Par exemple : AAABBBCCCG => le résultat sera C.
Conséquence : si la chaîne d'entrée est vide ou remplie uniquement de caractères différent d'une majuscule, le résultat sera Z (on peut arranger ça mais j'ai la flemme ).

En tout cas, avec cet algo, pas de segfault en cas de caractères différent d'une majuscule.

Cordialement,
Idriss