Bonjour,

J'ai un problème avec un algorithme :

Compter le nombres de voyelles dans une chaîne.

Programme : compter Nb voyelles

Cst : NB
Var : i:entier
chaine[NB]:car
Début
Afficher"Saisir chaîne de caractère"
Saisir chaîne
tant que (chaine[i]<>'\0') Faire
Si (chaine[i] ?????? // Je ne vois pas la condition à mettre
i <- i+1
Fin si
Fin tant que
Fin.

Merci pour votre aide.

"Si (chaine[i] ?????? // Je ne vois pas la condition à mettre "

Ta condition est chaine[i] est une voyelle. Qu'est ce que ca veut dire d'etre une voyelle ?

J'ai pas mi sa mais sinon tu veux dire si la case prend la valeur d'une voyelle ? sa serait sa la condition ? Mais faut déclarer voyelle ?

peut tu ecrire une fonction
bool estUneVoyelle(c : car)
?

il faut tester la valeur du caractère pour voir si c'est égal à celui des voyelles (1 test par voyelle). Soit tu le met dans le programme soit tu fais une fonction à part qui renvoi un booléen. Faudrait aussi initialiser i à 0.

Imagine si le programme serait de compter les consonnes faudrait 20 tests.
Il n'y aurait pas une autre solution ?

Tu connais un autre moyen de différencier voyelles et consonnes que par extension ?

Ben je suis en 1ère année je connais pas grand chose.

Sinon pour convertir minuscule en majuscule par exemple on avait fait le code ASCII

Si (chaine[i]>'a')ET(chaine[i]<='z')
chaine[i]<- chaine[i] - 0X20

Asran63 >> Pour les majuscules ou minuscules, c'est faciles puisque c'est ordonné. Mais différencier les voyelles de consonnes, il faut tester les valeurs une par une puisque elles sont mélangées.

"Imagine si le programme serait de compter les consonnes faudrait 20 tests. "

Non car tu aurais aussi fais appel au test de voyelle donc 6 tests et non 20

Même sans parler de l'aspect machine, pour des lettres ordonnées de A à Z, il n'y a pas vraiment moyen de différencier une voyelle d'une consonne autrement qu'en regardant à quel ensemble il appartient.

Maintenant, pour t'économiser des tests... toute lettre (attention : pas tout caractère) qui n'est pas une voyelle est a priori une consonne, les deux ensembles sont distincts. Tu peux donc limiter ton nombre de tests au groupe le plus petit par négation.

Reste à définir ce qu'est une voyelle.

"Ben je suis en 1ère année je connais pas grand chose."
En ragle generale, il ne faut pas essayer de faire des choses plus complique que ce que l'on sait faire.

De plus, comme toujours en informatique, tu cherches d'abors une solution qui repond au probleme. et apres tu vois si tu peux faire mieux.

Merci les gars

Une solution sur des plus gros ensembles c'est de mettre les valeurs dans une table de hachage et de tester si celle-ci contient la valeur à tester. Là dans ce cas je doute que ça vaille la peine mais sur des objets plus nombreux pour lesquels l'égalité est coûteuses en test, ça peut être une voie.

Pour ne pas enchaîner plein de tes, il serait sans doute intéressant de mettre dans un tableau l'ensemble des voyelles et de le parcourir tant qu'on est pas à la fin et que le booleen (daclaré à false avant) ne passe pas à true si le caractère testé en est une. Tout ça dans une fonction.

Il peut aussi tester dichotomiquement les valeurs ascii, pour arriver en 3 tests mais ça risque d'être pire qu'avec la méthode bourrin sur un aussi petit ensemble (6).

Le truc c'est qu'avec la méthode bourrin, sachant que A et E sont parmi les lettres les plus fréquentes en langues françaises, si elles sont testées en premier les chances de pouvoir couper court aux autres tests sont élevées.

http://fr.wikipedia.org/wiki/Fr%C3%A9quence_d%27apparition_des_lettres_en_fran%C3%A7ais

Comme quoi des fois se casser la tête n'est pas toujours gagnant.

Perso j'utiliserais une lookup table:

bool IsVowel( unsigned char c )
{
static unsigned int s_aVowelLookup[] = { 0, 0, 0, 0x02208222, 0, 0, 0, 0 };
return ( s_aVowelLookup[ c >> 5 ] & (1 << ( c & 31 )) ) != 0;
}

Jolie solution, mais elle n'est pas tout public.

La seule fois ou j'ai utilisé ce genre de chose c'était pour des tables de logarithmes.
Il y en a aussi un superbe exemple dans certains algos comme le CRC32.

C'est vrai que c'est impressionnant comme solution, mais si un étudiant me rendait ça, je ne suis pas sûr que j'essayerais de vérifier que ça fonctionne.

Hmm j'ai ecris ca vite fait, et j'ai oublie les lettres majuscules, oups.. le fix:
static unsigned int s_aVowelLookup[] = { 0, 0, 0x02208222, 0x02208222, 0, 0, 0, 0 };

J'utilise en general ce genre de technique pour faire un premier filtre pour ce qui est nickname/url/clan name/email/etc dans des GUI, mais aussi pour une table de glyphs supportes par un font, etc. L'avantage etant bien entedu aucune comparaison (lent sur console), et une tres petite occupation memoire. Bon un peu plus tricky lorsqu'on travaille en utf-8 cela dit.

Pour ceux qui ont pas suivis (et vu comme ajd j'ai un peu de temps pour poster =), une petite description:
l'idee est d'avoir une fonction qui prend un character et qui renvoi un bool indiquant si le character est une voyelle on non. Donc unsigned char (256 valeurs possibles) -> bool (2 valeurs possibles).
On pourrait faire qqchose du style:
static bool s_abIsVowel[256] = { .... };
bool IsVowel(unsigned char c) { return s_abIsVowel[c]; }
mais ca prends un peu trop de memoire a mon gout, vu que pour un caracter on utilise un bool en memoire, donc 8 bits, la taille d'un char; 256 valeurs au lieu d'une.
L'idee est donc d'utiliser un bit au lieu de 8; on a 32 bits dans un unsigned int, donc ca nous fait plus que 256/32=8 unsigned int (donc un total de 8*4=32 octets a la place de 256).
c >> 5 nous indique l'unsigned int a utiliser, (c & 31) le bit correspondant: on divise l'espace des 256 valeurs en 8 groupes (correspondant au 3 bits de poids forts de c), et chaque sous groupe en 32 (correspondant au 5 bits de poids faibles de c).

On peut noter que pour ceux qui font du C++, cette table de lookup a exactement en mémoire (sur une archi 32 bits) la structure qu'aurait un bitset<256> initialisé comme ton tableau de bool.