Question 1 :

#include <stdio.h>

/*! \fn int main (int argc, char** argv)
 *  \author EISTI
 *  \version 0.1
 *
 *  \brief Fonction principale, initialise un entier, un pointeur, affiche les valeurs à partir du pointeur
 *
 *
 * \param argc : Nombre d'argument
 * \param argv : Tableau des arguments
 * \return 0 : le programme doit se terminer normalement
 *
 * \remarks 
 */
int main (int argc, char** argv) {
  int n, *p_int;
  
  n=12;
  p_int=&n;
  printf("adr=%p, val=%d\n ",p_int,*p_int);
  //Fin du programme, Il se termine normalement, et donc retourne 0
  return 0;
}

Question 2 :

/*! \file q2.c

 *  \author EISTI
 *  \version 0.1
 *
 *  \brief affiche infos sur les pointeurs
 *
 */

#include <stdio.h>
#include <stdlib.h>

/*! \fn int main (int argc, char** argv)
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 15:29:37 2010
 *
 *  \brief Fonction principale
 *
 *
 * \param argc : Nombre d'argument
 * \param argv : Tableau des arguments
 * \return 0 : le programme doit se terminer normalement
 *
 * \remarks 
 */

int main (int argc, char** argv) {
	int a,b,c,*p1,*p2;

	a=1; 
	b=3;
	c=-2;
	printf("1 : a=%d, b=%d, c=%d, p1=%p, *p1=%d, p2=%p, *p2=%d \n",a,b,c,p1,*p1,p2,*p2);

	p1=&a;
	p2=&c;
	printf("2 : a=%d, b=%d, c=%d, p1=%p, *p1=%d, p2=%p, *p2=%d \n",a,b,c,p1,*p1,p2,*p2);

	*p1=(*p2)++;
	printf("3 : a=%d, b=%d, c=%d, p1=%p, *p1=%d, p2=%p, *p2=%d \n",a,b,c,p1,*p1,p2,*p2);

	p1=p2;
	printf("4 : a=%d, b=%d, c=%d, p1=%p, *p1=%d, p2=%p, *p2=%d \n",a,b,c,p1,*p1,p2,*p2);

	++*p1;
	printf("5 : a=%d, b=%d, c=%d, p1=%p, *p1=%d, p2=%p, *p2=%d \n",a,b,c,p1,*p1,p2,*p2);

	p2=&b;
	printf("6 : a=%d, b=%d, c=%d, p1=%p, *p1=%d, p2=%p, *p2=%d \n",a,b,c,p1,*p1,p2,*p2);

	*p1 -= *p2;
	printf("7 : a=%d, b=%d, c=%d, p1=%p, *p1=%d, p2=%p, *p2=%d \n",a,b,c,p1,*p1,p2,*p2);

	a = ++*p2 * *p1;
	printf("8 : a=%d, b=%d, c=%d, p1=%p, *p1=%d, p2=%p, *p2=%d \n",a,b,c,p1,*p1,p2,*p2);

	a *= *p2;
	printf("9 : a=%d, b=%d, c=%d, p1=%p, *p1=%d, p2=%p, *p2=%d \n",a,b,c,p1,*p1,p2,*p2);
	//Fin du programme, Il se termine normalement, et donc retourne 0
	return (EXIT_SUCCESS);
} 

Question 3 :

/*! \file q3.c

 *  \author EISTI
 *  \version 0.1
 *
 *  \brief recherche dichotomique dans un tableau trié
 *
 */

#include <math.h>
#include <stdlib.h>
#include <stdio.h>

/*! \fn int perimAire(int r, int* perim, int* aire)
 *  \author Peio Loubiere <peio.loubiere@eisti.fr> 
 *  \version 0.1
 *  \date Fri Jan 15 15:36:00 2010
 *
 *  \brief recherche dichotomique itérative
 *
 *  \param r : rayon du cercle
 *  \param perim: périmètre du cercle
 *  \param aire: aire du cercle
 *
 *  \return le perimetre, l'aire du cercle et 1 si le calcul s'est bien déroulé, 0 sinon
 */

int perimAire(int r, float* perim, float* aire) {

	if(r<0){
		return 0;
	}else{
		*perim = 2*M_PI*r;
		*aire = M_PI*r*r;
		return 1;
	}
}



/*! \fn int main (int argc, char** argv)
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 15:29:37 2010
 *
 *  \brief Fonction principale
 *
 *
 * \param argc : Nombre d'argument
 * \param argv : Tableau des arguments
 * \return 0 : le programme doit se terminer normalement
 *
 * \remarks 
 */

int main (int argc, char** argv) {
	

  int rayon, res;
	float perim, aire;

	//saisie des paramètres
	printf("\n Saisissez le rayon d'un cercle: \n ");
	scanf("%d", &rayon);
	//appel de la fonction
	res = perimAire(rayon, &perim, &aire);

	if(res==0)
		printf("\n Saisissez un rayon positif! \n ");
  else
		printf("le périmètre du cercle de rayon %dcm est: %.2fcm,  l'aire est: %.2fcm²\n", rayon, perim, aire);

  //Fin du programme, Il se termine normalement, et donc retourne 0
  return (EXIT_SUCCESS);
} 

Question 4 :

/*! \file q4.c

 *  \author EISTI
 *  \version 0.1
 *
 *  \brief calcule le schtroumpf de 2 tableaux
 *
 */

#include <stdio.h>
#include <stdlib.h>

/*! \fn int strlength(char* taille1)
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 17:16:51 2010
 *
 *  \brief  calcule le schtroumpf de 2 tableaux
 *
 *  \param ch chaîne dont la taille est à calculer
 *
 *  \return taille de la chaîne
 */

int strlength(char* ch) {

  int taille=0;
 
	while(*ch != '\0'){
		taille++;
		ch++;
	}
  return taille;
}


/*! \fn int main (int argc, char** argv)
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 15:29:37 2010
 *
 *  \brief Fonction principale
 *
 *
 * \param argc : Nombre d'argument
 * \param argv : Tableau des arguments
 * \return 0 : le programme doit se terminer normalement
 *
 * \remarks 
 */
int main(int argc, char** argv){
  char chaine[50];

	printf("Saisissez un mot\n");
	scanf("%s",chaine);
  printf("la taille de \"%s\" est : %d\n",chaine,strlength(chaine));
	return (EXIT_SUCCESS);
}

Question 5 :

/*! \file q5.c

 *  \author EISTI
 *  \version 0.1
 *
 *  \brief normalise un tableau
 *
 */

#include <stdio.h>
#include <stdlib.h>
#define N 5

/*! \fn void afficheTab(int tailleT, int t[])
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 15:57:52 2010
 *
 *  \brief Affiche un tableau d'entier
 *
 *  \param tailleT taille du tableau
 *  \param t[] tableau à afficher
 *
 */
void afficheTab(int tailleT, int t[]) {

  int i;

  for(i=0;i<tailleT;i++){
    printf("| %d ",t[i]);
  }
  printf("|\n ");

}


/*! \fn int* concat(int tailleT1, int t1[], int tailleT2, int t2[])
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 16:01:05 2010
 *
 *  \brief Récupère la valeur maximum d'un tableau
 *
 *  \param tailleT1 taille du tableau 1
 *  \param t1[] tableau1
 *  \param tailleT2 taille du tableau 2
 *  \param t2[] tableau2 
 *  \param *tailleRes[] pointeur vers la taille du tableau resultat
 *
 *  \return le tableau concatene
 */

int* concat(int tailleT1, int t1[], int tailleT2, int t2[], int* tailleRes) {

  int i, j, *tRes;

	*tailleRes = 2*N;	//calcul de la taille du tableau resultat
	tRes=malloc(*tailleRes*sizeof(int)); //allocation de la memoire

	if(tRes!=NULL){// si l'allocation résussit
		//copie du 1er tableau dans le tableau résultat
		for(i=0;i<tailleT1;i++){
			tRes[i] = t1[i];
		}
		//copie du 2e tableau dans le tableau résultat
		for(j=0;j<tailleT2;j++){
			tRes[i+j] = t2[j];
		}
		//on retourne la taille du tableau cree pour l'afficher
		return(tRes);
	}else{
		// erreur d'allocation, on quitte le programme
		perror("Erreur d'allocation mémoire");
		exit(-1);
	}
}


/*! \fn int main (int argc, char** argv)
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 15:29:37 2010
 *
 *  \brief Fonction principale
 *
 *
 * \param argc : Nombre d'argument
 * \param argv : Tableau des arguments
 * \return 0 : le programme doit se terminer normalement
 *
 * \remarks 
 */
int main(int argc, char** argv){
  int t1[N],t2[N],i,*tRes,tailleRes;

  //saisie du 1er tableau
  for(i=0;i<5;i++){
    printf("\nSaisissez la valeur de la case %d : ",i);
    scanf("%d",&t1[i]);
  }

  //saisie du 2e tableau
  for(i=0;i<5;i++){
    printf("\nSaisissez la valeur de la case %d : ",i);
    scanf("%d",&t2[i]);
  }

	//affichage des tableaux saisis
  printf("\n Votre saisie 1 : \n ");
  afficheTab(5,t1);
  printf("\n Votre saisie 2 : \n ");
  afficheTab(5,t2);
  //concatenation
  tRes = concat(5,t1,5,t2,&tailleRes);
  printf("\n Résultat : \n ");
  // affichage du tableau normalise
  afficheTab(tailleRes,tRes);
	//quitte la fonction
	return (EXIT_SUCCESS);
}

Question 6 :

/*! \file q6.c

 *  \author EISTI
 *  \version 0.1
 *
 *  \brief normalise un tableau
 *
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>


/*! \fn int* concat(char ch1[], char ch2[])
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 16:01:05 2010
 *
 *  \brief Récupère la valeur maximum d'un tableau
 *
 *  \param ch1 1ere chaine
 *  \param ch2 2eme chaine
 *
 *  \return pointeur vers la concatenation des 2 chaines
 */

char* concat(char ch1[], char ch2[]) {

  int i, j;
	char *tRes;

	tRes=malloc((strlen(ch1)+strlen(ch2))*sizeof(char)); //allocation de la memoire

	if(tRes==NULL){// si l'allocation plante
		// erreur d'allocation, on quitte le programme
		perror("Erreur d'allocation mémoire");
		exit(-1);
	}

	//copie du 1er tableau dans le tableau résultat
	i=0;
	while(ch1[i]!='\0'){
		tRes[i] = ch1[i];
		i++;
	}
	//copie du 2e tableau dans le tableau résultat
	j=0;
	while(ch2[j]!='\0'){
		tRes[i+j] = ch2[j];
		j++;
	}
	tRes[i+j]='\0';//on marque la fin de chaine
	//on retourne la taille du tableau cree pour l'afficher
	return(tRes);
}


/*! \fn int main (int argc, char** argv)
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 15:29:37 2010
 *
 *  \brief Fonction principale
 *
 *
 * \param argc : Nombre d'argument
 * \param argv : Tableau des arguments
 * \return 0 : le programme doit se terminer normalement
 *
 * \remarks 
 */
int main(int argc, char** argv){
  char c1[20],c2[20], *cRes;

  //saisie de la 1ere chaine
	printf("\nSaisissez la 1ere chaîne : ");
	scanf("%s",c1);

  //saisie de la 2eme chaine
	printf("\nSaisissez la 2eme chaîne : ");
	scanf("%s",c2);

  //concatenation
  cRes = concat(c1,c2);
  printf("\nRésultat : %s\n ",cRes);

	//quitte la fonction
	return (EXIT_SUCCESS);
}

Question 7 :

/*! \file q7.c

 *  \author EISTI
 *  \version 0.1
 *
 *  \brief normalise un tableau
 *
 */

#include <stdio.h>
#include <ctype.h>//librairie pour islower
#include <stdlib.h>
#include <string.h>


/*! \fn int* concat(char ch1[], char ch2[])
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 16:01:05 2010
 *
 *  \brief Récupère la valeur maximum d'un tableau
 *
 *  \param ch1  chaine à transformer
 *  \param ch2 chaine transformée
 *
 */
void majusc(char ch1[], char ch2[]) {

  int i;
	char car;

	//traitement majuscule lettre a lettre
	i=0;
	while(ch1[i]!='\0'){
		car=ch1[i];
		if(islower(car))
		  car -= 32;// ascii+32 = lettre majuscule
		ch2[i] = car;
		i++;
	}

	ch2[i]='\0';//on marque la fin de chaine
}


/*! \fn int main (int argc, char** argv)
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 15:29:37 2010
 *
 *  \brief Fonction principale
 *
 *
 * \param argc : Nombre d'argument
 * \param argv : Tableau des arguments
 * \return 0 : le programme doit se terminer normalement
 *
 * \remarks 
 */
int main(int argc, char** argv){
  char c1[20],c2[20];

  //saisie de la 1ere chaine
	printf("\nSaisissez votre chaîne : ");
	scanf("%s",c1);

  //majusculation
  majusc(c1,c2);
  printf("\nRésultat : %s\n ",c2);

	//quitte la fonction
	return (EXIT_SUCCESS);
}

Question 8 :

/*! \file q8.c

 *  \author EISTI
 *  \version 0.1
 *
 *  \brief normalise un tableau
 *
 */

#include <stdio.h>
#include <stdlib.h>
#define N 10

/*! \fn void afficheTab(int tailleT, int t[])
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 15:57:52 2010
 *
 *  \brief Affiche un tableau d'entier
 *
 *  \param tailleT taille du tableau
 *  \param t[] tableau à afficher
 *
 */
void afficheTab(int tailleT, int t[]) {

  int i;

  for(i=0;i<tailleT;i++){
    printf("| %d ",t[i]);
  }
  printf("|\n ");

}

/*! \fn int max(int tailleT, int t[])
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 16:01:05 2010
 *
 *  \brief Récupère la valeur maximum d'un tableau
 *
 *  \param tailleT taille du tableau
 *  \param t[] tableau d'entiers à parcourir
 *
 *  \return valeur maximale du tableau
 */

int max(int tailleT, int t[]) {

  int i,max;
  
  max = t[0];
  for(i=1;i<tailleT;i++){
    if(max<t[i])
      max=t[i];
  }
  return(max);
}


/*! \fn int min(int tailleT, int t[])
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 16:01:05 2010
 *
 *  \brief Récupère la valeur minimum d'un tableau
 *
 *  \param tailleT taille du tableau
 *  \param t[] tableau d'entiers à parcourir
 *
 *  \return valeur minimale du tableau
 */
int min(int tailleT, int t[]){
  int i,min;
  
  min = t[0];
  for(i=1;i<tailleT;i++){
    min = (min>t[i])?t[i]:min;
  }
  return(min);
}

/*! \fn void triCasier(int taille, int t[])
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 16:01:05 2010
 *
 *  \brief trie un tableau par la méthode des casiers
 *
 *  \param taille taille du tableau
 *  \param t[] tableau à trier
 *
 */
void triCasier(int taille, int t[]){

  int i, m, M, pos, tailleTmp, *tTemp;

	m = min(taille,t);//max du tableau
	M = max(taille,t);//min du tableau
	tailleTmp = (M-m)+1;//taille du tableau de nombre de chaque element
	
	tTemp = malloc(tailleTmp*sizeof(int)); //allocation de la memoire

	if(tTemp==NULL){// si l'allocation résussit
		// erreur d'allocation, on quitte le programme
		perror("Erreur d'allocation mémoire");
		exit(-1);
	}

	//initialisation à 0 du tableau de nombre de chaque element
	for(i=0;i<tailleTmp;i++){
		tTemp[i] = 0;
	}
	//on remplit le tableau de nombre de chaque element
	for(i=0;i<taille;i++){
		tTemp[t[i]-m]++;
	}

	pos=0;
	//remplissage trié du tableau
	for(i=0;i<tailleTmp;i++){
		while(tTemp[i]>0){
			t[pos] = m + i;
			tTemp[i]--;
			pos++;
		}
	}
}


/*! \fn int main (int argc, char** argv)
 *  \author EISTI
 *  \version 0.1
 *  \date Fri Jan 15 15:29:37 2010
 *
 *  \brief Fonction principale
 *
 *
 * \param argc : Nombre d'argument
 * \param argv : Tableau des arguments
 * \return 0 : le programme doit se terminer normalement
 *
 * \remarks 
 */
int main(int argc, char** argv){
  int t1[N],i;

  //saisie du 1er tableau
  for(i=0;i<5;i++){
    printf("\nSaisissez la valeur de la case %d : ",i);
    scanf("%d",&t1[i]);
  }

	//affichage des tableaux saisis
  printf("\n Votre saisie : \n ");
  afficheTab(5,t1);

  //tri casier
  triCasier(5,t1);
  printf("\n Résultat : \n ");
  // affichage du tableau trie
  afficheTab(5,t1);
	//quitte la fonction
	return (EXIT_SUCCESS);
}