EXO 1
======  

(1) x=2, y=5    // paramétres non modifiés par l'appel à f1
(2) x=2, y=7    // le paramétre y est modifié par l'appel à f2



EXO 2  

Q1. Si la chaîne initiale contient un chiffre alors on ne saura plus
distinguer dans la chaine codée entre ce chiffre et une indication 
de répétition.

Ainsi, le code RLE de "1AA" sera "12A", que l'on peut décoder en une 
chaîne de 12 'A' consécutifs ...

Q2.

#include <stdio.h>

#define N 255

int main() {
	unsigned int i, j ;
	char c[N] ;

	scanf("%s", c) ;
	i=0 ;
	while (c[i] != '\0') {
		j=i+1 ;
		while (c[j] != '\0' && c[i]==c[j]) j=j+1 ;
		if (j>i+1) printf("%d", j-i) ;
		printf("%c", c[i]) ;
		i=j ;
	} ;
	printf("\n") ;
	return 0 ;
}

Q3.

#include <stdio.h>

#define N 255

int main() {
	unsigned int i, j, n ;
	char c[N] ;

	scanf("%s", c) ;
	i=0 ;
	while (c[i] != '\0') {
		if (c[i] >= '0' && c[i] <= '9') {;
			// si le caractère est un chiffre
			n = c[i] - '0' ; // nombre de repetition
			i=i+1 ;
            // on affiche n fois le caractère suivant
			for (j=0 ; j<n ; j++) {
				printf("%c", c[i]) ;
			} ;
		} else {
		// si c'est une lettre on l'affiche ...
			printf("%c", c[i]) ;
		} ;
		i=i+1;
	} ;
	printf("\n") ;
	return 0 ;
}

Le fait de considérer des entiers < 10 dans la chaîne codée 
simplifie la transformation d'un caractère "chiffre" en 
l'entier correspondant ...


EXO 3

Q1.

int Evaluer(Polynome P, int v) {
	Monome M ;
	int resultat = 0 ;
	while (! EstVide(P)) {
		M = PremierMonome(P) ;
		resultat = resultat +  M.coef * (puissance(v, M.deg)) ; 
	} ;
	return resultat ;
}

Q2.

void Deriver(Polynome P1, Polynome *P2) {
	Monome Mcour, Mderiv ;
	*P2 = PolynomeVide() ;
	while (! EstVide(P1)) {
		Mcour = PremierMonome(P1) ;
		if (Degre(Mcour) > 0) {
			Mderiv = CreerMonome(Mcour.coef, Mcour.deg) ;
			AjouterMonome(P2, Mderiv) ;
		} ;
	} ;
}


Q3. 


/* Constructeurs */

Monome CreerMonome (int c,  unsigned int d) {
// renvoie le monome (coefficient, degre)
Monome m ;
m.coef = c ;
m.deg = d ;
return m ;
}


void AjouterMonome (Polynome *P, Monome M) {
// ajoute le monome M au polynome P
// P est donc modifié par cette action (parametre resultat)
Polynome nouveau ;

nouveau = (Polynome) malloc(sizeof(Cellule)) ;
nouveau->m.coef = M.coef ;
nouveau->m.deg = M.deg ;
nouveau->suiv = *P ;
*P = nouveau ;
}

Polynome PolynomeVide() {
// renvoie un polynome "vide"
// (que l’on pourra compléter en lui ajoutant des monomes ...)
return NULL ;
}

/* Selecteurs */

unsigned int Degre(Monome M) {
   	// degre du monome M
	return M.deg ;
}

int Coefficient(Monome M) {
// coefficient du monome M
	return M.coef ;
}

/* Parcours de la sequence des monomes d’un polynome */

int EstVide(Polynome P) {
// vaut vrai si et seulement si P est un polynome vide
 return P==NULL ;
}

Monome PremierMonome(Polynome P) {
// renvoie le "premier" monome du polynome P (si P est non vide !)
 return P->m ;
}

void MonomeSuivant(Polynome *P) {
// modifie P pour acceder au monome suivant (si P est non vide !)
// P est donc un parametre donnee-resultat
  *P = (*P)->suiv ;
}

/* un parcours des monomes du polynome P pourra donc s’ecrire :
Polynome P ;
Monome M ;
while (! EstVide(P)) {
M = PremierMonome(P) ;
MonomeSuivant(&P) ;
}
*/

Q4

int AdditionPolynome (Polynome P1, Polynome P2, Polynome *P3) {

  Monome M1, M2, M ;

  while (! EstVide(P1) && ! EstVide(P2)) {
     // tant que P1 et P2 ne sont pas vides
	M1 = PremierMonome(P1) ;
	M2 = PremierMonome(P2) ;
	if (Degre(M1) > Degre(M2)) {
		AjouterMonome (P3, M1) ;
		MonomeSuivant(P1) ;
	}
    else{ 
       if (Degre(M1) < Degre(M2)) {
		AjouterMonome (P3, M2) ;
		MonomeSuivant(P2) ;
       }
       else { // Degre(M1) == Degre(M2) 
        M = CreerMonome (Coeff(M1) + Coeff(M2),  Degre(M1)) 
		AjouterMonome (P3, M)
		MonomeSuivant(P1) ;
		MonomeSuivant(P2) ;
       }
    } ;

	 // on ajoute à P3 les monomes restants de P1
    while (! EstVide(P1)) {
		M1 = PremierMonome(P1) ;
		AjouterMonome (P3, M1) ;
		MonomeSuivant(P1) ;
	} ;
    
	 // on ajoute à P3 les monomes restants de P2
    while (! EstVide(P2)) {
		M2 = PremierMonome(P2) ;
		AjouterMonome (P3, M2) ;
		MonomeSuivant(P2) ;
	} ;
    
}