Exercice langage C tri par propagation avec fonctions

Ecrire la fonction TRI_BULLE qui trie un tableau de N éléments entiers par ordre croissant en appliquant la méthode de la bulle (tri par propagation - voir exercice 7.15). Employer la fonction RANGER de l'exercice ci-dessus. 

Ecrire un programme pour tester la fonction TRI_BULLE.

Corrigé exercice langage C tri par propagation avec fonctions

#include
main()
{
/* Prototypes des fonctions appelées */
void LIRE_TAB (int *TAB, int *N, int NMAX);
void TRI_BULLE(int *T, int N);
void ECRIRE_TAB (int *TAB, int N);
/* Variables locales */
int T[100]; /* Tableau d'entiers */
int DIM; /* Dimension du tableau */
/* Traitements */
LIRE_TAB (T, &DIM, 100);
printf("Tableau donné : \n");
ECRIRE_TAB (T, DIM);
TRI_BULLE(T, DIM);
printf("Tableau trié : \n");
ECRIRE_TAB (T, DIM);
return 0;
}

void TRI_BULLE(int *T, int N)
{
/* Prototypes des fonctions appelées */
int RANGER(int *X, int *Y);
/* Variables locales */
int I,J; /* indices courants */
int FIN; /* position où la dernière permutation a eu lieu */
/* permet de ne pas trier un sous-ensemble déjà trié. */
/* Tri de T par propagation de l'élément maximal */
for (I=N-1 ; I>0 ; I=FIN)
{
FIN=0;
for (J=0; Jif (RANGER(T+J, T+J+1)) FIN = J;
}
}

int RANGER(int *X, int *Y)
{
. . .
}
void LIRE_TAB (int *TAB, int *N, int NMAX)
{
. . .
}
void ECRIRE_TAB (int *TAB, int N)
{
. . .
}

Exercice langage C : Les Fonctions et les prototypes ds fonctions

/* jeu des cailloux */
#include
/* initialisation de la partie, avec la saisie du nombre total de cailloux et
* du joueur qui demarre la partie */
void initialiser(int *nbCa, int *jo);
/* le jeu proprement dit pour un des deux joueurs : choix du nombre de
* cailloux */
void jeu(int jo, int *nbCa);
/* la machine joue */
void machine_joue(int *nbCa);
/* l'utilisateur joue, et saisit le nombre de cailloux */
void utilisateur_joue(int *nbCa);
/* changement de joueur dans *jo */
void changer_joueur (int *jo);
int main()
{
int finJeu = 0;
int nbCailloux , joueur, perdant;
initialiser(&nbCailloux, &joueur);
while ( !finJeu )
{
printf("\nil reste %d cailloux\n", nbCailloux);
jeu (joueur, &nbCailloux);
if (nbCailloux == 0)
{
perdant = joueur;
finJeu = 1;
}
else
{
changer_joueur (&joueur);
}
}
if (perdant == 1)
{
printf("dommage: tu as perdu\n");
}
else
{
printf("bravo: tu as gagne\n");
}
return 0;
}
void initialiser(int *nbCa, int *jo)
{
int rep;
printf("donnez le nombre de cailloux : "); scanf("%d", nbCa);
printf("\nchoix du premier joueur :\n");
printf("\tutilisateur.: 1\n");
printf("\tmachine.....: 2\n");
printf("qui ? ");
scanf("%d", &rep);
switch (rep)
{
case 1: *jo = 1;
break;
case 2: *jo = 2;
break;
}
}
void jeu(int jo, int *nbCa)
{
if (jo == 2)
{
machine_joue(nbCa);
}
else
{
utilisateur_joue(nbCa);
}
}
void machine_joue(int *nbCa)
{
int cailloux_pris, modu;
modu = *nbCa % 4;
switch (modu)
{
case 0: cailloux_pris = 3;
break;
case 1: cailloux_pris = 1;
break;
case 2: cailloux_pris = 1;
break;
case 3: cailloux_pris = 2;
break;
}
printf("j\'ai pris %d cailloux \n",cailloux_pris);
*nbCa = *nbCa - cailloux_pris;
}
void utilisateur_joue(int *nbCa)
{
int cailloux_pris;
do
{
printf("combien de cailloux: ");
scanf("%d", &cailloux_pris);
}
while ((cailloux_pris = 4) ||
(cailloux_pris > *nbCa));
*nbCa = *nbCa - cailloux_pris;
}
void changer_joueur (int *jo)
{
if (*jo == 2)
{
*jo = 1;
}
else
{
*jo = 2;
}
}

Exercice langage C sur les notions de base

Exercice 1

Modifiez le programme 'hello world' de façon à obtenir le même résultat sur l'écran en utilisant plusieurs fois la fonction printf.

Exercice 2

Expérimentez avec les séquences d'échappement que vous trouvez dans le tableau ci-dessous et complétez les colonnes vides.

Exercice 3

Ci-dessous, vous trouvez un simple programme en C. Essayez de distinguer et de classifier autant que possible les éléments qui composent ce programme (commentaires, variables, déclarations, instructions, etc.)

#include
/* Ce programme calcule la somme de 4 nombres entiers
introduits au clavier.
*/
main()
{
int NOMBRE, SOMME, COMPTEUR;
/* Initialisation des variables */
SOMME = 0;
COMPTEUR = 0;
/* Lecture des données */
while (COMPTEUR {
/* Lire la valeur du nombre suivant */
printf("Entrez un nombre entier :");
scanf("%i", &NOMBRE);
/* Ajouter le nombre au résultat */
SOMME += NOMBRE;
/* Incrémenter le compteur */
COMPTEUR++;
}
/* Impression du résultat */
printf("La somme est: %i \n", SOMME);
return 0;
}

- Commande au compilateur: #include

pour pouvoir utiliser les fonctions printf et scanf.

- Fonction main

n'a pas de paramètres (la liste des paramètres est vide) et fournit par défaut un résultat du type int (à l'environnement).

- Commentaires (mis en italique).

- Variables utilisées:

NOMBRE, SOMME, COMPTEUR déclarées comme entiers (type int).

- Fonctions utilisées:

printf, scanf de la bibliothèque .

- Opérateurs:

- Structure de contrôle: while() { ... }

répète le bloc d'instructions aussi longtemps que la est remplie.

- L'instruction return 0;

retourne la valeur zéro comme code d'erreur à l'environnement après l'exécution du programme

Ajoutes :

- la fonction scanf est appelée avec deux paramètres:

le format de saisie de la donnée (ici: "%i" pour lire un entier du type int)

l'adresse de la variable destination (ici: l'adresse de NOMBRE).

- la fonction printf est appelée avec un respectivement avec deux paramètres:

le premier paramètre est une chaîne de caractères, qui peut contenir une information pour le format d'affichage des variables indiquées dans la suite (ici: "%i" pour afficher la valeur du type int contenue dans SOMME).

les paramètres qui suivent la chaîne de caractères indiquent les noms des variables à afficher. (ici: SOMME)

Voici une des solutions possibles:

#include
/* Notre premier programme en C */
main()
{
printf("hello, ");
printf("world");
printf("\n");
return 0;
}

Exercice langage C : while Erreur

Que fait ce programme ?

#include
#include
#define debut 100
#define pas 0.01
int main(void)
{
float nombre=debut;
int compte=0,tous_les;
puts("afficher les résultats intermédiaires
tous les ? (333 par exemple) ?");
scanf("%d",&tous_les);
while (fabs(nombre-(debut+(compte*pas))){
nombre+=pas;
if (!(++compte%tous_les))
printf("valeur obtenue %12.8f, au lieu de %6.2f en %d calculs\n",
nombre,(float)(debut+(compte*pas)), compte);
}
printf("erreur de 100%% en %d calculs\n",compte);

Ce programme démontre les erreurs de calcul toujours effectuées sur des nombres réels.
On additione successivement 0.01 (qui n'a pas de représentation finie en binaire) à un réel initialement nul.
On compte le nombre de calculs jusqu'à obtenir une erreur de 100%.
Dans ce cas il faut 16246 calculs.
On peut essayer d'autres pas et d'autres débuts.

Exercice langage C : Plusieurs Fonctions

1. Soit la fonction C suivante :

int decimale( char t[10], int n)
{ int exposant=0;
int puissance=1;
int j;
int q = n;
if ( n == 0 )
{ t[0]=’0’;
return 1;
}else
{ while ( puissance{ puissance = puissance? 10;
exposant = exposant + 1;
}for (j=0; jexposant; j = j + 1)
{ t[j] = ’0’ + (q % 10);
q=q/10;
}return (exposant);
}
}

(a) Quels sont les arguments de la fonction? Identi?ez leurs rôles.

(b) Quelle est la spéci?cité du passage de tableau comme paramètre d’une fonction.

(c) Quel est le résultat de la fonction? Quelle est la signi?cation du contenu du tableaut?

(d) Donnez la signi?cation et le rôle des variables suivantes :q ,puissance et exposant.

(e) Complétez l’écriture de la fonction avec des commentaires a?n de la rendre claire.

2. (a) Ecrivez une fonction imprime(t,i) qui a?che sur une même ligne

Les i premiers caractères du tableau t. Son prototype est :

int imprime ( char t[], int i);

(b) A l’aide des fonctions décimale (t,n) et imprime(t,i), concevez un programme C qui demande à l’utilisateur de saisir un entier positif et qui a?che ses chi?res (dans son écriture décimale) dans l’ordre inverse.

Exemple d’exécution :

Entrez un entier positif : 12345

54321

(c) Modi?ez la fonction décimale(t,n) pour écrire une fonction hexadécimale(t,n). Son prototype est :

int hexadécimale ( char t[], int i);

Ses arguments sont, un tableau de char de taille 10, et un entier Positif n. Elle place dans t les caractères chi?res de son écriture en base 16 et retourne le nombre de chi?res dans son ´ecriture en base 16.

Rappel : Les caractères chi?res en base 16 sont :

’0’, ’1’, ’2’, ’3’, ’4’, ’5’, ’6’, ’7’, ’8’, ’9’, ’A’ (10), ’B’ (11), ’C’ (12),

’D’ (13), ’E’ (14), ’F’ (15).

Exemple d’exécution :

Entrez un entier positif : 3081

90C

#include
#include
/? decimale( t,n) remplit le tableau de caract`eres t en t[0], t[1], ... t[e?1]
et renvoie e, tels que n= t 0?10ˆ0 + a 1?10ˆ1 + ... + a (e?1)?10ˆ(e?1)?/
int decimale( char t[10], int n);
/? a?che sur une mˆeme ligne les k premiers caract`eres du tableau t ?/
int imprime (char t[10], int k);
/? hexadecimale( t,n) remplit le tableau de caract`eres t en t[0], t[1], ... t[e?1]
et renvoie e, tels que n= t 0?16ˆ0 + a 1?16ˆ1 + ... + a (e?1)?16ˆ(e?1)?/
int hexadecimale( char t[10], int n);
int main (){
// insert code here...
char ch[10];
int n,e;
/? saisit un entier n et a?che sa representation d´ecimale t[0], t[1], t[e?1]?/
/? rang´ee dans le tableau t.
On a ainsi n= t 0?10ˆ0 + a 1?10ˆ1 + ... + a (e?1)?10ˆ(e?1)?/
printf(” nombre\n”);
scanf(”%d”,&n);
e=decimale(ch,n);
printf(”premier exposant e tel que 10ˆe> %d est %d\n”, n, e);
printf(”repr´esentation d´ecimale de %d en a 0?10ˆ10 + a 1?10ˆ1 + ...\n”);
imprime(ch,e);
e=hexadecimale(ch,n);
printf(”premier exposant e tel que 16ˆe> %d est %d\n”, n, e);
printf(”repr´esentation hexad´ecimale de %d en a 0?16ˆ10 + a 1?16ˆ1 + ...\n”);
imprime(ch,e);
return EXIT SUCCESS;
}
/? decimale( t,n) remplit le tableau de caract`eres t en t[0], t[1], ... t[e?1]
et renvoie e, tels que n= t 0?10ˆ0 + a 1?10ˆ1 + ... + a (e?1)?10ˆ(e?1)?/
int decimale( char t[10], int n)
{ /? On cherche le plus petit exposant e tel que puissance = 10ˆe> n?/
/? Dans ce cas on peut ´ecrire
n= t 0?10ˆ0 + a 1?10ˆ1 + ... + a (e?1)?10ˆ(e?1) )?/
/? on ´ecrit les coee?cients a 0, ... , a (e?1)
dans le tableau de caract`eres t[0], ..., t[e?1]?/
int exposant=0;
int puissance=1;
int j;
int q = n;
if ( n == 0 )
{ t[0]=’0’; /? 0= 0?10ˆ0?/
return 1; /? 10ˆ0 = 1> 0?/
}else
{ /? on cherche puissance et exposant tels que
puissance=10ˆexposant> n?/
while ( puissance{ puissance = puissance? 10;
exposant = exposant + 1;
}/? On ´ecrit les a j de la repr´esentation dans t
(entre 0 et exposant?1) :?/
/? par exemple : 153 % 10 = 3 et 153 / 10 = 15 puis
15 % 10 = 5 et 15 /10 = 1
puis 1 % 10 = 1 et 1 / 10 = 0 ===> t= 3 5 1?/
for (j=0; jexposant; j = j + 1)
{ t[j] = ’0’ + (q % 10);
q=q/10;
}return (exposant);
}
}int imprime (char t[10], int k){
int j;
for (j=0; jk; j = j + 1)
{ printf(”%c ”, t[j]);
}
printf(”\n”);
return 0; /? valeur de retour `a ignorer?/
}/? hexadecimale( t,n) remplit le tableau de caract`eres t en t[0], t[1], ... t[e?1]
et renvoie e, tels que n= t 0?16ˆ0 + a 1?16ˆ1 + ... + a (e?1)?16ˆ(e?1)?/
int hexadecimale( char t[10], int n)
{ /? On cherche le plus petit exposant e tel que puissance = 16ˆe> n?/
/? Dans ce cas on peut ´ecrire
n= t 0?16ˆ0 + a 1?16ˆ1 + ... + a (e?1)?16ˆ(e?1) )?/
/? on ´ecrit les coee?cients a 0, ... , a (e?1)
dans le tableau de caract`eres t[0], ..., t[e?1]?/
int exposant=0;
int puissance=1;
int j;
char tab[16] =”0123456789ABCDEF” ;
int q = n;
if ( n == 0 )
{ t[0]=’0’; /? 0= 0?16ˆ0?/
return 1; /? 16ˆ0 = 1> 0?/
}else
{ /? on cherche puissance et exposant tels que
puissance=16ˆexposant> n?/
while ( puissance{ puissance = puissance? 16;
exposant = exposant + 1;
}/? On ´ecrit les a j de la repr´esentation dans t
(entre 0 et exposant?1) :?/
for (j=0; jexposant; j = j + 1)
{ t[j] = tab[q % 16];
q=q/16;
}return (exposant);
}
}
//nombre
//3081
//premier exposant e tel que 10ˆe> 3081 est 4
//repr´esentation d´ecimale de 0 en a 0?10ˆ10 + a 1?10ˆ1 + ...
//1 8 0 3
//premier exposant e tel que 16ˆe> 3081 est 3
//repr´esentation hexad´ecimale de 0 en a 0?16ˆ10 + a 1?16ˆ1 + ...
//9 0 C

Exercice langage C : Réaliser des écritures

Réalisez un programme dans un fichier contenant une fonction main() qui réalise les écritures suivantes:

• écrire le caractère 'a'
• écrire la chaîne de caractères "bonjour"
• écrire l'entier 32767 dans les formats
  • décimal
  • hexadécimal
  • octal
  • non signé
• écrire le flottant 3.1415927 dans les formats suivants :
  • notation exponentielle
  • notation avec point décimal
  • variable (g)

/* TP1. Serie 1. Exercice 1. */
#include
int main ()
{
printf("%c\n", 'a');
printf("bonjour\n");
printf("%d\n", 32567);
printf("%x\n", 32567);
printf("%o\n", 32567);
printf("%d\n", (unsigned) 32567);
printf("%e\n", 3.1415927);
printf("%9.7f\n", 3.1415927);
printf("%g\n", 3.1415927);
return 0;
}

Exercice langage C: Éléments en indice

Écrivez une fonction prenant un tableau T d'entiers et sa taille en paramètres. La fonction devra allouer un nouveau tableau T2. T2 sera construit de la façon suivante: Les éléments de T d'indice pair seront placés dans T2 à l'indice donné par l'élément suivant de T. Exemple:

• T[0] sera plaçé dans T2 à l'indice T[1],
• T[2] sera plaçé dans T2 à l'indice T[3],
• etc...

La fonction devra renvoyer un pointeur sur le premier élément de T2. On remarquera que la taille de T doit être paire. Si ce n'est pas le cas, la fonction devra renvoyer le pointeur 0 pour indiquer une erreur.

Exemple:

T:

T2:

int *indice(int *T, int taille)
{
if (taille % 2 != 0)
return 0; // erreur: taille n'est pas pair
int *T2 = new int[taille / 2];
for (int i=0; itaille/2; i++) {
if (T[i*2+1] taille / 2 && T[i*2+1] >= 0)
T2[T[i*2+1]] = T[i * 2];
else
return 0; // erreur: l'indice est en dehors du tableau
}
return T2;
}

Exercice langage C: Déterminer les erreurs commises dans un programme

Quelles erreurs ont été commises dans chacun des groupes d'instructions suivants :

1)

if (aelse printf ("non ascendant") ;

2)

int n ;
...
switch (2*n+1)
{ case 1 : printf ("petit") ;
case n : printf ("moyen") ;
}

3)

#define LIMITE 100
int n ;
...
switch (n)
{ case LIMITE-1 : printf ("un peu moins") ;
case LIMITE : printf ("juste") ;
case LIMITE+1 : printf ("un peu plus") ;
}

4)

const int LIMITE=100
int n ;

1) Il manque un point-virgule à la fin du premier printf :

if (a

else printf ("non ascendant") ;

2) Les valeurs suivant le mot case doivent obligatoirement être des "expressions constantes", c'est-à-dire des expressions calculables par le compilateur lui-même. Ce n'est pas le cas de n.

3) Aucune erreur, les expressions telles que LIMITE-1 étant bien des expressions constantes.

4) Ici, les expressions suivant le mot case ne sont plus des expressions constantes, car le symbole LIMITE a été défini sous forme d'une "constante symbolique" (en C++, cependant, ces instructions seront correctes).

Exercice langage C: Résolution d'équation du deuxième degré

Travail à Faire:

Reprenez votre programme de la séance précédente qui calculait les racines d'une équation du second degré. Ce programme renvoyait une erreur à l'exécution au moment où il essayait de calculer la racine carrée du discriminant  ? , quand ? était négatif. L'instruction if va nous permettre d'éviter cette erreur à l'exécution.

Modifiez votre programme pour qu'il affiche le message:

Je ne sais pas calculer les racines dans ce cas.

si ? ? >= 0, le programme devra afficher les racines de l'équation.

Vérifiez que votre programme est correct:

• Le cas  = 1,  = -4,  = 1 a pour racines: 0.267949 et 3.732051.
• Dans le cas  = 1,  = 1,  = 1 le programme doit afficher le message Je ne sais pas calculer les racines dans ce cas.

#include
#include
using namespace std;
int main(int argc, char **argv)
{
float a, b, c;
float delta;
cout cin >> a;
cout cin >> b;
cout cin >> c;
delta = b*b-4*a*c;
if (delta cout else {
cout cout cout }
return 0;
}

Exercice langage C : Recherche des Points-Clos MaxLignes

/* Calculs matriciels */
#include
/* Saisie d'une matrice carree */
void saisir(double Mat[100][100], int nb);
/* Affichage d'une matrice carree */
void afficher(double Mat[100][100], int nb);
/* Addition de deux matrices */
void additionner(double Mat1[100][100], double Mat2[100][100],
double Mat3[100][100], int nb);
/* Multiplication de deux matrices */
void multiplier(double Mat1[100][100], double Mat2[100][100],
double Mat3[100][100], int nb);
/* Affichage d'un menu et retour du choix de l'utilisateur */
char menu();
int main ()
{
double M[100][100], P[100][100], R[100][100];
int nb_val;
char rep;
rep = menu();
while (rep == 'A' || rep == 'M')
{
printf ("taille de la matrice carree :\n");
scanf ("%d", &nb_val);
printf("saisie de la 1ere matrice\n");
saisir(M, nb_val);
printf("saisie de la 2eme matrice\n");
saisir(P, nb_val);
switch(rep)
{
case 'A':
additionner(M, P, R, nb_val);
break;
case 'M':
multiplier(M, P, R, nb_val);
break;
}
printf("Matrice M:\n"); afficher(M, nb_val);
printf("Matrice P:\n"); afficher(P, nb_val);
printf("Matrice R:\n"); afficher(R, nb_val);
rep = menu();
}
return 0;
}
char menu(void)
{
char rep;
printf("A...........Addition\n");
printf("M...........Multiplication\n");
printf("(autres)....Quitter\n");
printf("Choix : ");
scanf(" %c", &rep);
if (rep > 'Z')
{
rep = rep - 'a' + 'A';
}
return rep;
}
void saisir(double Mat[100][100], int nb)
{
int i, j;
printf("entrer les valeurs de la matrice\n");
for (i=0; i{
for (j=0; j{
printf ("M[%d][%d] = ", i+1, j+1);
scanf ("%lf", &(Mat[i][j]));
}
}
}
void afficher(double Mat[100][100], int nb)
{
int i, j;
printf("\t");
for (i=0; i{
printf("%d\t\t", i+1);
}
printf("\n");
for (i=0; i{
printf("----------------");
}
printf("\n");
for (i=0; i{
printf("%d:", i+1);
for (j=0; j{
printf ("\t%f", Mat[i][j]);
}
printf("\n");
}
for (i=0; i{
printf("----------------");
}
printf("\n\n");
}
void additionner(double Mat1[100][100], double Mat2[100][100],
double Mat3[100][100], int nb)
{
int i, j;
for (i=0; i{
for (j=0; j{
Mat3[i][j] = Mat1[i][j] + Mat2[i][j];
}
}
}
void multiplier(double Mat1[100][100], double Mat2[100][100],
double Mat3[100][100], int nb)
{
int i, j, k;
for (i=0; i{
for (j=0; j{
Mat3[i][j] = 0;
for (k=0; k{
Mat3[i][j] = Mat3[i][j] + Mat1[i][k]*Mat2[k][j];
}
}
}
}

Exercice langage C : Valeur correspondante

Cet exercice a pour but de vérifier les points techniques suivants :

• Utilisation du while et du for.
• Imbrication de boucles.
• Lire précisément un énoncé.
• Modélisation assez complexe d'un problème issu des mathématiques.

Travail à Faire :

Ecrire un programme qui demande à l'utilisateur de taper un entier M puis qui cherche la valeur de a comprise entre 2 et M qui maximise la valeur de N.
On appelle A cette valeur.
Le programme doit afficher la valeur A et la valeur N correspondante.

#include
using namespace std;
int main()
{
int a,n,u,M,amax,nmax;
cout"Tapez la valeur de M : ";cin>>M;
amax=2;
nmax=2;
for(a=3;aM;a++)
{
n=0;
u=a;
while(u!=1)
{
if(u%2==0)u=u/2; else u=3*u+1;
n++;
}
if(n>nmax){amax=a;nmax=n;}
}
cout"La valeur de A est :"amaxendl;
cout"La valeur de N correspondante est :"nmaxendl;

return 0;
}

Exercice langage C: Calcules Mathématiques

Exercice 1 :

Écrire un programme qui remplit les 100 éléments d'un tableau avec la valeur 3 et affiche ce tableau à l'écran.

Exercice 2 :

Moyenne :

Écrire un programme qui lit 12 nombres, en fait la moyenne, et affiche les nombres supérieurs à cette moyenne.

Exercice 3 :

Produit scalaire :

On peut représenter un vecteur de l'espace vectoriel Rn à l'aide d'un tableau de n réels.

Écrire un programme qui lit deux vecteurs de R10, calcule leur produit scalaire et affiche les deux vecteurs et leur produit scalaire.

Exercice 1 :

Correction
#include
void main()
{
int tab[100];
int i;
for (i=0;i{ tab[i]=3;
printf("%d ",tab[i]);
}
}

Exercice 2 :

#include
int main(){
int tab[12];
int i,j,som=0;
float moy;
for (i=0; i { /*saisie des nombres*/
printf("entrez le %d chiffre : ",i);
scanf("%d",&tab[i]);
som+=tab[i];
}
moy=(float)som/12;
printf("affichage des chiffres superieur à la moyenne\n");
for (i=0; i { if (tab[i]>moy) printf("%d\n",tab[i]);
}
return 0;
}

Exercice 3 :

#include
int main(){
float tab1[10];
float tab2[10];
int i,j;
float prod=0;
for (i=0;i{
printf("\nentrez la coordonnee %d du premier vecteur : ",i+1);
scanf("%f",&tab1[i]);
}
for (i=0;i{
printf("\nentrez la coordonnee %d du deuxième vecteur : ",i+1);
scanf("%f",&tab2[i]);
}
for (j=0;j{
prod = prod + tab1[j]*tab2[j];
}
printf("le produit sacalaire des deux vecteurs est : %f" ,prod);
return 0;
}

Exercice langage C : Examen partie partie administrateur

1) Faire une fonction de prototype int fnb_quest(FILE *fq) qui compte le nombre de question d'un fichier précédemment ouvert en lecture. On pensera à compter le nombre de blocs d'octets de type TQCM, lus.

2) Faire une fonction de prototype TQCM fune_quest(FILE *fq, int ind) qui retourne la question placée à l'ind in du fichier fq précédemment ouvert en lecture.

3) Faire une fonction de prototype void fqcm(char *UTIL, char *nomficQCM) qui pose les questions du fichier nomficQCM à l'utilisateur dont le nom UTIL est passé en paramètre. Cette fonction enregistre dans un fichier nommé resu la trace des questions et des réponses de l'utilisateur UTIL. Ce fichier de trace sera écrit directement en mode texte avec la fonction fprintf. Le fichier resuUTIL sera effacé s'il existait.

4) Faire une fonction de prototype void ftrace(char *UTIL) qui permet d'afficher la dernière trace de l'utilisateur UTIL. La dernière trace si elle existe est un ficher enregistré sous le nom resuUTIL, UTIL étant le nom donné par l'utilisateur.

5) Faire une fonction de prototype char menu_util(void) qui permet l'affichage à l'écran du dialogue suivant et qui récupère et retourne le choix de l'utilisateur.

menu utilisateur :

(a) afficher sa dernière session,

(b) faire une nouvelle session,

(c) quitter

6) Faire une fonction de prototype void gestion_util(void) qui gère les fonctionnalités du mode utilisateur.

Avant d'afficher le menu de choix, l'utilisateur devra entrer son nom. Ce nom sera mémorisé et utilisé dans toute la session pour gérer le fichier trace.

int fnb_quest(FILE * fq);
/* mode utilisateur, compte le nombre de questions d'un fichier de
structure Question */
Question fune_quest(FILE * fq, int index);
/* mode utilisateur, retourne la question a la place (index) du
fichier (fq) */
void fqcm(char * util, char * nomficQCM);
/* mode utilisateur, pose les questions du fichier (nomficQCM) a
l'utilisateur (util) enregistre la session dans un fichier
"resu", donne le resultat du test a la fin */
void ftrace(char * util);
/* mode utilisateur, affiche la trace des questions et des reponses
d'un utilisateur de nom (util) enregistre dans un fichier de
resultat "resu" s'il existe */
char menu_util(void);
/* menu utilisateur :
(a) afficher sa derniere session,
(b) faire un test qcm,
(c) quitter */
void gestion_util(void);
/* mode utilisateur, gestion des fonctionnalites utilisateur */
int main (void)
{
char calu[3];
do
{
printf("(a) mode administrateur,\n");
printf("(u) mode utilisateur,\n");
printf("(q) quitter,\n");
printf("votre choix :");
fgets(calu, 3, stdin);
switch(calu[0])
{
case 'a':
case 'A':
gestion_admin();
break;
case 'u':
case 'U':
gestion_util();
break;
case 'q':
case 'Q':
printf("fin du programme \n\n");
break;
default :
printf("\nmauvaise saisie recommencer !!\n");
}
}
while( calu[0] !='q' && calu[0] != 'Q');
return 0;
}

Question tsaisie_quest(int num)
{
Question q;
printf("Question %d: ", num);
fgets(q.quest, MLIGNE-1, stdin);
printf("Reponse 1 : ");
fgets(q.rep1, MLIGNE-1, stdin);
printf("Reponse 2 : ");
fgets(q.rep2, MLIGNE-1, stdin);
printf("Reponse 3 : ");
fgets(q.rep3, MLIGNE-1, stdin);
printf("Reponse 4 : ");
fgets(q.rep4, MLIGNE-1, stdin);
do
{
printf("Numero de la solution (1 a 4) : ");
scanf("%d", &q.solrep);
if (q.solrep 4)
{
printf("erreur de saisie\n");
}
}
while (q.solrep 4);
return q;
}

void fenr_quest(Question * pq, FILE * fq)
{
fwrite(pq, sizeof(Question), 1, fq);
}

int fcreer_qcm(char * nomfic)
{
FILE *fq;
Question q;
char rep[3];
int nquest, ret;
fq = fopen(nomfic, "a+");
if (fq == NULL)
{
printf("Erreur d'ouverture de %s\n", nomfic);
return 0;
}
fseek(fq, -1l*sizeof(Question), SEEK_END);
ret = fread(&q, sizeof(Question), 1, fq);
if (ret == 0)
{
nquest = 0;
}
else
{
nquest = q.numquest;
}
rep[0] = 'o';
while (rep[0] == 'o' || rep[0] == 'O')
{
nquest++;
q = tsaisie_quest(nquest);
q.numquest = nquest;
fenr_quest(&q, fq);
getchar();
printf("Encore (o/n): ");
fgets(rep, 3, stdin);
}
fclose(fq);
return 1;
}
int faff_qcm(char * nomfic)
{
FILE *fq;
Question q;
fq = fopen(nomfic, "r");
if (fq == NULL)
{
printf("Fichier %s inexistant\n", nomfic);
perror("fopen");
return 0;
}
fread(&q, sizeof(Question), 1, fq);
while (! feof(fq))
{
faff_quest(stdout, &q);
printf("\n\tSolution : %d\n", q.solrep);
fread(&q, sizeof(Question), 1, fq);
}
fclose(fq);
return 1;
}

int frech_quest(Question * qret, FILE * fq, int numquest)
{
int ret = -1, rang = 0;
if (fq == NULL)
{
return -1;
}
rewind(fq);
fread(qret, sizeof(Question), 1, fq);
while (! feof(fq))
{
rang++;
if (qret->numquest == numquest)
{
ret = rang;
break;
}
fread(qret, sizeof(Question), 1, fq);
}
if (ret > 0)
{
fseek(fq, -1l * sizeof(Question), SEEK_CUR);
}
return ret;
}

void fmodif_quest(Question * qamodif)
{
int choix;
do
{
printf("\nMenu Modification question %d:\n", qamodif->numquest);
do
{
printf("\n\t(1) Modifier question\n");
printf("\t(2) Modifier reponse 1\n");
printf("\t(3) Modifier reponse 2\n");
printf("t(4) Modifier reponse 3\n");
printf("\t(5) Modifier reponse 4\n");
printf("\t(6) Modifier numero solution\n");
printf("\t(7) Sauvegarder\n\n");
printf("\tVotre choix : ");
scanf("%d", &choix);
}
while (choix 7);
getchar();
switch (choix)
{
case 1:
printf("Ancienne question : \"%s\"\n", qamodif->quest);
printf("Nouvelle question : ");
fgets(qamodif->quest, MLIGNE-1, stdin);
break;
case 2:
printf("Ancienne reponse 1 : \"%s\"\n", qamodif->rep1);
printf("Nouvelle reponse 1 : ");
fgets(qamodif->rep1, MLIGNE-1, stdin);
break;
case 3:
printf("Ancienne reponse 2 : \"%s\"\n", qamodif->rep2);
printf("Nouvelle reponse 2 : ");
fgets(qamodif->rep2, MLIGNE-1, stdin);
break;
case 4:
printf("Ancienne reponse 3 : \"%s\"\n", qamodif->rep3);
printf("Nouvelle reponse 3 : ");
fgets(qamodif->rep3, MLIGNE-1, stdin);
break;
case 5:
printf("Ancienne reponse 4 : \"%s\"\n", qamodif->rep4);
printf("Nouvelle reponse 4 : ");
fgets(qamodif->rep4, MLIGNE-1, stdin);
break;
case 6:
printf("Ancien numero de solution : %d\n", qamodif->solrep);
printf("Nouveau numero de solution : ");
scanf("%d", &qamodif->solrep);
break;
case 7:
default:
break;
}
}
while (choix != 7);
}
int fmodif_qcm(char * nomfic)
{
FILE *fq;
Question q;
int noq, ret;
fq = fopen(nomfic, "r+");
if (fq == NULL)
{
printf("Fichier %s inexistant\n", nomfic);
perror("fopen");
return 0;
}
do
{
printf("Numero de la question a modifier (-1 pour terminer) : ");
scanf("%d", &noq);
if (noq {
break;
}
ret = frech_quest(&q, fq, noq);
if (ret {
continue;
}
fmodif_quest(&q);
fenr_quest(&q, fq);
} while (noq > 0);
fclose(fq);
return 1;
}
char menu_admin(void)
{
char calu[3];
printf("\nMenu administrateur :\n");
printf("\t(a) consulter un fichier qcm\n");
printf("\t(b) creer ou ajouter dans un fichier qcm\n");
printf("\t(c) modification d'un fichier qcm\n");
printf("\t(q) quitter.\n\n");
printf("\tVotre choix : ");
fgets(calu, 3, stdin);
return calu[0];
}
/* mode administrateur, gestion des fonctionnalites de l'administrateur */
void gestion_admin()
{
char calu;
char nomficQCM[MNAME];
do
{
calu = menu_admin();
switch(calu)
{
case 'a':
printf("\nNom du fichier : ");
fgets(nomficQCM, MNAME-1, stdin);
nomficQCM[strlen(nomficQCM)-1] = 0;
faff_qcm(nomficQCM);
break;
case 'b':
printf("\ncreer ou ajouter dans un fichier qcm\n");
printf("\nNom du fichier : ");
fgets(nomficQCM, MNAME-1, stdin);
nomficQCM[strlen(nomficQCM)-1] = 0;
fcreer_qcm(nomficQCM);
break;
case 'c':
printf("modification d'un fichier qcm\n");
printf("\nNom du fichier : ");
fgets(nomficQCM, MNAME-1, stdin);
nomficQCM[strlen(nomficQCM)-1] = 0;
fmodif_qcm(nomficQCM);
break;
case 'q':
printf("sortie du mode administrateur \n\n");
break;
default :
printf("\nmauvaise saisie recommencer !!\n");
}
} while( calu != 'q');
}
/***** PARTIE UTILISATEUR *******/
void faff_quest(FILE *faff, Question *tq)
{
fprintf(faff, "\nQUESTION numero %d : %s", tq->numquest, tq->quest);
fprintf(faff, "\n\tREPONSE 1 : %s", tq->rep1);
fprintf(faff, "\n\tREPONSE 2 : %s", tq->rep2);
fprintf(faff, "\n\tREPONSE 3 : %s", tq->rep3);
fprintf(faff, "\n\tREPONSE 4 : %s", tq->rep4);
}
int fnb_quest(FILE *fq)
{
int i= 0;
long sQuestion = sizeof(Question);
Question tq;
fseek(fq, 0, SEEK_SET);
while(fread(&tq, sQuestion, 1, fq) != 0)
i++;
return i;
}
Question fune_quest(FILE *fq, int index)
{
long sQuestion = sizeof(Question);
Question tq;
fseek(fq, index*sQuestion, SEEK_SET);
if (fread(&tq, sQuestion, 1, fq) != 1)
{
printf("\nERREUR DE LECTURE DU FICHIER\n");
memset(&tq, 0l, sQuestion);
}
return tq;
}
void fqcm(char *UTIL, char *nomficQCM)
{
FILE *fqcm;
FILE *fresu;
Question tq;
char nomficRESU[MNAME] = "resu";
int i, n;
int rep, cptrep = 0;
strcat(nomficRESU, UTIL);
fqcm = fopen(nomficQCM, "r");
fresu = fopen(nomficRESU, "w");
if ((fqcm == NULL) || (fresu == NULL))
{
printf("\nERREUR D'OUVERTURE DU FICHIER - ABANDON\n");
return;
}
else
{
n= fnb_quest(fqcm);
for(i = 0; i {
tq = fune_quest(fqcm, i);
faff_quest(stdout, &tq);
printf("\nVOTRE REPONSE : ");
scanf(" %d", &rep);
if(rep != tq.solrep)
printf("\nMAUVAISE REPONSE");
else
{
printf("\nBONNE REPONSE");
cptrep++;
}
faff_quest(fresu,&tq);
fprintf(fresu,"\nVOTRE REPONSE : %d", rep);
}
printf("\nFICHIER : %s, Bonnes reponses/ total des questions : %d/%d\n",nomficQCM, cptrep, n );
fprintf(fresu,"\nFICHIER : %s, Bonnes reponses/ total des questions : %d/%d\n",nomficQCM, cptrep, n );
fclose(fqcm);
fclose(fresu);
}
}
void ftrace(char *UTIL)
{
FILE *fresu;
int i =0;
char nomficRESU[MNAME] = "resu";
char lignelue[MLIGNE];
strcat(nomficRESU,UTIL);
fresu = fopen(nomficRESU, "r");
if (fresu == NULL)
{
printf("\nERREUR D'OUVERTURE DE FICHIER, ABANDON\n");
return;
}
else
{
printf("\nTRACE DE L'UTILISATEUR : %s\n", UTIL);
while(fgets(lignelue, MLIGNE-1, fresu) != NULL)
{
i++;
printf("%d : %s", i, lignelue);
}
printf("\n***********FIN DE TRACE**********\n");
fclose(fresu);
}
}
char menu_util(void)
{
char calu;
printf("\nMenu utilisateur :\n\t(a) afficher sa derniere session,\n\t(b) faire un test QCM,");
printf("\n\t(c) quitter.\n\n\tVotre choix : ");
scanf(" %c", &calu);
return calu;
}
void gestion_util(void)
{
char calu;
char nomficQCM[MNAME];
char nomUTIL[MNAME];
printf("\nDonner votre nom d'utilisateur\n");
scanf("%s", nomUTIL);
do
{
calu = menu_util();
switch(calu)
{
case 'a': printf("\nDerniere session de l'utilisateur : %s\n", nomUTIL);
ftrace(nomUTIL);
break;
case 'b': printf("\nCreation d'une nouvelle session pour : %s\n", nomUTIL);
printf("\nDonnez le nom du fichier de questions : \n");
scanf(" %s", nomficQCM);
fqcm(nomUTIL, nomficQCM);
break;
case 'c': printf("sortie de l'application en utilisateur \n\n");
break;
default : printf("\nmauvaise saisie recommencer !!\n");
}
} while( calu != 'c');
}

Exercice langage C: Les résultats fournis par un programme

Quels seront les résultats fournis par ce programme :

#include
main ()
{ int n = 543 ;
int p = 5 ;
float x = 34.5678;
printf ("A : %d %f\n", n, x) ;
printf ("B : %4d %10f\n", n, x) ;
printf ("C : %2d %3f\n", n, x) ;
printf ("D : %10.3f %10.3e\n", x, x) ;
printf ("E : %-5d %f\n", n, x) ;
printf ("F : %*d\n", p, n) ;
printf ("G : %*.*f\n", 12, 5, x) ;
printf ("H : %x : %8x :\n", n, n) ;
printf ("I : %o : %8o :\n", n, n) ;
}

A : 543 34.567799

B : 543 34.567799

12 Exercices en langage C

C : 543 34.567799

D : 34.568 3.457e+01

E : 543 34.567799

F : 543

G : 34.56780

H : 21f : 21f :

I : 1037 : 1037 :