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

Q1. 

	int main() {
		f1(4,5) ;  // renvoie faux
		f1(5,5) ;  // renvoie vrai
	}


Q2. 

	int main() {
		int a=0, b=0 ; // peu importe les valeurs initiales ... 
		f2(&a,&b) ;  // renvoie faux (car a et b ont des adresses differentes) 
		f2(&a,&a) ;  // renvoie vrai
	}

Q3. Après l'appel "a = f3(a, b)" on aura :
	   a contient la valeur 4 (car l'appel à f3 renvoie la valeur de b)
       b contient la valeur 4 (b est inchangee)


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

Q1.

void strcpy (char dest[], char src[]) {
  int i=0 ;
  while (src[i] != '\0') {
	  dest[i] = src[i] ;
      i = i+1 ;
  } ;
  dest[i] = src[i] ;  // pour copier le '\0'   
}

Q2. Lorsque l'on appelle strcpy (t, "mystere") le tableau t va déborder
(il ne peut contenir que 4 caractères). Cela peut provoquer une erreur 
à l'exécution ...

Q3. 

     /* copie du plus long prefixe de "mystere" dans t */
     int i ; 
     strncpy (t, "mystere", TAILLE-1) ; // copie "mys" dans les 3 premieres cases de t
     dest[TAILLE-1] = '\0' ; // copie '\0' dans la derniere case de t


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

Q1.

#define NbCouleur 255
#define TailleImage 1024

typedef enum {Blanc, Gris, Noir} PixelBGN ;
typedef int PixelC ;   // [0..NbCouleur] ;
typedef PixelBGN ImageBGN[TailleImage+1] ; 
typedef PixelC ImageC[TailleImage+1] ;

Q2. 

#define seuilBlanc 75
#define seuilNoir 200

void Transformer (ImageC Src, ImageBGN Dest) {
	unsigned int i ;
	for (i=0; i<=TailleImage ; i++) {
		if (Src[i] <= seuilBlanc) 
			Dest[i] = Blanc ; 
		else 
			if (Src[i] >= seuilNoir) 
				Dest[i] = Noir ;
			else 
				Dest[i] = Gris ;
	 } ;
}

Q3.

int main() {

ImageC imgSrc ;
ImageBGN imgDest ;

  /* lecture image source */
  for (i=0 ; i<=TailleImage ; i++) {
	scanf("%d", &(imgSrc[i])) ;
  }

  Transformer (imgSrc, imgDest) ;

  /* affichage image destination */
  for (i=0 ; i<=TailleImage ; i++) {
	switch (imgDest[i]) {
		case Blanc:
			printf("0") ;
			break ;
		case Gris:
			printf("1") ;
			printf("%d", &(imgSrc[i])) ;
			break ;
		case Noir:
			printf("2") ;
			printf("%d", &(imgSrc[i])) ;
			break ;
  	}
  } 
}

Remarque : on peut aussi remplacer simplement l'affichage de 
l'image destination par :

  for (i=0 ; i<=TailleImage ; i++) {
	printf("%d", imgDest[i]) ;
  }


Q4.

1.

On parcourt le tableau P et on affiche l'element d'indice i a la position (x,y+i).

void affImageLigne (unsigned int x, unsigned int y, ImageC P) {
	int i ; 
  	for (i=0 ; i<=TailleImage ; i++) {
		affPixel (x, y+i, P[i]) ;
	}
}


2.

L'objectif ici est d'afficher l'element P[i] à la position (l,c) telle que :
  - l est un numero de ligne compris entre 0 et 31 
  - c est un numero de colonne compris entre 0 et 31
  - les elements sont affiches "ligne par ligne" a partir de la position (x,y), l et c sont donc determines de la maniere suivante :
        - pour i=0, l vaut x et c vaut y // on place cet element en ligne 0, colonne 0
        - pour i=1, l vaut x et c vaut y+1 // on reste sur la meme ligne 0, colonne 1 
        - pour i=2, l vaut x et c vaut y+2 // on reste toujours sur la meme ligne 0, colonne 2
        - ... 
        - pour i=31, l vaut x+31 et c vaut y // on reste encore sur la meme ligne 0, colonne 31
        - pour i=32, l vaut x et c vaut y // on passe a la ligne 1, colonne 0
        - pour i=33, l vaut x+1 et c vaut y+1 // on reste sur la ligne 1, colonne 1
        - pour i=34, l vaut x+1 et c vaut y+2 // on continue sur la ligne 1 colonne 2
        - etc.


solution 1 :

On utilise 2 boucles imbriquees pour calculer l'indice de l'element de P a afficher 
au point (x+l, y+c).

Par exemple, au point (x+1, y+2) on veut afficher l'element correspondant a la ligne 1, colonne 2, 
donc l'element d'indice (31*1)+(2+1).
La formule generale est :
   au point (x+l, y+c) on affiche l'element d'indice (l*31) + (c+1)

void affImageCarre (unsigned int x, unsigned int y, ImageC P) {
	int l, c ; 
  	for (l=0 ; l<31 ; l++) {
                // pour toute ligne i entre 0 et 31
  		for (i=0 ; i<31 ; i++) {
                        // pour toute colonne j entre O et 31
			affPixel (x+l, y+c, P[l*31+c+1]) ;
                           // on affiche l'element (l*31)+(c+1) 
	}

}
   
solution 2 :

A chaque fois que i est un *multiple* de 32, on doit :
        - passer à la ligne suivante, donc ajouter 1 a x
        - remettre le numéro de colonne a 0, donc re-initialiser y a 0 

Par exemple, pour  i=34, on veut donc afficher en position (x+34/32, y+34%32), avec / pour la division etiere et % pour le modulo,
ce qui fait bien (x+1, y+2).

void affImageLigne (unsigned int x, unsigned int y, ImageC P) {
	int i ; 
  	for (i=0 ; i<=TailleImage ; i++) {
		affPixel (x+i/32, y+i%32, P[i]) ;
	}
}