Séance de laboratoire Écrire un programme qui considère une

Séance de laboratoire
1.
Écrire un programme qui considère une chaîne de caractères CH et affiche le
nombre de mots contenus dans la chaîne. Utiliser uniquement un pointeur P et une
variable numérique N qui contiendra le nombre de mots.
#include <iostream.h>
void main()
{
char * CH = "Tenir un restaurant japonais, c'est beaucoup de sushis!";
int N;
char * P;
//
Compléter le programme suivant.
cout << N;
}
#include <iostream.h>
void main()
{
char * CH = "Tenir un restaurant japonais, c'est beaucoup de sushis!";
int N = !(*CH == '\0');
char * P = CH;
while (*P != '\0')
{
if (*P == ' ') N++;
P++;
}
cout << N;
}
2.
Écrire un programme qui considère une chaîne de caractères CH et affiche la
longueur de la chaîne à l’aide d’un pointeur P seulement. Le programme
n’utilisera pas de variables numériques.
#include <iostream.h>
void main()
{
char * CH = "Quelle est la longueur de cette chaine ?";
//
}
Compléter le programme suivant.
#include <iostream.h>
void main()
{
char * CH = "Quelle est la longueur de cette chaine ?";
char * P = CH;
while (*P != '\0') P++;
cout << P - CH;
}
3.
Complétez l’étape 2 du programme suivant qui prend en considération deux
chaînes de caractères CH1 et CH2, élimine tous les caractères de CH1 qui font
partie de CH2 et affiche la chaîne de caractères CH1 réduite. Utiliser uniquement
des pointeurs et une variable logique TROUVE.
#include <iostream.h>
void main()
{
// Étape 1.
Déclaration des variables et initialisation.
char CH1[] = "Le verbe aimer est le plus complique de la langue. "
"Son passe n'est jamais simple, son present n'est qu'imparfait "
"et son futur toujours conditionnel.";
char * CH2 = "Quand le poisson mord, c'est qu'il a pris un ver de trop.";
char * P1 = CH1;
char * P = CH1;
char * P2;
// Étape 2.
// P1 va nous permettre de parcourir CH1 au complet.
// P2 va nous permettre de parcourir CH2 au complet.
Élimine tous les caractères de CH1 qui font partie de CH2.
Tant et aussi longtemps que P1 ne pointe pas vers le caractère de fin de chaîne de
CH1 alors
{
2.1
Définir une variable booléenne « Trouve » et l’initialiser à vrai.
// Déterminer si le caractère pointé par P1 est présent dans la chaîne CH2.
// Si ce caractère est présent, alors la variable booléenne « Trouve » sera
// égale à faux, vrai autrement.
2.2
Positionner P2 au début de la chaîne CH2.
2.3
Tant et aussi longtemps que « TROUVE » est égale à vrai et que
P2 ne pointe pas vers le caractère de fin de chaîne de CH2 alors
si le caractère pointé par P1 est égale à celui pointé par P2
alors la variable « TROUVE » est mise à faux
sinon passer au caractère suivant dans CH2 à l’aide de P2.
// Si le caractère pointé par P1 n’est pas présent dans la chaîne CH2, alors
// alors conserver ce caractère dans CH1.
2.4
Si la variable booléenne « Trouve » est égale à vrai alors
Placer le caractère pointé par P1 à l’adresse P.
Mettre à jour P avec l’adresse qui suit celle de P.
// Passer au caractère suivant dans CH1 à l’aide de P1.
2.5
Mettre à jour P1 avec l’adresse qui suit celle de P1.
}
Insérer dans la chaîne CH1 à l’adresse P le marqueur de fin de chaîne.
// Étape 3.
Affiche la nouvelle chaîne de CH1.
cout << CH1 << endl;
}
#include <iostream.h>
void main()
{
char CH1[] = "Le verbe aimer est le plus complique de la langue. "
"Son passe n'est jamais simple, son present n'est qu'imparfait "
"et son futur toujours conditionnel.";
char * CH2 = "Quand le poisson mord, c'est qu'il a pris un ver de trop.";
char * P1 = CH1;
char * P = CH1;
char * P2;
while (*P1 != '\0')
{
P2 = CH2;
bool TROUVE = true;
while (TROUVE && (*P2 != '\0'))
if (*P2 == *P1) TROUVE = false;
else P2++;
if (TROUVE)
{
*P = *P1;
P++;
}
P1++;
}
*P = '\0';
cout << CH1 << endl;
}
4.
Écrire un programme qui lit pour chaque étudiant d’une liste donnée, son nom, son
prénom, son matricule, son sexe (0 ou 1) et ses 2 codes, et qui affiche le nom, le prénom
et le matricule de chaque étudiant en ordre croissant de faculté, puis, à l’intérieur d’une
faculté, en ordre croissant de niveau, puis, à l’intérieur d’un niveau, les garçons puis,
ensuite, les filles. Utiliser un tableau de pointeurs de fiches pour éviter d’avoir à déplacer
des fiches en mémoire.
Pour tester votre programme, voici un exemple de jeu d’essai :
Luc
Pierre
Mario
Helene
Michel
Lise
Lucille
Boivin
Laroche
Pelchat
Rioux
Roy
Morin
Roy
99456123 0 2 12
98234098 0 4 14
95097790 0 3 9
98767434 1 4 14
95657765 0 1 1
97653123 1 3 9
96490471 1 4 14
#include <iostream.h>
#include <stdlib.h>
#include <iomanip.h>
void main()
{
typedef enum niveau {
typedef enum faculte {
preparatoire = 1, certificat, baccalaureat,
maitrise, doctorat} Niveau;
Amenagement = 1, Arts_et_sciences, Droit,
Education_permanente, Education_physique,
Etudes_superieures, Medecine, Medecine_dentaire,
Medecine_veterinaire, Musique, Optometrie,
Pharmacie, Sciences_de_l_education,
Sciences_infirmieres } Faculte;
typedef struct fiche
{
char prenom[15];
char nom[15];
int matricule;
bool sexe;
Niveau N;
Faculte F;
} Fiche;
const int Nombre_d_etudiants = 7;
Fiche * Etudiants[Nombre_d_etudiants];
cout << "Entrez les donnees d'un etudiant dans l'ordre suivant :"
<< endl << endl
<< "Prenom Nom Matricule Sexe(0 ou 1) Niveau(1 - 5) Faculte(1 - 14) "
<< endl;
for (int i = 0; i < Nombre_d_etudiants; i++)
{
int j, k, s;
Etudiants[i] = (Fiche *) malloc(sizeof(Fiche));
cin >> (*Etudiants[i]).prenom
>> (*Etudiants[i]).nom
>> (*Etudiants[i]).matricule >> s
>> j >> k;
(*Etudiants[i]).N = (Niveau)j;
(*Etudiants[i]).F = (Faculte)k;
s > 0 ? (*Etudiants[i]).sexe = true : (*Etudiants[i]).sexe = false;
}
for (i = 0; i < Nombre_d_etudiants - 1; i++)
{
int min = i;
for (int j = i+1; j < Nombre_d_etudiants; j++)
if( (*Etudiants[min]).F * 100 +
(*Etudiants[min]).N * 10 +
(*Etudiants[min]).sexe >
(*Etudiants[j]).F * 100 +
(*Etudiants[j]).N * 10 +
(*Etudiants[j]).sexe) min = j;
Fiche * w = Etudiants[i];
Etudiants[i] = Etudiants[min];
Etudiants[min] = w;
}
for (i = 0; i < Nombre_d_etudiants; i++)
cout << "\n" << setw(15) << setiosflags(ios::left)
<< (*Etudiants[i]).prenom
<< "\t" << setw(15) << (*Etudiants[i]).nom
<< "\t" << (*Etudiants[i]).matricule
<< "\t" << ((*Etudiants[i]).sexe ? "F" : "M")
<< "\t" << (*Etudiants[i]).N << "\t"
<< (*Etudiants[i]).F;
cout << endl << endl;
}
===================================