Exercice 1
===========

Programme principal :

int main() {
   int a, b ;
   a = 42 ;
   b = f(a) ;
   printf("%d %d\n", a, b) ;
   return 0 ;
}

1) cas de la fonction f1 :

int f1 (int x) {
   return x+1;
}

cette fonction ne modifie aucune variable et renvoie x+1.
L'affichage produit pour les variables a et b après l'appel sera donc : 
    42 43

2) cas de la fonction f2 :

int f2 (int x) {
   x = x+1 ;
   return x ;
}

cette fonction incrémente son paramètre "donné" x et renvoie sa nouvelle valeur. 
Le paramètre effectif  a n'est donc pas modifié.
L'affichage produit pour les variables a et b après l'appel sera donc : 
    42 43

3) cas de la fonction f3 :

int f3 (int x) {
   int *p ;
   p = &x ;
   x = x+1 ;
   return *p ;
}

cette fonction déclare un pointeur p sur son paramètre "donné" x, incrémente ce paramètre, 
et renvoie la valeur pointée par p.
Le paramètre effectif a n'est donc pas modifié.
L'affichage produit pour les variables a et b après l'appel sera donc : 
    42 43

4) cas de la fonction f4 :

int f4 (int x) {
   int *p ;
   p = &x ;
   *p = *p+1 ;
   return x ;
}

cette fonction déclare un pointeur p sur son paramètre "donné" x, 
incrémente la valeur pointée par p (donc la valeur de x) et renvoie 
la (nouvelle) valeur de x.
Le paramètre effectif a n'est donc pas modifié.
L'affichage produit pour les variables a et b après l'appel sera donc : 
    42 43


Exercice 2
===========

Element : un type ne contenant pas plus de 256 valeurs
Taille : la constante entiere 255
Ensemble: le type tableau sur [0,Taille] de booleens

Q1. 
Donnez une traduction de ce lexique en langage C lorsque {\tt Element} est le type {\tt char}.
On rappelle que les booléens sont représentés par des entiers en C.

#define Taille 256
typedef char Element ;
typedef Element Ensemble[Taille] ;


Q2.
Peut-on adapter ce lexique pour représenter des ensembles dont les éléments seraient des jours de la semaine, c'est à dire des 
valeurs allant de {\tt Lundi}, {\tt Mardi}, \dots à {\tt Dimanche} ? Si oui, comment, si non pourquoi \dots

#define Taille 8 // (le nombre de jours de la semaine)
typedef enum {lundi, mardi, mercredi, ..., dimanche} Element ;
typedef Element Ensemble[Taille] ;

Q3.

void inserer (Ensemble E, Element x) {
   // E est ici un pointeur sur un tableau, donc permet un passage par donnée-résultat
  E[x] = 1 ;  // ou toute autre valeur différente de 0 ...
}



Q4.
Union : action  (le resultat E : un  Ensemble E, 
                       la donnee E1 : un Ensemble, la donnee E2 : un Ensemble) ;

void Union (Ensemble E, Ensemble E1, Ensemble E2) {
   // E est ici un pointeur sur un tableau, donc permet un passage par résultat
  int i ; 
  for (i=0; i<Taille ; i++) {
      // i est ajouté à E s'il est présent dans E1 ou dans E2
	E[i] = E1[i] || E2[i] ; 
  }
}

Q5. estInclus: fonction  (E1 : un Ensemble, E2 : un Ensemble) -> booleen ;
{ renvoie vrai si et seulement si E1 est inclus dans E2 }
\end{verbatim}

une premiere version, basée sur un schéma de recherche :
(on recherche un element de E1 non present dans E2, ce qui signifie que E1 non inclus dans E2)

int estInclus (Ensemble E1, Ensemble E2) {
  int i, inclus ;
  inclus = 1 ;  
  i=0; 

  while (i<Taille && inclus) {
     if (E1[i] && !E2[i]) { 
         inclus = 0 ;
     } ;
     i = i+1 ,
  } ;
  return i==Taille ;
}

une seconde version, qui utilise l'instruction break :

int estInclus (Ensemble E1, Ensemble E2) {
  int i;
  i=0; 

  for (i=0; i<Taille ; i++) {
     if (E1[i] && !E2[i]) { 
         break ; // il existe un element present dans E1 et absent dans E2
     } ;
  } ;
  return i==Taille ;
}


Exercice 3
===========

Q1.
char * f(char *dest, const char *src, unsigned int n)
{
  unsigned int dest_len = strlen(dest);  // longueur de la chaine dest
  unsigned int i;

  for (i = 0 ; i < n && src[i] != '\0' ; i++) {
     dest[dest_len + i] = src[i];  // ajout des catacteres de src à a suite de ceux de dest
  } ;
  // on a ajoute n caracteres de src, ou atteint la fin de la chaine src ...
  dest[dest_len + i] = '\0';  // on ajoute la marque de fin de chaine a dest
  return dest;
}

Cette fonction concatene les n premiers caractères de la chaine src à la chaine dest.
Seul le contenu du paramètre dest est modifié (src et n sont inchangés)

Q2. 
Complétez le programme principal ci-dessous (déclaration de la variable {\tt z} et paramètres manquants de la fonction {\tt f()})
 afin qu'il affiche à l'écran la chaîne {\tt "M2 CCI"}. Vous pouvez ajouter d'autres déclarations de variables si besoin.

Il suffit d'appeler la fonction f avec : 
  - un parametre "dest" contenant la chaine "M2 "
 - un paramètre n de valeur 3 (pour ajouter les 3 premiers caractères du paramètre src)

int main(){
  char dest[7] ;   // 7 characters are enough ...
  strcpy (dest, "M2 ") ; 
  dest = f(dest, "CCI 20-21", 3) ;
  printf ("%s\n", z) // affiche "M2 CCI"
  return 0 ;
}

Q3. 
   
char *strpbrk(char s[], char a[]);
	Renvoie un pointeur sur la première occurence dans la chaîne s de n'importe quel caractère présent dans la chaîne a
       (ces deux chaînes étant terminées par '\0', et renvoie NULL si aucun caractère de a n'est présent dans s.
       Par exemple si s contient la chaîne "bonjour" et a la chaîne "nord" alors strpbrk(s, a) renvoie l'adresse 
       de s[1] (et non l'adresse de s[2] ou de s[6] car ce ne sont pas les premiers caractères de s présents dans a).

Algo :
        parcours de s (par indices croissants) et recherche de chacun de ses caractères dans a avec strchr

char *strpbrk(char s[], char a[]) {
 int i ;
 i=0 ;
 while (s[i] != '\0') {
    if (strchr(a, s[i]) != NULL) {  // si s[i] est dans la chaine a
       return &(s[i]) ; // on renvoie son adresse
    }
    i = i+1 ;
 } ;
 return NULL ;  // on renvoie NULL si aucun caractere de s n'est dans la chaine a
}

Pour tester cette solution il est préférable de "couvrir" différents cas :
   - strpbrk ("", "")      	// 2 chaines vides
   - strpbrk ("", "x") 		// chaine s vide
   - strpbrk ("x", "") 		// chaine a vide
   - strpbrk ("abc", "d") 	//  aucun element de s dans a
   - strpbrk ("abc", "a") 	// 1 occurrence d'un element de s dans a
   - strpbrk ("aba", "a") 	// plusieurs occurrences d'un element de s dans a
   - strpbrk ("abc", "cba")     // verifier que c'est bien la 1ere occurence qui est trouvée
   - etc.