M1102-TD5 Exercice 1

Le but de cet exercice est d’afficher le nombre d’occurrences de chaque élément d’un petit ensemble de valeurs dans une collection. Ici, on comptera le nombre de voyelles contenues dans une chaîne de caractères. Pour cela :

  1. initialiser les compteurs ;
  2. pour chaque valeur de la collection (chaque caractère de la chaîne), balayer complètement le petit ensemble (l’ensemble des voyelles) et incrémenter le bon nombre d’occurrence quand il le faut ;
  3. calculer le nombre total d’occurrence des éléments de l’ensemble (le nombre total de voyelles) ;
  4. afficher le nombre d’occurrences de chacun des éléments de l’ensemble (de chacune des voyelles) ainsi que leur fréquence relative (au nombre total d’éléments de l’ensemble (de voyelles)) ;
  5. on pourra utiliser les fonctions ComptCaract() et/ou TrouveCarDansStr ().

M1102-TD5 Exercie1 Corrigé

fonction TrouveCarDansStr (Caract : in caractere, 
                           Chaine : in string, 
                           Debut  : in entier_naturel) renvoie entier_naturel
debut
	declarer i : entier_naturel;
	i <- Debut;
	tant_que (i < taille(Chaine) ET_ALORS Caract ne_vaut_pas Chaine [i])
	faire
		i <- i +1;
	ffaire
	renvoie i;
fin

fonction ComptCarac (Caract : in caractere, 
                     Chaine : in string) 	renvoie entier_naturel
debut
	declarer Cpt : entier_naturel;
	Cpt <- 0;
	
	declarer Pos : entier_naturel;
	Pos <- 0;
	
	boucle
		Pos <- TrouveCarDansStr (Caract, Chaine, Pos);
		si (Pos vaut taille (Chaine)) sortie;
		Cpt <- Cpt + 1;
		Pos <- Pos + 1;		
	fboucle
	
	renvoie Cpt;
fin

algorithme ComptagePetitEnsemble
debut
	declarer KStrVoy : constante string <- "aeiouy";
	
	declarer TabCpt : tableau_de taille (KStrVoy) entier_naturel;
	
	declarer Chaine : string;
	afficher ("Veuillez saisir une chaine de caractères : ");
	saisir (Chaine);
	
	//comptage
	pour (i variant_de 0 a taille (KStrVoy) -1)
	faire
		TabCpt [i] <- ComptCarac (KStrVoy [i], Chaine);
	ffaire
	
	//nb total d'occurence
	declarer Somme : entier_naturel;
	Somme <- 0;
	pour (i variant_de 0 a taille (TabCpt) - 1)
	faire
		Somme <- Somme + TabCpt [i];
	ffaire
	
	//affichage final
	pour (i variant_de 0 a taille (KStrVoy) -1)
	faire
		afficher ("Le caractère ", KStrVoy [i], " apparait ", TabCpt [i], " fois en absolu et ", TabCpt [i]*100 / Somme, "% en relatif");
		ligne_suivante;
	ffaire
fin

M1102 TD5 Exercice 2

Ecrire les prédicats suivants :

fonction IsUpper (Car : in caractere) renvoie booleen;
fonction IsLower (Car : in caractere) renvoie booleen;
fonction IsDigit (Car : in caractere) renvoie booleen;

Ces prédicats renvoient vrai si le caractère qui leur est passé en paramètre est respectivement une majuscule, une minuscule ou un chiffre décimal (de '0' à '9').
Ecrire le prédicat IsSpace (), qui renvoie vrai si le caractère passé en paramètre est un caractère d’espacement (espace, tabulation ou retour à la ligne).

M1102-TD5 Exercie2 Corrigé

fonction TrouveCarDansStr (Caract : in caractere, 
                           Chaine : in string, 
                           Debut  : in entier_naturel) renvoie entier_naturel
debut
	declarer i : entier_naturel;
	i <- Debut;
	tant_que (i < taille(Chaine) ET_ALORS Caract ne_vaut_pas Chaine [i])
	faire
		i <- i +1;
	ffaire
	renvoie i;
fin

algorithme ComptagePetitEnsemble
debut
	declarer KStrVoy : constante string <- "aeiouy";
	
	declarer TabCpt : tableau_de taille (KStrVoy) entier_naturel;
	pour (i variant_de 0 a taille (TabCpt) - 1)
	faire
		TabCpt [i] <- 0;
	ffaire
	
	declarer Chaine : string;
	afficher ("Veuillez saisir une chaine de caractères : ");
	saisir (Chaine);
	
	//comptage
	pour (i variant_de 0 a taille (Chaine) -1)
	faire
		declarer Pos : entier_naturel;
		Pos <- TrouveCarDansStr (Chaine [i], KStrVoy, 0);
		si (Pos vaut taille (KStrVoy)) continue;
		TabCpt [Pos] <- TabCpt [Pos] + 1;
	ffaire
	
	//nb total d'occurence
	declarer Somme : entier_naturel;
	Somme <- 0;
	pour (i variant_de 0 a taille (TabCpt) - 1)
	faire
		Somme <- Somme + TabCpt [i];
	ffaire
	
	//affichage final
	pour (i variant_de 0 a taille (KStrVoy) -1)
	faire
		afficher ("Le caractère ", KStrVoy [i], " apparait ", TabCpt [i], " fois en absolu et ", TabCpt [i]*100 / Somme, "% en relatif");
		ligne_suivante;
	ffaire
fin

M1102 TD5 Exercice 3

Ecrire la fonction CompterDoublons () présentée ci-dessous. Les “règles du jeu” (les spécifications) sont les suivantes :

  1. un doublon est une suite de deux caractères consécutifs (deux éléments dont les rangs diffèrent d’une unité) identiques.
  2. trois caractères consécutifs identiques constituent deux doublons.

Les doublons de caractères d’espacement  ne sont pas comptabilisés.
Lorsque le caractère courant est de rang i, il y a deux façons de tester s’il appartient à un doublon :

  1. soit en testant le caractère de rang précédent (de rang i - 1), dans ce cas, le premier élément ne peut être comparé avec son prédécesseur. Il faut donc commencer les comparaisons à l’élément de rang 1.
  2. soit en testant le caractère de rang suivant (de rang i + 1), dans ce cas, le dernier élément ne peut être comparé avec son successeur. Il faut donc terminer les comparaisons par l’avant-dernier élément.

Ecrire une version de la fonction CompterDoublons() en utilisant une boucle pour, puis une autre en utilisant une boucle tant_que.

M1102-TD5 Exercie3 Corrigé

fonction isspace (C : in caractere) renvoie booleen
debut
renvoie (C vaut ' ' OU_SINON C vaut '\t' OU_SINON C vaut '\n');
fin

//variante avec une boucle pour
//fonction CompterDoublonsV0 (Chaine : in string) renvoie entier_naturel
//debut
//
//	si (taille(Chaine) < 2) renvoie 0;
//
//	declarer Compt : entier_naturel;
//    Compt <- 0;
//
//	pour (i variant_de 1 a taille (Chaine) - 1)
//	faire
//		si (isspace (Chaine [i])) continue;
//		si (Chaine [i] vaut Chaine [i-1])
//			Compt <- Compt + 1;
//		fsi
//	ffaire
//
//  renvoie Compt;
//fin

//variante en utilisant une boucle tant_que
fonction CompterDoublonsV0 (Chaine : in string) renvoie entier_naturel
debut

si (taille(Chaine) < 2) renvoie 0;

declarer Compt : entier_naturel;
Compt <- 0;

declarer i : entier_naturel;
i <- 1;

tant_que (i < taille (Chaine))
faire
si (NON isspace (Chaine [i]) ET_ALORS Chaine [i] vaut Chaine [i-1])
Compt <- Compt +1;
fsi
i <- i + 1;
ffaire

renvoie Compt;
fin

algorithme Nb_de_Doublons
debut

boucle
// Saisie

declarer LigneLue : string;
afficher ("Entrer une string (ligne vide pour sortir) : ");
saisir (LigneLue);

si (taille (LigneLue) vaut 0) sortie;

// La ligne traitée est non vide
// Comptage
declarer NbreDoublons : entier_naturel;

NbreDoublons <- CompterDoublonsV0 (LigneLue);

// Affichage
afficher (LigneLue);
ligne_suivante;
afficher ("Nombre de doublons : ", NbreDoublons);
ligne_suivante;
fboucle

fin