Exercice langage C: Tests d'égalité

Travail à Faire:

Ecrivez un programme qui demande trois valeurs entières à l'utilisateur, et affiche, le cas échéant, un de ces cinq messages:

1. Les 3 valeurs sont egales;
2. Seules les 2 premieres valeurs sont egales;
3. Seules les 2 dernieres valeurs sont egales;
4. Seules la premiere et la troisieme valeurs sont egales;
5. Les 3 valeurs sont differentes.

Comment écrire le programme en n'utilisant que quatre instructions if (et quatre else) et pas d'opérateurs logiques?

#include
using namespace std;
int main(int argc, char **argv) {
int x, y ,z;
cout cin >> x;
cout cin >> y;
cout cin >> z;
if (x == y) {
if (y == z)
cout else
cout }
else {
if (x == z)
cout else {
if (y == z)
cout else
cout }
}
return 0;
}

Créez un programme contenant:

#include
using namespace std;
#include
#include "swindow.h"
int main(int argc, char ** argv)
{
const int longueur = 300;
const int hauteur = 200;
const int rayon_max = 50;
SimpleWindow window("cercles", longueur, hauteur);
window.map();
// Remplit la fenetre en blanc:
window.color(1, 1, 1);
window.fill();
// Dessine en noir:
window.color(0, 0, 0);
window.drawCircle(longueur / 2, hauteur / 2, rayon_max);
window.show();
// Attend que l'utilisateur appuie sur une touche:
getchar();
return 0;
}

Comment modifier ce programme pour qu'il affiche plusieurs cercles, dont le centre et le rayon seront tirés au hasard ?

#include
using namespace std;
#include
#include "swindow.h"
int main(int argc, char ** argv)
{
const int longueur = 300;
const int hauteur = 200;
const int rayon_max = 50;
const int nbr_cercles = 20;
// Initialise le generateur de nombres aleatoires
srand(time(0));
SimpleWindow window("cercles", longueur, hauteur);
window.map();
// Remplit la fenetre en blanc:
window.color(1, 1, 1);
window.fill();
// Dessine en noir:
window.color(0, 0, 0);
for (int i=0; inbr_cercles; i++) {
// Tire les coordonnees et le rayon du cercle aleatoirement
int x = rand() % longueur;
int y = rand() % hauteur;
int rayon = rand() % rayon_max;
// Dessine un cercle
window.drawCircle(x, y, rayon);
}
window.show();
getchar();
return 0;
}

Exercice langage C: Programme essai

Créez un programme contenant:

#include
using namespace std;
#include
#include "swindow.h"
int main(int argc, char ** argv)
{
const int longueur = 300;
const int hauteur = 200;
const int rayon_max = 50;
SimpleWindow window("cercles", longueur, hauteur);
window.map();
// Remplit la fenetre en blanc:
window.color(1, 1, 1);
window.fill();
// Dessine en noir:
window.color(0, 0, 0);
window.drawCircle(longueur / 2, hauteur / 2, rayon_max);
window.show();
// Attend que l'utilisateur appuie sur une touche:
getchar();
return 0;
}

Comment modifier ce programme pour qu'il affiche plusieurs cercles, dont le centre et le rayon seront tirés au hasard ?

#include
using namespace std;
#include
#include "swindow.h"
int main(int argc, char ** argv)
{
const int longueur = 300;
const int hauteur = 200;
const int rayon_max = 50;
const int nbr_cercles = 20;
// Initialise le generateur de nombres aleatoires
srand(time(0));
SimpleWindow window("cercles", longueur, hauteur);
window.map();
// Remplit la fenetre en blanc:
window.color(1, 1, 1);
window.fill();
// Dessine en noir:
window.color(0, 0, 0);
for (int i=0; inbr_cercles; i++) {
// Tire les coordonnees et le rayon du cercle aleatoirement
int x = rand() % longueur;
int y = rand() % hauteur;
int rayon = rand() % rayon_max;
// Dessine un cercle
window.drawCircle(x, y, rayon);
}
window.show();
getchar();
return 0;
}

Exercice langage C : Les Types Float et Double

En langage C, les types prédé?nis ?oat et double permettent de manipuler des nombres à virgule ?ottante en simple et double précision mais il n’y a pas de type prédé?ni permettant de manipuler des nombres complexes.

On dé?nira un type cmplx1en utilisant une structure et deux champs de type double qui représentent la partie réelle et la partie imaginaire.

On écrira des fonctions lit c(), a?che c(c),somme c(c1,c2) et produit c(c1,c2) que l’on utilisera dans un programme permettant de calculer des expressions de la forme ((c1op1c2)op2c3)op3c4)...opn?1cn) o`u les complexes sont rentrés dans

l’ordre c1, c2,... et l’expression calculée dans l’ordre c1op1c2 d’abord puis son résultat utilisé comme argument gauche de op2 et ainsi de suite.

#include
#include
#de?ne N 5
/? type?/
struct cmplx
{ double re;
double im;
};
/? prototypes ?/
struct cmplx lit c(void);
void a?che c(struct cmplx c);
struct cmplx somme c(struct cmplx c1, struct cmplx c2);
struct cmplx produit c(struct cmplx c1, struct cmplx c2);
/? principale ?/
int main()
{ struct cmplx resg,d;
char rep[10];
printf(”gauche ? (deux r´eels a et b pour le complexe a+ ib)\n”);
resg=lit c();
a?che c (resg);
printf(”op? (+ ou? ou r (esultat) )\n”);
scanf(”%s”,rep);
while (rep[0] !=’r’)
{ printf(”droit ? (deux r´eels a et b pour le complexe a+ ib)\n”);
d=lit c();
if (rep[0]==’+’)
{ resg=somme c(resg,d);
}else
{ if (rep[0]==’?’)
{ resg=produit c(resg,d);
}else
{ printf(”erreur\n”);break;
}
}printf(”(interm´ediaire) ==>”);
a?che c (resg);
printf(”op? (+ ou? ou r (esultat) )\n”);
scanf(”%s”,rep);
}printf(”==>”);
a?che c (resg);
return EXIT SUCCESS;
}/?fonctions?/
truct cmplx lit c(void)
{ struct cmplx c;
scanf(”%lf”,&c.re);
scanf(”%lf”,&c.im);
return (c);
}void a?che c(struct cmplx c)
{ printf(”(%lf,%lf)\n”,c.re,c.im);
return ;
}struct cmplx somme c(struct cmplx c1, struct cmplx c2)
{ struct cmplx c;
c.re=c1.re+c2.re;
c.im=c1.im+c2.im;
return (c);
}struct cmplx produit c(struct cmplx c1, struct cmplx c2)
{ struct cmplx c;
c.re=(c1.re?c2.re)?(c1.im?c2.im);
c.im=(c1.re?c2.im)+(c1.im?c2.re);
return (c);
}//((a op b) op c)op d ) etc ...
//[Session started at 2006?11?14 15:45:21 +0100.]
//gauche ? (deux r´eels a et b pour le complexe a+ ib)
//1 1
//(1.000000,1.000000)
//op? (+ ou? ou r (esultat) )
//+
//droit ? (deux r´eels a et b pour le complexe a+ ib)
//3 3
//(interm´ediaire) ==>(4.000000,4.000000)
//op? (+ ou? ou r (esultat) )
//?
//droit ? (deux r´eels a et b pour le complexe a+ ib)
//2 1
//(interm´ediaire) ==>(4.000000,12.000000)
//op? (+ ou? ou r (esultat) )
//r
//==>(4.000000,12.000000)

Exercice langage C : Simple Programme

Ecrire un programme qui a?che la sortie suivante :

a?che 10 fois 1

a?che 10 fois 2

a?che 10 fois 3

a?che 10 fois 4

a?che 10 fois 5

a?che 10 fois 6

a?che 10 fois 7

a?che 10 fois 8

a?che 10 fois 9

a?che 10 fois 10

a?che 10 fois 11

#include
#include
/? a?che une table de 11 lignes dont la
ieme ligne contient iiiiiiiiii (la valeur de i 10 fois).
Dans un premier temps on se contente d’a?cher
”a?che 10 fois i ” en passant `a la ligne `a chaque fois.
Dans un second temps on remplace cet a?chage par une boucle
?/
int main ()
{ int i;
int compteur;
/? version 1 (simple)?/
for(i = 1;i{ printf(”a?che 10 fois %d\n”,i);
}/? version 2 (avec une double boucle)?/
for(i = 1;i{ for(compteur = 1;compteur{ printf(”%d ”,i);
}printf(”\n”);
}
return EXIT SUCCESS;
}

Exercice langage C : Fonction convertit un entier

Travail à Faire:

1.Ecrire une fonction de prototype  void conv(int) convertit un entier en base 2.

Cette fonction affiche les bits de l’entier n passé en argument.

2. Ecrire une fonction de prototype void conv(int n, int B) convertit un entier n en base

B. Cette fonction affiche  les chiffres  en base B de l’entier n passé en argument. La fonction doit fonctionner pour les bases 2 `a 16 au moins.

L’application directe de l’algorithme vu en cours a un petit défaut : les chiffres sont affichés  à l’envers. C¸ a n’est pas grave : l’´enonc´e ne demande pas de les affichés  l’endroit.

Résoudre ce problème en toute généralité nécessite d’utiliser un algorithme ine?cace ou des tableaux.

Ci-dessous, une combine pour afficher à  l’endroit en base 2.

#include
void conv2(int n){
while (n!=0){
printf("%i", n%2);
n=n/2;
}
printf("\n");
}
void convB(int n, int B){
int c; char affc;
while (n!=0){
c=n%B;
if (cprintf("%c", affc);
n=n/B;
}
printf("\n");
}
void convAlendroit(int n){
int res, d;
res=0;
d=1;
while (n!=0){
res = res + n%2*d;
d=10*d;
n=n/2;
}
printf("%i", res);
printf("\n");
}
main(){
convB(255, 16);
}

Exercice langage C: Lire les dimensions d'un Tableau à deux dimensions

Travail à Faire:

Ecrire un programme qui lit les dimensions L et C d'un tableau T à deux dimensions du type int  (dimensions maximales: 50 lignes et 50 colonnes).

Remplir le tableau par des valeurs entrées au clavier et afficher le tableau ainsi que la somme de tous ses éléments.

Pour cela on écrira les fonctions suivantes :

void RemplirTableau(void)

void AfficherTableau(void)

#include
void RemplirTableau(void) ;
void AfficherTableau(void) ;
int T[50][50]; /* tableau donné */
int L, C; /* dimensions */
main()
{
/* Déclarations */
long SOM; /* somme des éléments - type long */
/* Saisie des données */
printf("Nombre de lignes (max.50) : ");
scanf("%d", &L );
printf("Nombre de colonnes (max.50) : ");
scanf("%d", &C );
RemplirTableau() ;
AfficherTableau() ;
/* Calcul de la somme */
for (SOM=0, I=0; Ifor (J=0; JSOM += T[I][J];
/* Edition du résultat */
printf("Somme des éléments : %ld\n", SOM);
return 0;
}
void RemplirTableau(void)
{
int i,j ;
for (i=0; ifor (j=0; j{
printf("Elément[%d][%d] : ",i,j);
scanf("%d", &T[i][j]);
}
}
void AfficherTableau(void)
{
int i,j ;
printf("Tableau donné :\n");
for (i=0; i{
for (j=0; jprintf("%d\t", T[i][j]);
printf("\n");
}
}

Exercice langage C : Réaliser multiples Programmes

Travail à Faire:

1. Réaliser un programme qui affiche la consommation d'un véhicule en litres aux 100 km, à partir d'une distance parcourue lue au clavier et d'un nombre de litres de carburant consommé lu au clavier
2. Réaliser un programme qui affiche le discriminant d'une équation du second degré (ax2 + bx + c = 0)
   1. les valeurs a, b et c seront lues au clavier
3. Réaliser un programme qui qui à partir d'une somme d'argent lue au clavier, donne le nombre minimal de pièces de 2 euros, de 1 euro, de 50 centimes, 20 centimes, 10 centimes, 5 centimes, 2 centimes et 1 centime qui compose cette somme.

/* Programme de calcul et d'affichage du discriminant d'une equation du
* second degre, sous la forme ax2 + bx + c = 0, avec a,b,c lus au clavier */
#include
int main()
{
double a, b, c, discriminant;
printf("a: ");
scanf("%lf", &a);
printf("b: ");
scanf("%lf", &b);
printf("c: ");
scanf("%lf", &c);
/* pas d'operateur 'square' en C */
discriminant = b*b - 4*a*c;
printf("Discriminant de %.2fx2 + %.2fx + %.2f = %.2f\n", a, b, c, discriminant);
(discriminant == 0) ? printf("Une seule racine\n"):0;
(discriminant > 0) ? printf("Deux racines reelles\n"):0;
(discriminant return 0;
}
2)
/* Programme de calcul et d'affichage des pieces necessaires pour produire
* une somme, lue au clavier */
#include
int main()
{
double sdouble;
int sEnCentime, nbPieces;
printf("somme en euros: ");
scanf("%lf", &sdouble);
/* arrondi a l'entier le plus proche !
* en effet, les nombre decimaux sont rarement representes de maniere
* exacte. Par exemple, le nombre 0,3 aura une representation approchee
* de 0.300000011920928955 en float et de 0.299999999999999989 en double.
* Dans ces deux cas, ajouter 0.005, permettra d'obtenir 30 centimes.
*/
sEnCentime = (sdouble + 0.005)*100;
nbPieces = sEnCentime / 200;
printf("Nombre de pieces de 2 euros : %d\n", nbPieces);
sEnCentime %= 200;
nbPieces = sEnCentime / 100;
printf("Nombre de pieces de 1 euros : %d\n", nbPieces);
sEnCentime %= 100;
nbPieces = sEnCentime / 50;
printf("Nombre de pieces de 50 centimes: %d\n", nbPieces);
sEnCentime %= 50;
nbPieces = sEnCentime / 20;
printf("Nombre de pieces de 20 centimes: %d\n", nbPieces);
sEnCentime %= 20;
nbPieces = sEnCentime / 10;
printf("Nombre de pieces de 10 centimes: %d\n", nbPieces);
sEnCentime %= 10;
nbPieces = sEnCentime / 5;
printf("Nombre de pieces de 5 centimes: %d\n", nbPieces);
sEnCentime %= 5;
nbPieces = sEnCentime / 2;
printf("Nombre de pieces de 2 centimes: %d\n", nbPieces);
sEnCentime %= 2;
printf("Nombre de pieces de 1 centime: %d\n", sEnCentime);
return 0;
}
3)
/* Programme de calcul et d'affichage de la repartition en groupes de
* personnes, d'effectifs equilibres, valeurs lues au clavier */
#include
int main()
{
int groupes, personnes;
printf("groupes: ");
scanf("%d", &groupes);
printf("personnes: ");
scanf("%d", &personnes);
printf("Nombre de grands groupes : %d et leur effectif %d\n",
personnes % groupes, personnes / groupes);
printf("Nombre de petits groupes : %d et leur effectif %d\n",
groupes - personnes % groupes, 1 + personnes / groupes);
return 0;
}

Exercices langage C fonctions passage des paramètres

Exercice 1

Exécuter le programme suivant et construire les grilles correspondantes. Implémenter le programme ensuite en C.

Exercice 2

Exécuter le programme suivant et construire les grilles correspondantes. Implémenter le programme ensuite en C.

Exercice 3

Exécuter le programme suivant et construire les grilles correspondantes. Implémenter le programme ensuite en C.

Exercice 4

Exécuter le programme suivant et construire les grilles correspondantes. Implémenter le programme ensuite en C.

Implémentation:

#include
main()
{
void P(int X, int *Y); /* Prototype de la fonction appelée */
int A,B;
A=0;
B=0;
P(A, &B);
printf("%d %d \n", A, B);
return 0;
}
void P(int X, int *Y)
{
X = X+1;
*Y = *Y+1;
printf("%d %d \n", X, *Y);
}
 

Affichage: 2

2

1000

2

Implémentation:

#include

main()
{
void MACHIN(int X); /* Prototype de la fonction appelée */
int A;
A=2;
printf("%d \n", A);
MACHIN(A);
printf("%d \n", A);
return 0;
}

void MACHIN(int X)
{
printf("%d \n", X);
X = 1000;
printf("%d \n", X);
}

Affichage: 3 -8 12

3 12 3

Implémentation:

#include

main()
{
void MODIFIER(int X, int *Y, int *Z); /* Prototype */
int A,B,C;
A=3;
B=-8;
C=12;
printf("%d %d %d \n", A, B, C);
MODIFIER(A,&B,&C);
printf("%d %d %d \n", A, B, C);
return 0;
}
void MODIFIER(int X, int *Y, int *Z)
{
int T;
T = X;
X = *Y;
*Y = *Z;
*Z = T;
}

suite . . .

Implémentation:

#include

main()
{
void MANIPULER(int X, int Y, int *Z); /* Prototype */
int A,B,C;
A=208;
B=5;
C=-34;
printf("%d %d %d \n", A, B, C);
MANIPULER(A,B,&C);
printf("%d %d %d \n", A, B, C);
return 0;
}
void MANIPULER(int X, int Y, int *Z)
{
printf("%d %d %d \n", X, Y, *Z);
X = X/2;
Y = Y*2;
*Z = X+Y;
printf("%d %d %d \n", X, Y, *Z);
}

Exercice langage C: Flocons

Créez un programme contenant:

#include
#include "swindow.h"
struct Flocon
{
int x, y;
};
void init_flocon(Flocon * f, int longueur, int hauteur)
{
// ...
}
void dessine_flocon(SimpleWindow * window, Flocon * f)
{
// ..
}
void avance_flocon(Flocon * f, int hauteur)
{
f->y = f->y + 1;
}
int main(int argc, char ** argv)
{
const int longueur = 200;
const int hauteur = 200;
const int nb_flocons = 500;
Flocon flocons[nb_flocons];
SimpleWindow window("neige", longueur, hauteur);
window.map();
// Initialisation aleatoire de la position des flocons:
for(int i = 0; i nb_flocons; i++)
init_flocon(flocons + i, longueur, hauteur);
// Efface la fenetre en bleu clair:
window.color(1, 0.5, 0.5);
window.fill();
// Dessine en blanc:
window.color(1, 1, 1);
// Affichage des flocons:
for(int i = 0; i nb_flocons; i++)
dessine_flocon(&window, flocons + i);
window.show();
getchar();
return 0;
}

1. Écrivez la fonction init_flocon qui initialise les coordonnées du flocon passé en paramètre à une position aléatoire, et la fonction affiche_flocon, qui affiche le flocon avec un pixel aux coordonnées du flocon. Le programme n'affiche pour l'instant que des points statiques.
2. Ajoutez une boucle comme vu en cours pour que les flocons soient animés.
3. Modifiez la fonction avance_flocon pour qu'un flocon qui dépasse le bas de la fenêtre recommence à tomber du haut de la fenêtre.
4. Le truc pour avoir un mouvement ``réaliste'' est de tirer le déplacement du flocon aléatoirement à chaque fois. Modifiez la fonction avance_flocon pour tirer le déplacement en y aléatoirement entre 0 et 3, le déplacement en x entre -2 et +2.

#include
#include "swindow.h"
struct Flocon
{
int x, y;
};
void init_flocon(Flocon * f, int longueur, int hauteur)
{
f->x = rand() % longueur;
f->y = rand() % hauteur;
}
void dessine_flocon(SimpleWindow * window, Flocon * f)
{
window->drawPoint(f->x, f->y);
}
void avance_flocon(Flocon * f, int hauteur)
{
// Deplacement vertical entre 0 et 3.
f->y = f->y + rand() % 4;
// Deplacement horizontal entre -2 et 2.
f->x = f->x + (rand() % 5) - 2;
// Si le flocon est arrive en bas de la fenetre, on le replace au sommet.
if (f->y >= hauteur)
f->y = 0;
}
int main(int argc, char ** argv)
{
const int longueur = 200;
const int hauteur = 200;
const int nb_flocons = 500;
Flocon flocons[nb_flocons];
// Initialise le generateur de nombres aleatoires
srand(time(0));
SimpleWindow window("neige", longueur, hauteur);
window.map();
// Initialisation aleatoire de la position des flocons:
for(int i = 0; i nb_flocons; i++)
init_flocon(flocons + i, longueur, hauteur);
// boucle infinie pour afficher les flocons
while (true) {
// Efface la fenetre en bleu clair:
window.color(1, 0.5, 0.5);
window.fill();
// Dessine en blanc:
window.color(1, 1, 1);
for(int i = 0; i nb_flocons; i++) {
// Affichage des flocons:
dessine_flocon(&window, flocons + i);
// Deplace les flocons:
avance_flocon(flocons + i, hauteur);
}
window.show();
// attends 20ms
usleep(20000);
}
getchar();
return 0;
}

Exercice langage C: Modularisation

Le code ci-dessous convertit un nombre décimal en binaire, l'affiche et fait la conversion inverse. Recopiez ce code dans un buffer d'Emacs, et essayez de le comprendre. Vous pouvez ensuite le compiler - il devrait fonctionner sans problème - et le tester.

#include
using namespace std;
int main(int argc, char **argv) {
const int max_bits = 10;
int decimal, binaire, original, n, bits;
long puissance2, puissance10;
cout cin >> decimal;
// calcul du nombre de bits
n = decimal;
bits = 0;
while (n > 0) {
bits++;
n /= 2;
}
cout if (bits > 10) {
cout return 0;
}
// conversion en binaire
n = decimal;
binaire = 0;
for (int i=bits-1; i>=0; i--) {
puissance2 = 1;
for (int j=0; jpuissance2 *= 2;
puissance10 = 1;
for (int j=0; jpuissance10 *= 10;
if (n / puissance2 > 0) {
n = n - puissance2;
binaire += puissance10;
}
}
cout // calcul du nombre de bits
n = binaire;
bits = 0;
while (n > 0) {
bits++;
n /= 10;
}
cout // conversion de binaire en decimal
original = 0;
n = binaire;
for (int i=bits-1; i>=0; i--) {
puissance2 = 1;
for (int j=0; jpuissance2 *= 2;
puissance10 = 1;
for (int j=0; jpuissance10 *= 10;
if (n / puissance10 > 0) {
n = n - puissance10;
original += puissance2;
}
}
cout return 0;
}

#include
using namespace std;
// calcule a^b
int puissance(int a, int b) {
int resultat = 1;
for (int i=0; iresultat *= a;
return resultat;
}
// calcule le log entier de n en base 'base'
int log_entier(int n, int base) {
int resultat = 0;
while (n > 0) {
resultat++;
n /= base;
}
return resultat;
}
// converti 'original', de taille 'bits' bits de la
// base de depart a la base d'arrivee
int conversion(int original, int bits,
int base_depart, int base_arrivee) {
int converti = 0;
int puissance_depart;
int puissance_arrivee;
for (int i=bits-1; i>=0; i--) {
puissance_depart = puissance(base_depart, i);
puissance_arrivee = puissance(base_arrivee, i);
if (original / puissance_arrivee > 0) {
original -= puissance_arrivee;
converti += puissance_depart;
}
}
return converti;
}
int main(int argc, char **argv) {
const int max_bits = 10;
int decimal, binaire, original, bits;
cout cin >> decimal;
// calcul du nombre de bits de 'decimal'
bits = log_entier(decimal, 2);
cout if (bits > 10) {
cout return 0;
}
// conversion en binaire
binaire = conversion(decimal, bits, 10, 2);
cout // calcul du nombre de bits
bits = log_entier(binaire, 10);
cout // conversion de binaire en decimal
original = conversion(binaire, bits, 2, 10);
cout return 0;
}