Cliquez ici pour retirer la feuille de style si vous souhaitez imprimer ce document (ou en cas de problème d'affichage).
Notes :
  • N'utilisez pas de navigateur de fichier ! Apprenez à ne vous servir que du terminal.
  • Pour chaque fonction demandée, vous écrirez le main associé

Structures de contrôle

  • Écrire une fonction "estPair()" qui prend un paramètre entier. Si ce paramètre est pair elle renvoie 1, sinon elle renvoie 0. Pour ca vous pouvez calculer le reste dans la division par 2 (a=2q+r donc r = a-2q et q est le résultat de la division entière). Vous pouvez aussi utiliser l'opérateur "modulo" du C qui s'écrit % et qui fait précisément ce travail.
  • Tester la fonction suivante :
    #include <stdio.h>
    void affiche_parite(int n){
    	printf("%d est ",n);
    	if(estPair(n)) printf("pair\n");
    	if(!estPair(n)) printf("impair\n");
    }
     
    Expliquez.
  • Écrire une fonction itérative (cad non récursive) qui prend deux entiers et affiche tous les entiers compris dans l'interval ainsi spécifié (ex: fct(4,6); affiche "4 5 6"
  • Si vous avez oublié de traiter ce cas, assurez vous que votre fonction marche également si le deuxième entier est plus petit que le premier (ex: fct(6,4); affiche "6 5 4"
  • Écrivez la fonction factorielle non récursive, mais avec une amélioration : retournez systématiquement -1 si le paramètre est négatif.
  • Essayez 6; ça fait bien 720 ?
  • En modifiant la fonction demandée un peu plus haut, écrivez une procédure de test qui affiche la factorielle de tous les nombres compris entre ses 2 paramètres ex: test(2,4); donne
    2! = 2
    3! = 6
    4! = 24
  • Essayez l'intervalle [-2, 6].

Le problème reste entier

  • Essayez [0, 17] ; pourquoi, simplement en voyant ce résultat, sait-on immédiatement que le nombre maximum dont on peut calculer la factoriel avec cette méthode sera inférieur à 17 ?
  • remplacez 17 par 13 ; pourquoi, simplement en voyant ce résultat, sait-on immédiatement que le maximum sera inférieur à 13 ?
  • Ajoutez dans votre fonction factoriel un test pour ne pas accepter un paramètre supérieur au maximum trouvé précédemment. Retournez -1 dans ce cas.
  • Pour calculer plus de nombre, la solution est d'utiliser un type qui comporte plus de bit. En C pour coder des valeur entière sur plus de bit que la taille d'un int, on peut utiliser le type "long int" : remplacez uniquement là où il le faut int par long int.
  • Pensez-vous que l'on pourra ainsi calculer jusqu'à 100, 1000, plus ? Soyons raisonnables : ayant doublé le nombre d'octets, nous supposerons dans un premier temps que le maximum ne peut pas plus que doubler. Modifiez la borne.
  • Essayez 24; puis regardez 23, puis ... (posez-vous les mêmes questions que précédemment). Réajustez le maximum en fonction des tests précédents.

Les tableaux

Il existe en C un moyen de déclarer en une seule instruction plusieurs variables. Si on a besoin de plusieurs variables du même type, on peut les déclarer en une seule instruction :

int tab[10]; /* declare 10 entiers */
Les dix entiers sont déclarés sur la pile, ils sont consécutifs en mémoire. Un seul nom est réservé : tab.

  • Pour accéder au premier entier, on utilise la notation tab[0].
  • Pour accéder au 9e, on utilise la notation tab[8].
  • etc.

Pour initialiser un tableau, on peut utiliser la notation :

int tab[3] = {1,2,3};
qui peut en fait également s'écrire :
int tab[] = {1,2,3};
la taille est alors déduite directement du nombre de valeurs dans les accolades à droite.

  • Ecrivez une fonction afficheTab(); qui prend un tableau d'entiers en paramètre et qui l'affiche. Votre fonction doit marcher quelque soit la taille du tableau.
  • sans tricher (c'est à dire sans essayer) demandez vous ce qu'affiche ce code :
  • #include <stdio.h>
    void change(int tab[]){
    	tab[0]=-1;
    	tab[1]=-2;
    	tab[2]=-3;
    }
    int main(void){
    	int tab[]={1,2,3};
    	change(tab);
    	afficheTab(tab,3);
    	return 0;
    }
     
  • Tester. Est-ce conforme à ce que vous pensiez ? Un tableau en C est en fait une variable qui contient l'adresse en mémoire des éléments (plus précisément du premier). C'est pour ca que si on passe un tableau en paramètre à une fonction, celle-ci recoit une copie de l'adresse des éléments, et peut donc modifier les éléments !
  • Écrire une fonction qui prend un tableau d'entier et renvoie le plus grand.
  • Écrire une fonction qui prend deux tableaux d'entiers et recopie le premier dans le second. Réfléchissez aux paramètres pour gérer correctement les cas où les deux tableaux ne font pas la même taille.

Chaine de caractère

Pour représenter les lettres en C, on utilise le type entier char. Les char sont codés sur un octet, et permette donc de stocker des valeurs entre -127 et 127. Les valeurs utilisées pour représenter les lettres sont celles de leur code ASCII. On peut les utiliser facilement grace à la notation ''. Par exemple, l'instruction : int i = 'a'; met la valeur du code ASCII de la lettre a dans la variable i (exprès un int et pas un char pour vous montrer que c'est une valeur entière).

Pour représenter un mot, le C utilise des tableaux de char, le mot s'arrête quand la valeur spéciale 0, notée de façon plus portable '\0' est rencontrée. Un tableau plus grand que la taille du mot peut ainsi être utilisé, ce qui peut s'avérer pratique dans certain cas. De plus, on a pas besoin de la taille du tableau pour afficher un mot.

  • Écrire une fonction qui affiche une chaine de caractère à l'envers (utiliser la programmation récursive pour ne parcourir la chaine qu'une seule fois.
  • Écrire une fonction qui prend deux chaines de caractère et renvoie la taille du plus long prefixe commun
  • Écrire une fonction qui prend deux chaines de caractère et renvoie la taille du plus long suffixe commun