Règlement

La réalisation de ces exercices est assujettie aux règles en vigueur dans l’école en matière de triche et de normalisation. Tricher vous expose à de graves sanctions.

Vous devez respecter les règles de normalisation suivantes : https://git.ecole-89.com/eriizu/coding_style/src/branch/main/norm.md

Le non-respect de la norme vous fera perdre une partie ou la totalité des points qui auraient pu être acquis, sur l’ensemble du rendu.

Instructions de rendu

Respectez à la lettre les noms de fichiers et leur emplacement dans le dépôt de rendu. S’il vous est demandé de rendre un fichier nommé hello.c sans qu’un nom de dossier soit précisé : rendez un fichier hello.c à la racine de votre dépôt.

La présence d’une étoile * signifie que le nom du fichier peut être n’importe lequel dès lors qu’il porte l’extension ou l’affixe (préfixe/suffixe) demandée. Elle signifie aussi qu’il est possible de rendre plusieurs fichiers.

La présence d’une double étoile ** signifie que les fichiers peuvent être placés n’importe où dans un dossier, y compris dans des sous-dossiers.

Pensez à faire des commits et des push fréquemment. Autrement nous ne pouvons pas vous aider à retrouver vos fichiers perdus.

Fonctions autorisées et interdites

Par défaut, toute fonction système (comme write) ou fonction des bibliothèques (comme printf ou puts) sont interdites.

À chaque exercice vous sera donné une liste de fonction autorisées, le cas échéant.

main de test

Chaque fois que vous devez rendre une fonction, vous devez aussi rendre un fichier *.main.c. Il s’agit du fichier qui doit contenir votre main de test.

Vous devez écrire des tests pour voir si votre fonction à le bon comportement.

Correction du code source C

Tout le code source sera compilé avec les drapeaux suivants :

-Wall -Wextra -Werror

Testez votre code avec ces drapeaux pour que le compilateur vous informe de tout ce qui peut poser problème avec votre programme avant de le rendre.

Pour tester qu’un fichier sans main compile, vous devez le compiler contre un second fichier qui lui contient un main.

gcc -Wall -Wextra -Werror example.c example.main.c

Exercices

Interversion

Fichier·s à rendre : swap_int.c, swap_int.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction swap_int qui prend 2 pointeurs sur des nombres entiers en paramètre et qui intervertit les valeurs pointées de sorte que l’exemple suivant fonctionne.

// [prototypes et includes tronqués]
int main(void)
{
	int tata;
	int toto;

	tata = 4;
	toto = 9651265;
	swap_int(&tata, &toto);
	if (tata == 9651265 && toto == 4) {
		puts("vous avez réussi");
	} else {
		puts("c'est le flop");
	}
	return (0);
}

Interversion dans un tableau

Fichier·s à rendre : swap_int_arr.c, swap_int_arr.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction swap_int_arr qui prend un tableau qui contient 2 nombres entiers et en fait l’interversion.

// [prototypes et includes tronqués]
int main(void)
{
	int arr[] = { 3, 4 };

	swap_int_arr(arr);
	if (arr[0] == 4 && arr[1] == 3) {
		puts("vous avez réussi");
	} else {
		puts("c'est le flop");
	}
}

Addition

Fichier·s à rendre : add_first_two.c, add_first_two.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction add_first_two qui prend un tableau qui additionne les deux premiers nombres d’un tableau et renvoie le résultat.

Addition et écriture

Fichier·s à rendre : store_add_first_two.c, store_add_first_two.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction store_add_first_two qui prend un tableau qui additionne les deux premiers nombres d’un tableau et écrit le résultat de l’addition dans une troisième case.

// [prototypes et includes tronqués]
int main(void)
{
	int arr[3] = { 3, 4 };

	store_add_first_two(arr);
	if (arr[2] == 7) {
		puts("vous avez réussi");
	} else {
		puts("c'est le flop");
	}
}

Somme

Fichier·s à rendre : sum.c, sum.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction sum qui prend un tableau de nombre entiers et sa taille en paramètre, elle doit renvoyer la somme de tous les éléments.

Moyenne

Fichier·s à rendre : avg.c, avg.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction avg qui prend un tableau de nombres entiers et sa taille en paramètre, elle doit renvoyer la moyenne de tous les éléments.

Compteur

Fichier·s à rendre : count_char_occurrences.c, count_char_occurrences.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction count_char_occurrences qui prend un tableau de caractères, sa taille et un caractère en paramètre, elle doit compter le nombre d’occurrence du caractère reçu à l’intérieur du tableau et renvoyer le résultat.

// [prototypes et includes tronqués]
int main(void)     
{     
    char arr[] = { 'a', 'b', 'c', 'd', 'c' };  
    int count;     
    char target;     
  
    target = 'c';     
    count = count_char_occurrences(arr, 5, target);     
    printf("Il y a %d '%c' dans le tableau !\n", count, target);     
}

Afficher un tableau de caractères

Fichier·s à rendre : print_char_arr.c, print_char_arr.main.c

Fonction·s autorisée·s : write

Écrivez la fonction print_char_arr qui prend un tableau de caractères et sa taille en paramètre, elle doit afficher chaque caractère dans le tableau.

Allouer et remplir

Fichier·s à rendre : malloc_and_fill_with_int.c, malloc_and_fill_with_int.main.c

Fonction·s autorisée·s : malloc

Écrivez la fonction malloc_and_fill_with_int qui prend deux nombres entiers en paramètre, l’un est un nombre arbitraire, l’autre est une taille, la fonction doit allouer dynamiquement un tableau d’entier de la taille demandée, mettre dans chaque case le nombre arbitraire et renvoyer le tableau.

// [prototypes et includes tronqués]
int main(void)  
{  
	int *arr;
	int size;
	int fill_with;
	int i;

	fill_with = 3;
	size = 6;
	arr = malloc_and_fill_with_int(fill_with, size);
	i = 0;
	while (i < size) {
		printf("expected: %d - received: %d\n", fill_with, arr[i]);
		i += 1;
	}
	free(arr);
}

Rotation vers l’avant

Fichier·s à rendre : rotate_forward.c, rotate_forward.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction rotate_forward qui reçoit un tableau d’entier et sa taille, elle doit faire avancer tous les nombres d’une case, et placer le dernier en premier.

Exemple : { 1, 2, 3, 4 } -> { 4, 1, 2, 3 }

Rotation vers l’arrière

Fichier·s à rendre : rotate_backward.c, rotate_backward.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction rotate_backward qui reçoit un tableau d’entier et sa taille, elle doit faire reculer tous les nombres d’une case, et placer le premier en dernier.

Exemple : { 1, 2, 3, 4 } -> { 2, 3, 4, 1 }

Effacer

Fichier·s à rendre : erase_one.c, erase_one.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction erase_one qui reçoit un tableau d’entier, sa taille et un indice, elle doit effacer l’élément du tableau à cet indice.

Exemple : { 1, 2, 3, 4 }, on supprime l’élément à l’indice 2 et le tableau devient : {1, 2, 4 }

Effacer plusieurs

Fichier·s à rendre : erase_many.c, erase_many.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction erase_many qui reçoit un tableau d’entier, sa taille, un indice de départ et un indice de fin, elle doit effacer tous les éléments entre ces deux indices (départ et fin incluses) et renvoyer la nouvelle taille du tableau.

Exemples :

int arr[] = { 1, 2, 3, 4, 5 };
int new_size;

new_size = erase_many(arr, 5, 0, 2);
// le tableau devient : { 4, 5 }
// new_size vaut : 2
// mais il a toujours la place pour 5 éléments, les 3 deniers sont juste ignorés

int arr[] = { 1, 2, 3, 4, 5 };
int new_size;

new_size = erase_many(arr, 5, 3, 3);
// le tableau devient : { 1, 2, 3, 5 }
// new_size vaut : 4
// mais il a toujours la place pour 5 éléments, le denier est juste ignoré

Somme avec bornes

Fichier·s à rendre : sum_inplace.c, sum_inplace.main.c

Fonction·s autorisée·s : aucune

Écrivez la fonction sum_inplace qui reçoit un tableau de nombre, sa taille, un indice de départ et un indice de fin, elle doit faire la somme des tous les éléments entre leur deux bornes (départ et fin incluses), remplacer les éléments par leur somme et renvoyer la nouvelle taille du tableau.

Exemples :

int arr[] = { 2, 4, 7, 1, 3 };
int new_size;

new_size = sum_inplace(arr, 5, 0, 2);
// le tableau devient : { 13, 1, 3 }
// new_size vaut : 3
// mais il a toujours la place pour 5 éléments, les 2 derniers sont juste ingorés

int arr[] = { 2, 4, 7, 1, 3 };
int new_size;

new_size = sum_inplace(arr, 5, 2, 3);
// le tableau devient : { 2, 4, 8, 3 }
// new_size vaut : 4
// mais il a toujours la place pour 5 éléments, le dernier est juste ignoré

Barème