/* devoir n°1 exercice 1 : menu.h */

char ce_choix(char *tels_autorises, char *tel_libelles[], char *telle_invite);

void affiche_le_menu(char *tel_libelles[], char *telle_invite);

/* devoir n°1 exercice 1 : menu.c */

#include <menu.h>

#include <stdio.h>

void affiche_le_menu(char *tels_libelles[], char *telle_invite){

int l_indice = 0;

while(tels_libelles[l_indice]){

printf("%s", tels_libelles[l_indice]);

l_indice++;

}

printf("%s",telle_invite);

}

char ce_choix(char *tels_autorises, char *tel_libelles[], char *telle_invite){

int la_place, l_indice;

char le_choix;

affiche_le_menu(tel_libelles, telle_invite);

fflush(stdin);

scanf("%c", &le_choix);

fflush(stdin);

for(la_place = l_indice = 0; !la_place && tels_autorises[l_indice]; l_indice++){

if(le_choix == tels_autorises[l_indice]){

la_place++;

}

if(la_place)

return le_choix;

else return 0;

}

/* devoir n°1 exercice 1 : pp.h */

#define MAX_ELEMENTS 20

#define MAX_VALEUR 100

extern int le_tableau[];

/* devoir n°1 exercice 1 : pp.c */

#include <pp.h>

#include <menu.h>

#include <recherches.h>

#include <moyenne.h>

#include <tri.h>

#include <stdio.h>

int le_tableau[MAX_ELEMENTS];

static char *les_libelles[] = {

"\n\tMENU\n\n",

"\t1 - Changer les valeurs du tableau.\n",

"\t2 - Rechercher le maximum\n",

"\t3 - Rechercher les 2 maximas\n",

"\t4 - Rechercher le maximum et le minimum\n",

"\t5 - Rechercher le minimum\n"

"\t6 - Rechercher les 2 minimas.\n",

"\t7 - Calculer la moyenne du tableau.\n",

"\t8 - Trier le tableau\n",

"\t0 - Terminer\n\n",

NULL

};

static char *les_autorises = "123456780";

static char *l_invite = "\tVotre choix :";

void main(void){

int run = 1;

remplis_le_tableau();

while(run){

switch(ce_choix(les_autorises, les_libelles, l_invite)){

case '1':remplis_le_tableau();

break;

case '2':recherches(LE_MAX);

break;

case '3':recherches(LE_MAX_MAX);

break;

case '4':recherches(LE_MIN + LE_MAX);

break;

case '5':recherches(LE_MIN);

break;

case '6':recherches(LE_MIN_MIN);

break;

case '7':calcule_la_moyenne();

break;

case '8':tri();

break;

case '0':run = 0;

break;

}

/* devoir n°1 exercice 2 : pp.h */

#define MAX 30

#define ELEMENTS 20

typedef struct {

int (*fonction)(int *pt_a, int *pt_b);

char *message;

} lien;

int compare(int *pt_a, int *pt_b);

int compare_unites(int *pt_a, int *pt_b);

int compare_farfelu(int *pt_a, int *pt_b);

/* devoir n°1 exercice 2 : pp.c */

#include <pp.h>

#include <stdio.h>

#include <math.h>

#include <time.h>

/* tri : ordre croissant */

int compare(int *pt_a, int *pt_b){

if(*pt_a > *pt_b) return 1;

if(*pt_a < *pt_b) return -1;

return 0;

}

/* tri : ordre croissant du chiffre des unites */

int compare_unites(int *pt_a, int *pt_b){

int a = *pt_a, b = *pt_b;

if(a < 0) a = -a;

else while(a > 9) a -= 10;

if(b < 0) b = -b;

else while(b > 9) b -= 10;

return(compare(&a, &b));

}

/* tri : tout nombre positif doit apparaitre avant tout nombre negatif

* les nombres positifs sont tries par ordre croissant

* et les nombres negatifs sont tries par ordre decroissant

int compare_farfelu(int *pt_a, int *pt_b){

int a = *pt_a, b = *pt_b;

if(a < 0) a = (-a) + MAX;

if(b < 0) b = (-b) + MAX;

return(compare(&a, &b));

}

/* main */

signed int le_tableau[ELEMENTS];

lien compare_f[] = {

{compare, "Tri croissant:"},

{compare_unites, "Tri croissant du chiffre des unites:"},

{compare_farfelu, "Tri farfelu:"},

NULL

};

void main(void){

int l_index, loop = 0;

time_t t;

(void)time(&t);

(void)srand((unsigned int)t);

printf("\tContenu du tableau:\n\t");

for(l_index = 0; l_index < ELEMENTS; l_index++){

le_tableau[l_index]= (rand() % (MAX + 10)) - 9;

printf("%d ", le_tableau[l_index]);

}

printf("\n");

while(compare_f[loop].fonction){

qsort(le_tableau, ELEMENTS, sizeof(int), compare_f[loop].fonction);

printf("\t%s\n\t", compare_f[loop].message);

for(l_index = 0; l_index < ELEMENTS; l_index++){

printf("%d ", le_tableau[l_index]);

}

printf("\n");

loop++;

}

/* exemples d'executions

[root@localhost /root]# cd /usr/src/cours/dev1ex2/

[root@localhost /usr/src/cours/dev1ex2]# gcc -o/usr/bin/pp -I./ pp.c

[root@localhost /usr/src/cours/dev1ex2]# pp

Contenu du tableau:

-2 -4 17 -1 5 27 -9 19 0 1 9 13 9 2 7 24 2 2 -9 -7

Tri croissant:

-9 -9 -7 -4 -2 -1 0 1 2 2 2 5 7 9 9 13 17 19 24 27

Tri croissant du chiffre des unites:

0 -1 1 -2 2 2 2 13 -4 24 5 -7 7 17 27 -9 -9 9 9 19

Tri farfelu:

0 1 2 2 2 5 7 9 9 13 17 19 24 27 -1 -2 -4 -7 -9 -9

[root@localhost /root]# pp

Contenu du tableau:

20 7 12 19 10 0 20 14 6 2 30 -2 20 30 -2 29 21 16 -9 7

Tri croissant:

-9 -2 -2 0 2 6 7 7 10 12 14 16 19 20 20 20 21 29 30 30

Tri croissant du chiffre des unites:

0 10 20 20 20 30 30 21 -2 -2 2 12 14 6 16 7 7 -9 19 29

Tri farfelu:

0 2 6 7 7 10 12 14 16 19 20 20 20 21 29 30 30 -2 -2 -9

[root@localhost /root]#

/* langage algorithmique

procedure compare(pt_a : pointeur d'entier, pt_b : pointeur d'entier)

debut

si *pt_a et strictement superieur a *pt_b

alors retourne 1;

si *pt_b et strictement superieur a *pt_b

alors retourne -1;

retourne 0;

fin

procedure compare_unites(pt_a : pointeur d'entier, pt_b : pointeur d'entier)

variable a, b : entier;

debut

a = *pt_a;

b = *pt_b;

si a est strictement inferieur a 0

alors a = -a;

sinon

tant que a et strictement superieur a 9

alors a -= 10;

fin de si

si b est strictement inferieur a 0

alors b = -b;

sinon

tant que b et strictement superieur a 9

alors b -= 10;

fin de si

retourne compare(&a, &b);

fin

definition MAX 30

procedure compare_farfelu(pt_a : pointeur d'entier, pt_b : pointeur d'entier)

variable a, b : entier;

debut

a = *pt_a;

b = *pt_b;

si a est strictement inferieur a 0

alors a = (-a) + MAX;

si b est strictement inferieur a 0

alors b = (-b) + MAX;

retourne compare(&a, &b);

fin

definition ELEMENTS 20

structure compare_f;

programme pricipal main()

variable l_index, loop, t : entier;

debut

time(&t);

srand(t);

affiche "Contenu du tableau";

pour l_index = 0 jusqu'a l_index strictement inferieur à ELEMENTS faire

le_tableau[l_index] = un nombre aleatoire compris entre -9 et MAX;

affiche le_tableau[l_index];

fin de pour

tant que compare_f[loop].fonction faire

qsort(le_tableau, ELEMENTS, sizeof(entier), compare_f[loop].fonction);

affiche compare_f[loop].message;

pour l_index = 0 jusqu'a l_index strictement inferieur à ELEMENTS faire

affiche le_tableau[l_index];

fin de pour

fin de tant que

fin

/* devoir n°1 exercice 3 : pp.h */

void echangep(char *pt_a, char *pt_b);

/* devoir n°1 exercice 3 : pp.c */

#include <pp.h>

#include <stdio.h>

void echangep(char *pt_a, char *pt_b){

char tmp;

tmp = *pt_a;

*pt_a = *pt_b;

*pt_b = tmp;

}

void main(void){

int int_a = 7, int_b = 1256;

double double_a = 1256.2, double_b = 2512.4;

char char_a[] = "deux", char_b[] = "dix";

char *pt_a, *pt_b;

pt_a = (char *)&int_a;

pt_b = (char *)&double_a;

printf("\n\tAvant exhangep\ta = %8d\t b = %5.3f\n", *((int *)pt_a), *((double *)pt_b) );

echangep((char *)&pt_a, (char *)&pt_b);

printf("\tApres exhangep\ta = %5.3f\t b = %8d\n\n", *((double *)pt_a), *((int *)pt_b) );

pt_a = (char *)&int_b;

pt_b = (char *)&char_a;

printf("\tAvant exhangep\ta = %8d\t b = %8s\n", *((int *)pt_a), (char *)pt_b );

echangep((char *)&pt_a, (char *)&pt_b);

printf("\tApres exhangep\ta = %8s\t b = %8d\n\n", (char *)pt_a, *((int *)pt_b) );

pt_a = (char *)&char_b;

pt_b = (char *)&double_b;

printf("\tAvant exhangep\ta = %8s\t b = %5.3f\n", (char *)pt_a, *((double *)pt_b) );

echangep((char *)&pt_a, (char *)&pt_b);

printf("\tApres exhangep\ta = %5.3f\t b = %8s\n\n", *((double *)pt_a), (char *)pt_b );

}

/* exemple d'execution

[root@localhost /root]# gcc -o/bin/ex3 /usr/src/cours/dev1ex3/dev1ex3.c

[root@localhost /root]# ex3

Avant exhangep a = 7 b = 1256.200

Apres exhangep a = 1256.200 b = 7

Avant exhangep a = 1256 b = deux

Apres exhangep a = deux b = 1256

Avant exhangep a = dix b = 2512.400

Apres exhangep a = 2512.400 b = dix

[root@localhost /root]#

/* langage algorithmique

procedure echangep(pt_a : pointeur de caractere, pt_b : pointeur de caractere)

variable tmp : caractere;

debut

tmp = *pt_a;

*pt_a = *pt_b;

*pt_b = tmp;

fin

programme principal main()

variable int_a, int_b : entier;

variable double_a, double_b : double;

variable char_a[], char_b[] : tableau de caracteres;

variable *pt_a, *pt_b : pointeur de caractere;

debut

pt_a = (char *)&int_a;

pt_b = (char *)&double_a;

affiche entier pointe par pt_a et double pointe par pt_b;

echangep ((char *)&pt_a, (char *)&pt_b);

affiche double pointe par pt_a et entier pointe par pt_b;

pt_a = (char *)&int_b;

pt_b = (char *)&char_a;

affiche entier pointe par pt_a et tableau pointe par pt_b;

echangep((char *)&pt_a, (char *)&pt_b);

affiche tableau pointe par pt_a et entier pointe par pt_b;

pt_a = (char *)&char_b;

pt_b = (char *)&double_b;

affiche tableau pointe par pt_a et double pointe par pt_b;

echangep((char *)&pt_a, (char *)&pt_b);

affiche double pointe par pt_a et tableau pointe par pt_b;

fin

/* devoir n°1 exercice 4a : pile_t.h */

#define MAX 5

typedef struct {

int sommet;

int elements[MAX];

} une_pile;

int depile(une_pile *la_pile);

int empile(une_pile *la_pile, int val);

void vide(une_pile *la_pile);

/* devoir n°1 exercice 4 : depile_t.c */

#include <pile_t.h>

int depile(une_pile *la_pile){

if(la_pile->sommet){

int retval = la_pile->elements[la_pile->sommet - 1];

la_pile->sommet -= 1;

return(retval);

}

else return -1;

}

/* langage algorithmique

procedure depile(la_pile : pointeur une_pile)

debut

si la_pile->sommet non nul

variable retval = la_pile->element[la_pile->sommet - 1];

decremente la_pile->sommet;

retourne retval

fin de si

sinon retourne -1;

fin

/* devoir n°1 exercice 4 : empile_t.c */

#include <pile_t.h>

int empile(une_pile *la_pile, int val){

if(val >= 0){

if(la_pile->sommet < MAX ){

la_pile->elements[la_pile->sommet] = val;

la_pile->sommet += 1;

return 0;

}

else return -1;

}

else return -2;

}

/* langage algorithmique

declaration MAX 5

procedure empile(la_pile : pointeur une_pile, val : entier)

debut

si val est superieur ou egal a 0

si la_pile->sommet est strictement inferieur a MAX

la_pile->element[la_pile->sommet ] = val;

incremente la_pile->sommet;

retourne 0

fin de si

sinon retourne -1;

fin de si

sinon retourne -2;

fin

/* devoir n°1 exercice 4 : vide_t.c */

#include <pile_t.h>

void vide(une_pile *la_pile){

la_pile->sommet = 0;

}

/* langage algorithmique

procedure vide(une_pile : pointeur la_pile)

debut

la_pile->sommet = 0;

fin

/* devoir n°1 exercice 4 : pp_t.c */

#include <pile_t.h>

#include <stdio.h>

static char *les_libelles[] = {

"\n\tMENU\n\n",

"\t1 - Empiler un entier positif\n",

"\t2 - Depiler une valeur\n",

"\t3 - Vider la pile\n",

"\t0 - Quiter\n\n",

NULL

};

static char *les_autorises = "1230";

static char *l_invite = "\tVotre choix :";

void affiche_le_menu( char *tels_libelles[], char *telle_invite ){

while(tels_libelles[l_indice]){

printf("%s", tels_libelles[l_indice]);

l_indice++;

}

printf("%s",telle_invite);

}

char ce_choix( char *tels_autorises, char *tel_libelles[], char *telle_invite ){

char le_choix;

affiche_le_menu(tel_libelles, telle_invite);

fflush(stdin);

scanf("%c", &le_choix);

fflush(stdin);

for(la_place = l_indice = 0; !la_place && tels_autorises[l_indice]; l_indice++){

if(le_choix == tels_autorises[l_indice]){

la_place++;

}

if(la_place)

return le_choix;

else return 0;

}

int ce_nombre(){

int le_nombre;

printf("\tValeur a empiler :");

scanf("%d", &le_nombre);

return le_nombre;

}

void main(void){

int val = 0, run = 1;

une_pile ma_pile = {0, 0};

while(run){

switch(ce_choix(les_autorises, les_libelles, l_invite)){

case '1':

switch( empile(&ma_pile, ce_nombre())){

case 0:

printf("\tOperation reussie.\n");

break;

case -1:

printf("\tLa pile est pleine, entier non empile.\n");

break;

case -2:

printf("\tCe nombre n'est pas strictement positif.\n");

break;

}

break;

case '2':

val = depile(&ma_pile);

val < 0 ? printf("\tLa pile est vide.\n") : printf("\tValeur depilee :%d\n", val);

break;

case '3':

vide(&ma_pile);

printf("\tPile videe.\n");

break;

case '0':

printf("\tFin de traitement.\n");

run = 0;

break;

}

/* exemple d'execution

[root@localhost /root]# cd /usr/src/cours/dev1ex4a/

[root@localhost /usr/src/cours/dev1ex4a/]# sh projet_t.prj

[root@localhost /usr/src/cours/dev1ex4a/]# pp_t

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :1

Valeur a empiler :20

Operation reussie.

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :1

Valeur a empiler :21

Operation reussie.

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :2

Valeur depilee :21

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :3

La pile a ete videe.

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :2

La pile est vide.

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :0

Fin de traitement.

[root@localhost /root]#

/* langage algorithmique

procedure affiche_le_menu(tels_libelles : pointeur tableau, telle_invite : pointeur tableau)

debut

tant que tels_libelles non nul

affiche tels_libelles;

fin de tant que

affiche telle_invite;

fin

procedure ce_choix() : caractere;

debut

affiche_le_menu();

saisir le_choix;

si le_choix est autorise alors

retourne le_choix

fin de si

sinon retourne 0;

fin

procedure principale main()

variable *ma_pile : pointeur une_pile;

debut

tant que

suivant la valeur de ce_choix() faire

'1':suivant la valeur de empile(&ma_pile, ce_nombre())

0: affiche "Operation reussie";

-1: affiche "La pile est pleine, entier non empile";

-2: affiche "Ce nombre n'est pas strictement positif";

fin de suivant

'2':depile(&ma_pile) < 0 alors affiche "La pile est vide" sinon affiche la valeur depilee

'3':vide(&ma_pile);

affiche "Pile videe";

'0':quitte;

fin de suivant

fin de tant que

fin

#!/bin/sh

# devoir n°1 exercice 4 : projet_t.prj

gcc -o/usr/bin/pp_t -I./ ./depile_t.c ./empile_t.c ./pp_t.c ./vide_t.c

/* devoir n°1 exercice 4b : pile_l.h */

#define MAX 5

typedef struct pile {

int element;

struct pile *suivant;

} une_pile;

typedef struct {

une_pile *debut;

} tete_de_pile;

int depile(tete_de_pile *le_debut);

int empile(tete_de_pile *le_debut, int val);

void vide(tete_de_pile *le_debut);

/* devoir n°1 exercice 4b : depile_l.c */

#include <pile_l.h>

int depile(tete_de_pile *tdp){

int retval;

une_pile *p = (une_pile *)tdp->debut;

if(p){

retval = p->element;

tdp->debut = p->suivant;

free(p);

return(retval);

}

else return -1;

}

/* langage algorithmique

procedure depile(tdp : pointeur tete_de_pile)

variable retval : entier, *p : pointeur une_pile;

debut

p = tdp->debut;

si p non nul

retval = p->element;

tdp->debut = p->suivant;

libere p;

retourne retval;

fin de si

sinon retourne -1

fin

/* devoir n°1 exercice 4b : empile_l.c */

#include <pile_l.h>

int empile(tete_de_pile *tdp, int val){

une_pile *p;

if(val >= 0){

if(!(p = (une_pile *) malloc(sizeof(une_pile)))){

return -1;

}

p->element = val;

p->suivant = tdp->debut;

tdp->debut = p;

return 0;

}

return -2;

}

/* langage algorithmique

procedure empile(tdp : pointeur tete_de_pile, val : entier)

debut

si val est superieur ou egal a 0

si aloue p = nul

retourne -1;

fin de si

p->element = val;

p->suivant = tdp->debut;

tdp->debut = p;

retourne 0;

fin de si

sinon retourne -2;

fin

/* devoir n°1 exercice 4b : vide_l.c */

#include <pile_l.h>

void vide(tete_de_pile *la_tdp){

while(depile(la_tdp)!=-1);

}

/* langage algorithmique

procedure vide(la_tdp : pointeur tete_de_pile)

debut

tant que depile(la_tdp) different de -1;

fin

/* devoir n°1 exercice 4b : pp_l.c */

#include <pile_l.h>

#include <stdio.h>

static char *les_libelles[] = {

"\n\tMENU\n\n",

"\t1 - Empiler un entier positif\n",

"\t2 - Depiler une valeur\n",

"\t3 - Vider la pile\n",

"\t0 - Quiter\n\n",

NULL

};

static char *les_autorises = "1230";

static char *l_invite = "\tVotre choix :";

void affiche_le_menu( char *tels_libelles[], char *telle_invite ){

int l_indice = 0;

while(tels_libelles[l_indice]){

printf("%s", tels_libelles[l_indice]);

l_indice++;

}

printf("%s",telle_invite);

}

char ce_choix( char *tels_autorises, char *tel_libelles[], char *telle_invite ){

int la_place, l_indice;

char le_choix;

affiche_le_menu(tel_libelles, telle_invite);

fflush(stdin);

scanf("%c", &le_choix);

fflush(stdin);

for(la_place = l_indice = 0; !la_place && tels_autorises[l_indice]; l_indice++){

if(le_choix == tels_autorises[l_indice]){

la_place++;

}

if(la_place)

return le_choix;

else return 0;

}

int ce_nombre(){

int le_nombre;

printf("\tValeur a empiler :");

scanf("%d", &le_nombre);

return le_nombre;

}

void main(void){

int val = 0, run = 1;

tete_de_pile ma_tdp = { NULL };

while(run){

switch(ce_choix(les_autorises, les_libelles, l_invite)){

case '1':

switch(empile(&ma_tdp, ce_nombre())){

case 0:

printf("\tOperation reussie.\n");

break;

case -1:

printf("\tLa pile (memoire) est pleine, entier non empile.\n");

break;

case -2:

printf("\tCe nombre n'est pas strictement positif.\n");

break;

}

break;

case '2':

val = depile(&ma_tdp);

val < 0 ? printf("\tLa pile est vide.\n") : printf("\tValeur depilee :%d.\n", val);

break;

case '3':

vide(&ma_tdp);

printf("\tPile videe.\n");

break;

case '0':

printf("\tFin de traitement.\n");

run = 0;

break;

}

/* exemple d'execution

[root@localhost /root]# cd /usr/src/cours/dev1ex4b/

[root@localhost /usr/src/cours/dev1ex4b/]# sh projet_l.prj

[root@localhost /usr/src/cours/dev1ex4b/]# pp_l

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :1

Valeur a empiler :20

Operation reussie.

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :1

Valeur a empiler :21

Operation reussie.

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :2

Valeur depilee :21

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :3

La pile a ete videe.

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :2

La pile est vide.

1 - Empiler un entier positif

2 - Depiler une valeur

3 - Vider la pile

0 - Quiter

Votre choix :0

Fin de traitement.

[root@localhost /root]#

/* langage algorithmique

procedure affiche_le_menu(tels_libelles : pointeur tableau, telle_invite : pointeur tableau)

debut

tant que tels_libelles non nul

affiche tels_libelles;

fin de tant que

affiche telle_invite;

fin

procedure ce_choix() : caractere;

debut

affiche_le_menu();

saisir le_choix;

si le_choix est autorise alors

retourne le_choix

fin de si

sinon retourne 0;

fin

procedure principale main()

variable *ma_tdp : pointeur tete_de_pile;

debut

tant que

suivant la valeur de ce_choix() faire

'1':suivant la valeur de empile(&ma_tdp, ce_nombre())

0: affiche "Operation reussie";

-1: affiche "La pile est pleine, entier non empile";

-2: affiche "Ce nombre n'est pas strictement positif";

fin de suivant

'2':depile(&ma_tdp) < 0 alors affiche "La pile est vide" sinon affiche la valeur depilee

'3':vide(&ma_tdp);

affiche "Pile videe";

'0':quitte;

fin de suivant

fin de tant que

fin

#!/bin/sh

# devoir n°1 exercice 4 : projet_l.prj

gcc -o/usr/bin/pp_l -I./ ./pp_l.c ./depile_l.c ./empile_l.c ./vide_l.c