Ladebeze66/Piscine42
1
0
Fork 0
mirror of https://github.com/Ladebeze66/Piscine42.git synced 2025-12-15 13:47:06 +01:00
Code Issues Packages Projects Releases Wiki Activity

Piscine42

Browse Source
This commit is contained in:
Ladebeze66 2023-12-12 17:25:55 +01:00
commit e07184f084
62 changed files with 1572 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
C00/ex00/ft_putchar.c Executable file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putchar.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/11/30 20:24:47 by fgras-ca #+# #+# */
/* Updated: 2022/12/01 17:49:23 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar(char c)
{
write(1, &c, 1);
}

18
C00/ex01/ft_print_alphabet.c Executable file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_print_alphabet.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/11/30 20:35:41 by fgras-ca #+# #+# */
/* Updated: 2022/12/01 19:28:23 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_print_alphabet(void)
{
write(1, "abcdefghijklmnopqrstuvwxyz", 26);
}

18
C00/ex02/ft_print_reverse_alphabet.c Executable file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_print_reverse_alphabet.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/01 19:21:48 by fgras-ca #+# #+# */
/* Updated: 2022/12/01 19:27:48 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_print_reverse_alphabet(void)
{
write(1, "zyxwvutsrqponmlkjihgfedcba", 26);
}

18
C00/ex03/ft_print_numbers.c Executable file
View File

@ -0,0 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_print_numbers.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/01 19:36:44 by fgras-ca #+# #+# */
/* Updated: 2022/12/02 11:52:51 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_print_numbers(void)
{
write(1, "0123456789", 10);
}

25
C00/ex04/ft_is_negative.c Executable file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_is_negative.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/01 19:42:52 by fgras-ca #+# #+# */
/* Updated: 2022/12/02 11:57:31 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_is_negative(int n)
{
if (n < 0)
{
write(1, "N", 1);
}
else
{
write(1, "P", 1);
}
}

401
C00/fr.subject .pdf Normal file
View File

@ -0,0 +1,401 @@
Piscine C
C 00
Résumé: CE document est le sujet du module C 00 de la piscine C de 42.
Version: 7.7
Table des matières
I Consignes 2
II Préambule 4
III Exercice 00 : ft_putchar 7
IV Exercice 01 : ft_print_alphabet 8
V Exercice 02 : ft_print_reverse_alphabet 9
VI Exercice 03 : ft_print_numbers 10
VII Exercise 04 : ft_is_negative 11
VIII Exercice 05 : ft_print_comb 12
IX Exercice 06 : ft_print_comb2 13
X Exercice 07 : ft_putnbr 14
XI Exercice 08 : ft_print_combn 15
XII Rendu et peer-evaluation 16
1
Chapitre I
Consignes
• Seule cette page servira de référence : ne vous fiez pas aux bruits de couloir.
• Relisez bien le sujet avant de rendre vos exercices. A tout moment le sujet peut
changer.
• Attention aux droits de vos fichiers et de vos répertoires.
• Vous devez suivre la procédure de rendu pour tous vos exercices.
• Vos exercices seront corrigés par vos camarades de piscine.
• En plus de vos camarades, vous serez corrigés par un programme appelé la Moulinette.
• La Moulinette est très stricte dans sa notation. Elle est totalement automatisée. Il
est impossible de discuter de sa note avec elle. Soyez d’une rigueur irréprochable
pour éviter les surprises.
• La Moulinette n’est pas très ouverte d’esprit. Elle ne cherche pas à comprendre le
code qui ne respecte pas la Norme. La Moulinette utilise le programme norminette
pour vérifier la norme de vos fichiers. Comprendre par là qu’il est stupide de rendre
un code qui ne passe pas la norminette.
• Les exercices sont très précisément ordonnés du plus simple au plus complexe.
En aucun cas nous ne porterons attention ni ne prendrons en compte un exercice
complexe si un exercice plus simple n’est pas parfaitement réussi.
• L’utilisation d’une fonction interdite est un cas de triche. Toute triche est sanctionnée
par la note de -42.
• Vous ne devrez rendre une fonction main() que si nous vous demandons un programme.
• La Moulinette compile avec les flags -Wall -Wextra -Werror, et utilise cc.
• Si votre programme ne compile pas, vous aurez 0.
• Vous ne devez laisser dans votre répertoire aucun autre fichier que ceux explicitement
specifiés par les énoncés des exercices.
• Vous avez une question ? Demandez à votre voisin de droite. Sinon, essayez avec
votre voisin de gauche.
2
Piscine C C 00
• Votre manuel de référence s’appelle Google / man / Internet / ....
• Pensez à discuter sur le forum Piscine de votre Intra, ainsi que sur le slack de votre
Piscine !
• Lisez attentivement les exemples. Ils pourraient bien requérir des choses qui ne
sont pas autrement précisées dans le sujet...
• Réfléchissez. Par pitié, par Odin ! Nom d’une pipe.
N’oubliez pas d’ajouter le header de 42 dans vos fichiers .c et .h.
La norminette vérifie la présence du header !
Pour ce module, la norminette doit être lancée avec le flag -R
CheckForbiddenSourceHeader. La moulinette l’utilisera aussi.
3
Chapitre II
Préambule
La confiture de nouilles, selon Pierre Dac
Avant d’utiliser la nouille pour la confection de la confiture, il faut
évidemment la récolter; avant de la récolter, il faut qu’elle pousse, et pour
qu’elle pousse, il va de soi qu’il faut d’abord la semer.
Les semailles de la graine de nouille, c’est-à-dire les senouilles, représentent
une opération extrêmement délicate. Tout d’abord, le choix d’un terrain propice
à la fécondation de la nouille demande une étude judicieusement approfondie. Le
terrain nouillifère type doit être, autant que possible, situé en bordure de la
route départementale et à proximité de la gendarmerie nationale.
Avant de semer la graine de nouille, les nouilliculteurs préparent longuement le
champ nouillifère pour le rendre idoine à la fécondation. Ils retournent la
terre avec une charrue spéciale dont le soc est remplacé par une lame Gillette,
ensuite délaissant les engrais chimiques, nettement contre-indiqués dans le cas
présent, ils fument le champ nouillifère avec du fromage râpé. Cette opération
s’effectue indifféremment avec une seringue ou une pompe à vélo.
Lorsque le champ est suffisamment imprégné de fromage râpé, on verse sur toute
sa surface de l’alcool de menthe dans la proportion d’un verre à Bordeaux par
hectare de superficie; cette opération qui est confiée à des spécialistes de
l’École de Nouilliculture, est effectuée avec un compte-gouttes.
Après cela, on laisse fermenter la terre pendant toute la durée de la nouvelle
lune et dès l’apparition du premier quartier, on procède alors aux senouilles
de la graine de nouilles. Il ne faudrait pas vous imaginer, Mesdames et
Messieurs, que la graine de nouilles est d’un commerce courant et qu’on la
trouve communément chez les grainetiers ; si vous croyez cela, il est
indiscutable que vous broutez les coteaux de l’erreur. La graine de nouilles ne
s’obtient qu’après une très longue préparation de laboratoire, car elle est le
produit d’un croisement de foie de veau avec le concombre adulte; voici
d’ailleurs quelques précisions sur cette merveilleuse con]onction qui est la
gloire de nos chimistes, dont la science n’a d’égale que la modestie.
On met côte à côte, dans une lessiveuse, une tranche de foie de veau et un
4
Piscine C C 00
concombre adulte, on place le tout dans un autoclave et on l’y laisse 45 jours
à une température de 120º sous la bienveillance d’un contrôleur de la Compagnie
du Gaz; au bout de ce laps de temps, on ouvre l’appareil et on n’a plus qu’à
recueillir la précieuse graine que l’on va verser dans la terre prête à la
recevoir et qu’elle va féconder.
Les senouilles s’effectuent à l’aide d’un poêle mobile dans lequel est versée la
graine, laquelle est projetée dans la terre par un dispositif spécial dont il ne
nous est pas permis de révéler le secret pour des raisons de défense nationale
que l’on comprendra aisément. Après ça, on arrose entièrement le champ avec des
siphons d’eau de seltz, on sèche ensuite avec du papier buvard, on donne un coup
de plumeau et on n’a plus qu’à s’en remettre au travail de la terre nourricière
et à la nature immortelle, généreuse et démocratique. Lorsque les senouilles
sont terminées, les nouilliculteurs qui sont encore entachés de superstition,
consultent les présages; ils prennent une petite taupe, la font courir dans
l’herbe et si elle fait : "ouh!" c’est que la récolte sera bonne; si elle ne
fait pas "ouh!" c’est que la récolte sera bonne tout de même, mais comme cela
les croyances sont respectées, et tout le monde est content.
Pendant la germination, il n’y a presque rien à faire ; tous les huit jours
seulement, on arrose le champ avec de l’huile de cade, de la cendre de cigare,
du jus de citron et de la glycérine pour éviter que la terre ne se crevasse.
Pendant la moisson, les nuits sont témoins de saines réjouissances auxquelles
se livrent les travailleurs de la nouilliculture, la jeunesse danse et s’en
donne à cœur joie aux sons d’un orchestre composé d’un harmonium, d’une
mandoline et d’une trompette de cavalerie ; les jeunes gens revêtent leur
costume régional composé d’une redingote, d’une culotte cycliste, d’espadrilles
et d’un chapeau Cronstadt ; les jeunes filles, rougissantes de joie pudique,
sont revêtues de ravissantes robes de toile à cataplasme, ornées d’empiècements
en schpoutnoutz, et se ceignent le front d’une couronne d’œufs durs du plus
gracieux effet Un feu d’artifice tiré avec des lampes Pigeon clôture la série
des réjouissances et chacun rentre chez soi, content du labeur accompli, pour
procéder alors à la confection de la confiture de nouilles, objet de la présente
étude.
La nouille encore à l’état brut, est alors soigneusement triée et débarrassée de
ses impuretés; après un premier stade, elle est expédiée à l’usine et passée
immédiatement au laminouille qui va lui donner l’aspect définitif que nous lui
connaissons – le laminouille est une machine extrêmement perfectionnée, qui
marche au guignolet-cassis et qui peut débiter jusqu’à 80 kilomètres de nouilles
à l’heure – ; à la sortie du laminouille, la nouille est passée au vernis
cellulosique qui la rend imperméable et souple; elle est ensuite hachée menue à
la hache d’abordage et râpée. Le râpage se fait encore à la main et avec une
râpe à bois. Après le râpage, la nouille est alors mise en bouteilles, opération
très délicate qui demande énormément d’attention ; on met ensuite les bouteilles
dans un appareil appelé électronouille, dans lequel passe un courant de 210
volts; après un séjour de 12 heures dans cet appareil, les bouteilles sont
5
Piscine C C 00
sorties et on vide la nouille désormais électrifiée dans un récipient placé
lui-même sur un réchaud à alcool à haute tension.
On verse alors dans ledit récipient : du sel, du sucre, du poivre de Cayenne,
du gingembre, de la cannelle, de l’huile, de la pomme de terre pilée, un flocon
de magnésie bismurée, du riz, des carottes, des peaux de saucisson, des tomates,
du vin blanc, et des piments rouges, on mélange lentement ces ingrédients avec
la nouille à l’aide d’une cuiller à pot et on laisse mitonner à petit feu
pendant 21 jours. La confiture de nouilles est alors virtuellement terminée.
Lorsque les 21 jours sont écoulés, que la cuisson est parvenue à son point
culminant et définitif, on place le récipient dans un placard, afin que la
confiture se solidifie et devienne gélatineuse; quand elle est complètement
refroidie, on soulève le récipient très délicatement, avec d’infinies
précautions et le maximum de prudence et on balance le tout par la fenêtre
parce que c’est pas bon!
Contrairement à la confiture de nouilles, le C c’est bon, mangez-en !
6
Chapitre III
Exercice 00 : ft_putchar
Exercice : 00
ft_putchar
Dossier de rendu : ex00/
Fichiers à rendre : ft_putchar.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche le caractère passé en paramètre.
• Elle devra être prototypée de la façon suivante :
void ft_putchar(char c);
Pour afficher le caractère, vous devez utiliser la fonction write de la manière
suivante.
write(1, &c, 1);
7
Chapitre IV
Exercice 01 : ft_print_alphabet
Exercice : 01
ft_print_alphabet
Dossier de rendu : ex01/
Fichiers à rendre : ft_print_alphabet.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche l’alphabet en minuscule sur une seule ligne, dans
l’ordre croissant, à partir de la lettre ’a’.
• Elle devra être prototypée de la façon suivante :
void ft_print_alphabet(void);
8
Chapitre V
Exercice 02 :
ft_print_reverse_alphabet
Exercice : 02
ft_print_reverse_alphabet
Dossier de rendu : ex02/
Fichiers à rendre : ft_print_reverse_alphabet.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche l’alphabet en minuscule sur une seule ligne, dans
l’ordre décroissant, à partir de la lettre ’z’.
• Elle devra être prototypée de la façon suivante :
void ft_print_reverse_alphabet(void);
9
Chapitre VI
Exercice 03 : ft_print_numbers
Exercice : 03
ft_print_numbers
Dossier de rendu : ex03/
Fichiers à rendre : ft_print_numbers.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche tous les chiffres sur une seule ligne, dans l’ordre
croissant.
• Elle devra être prototypée de la façon suivante :
void ft_print_numbers(void);
10
Chapitre VII
Exercise 04 : ft_is_negative
Exercice : 04
ft_is_negative
Dossier de rendu : ex04/
Fichiers à rendre : ft_is_negative.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche ’N’ ou ’P’ suivant le signe de l’entier passé en
paramètre. Si n est négatif alors afficher ’N’. Si n est positif ou nul alors afficher
’P’.
• Elle devra être prototypée de la façon suivante :
void ft_is_negative(int n);
11
Chapitre VIII
Exercice 05 : ft_print_comb
Exercice : 05
ft_print_comb
Dossier de rendu : ex05/
Fichiers à rendre : ft_print_comb.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche, dans l’ordre croissant, toutes les différentes combinaisons
de trois chiffres différents dans l’ordre croissant - oui, la répétition est volontaire.
• Cela donne quelque chose comme ça :
$>./a.out | cat -e
012, 013, 014, 015, 016, 017, 018, 019, 023, ..., 789$>
• 987 n’est pas là car 789 est déjà présent
• 999 n’est pas là car ce nombre ne comporte pas exclusivement des chiffres différents
les uns des autres
• Elle devra être prototypée de la façon suivante :
void ft_print_comb(void);
12
Chapitre IX
Exercice 06 : ft_print_comb2
Exercice : 06
ft_print_comb2
Dossier de rendu : ex06/
Fichiers à rendre : ft_print_comb2.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche toutes les différentes combinaisons de deux nombres
entre 0 et 99, dans l’ordre croissant.
• Cela donne quelque chose comme ça :
$>./a.out | cat -e
00 01, 00 02, 00 03, 00 04, 00 05, ..., 00 99, 01 02, ..., 97 99, 98 99$>
• Elle devra être prototypée de la façon suivante :
void ft_print_comb2(void);
13
Chapitre X
Exercice 07 : ft_putnbr
Exercice : 07
ft_putnbr
Dossier de rendu : ex07/
Fichiers à rendre : ft_putnbr.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche un nombre passé en paramètre. La fonction devra
être capable d’afficher la totalité des valeurs possibles dans une variable de type
int.
• Elle devra être prototypée de la façon suivante :
void ft_putnbr(int nb);
• Par exemple :
◦ ft_putnbr(42) affiche "42".
14
Chapitre XI
Exercice 08 : ft_print_combn
Exercice : 08
ft_print_combn
Dossier de rendu : ex08/
Fichiers à rendre : ft_print_combn.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche toutes les différentes combinaisons de n chiffres dans
l’ordre croissant.
• n sera tel que : 0 < n < 10.
• Si n = 2, cela donne quelque chose comme ça :
$>./a.out | cat -e
01, 02, 03, ..., 09, 12, ..., 79, 89$>
• Elle devra être prototypée de la façon suivante :
void ft_print_combn(int n);
15
Chapitre XII
Rendu et peer-evaluation
Rendez votre travail sur votre dépot Git comme d’habitude. Seul le travail présent
sur votre dépot sera évalué en soutenance. Vérifiez bien les noms de vos dossiers et de
vos fichiers afin que ces derniers soient conformes aux demandes du sujet.
Vous ne devez rendre uniquement les fichiers demandés par le sujet de
ce projet.
16

16
C01/ex00/ft_ft.c Executable file
View File

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ft.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/03 18:27:18 by fgras-ca #+# #+# */
/* Updated: 2022/12/05 15:43:03 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
void ft_ft(int *nbr)
{
*nbr = 42;
}

16
C01/ex01/ft_ultimate_ft.c Executable file
View File

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ultimate_ft.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/05 15:48:06 by fgras-ca #+# #+# */
/* Updated: 2022/12/08 10:13:16 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
void ft_ultimate_ft(int *********nbr)
{
*********nbr = 42;
}

20
C01/ex02/ft_swap.c Executable file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_swap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/05 15:50:26 by fgras-ca #+# #+# */
/* Updated: 2022/12/05 15:54:58 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
void ft_swap(int *a, int *b)
{
int swap;
swap = *a;
*a = *b;
*b = swap;
}

17
C01/ex03/ft_div_mod.c Executable file
View File

@ -0,0 +1,17 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_div_mod.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/05 15:57:30 by fgras-ca #+# #+# */
/* Updated: 2022/12/07 09:17:14 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
void ft_div_mod(int a, int b, int *div, int *mod)
{
*div = a / b;
*mod = a % b;
}

20
C01/ex04/ft_ultimate_div_mod.c Executable file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ultimate_div_mod.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/06 16:55:09 by fgras-ca #+# #+# */
/* Updated: 2022/12/07 09:50:31 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
void ft_ultimate_div_mod(int *a, int *b)
{
int swap;
swap = *a;
*a = swap / *b;
*b = swap % *b;
}

25
C01/ex05/ft_putstr.c Executable file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/06 17:08:21 by fgras-ca #+# #+# */
/* Updated: 2022/12/07 12:42:16 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putstr(char *str)
{
int a;
a = 0;
while (str[a] != '\0')
{
write(1, &str[a], 1);
a++;
}
}

23
C01/ex06/ft_strlen.c Executable file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/07 11:01:26 by fgras-ca #+# #+# */
/* Updated: 2022/12/07 12:40:42 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_strlen(char *str)
{
int a;
a = 0;
while (str[a] != '\0')
{
a++;
}
return (a);
}

299
C01/fr.subject.pdf Normal file
View File

@ -0,0 +1,299 @@
Piscine C
C 01
Résumé: Ce document est le sujet du module C 01 de la piscine C de 42.
Version: 5.4
Table des matières
I Consignes 2
II Préambule 4
III Exercice 00 : ft_ft 5
IV Exercice 01 : ft_ultimate_ft 6
V Exercice 02 : ft_swap 7
VI Exercice 03 : ft_div_mod 8
VII Exercice 04 : ft_ultimate_div_mod 9
VIII Exercice 05 : ft_putstr 10
IX Exercice 06 : ft_strlen 11
X Exercice 07 : ft_rev_int_tab 12
XI Exercice 08 : ft_sort_int_tab 13
XII Rendu et peer-evaluation 14
1
Chapitre I
Consignes
• Seule cette page servira de référence : ne vous fiez pas aux bruits de couloir.
• Relisez bien le sujet avant de rendre vos exercices. A tout moment le sujet peut
changer.
• Attention aux droits de vos fichiers et de vos répertoires.
• Vous devez suivre la procédure de rendu pour tous vos exercices.
• Vos exercices seront corrigés par vos camarades de piscine.
• En plus de vos camarades, vous serez corrigés par un programme appelé la Moulinette.
• La Moulinette est très stricte dans sa notation. Elle est totalement automatisée. Il
est impossible de discuter de sa note avec elle. Soyez d’une rigueur irréprochable
pour éviter les surprises.
• La Moulinette n’est pas très ouverte d’esprit. Elle ne cherche pas à comprendre le
code qui ne respecte pas la Norme. La Moulinette utilise le programme norminette
pour vérifier la norme de vos fichiers. Comprendre par là qu’il est stupide de rendre
un code qui ne passe pas la norminette.
• Les exercices sont très précisément ordonnés du plus simple au plus complexe.
En aucun cas nous ne porterons attention ni ne prendrons en compte un exercice
complexe si un exercice plus simple n’est pas parfaitement réussi.
• L’utilisation d’une fonction interdite est un cas de triche. Toute triche est sanctionnée
par la note de -42.
• Vous ne devrez rendre une fonction main() que si nous vous demandons un programme.
• La Moulinette compile avec les flags -Wall -Wextra -Werror, et utilise cc.
• Si votre programme ne compile pas, vous aurez 0.
• Vous ne devez laisser dans votre répertoire aucun autre fichier que ceux explicitement
specifiés par les énoncés des exercices.
• Vous avez une question ? Demandez à votre voisin de droite. Sinon, essayez avec
votre voisin de gauche.
2
Piscine C C 01
• Votre manuel de référence s’appelle Google / man / Internet / ....
• Pensez à discuter sur le forum Piscine de votre Intra, ainsi que sur le slack de votre
Piscine !
• Lisez attentivement les exemples. Ils pourraient bien requérir des choses qui ne
sont pas autrement précisées dans le sujet...
• Réfléchissez. Par pitié, par Odin ! Nom d’une pipe.
Pour cette journée, la norminette doit être lancée avec le flag -R
CheckForbiddenSourceHeader. La moulinette l’utilisera aussi.
3
Chapitre II
Préambule
Le jeu du Sirop selon Perceval, tiré de la série Kaamelott :
"Bon, j’vais vous apprendre les règles simplifiées, parce que les vraies règles,
elles sont velues. Bon, le seul truc, c’est que normalement, ça se joue à trois.
Mais c’est pas grave on va se débrouiller.
Le principe, c’est de faire des valeurs. Donc là, mettons, on est trois, il y a
trois valeurs à distribuer. On va dire, sirop de huit, sirop de quatorze et
sirop de vingt-et-un. Vous occupez pas des sirops tout de suite. Ce qu’il faut
comprendre d’abord, c’est les valeurs. Si vous lancez une valeur en début de
tour, mettons un sirop de huit, pour commencer petit, les autres ont le choix
entre laisser filer la mise ou relancer un sirop de quatorze. On tourne dans le
sens des valeurs. C’est pour ça, il faut bien comprendre le système des valeurs;
après, ça va tout seul.
Bon alors mettons que j’ouvre avec un sirop de huit.
Si c’est vous qu’avez siroté au tour d’avant, ça tourne dans votre sens. Alors
soit vous laissez filer, vous dites "file-sirop", soit vous vous sentez de
relancer et vous annoncez un sirop de quatorze. Comme on a commencé les
annonces, le second joueur a pas le droit de laisser filer. Vous pouvez soit
relancer un sirop de vingt-et-un, soit vous abandonnez le tour et vous dites
"couche-sirop" ou "sirop Jeannot", ça dépend des régions. Et après, soit on
fait la partie soit je fais un "contre-sirop" ! Et à partir de là, sirop de pomme
sur vingt-et-un donc on fait la partie en quatre tours jusqu’à qu’il y en ait un
qui sirote.
À la gagne, il n’y a que trois possibilités : soit vous faites votre
sirop de huit, vous dites "beau sirop" et on recompte, soit vous faites votre
sirop de quatorze, vous dites "beau sirop, sirop gagnant" et on vous rajoute la
moitié, soit vous faites votre sirop de vingt-et-un et vous dites "beau sirop,
mi-sirop, siroté, gagne-sirop, sirop-grelot, passe-montagne, sirop au bon goût".
Normalement ça se joue avec des cartes mais si vous avez que des dés, vous
pouvez aussi jouer avec des dés puisque ce qui compte c’est les valeurs."
Au moins un des exercices suivants n’a aucun rapport avec le jeu du Sirop.
4
Chapitre III
Exercice 00 : ft_ft
Exercice : 00
ft_ft
Dossier de rendu : ex00/
Fichiers à rendre : ft_ft.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui prend un pointeur sur int en paramètre et donne à l’int la
valeur de 42.
• Elle devra être prototypée de la façon suivante :
void ft_ft(int *nbr);
5
Chapitre IV
Exercice 01 : ft_ultimate_ft
Exercice : 01
ft_ultimate_ft
Dossier de rendu : ex01/
Fichiers à rendre : ft_ultimate_ft.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui prend un pointeur sur pointeur sur pointeur sur pointeur
sur pointeur sur pointeur sur pointeur sur pointeur sur pointeur sur int en paramètre
et donne à l’int la valeur de 42.
• Elle devra être prototypée de la façon suivante :
void ft_ultimate_ft(int *********nbr);
6
Chapitre V
Exercice 02 : ft_swap
Exercice : 02
ft_swap
Dossier de rendu : ex02/
Fichiers à rendre : ft_swap.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui échange le contenu de deux entiers dont les adresses sont
données en paramètres.
• Elle devra être prototypée de la façon suivante :
void ft_swap(int *a, int *b);
7
Chapitre VI
Exercice 03 : ft_div_mod
Exercice : 03
ft_div_mod
Dossier de rendu : ex03/
Fichiers à rendre : ft_div_mod.c
Fonctions Autorisées : Aucune
• Écrire une fonction ft_div_mod qui a le prototypage suivant :
void ft_div_mod(int a, int b, int *div, int *mod);
• Cette fonction divise les deux paramètres a et b et stocke le resultat dans l’int
pointé par div.
Elle stocke également le reste de la division de a et b dans l’int pointé par mod.
8
Chapitre VII
Exercice 04 : ft_ultimate_div_mod
Exercice : 04
ft_ultimate_div_mod
Dossier de rendu : ex04/
Fichiers à rendre : ft_ultimate_div_mod.c
Fonctions Autorisées : Aucune
• Écrire une fonction ft_ultimate_div_mod qui a le prototypage suivant :
void ft_ultimate_div_mod(int *a, int *b);
• Cette fonction divise les int pointés par a et b.
Le résultat de la division est stocké dans l’int pointé par a.
Le résultat du reste de la division est stocké dans l’int pointé par b.
9
Chapitre VIII
Exercice 05 : ft_putstr
Exercice : 05
ft_putstr
Dossier de rendu : ex05/
Fichiers à rendre : ft_putstr.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche une chaine de caractères à l’écran.
• Elle devra être prototypée de la façon suivante :
void ft_putstr(char *str);
10
Chapitre IX
Exercice 06 : ft_strlen
Exercice : 06
ft_strlen
Dossier de rendu : ex06/
Fichiers à rendre : ft_strlen.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui compte le nombre de caractères dans une chaîne de caractères
et qui retourne le nombre trouvé.
• Elle devra être prototypée de la façon suivante :
int ft_strlen(char *str);
11
Chapitre X
Exercice 07 : ft_rev_int_tab
Exercice : 07
ft_rev_int_tab
Dossier de rendu : ex07/
Fichiers à rendre : ft_rev_int_tab.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui inverse l’ordre des élements d’un tableau d’entiers.
• Les paramètres sont un pointeur sur entier et le nombre d’entiers dans le tableau.
• La fonction devra être prototypée de la façon suivante :
void ft_rev_int_tab(int *tab, int size);
12
Chapitre XI
Exercice 08 : ft_sort_int_tab
Exercice : 08
ft_sort_int_tab
Dossier de rendu : ex08/
Fichiers à rendre : ft_sort_int_tab.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui trie un tableau d’entiers par ordre croissant.
• Les paramètres sont un pointeur sur entier et le nombre d’entiers dans le tableau.
• La fonction devra être prototypée de la façon suivante :
void ft_sort_int_tab(int *tab, int size);
13
Chapitre XII
Rendu et peer-evaluation
Rendez votre travail sur votre dépot Git comme d’habitude. Seul le travail présent
sur votre dépot sera évalué en soutenance. Vérifiez bien les noms de vos dossiers et de
vos fichiers afin que ces derniers soient conformes aux demandes du sujet.
Vous ne devez rendre uniquement les fichiers demandés par le sujet de
ce projet.
14

25
C02/ex00/ft_strcpy.c Executable file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/07 12:44:06 by fgras-ca #+# #+# */
/* Updated: 2022/12/10 10:29:05 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
char *ft_strcpy(char *dest, char *src)
{
int i;
i = 0;
while (src[i] != '\0')
{
dest[i] = src[i];
i++;
}
dest[i] = '\0';
return (dest);
}

29
C02/ex01/ft_strncpy.c Executable file
View File

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/07 13:20:04 by fgras-ca #+# #+# */
/* Updated: 2022/12/10 16:55:53 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
char *ft_strncpy(char *dest, char *src, unsigned int n)
{
unsigned int i;
i = 0;
while (src[i] != '\0' && i < n)
{
dest[i] = src[i];
i++;
}
while (i < n)
{
dest[i] = '\0';
i++;
}
return (dest);
}

BIN
C02/ex02/.main.c.swp Executable file
View File

Binary file not shown.

34
C02/ex02/ft_str_is_alpha.c Executable file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_str_is_alpha.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/07 14:06:49 by fgras-ca #+# #+# */
/* Updated: 2022/12/10 17:05:15 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_str_is_alpha(char *str)
{
int i;
i = 0;
if (str[i] == '\0')
{
return (1);
}
while (str[i] != '\0')
{
if ((str[i] >= 65 && str[i] <= 90) || (str[i] >= 97 && str[i] <= 122))
{
i++;
}
else
{
return (0);
}
}
return (1);
}

34
C02/ex03/ft_str_is_numeric.c Executable file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_str_is_numeric.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/07 17:46:52 by fgras-ca #+# #+# */
/* Updated: 2022/12/10 17:06:15 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_str_is_numeric(char *str)
{
int i;
i = 0;
if (str[i] == '\0')
{
return (1);
}
while (str[i] != '\0')
{
if ((str[i] >= 48 && str[i] <= 57))
{
i++;
}
else
{
return (0);
}
}
return (1);
}

34
C02/ex04/ft_str_is_lowercase.c Executable file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_str_is_lowercase.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/07 18:03:49 by fgras-ca #+# #+# */
/* Updated: 2022/12/07 18:11:53 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_str_is_lowercase(char *str)
{
int i;
i = 0;
if (str[i] == '\0')
{
return (1);
}
while (str[i] != '\0')
{
if ((str[i]) >= 97 && (str[i] <= 122))
{
i++;
}
else
{
return (0);
}
}
return (1);
}

34
C02/ex05/ft_str_is_uppercase.c Executable file
View File

@ -0,0 +1,34 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_str_is_uppercase.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/07 18:13:20 by fgras-ca #+# #+# */
/* Updated: 2022/12/08 08:12:15 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_str_is_uppercase(char *str)
{
int i;
i = 0;
if (str[i] == 0)
{
return (1);
}
while (str[i] != '\0')
{
if ((str[i] >= 65 && str[i] <= 90))
{
i++;
}
else
{
return (0);
}
}
return (1);
}

30
C02/ex06/ft_str_is_printable.c Executable file
View File

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_str_is_printable.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/07 18:30:32 by fgras-ca #+# #+# */
/* Updated: 2022/12/08 08:26:33 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_str_is_printable(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
if ((str[i] >= 32 && str[i] <= 126))
{
i++;
}
else
{
return (0);
}
}
return (1);
}

BIN
C02/ex07/.main.c.swo Executable file
View File

Binary file not shown.

25
C02/ex07/ft_strupcase.c Executable file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strupcase.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/08 08:28:11 by fgras-ca #+# #+# */
/* Updated: 2022/12/10 11:01:18 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
char *ft_strupcase(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
if ((str[i] >= 97 && str[i] <= 122))
str[i] -= 32;
i++;
}
return (str);
}

BIN
C02/ex08/.main.c.swp Executable file
View File

Binary file not shown.

25
C02/ex08/ft_strlowcase.c Executable file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlowcase.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/08 10:34:31 by fgras-ca #+# #+# */
/* Updated: 2022/12/08 10:44:36 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
char *ft_strlowcase(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
if ((str[i] >= 65 && str[i] <= 90))
str[i] += 32;
i++;
}
return (str);
}

447
C02/fr.subject.pdf Normal file
View File

@ -0,0 +1,447 @@
Piscine C
C 02
Résumé: Ce document est le sujet du module C 02 de la piscine C de 42.
Version: 5.4
Table des matières
I Consignes 2
II Préambule 4
III Exercice 00 : ft_strcpy 5
IV Exercice 01 : ft_strncpy 6
V Exercice 02 : ft_str_is_alpha 7
VI Exercice 03 : ft_str_is_numeric 8
VII Exercice 04 : ft_str_is_lowercase 9
VIII Exercice 05 : ft_str_is_uppercase 10
IX Exercice 06 : ft_str_is_printable 11
X Exercice 07 : ft_strupcase 12
XI Exercice 08 : ft_strlowcase 13
XII Exercice 09 : ft_strcapitalize 14
XIII Exercice 10 : ft_strlcpy 15
XIV Exercice 11 : ft_putstr_non_printable 16
XV Exercice 12 : ft_print_memory 17
XVI Rendu et peer-evaluation 19
1
Chapitre I
Consignes
• Seule cette page servira de référence : ne vous fiez pas aux bruits de couloir.
• Relisez bien le sujet avant de rendre vos exercices. A tout moment le sujet peut
changer.
• Attention aux droits de vos fichiers et de vos répertoires.
• Vous devez suivre la procédure de rendu pour tous vos exercices.
• Vos exercices seront corrigés par vos camarades de piscine.
• En plus de vos camarades, vous serez corrigés par un programme appelé la Moulinette.
• La Moulinette est très stricte dans sa notation. Elle est totalement automatisée. Il
est impossible de discuter de sa note avec elle. Soyez d’une rigueur irréprochable
pour éviter les surprises.
• La Moulinette n’est pas très ouverte d’esprit. Elle ne cherche pas à comprendre le
code qui ne respecte pas la Norme. La Moulinette utilise le programme norminette
pour vérifier la norme de vos fichiers. Comprendre par là qu’il est stupide de rendre
un code qui ne passe pas la norminette.
• Les exercices sont très précisément ordonnés du plus simple au plus complexe.
En aucun cas nous ne porterons attention ni ne prendrons en compte un exercice
complexe si un exercice plus simple n’est pas parfaitement réussi.
• L’utilisation d’une fonction interdite est un cas de triche. Toute triche est sanctionnée
par la note de -42.
• Vous ne devrez rendre une fonction main() que si nous vous demandons un programme.
• La Moulinette compile avec les flags -Wall -Wextra -Werror, et utilise cc.
• Si votre programme ne compile pas, vous aurez 0.
• Vous ne devez laisser dans votre répertoire aucun autre fichier que ceux explicitement
specifiés par les énoncés des exercices.
• Vous avez une question ? Demandez à votre voisin de droite. Sinon, essayez avec
votre voisin de gauche.
2
Piscine C C 02
• Votre manuel de référence s’appelle Google / man / Internet / ....
• Pensez à discuter sur le forum Piscine de votre Intra, ainsi que sur le slack de votre
Piscine !
• Lisez attentivement les exemples. Ils pourraient bien requérir des choses qui ne
sont pas autrement précisées dans le sujet...
• Réfléchissez. Par pitié, par Odin ! Nom d’une pipe.
Pour cette journée, la norminette doit être lancée avec le flag -R
CheckForbiddenSourceHeader. La moulinette l’utilisera aussi.
3
Chapitre II
Préambule
Voici une discussion extraite de la série Silicon Valley :
- I mean, why not just use Vim over Emacs? (CHUCKLES)
- I do use Vim over Emac.
- Oh, God, help us! Okay, uh you know what? I just don’t think this is
going to work. I’m so sorry. Uh, I mean like, what, we’re going to bring
kids into this world with that over their heads? That’s not really fair
to them, don’t you think?
- Kids? We haven’t even slept together.
- And guess what, it’s never going to happen now, because there is no
way I’m going to be with someone who uses spaces over tabs.
- Richard! (PRESS SPACE BAR MANY TIMES)
- Wow. Okay. Goodbye.
- One tab saves you eight spaces! - (DOOR SLAMS) - (BANGING)
...
(RICHARD MOANS)
- Oh, my God! Richard, what happened?
- I just tried to go down the stairs eight steps at a time. I’m okay, though.
- See you around, Richard.
- Just making a point.
Heureusement, vous n’êtes pas obliger d’utiliser emacs et votre barre espace pour
compléter les exercices suivants.
4
Chapitre III
Exercice 00 : ft_strcpy
Exercice : 00
ft_strcpy
Dossier de rendu : ex00/
Fichiers à rendre : ft_strcpy.c
Fonctions Autorisées : Aucune
• Reproduire à l’identique le fonctionnement de la fonction strcpy (man strcpy).
• Elle devra être prototypée de la façon suivante :
char *ft_strcpy(char *dest, char *src);
5
Chapitre IV
Exercice 01 : ft_strncpy
Exercice : 01
ft_strncpy
Dossier de rendu : ex01/
Fichiers à rendre : ft_strncpy.c
Fonctions Autorisées : Aucune
• Reproduire à l’identique le fonctionnement de la fonction strncpy (man strncpy).
• Elle devra être prototypée de la façon suivante :
char *ft_strncpy(char *dest, char *src, unsigned int n);
6
Chapitre V
Exercice 02 : ft_str_is_alpha
Exercice : 02
ft_str_is_alpha
Dossier de rendu : ex02/
Fichiers à rendre : ft_str_is_alpha.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui renvoie 1 si la chaîne passée en paramètre ne contient que
des caractères alphabétiques et renvoie 0 si la chaîne passée en paramètre contient
d’autres types de caractères.
• Elle devra être prototypée de la façon suivante :
int ft_str_is_alpha(char *str);
• Elle devra renvoyer 1 si str est une chaîne vide.
7
Chapitre VI
Exercice 03 : ft_str_is_numeric
Exercice : 03
ft_str_is_numeric
Dossier de rendu : ex03/
Fichiers à rendre : ft_str_is_numeric.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui renvoie 1 si la chaîne passée en paramètre ne contient que
des chiffres et renvoie 0 si la chaîne passée en paramètre contient d’autres types
de caractères.
• Elle devra être prototypée de la façon suivante :
int ft_str_is_numeric(char *str);
• Elle devra renvoyer 1 si str est une chaîne vide.
8
Chapitre VII
Exercice 04 : ft_str_is_lowercase
Exercice : 04
ft_str_is_lowercase
Dossier de rendu : ex04/
Fichiers à rendre : ft_str_is_lowercase.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui renvoie 1 si la chaîne passée en paramètre ne contient
que des caractères alphabétiques minuscules et renvoie 0 si la chaîne passée en
paramètre contient d’autres types de caractères.
• Elle devra être prototypée de la façon suivante :
int ft_str_is_lowercase(char *str);
• Elle devra renvoyer 1 si str est une chaîne vide.
9
Chapitre VIII
Exercice 05 : ft_str_is_uppercase
Exercice : 05
ft_str_is_uppercase
Dossier de rendu : ex05/
Fichiers à rendre : ft_str_is_uppercase.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui renvoie 1 si la chaîne passée en paramètre ne contient
que des caractères alphabétiques majuscules et renvoie 0 si la chaîne passée en
paramètre contient d’autres types de caractères.
• Elle devra être prototypée de la façon suivante :
int ft_str_is_uppercase(char *str);
• Elle devra renvoyer 1 si str est une chaîne vide.
10
Chapitre IX
Exercice 06 : ft_str_is_printable
Exercice : 06
ft_str_is_printable
Dossier de rendu : ex06/
Fichiers à rendre : ft_str_is_printable.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui renvoie 1 si la chaîne passée en paramètre ne contient que
des caractères affichables et renvoie 0 si la chaîne passée en paramètre contient
d’autres types de caractères.
• Elle devra être prototypée de la façon suivante :
int ft_str_is_printable(char *str);
• Elle devra renvoyer 1 si str est une chaîne vide.
11
Chapitre X
Exercice 07 : ft_strupcase
Exercice : 07
ft_strupcase
Dossier de rendu : ex07/
Fichiers à rendre : ft_strupcase.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui met en majuscule chaque lettre.
• Elle devra être prototypée de la façon suivante :
char *ft_strupcase(char *str);
• Elle devra renvoyer str.
12
Chapitre XI
Exercice 08 : ft_strlowcase
Exercice : 08
ft_strlowcase
Dossier de rendu : ex08/
Fichiers à rendre : ft_strlowcase.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui met en minuscule chaque lettre.
• Elle devra être prototypée de la façon suivante :
char *ft_strlowcase(char *str);
• Elle devra renvoyer str.
13
Chapitre XII
Exercice 09 : ft_strcapitalize
Exercice : 09
ft_strcapitalize
Dossier de rendu : ex09/
Fichiers à rendre : ft_strcapitalize.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui met en majuscule la première lettre de chaque mot et le
reste du mot en minuscule.
• Un mot est une suite de caractères alphanumériques.
• Elle devra être prototypée de la façon suivante :
char *ft_strcapitalize(char *str);
• Elle devra renvoyer str.
• Par exemple :
salut, comment tu vas ? 42mots quarante-deux; cinquante+et+un
• Doit donner :
Salut, Comment Tu Vas ? 42mots Quarante-Deux; Cinquante+Et+Un
14
Chapitre XIII
Exercice 10 : ft_strlcpy
Exercice : 10
ft_strlcpy
Dossier de rendu : ex10/
Fichiers à rendre : ft_strlcpy.c
Fonctions Autorisées : Aucune
• Reproduire à l’identique le fonctionnement de la fonction strlcpy (man strlcpy).
• Elle devra être prototypée de la façon suivante :
unsigned int ft_strlcpy(char *dest, char *src, unsigned int size);
15
Chapitre XIV
Exercice 11 :
ft_putstr_non_printable
Exercice : 11
ft_putstr_with_non_printable
Dossier de rendu : ex11/
Fichiers à rendre : ft_putstr_non_printable.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche une chaîne de caractères à l’écran. Si cette chaîne
contient des caractères non-imprimables, ils devront être affichés sous forme hexadécimale
(en minuscules) en les précédant d’un "backslash".
• Par exemple, avec ce paramètre :
Coucou\ntu vas bien ?
• La fonction devra afficher :
Coucou\0atu vas bien ?
• Elle devra être prototypée de la façon suivante :
void ft_putstr_non_printable(char *str);
16
Chapitre XV
Exercice 12 : ft_print_memory
Exercice : 12
ft_print_memory
Dossier de rendu : ex12/
Fichiers à rendre : ft_print_memory.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche une zone mémoire à l’écran.
• L’affichage de la zone mémoire est séparée en trois "colonnes" séparées par un
espace :
◦ L’adresse en hexadécimal du premier caractère de la ligne suivi d’un ’ :’.
◦ Le contenu en hexadécimal avec un espace tous les deux caractères et doit etre
complété avec des espaces si nécessaire (voir l’exemple en dessous).
◦ Le contenu en caractères imprimables.
• Si un caractère est non-imprimable il sera remplacé par un point.
• Chaque ligne doit gérer seize caractères.
• Si size est égale à 0, rien ne sera affiché.
17
Piscine C C 02
• Exemple :
$> ./ft_print_memory
000000010a161f40: 426f 6e6a 6f75 7220 6c65 7320 616d 696e Bonjour les amin
000000010a161f50: 6368 6573 090a 0963 0720 6573 7420 666f ches...c. est fo
000000010a161f60: 7509 746f 7574 0963 6520 7175 206f 6e20 u.tout.ce qu on
000000010a161f70: 7065 7574 2066 6169 7265 2061 7665 6309 peut faire avec.
000000010a161f80: 0a09 7072 696e 745f 6d65 6d6f 7279 0a0a ..print_memory..
000000010a161f90: 0a09 6c6f 6c2e 6c6f 6c0a 2000 ..lol.lol. .
$> ./ft_print_memory | cat -te
0000000107ff9f40: 426f 6e6a 6f75 7220 6c65 7320 616d 696e Bonjour les amin$
0000000107ff9f50: 6368 6573 090a 0963 0720 6573 7420 666f ches...c. est fo$
0000000107ff9f60: 7509 746f 7574 0963 6520 7175 206f 6e20 u.tout.ce qu on $
0000000107ff9f70: 7065 7574 2066 6169 7265 2061 7665 6309 peut faire avec.$
0000000107ff9f80: 0a09 7072 696e 745f 6d65 6d6f 7279 0a0a ..print_memory..$
0000000107ff9f90: 0a09 6c6f 6c2e 6c6f 6c0a 2000 ..lol.lol. .$
$>
• Elle devra être prototypée de la façon suivante :
void *ft_print_memory(void *addr, unsigned int size);
• Elle devra renvoyer addr.
18
Chapitre XVI
Rendu et peer-evaluation
Rendez votre travail sur votre dépot Git comme d’habitude. Seul le travail présent
sur votre dépot sera évalué en soutenance. Vérifiez bien les noms de vos dossiers et de
vos fichiers afin que ces derniers soient conformes aux demandes du sujet.
Vous ne devez rendre uniquement les fichiers demandés par le sujet de
ce projet.
19

23
C03/ex00/ft_strcmp.c Executable file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/09 06:53:45 by fgras-ca #+# #+# */
/* Updated: 2022/12/09 08:31:32 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_strcmp(char *s1, char *s2)
{
int i;
i = 0;
while ((s1[i] == s2[i]) && ((s1[i] != '\0') || (s2[i] != '\0')))
{
i++;
}
return (s1[i] - s2[i]);
}

27
C03/ex01/ft_strncmp.c Executable file
View File

@ -0,0 +1,27 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/09 08:08:10 by fgras-ca #+# #+# */
/* Updated: 2022/12/10 13:40:02 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_strncmp(char *s1, char *s2, unsigned int n)
{
unsigned int i;
i = 0;
if (n == 0)
{
return (0);
}
while (s1[i] == s2[i] && (s1[i] != '\0' || s2[i] != '\0') && i < (n -1))
{
i++;
}
return (s1[i] - s2[i]);
}

39
C03/ex02/ft_strcat.c Executable file
View File

@ -0,0 +1,39 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strcat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/09 09:45:42 by fgras-ca #+# #+# */
/* Updated: 2022/12/10 16:13:32 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_strlen(char *str)
{
int i;
i = 0;
while (str[i])
{
i++;
}
return (i);
}
char *ft_strcat(char *dest, char *src)
{
int i;
int dest_len;
i = 0;
dest_len = ft_strlen(dest);
while (src[i] != '\0')
{
dest[dest_len + i] = src[i];
i++;
}
dest[dest_len + i] = '\0';
return (dest);
}

39
C03/ex03/ft_strncat.c Executable file
View File

@ -0,0 +1,39 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/10 16:23:52 by fgras-ca #+# #+# */
/* Updated: 2022/12/12 18:33:50 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_strlen(char *str)
{
int i;
i = 0;
while (str[i])
{
i++;
}
return (i);
}
char *ft_strncat(char *dest, char *src, unsigned int nb)
{
unsigned int i;
unsigned int dest_len;
i = 0;
dest_len = ft_strlen(dest);
while (src[i] && i < nb)
{
dest[dest_len + i] = src[i];
i++;
}
dest[dest_len + i] = '\0';
return (dest);
}

223
C03/fr.subject.pdf Normal file
View File

@ -0,0 +1,223 @@
Piscine C
C 03
Résumé: Ce document est le sujet du module C 03 de la piscine C de 42.
Version: 3.2
Table des matières
I Consignes 2
II Préambule 4
III Exercice 00 : ft_strcmp 5
IV Exercice 01 : ft_strncmp 6
V Exercice 02 : ft_strcat 7
VI Exercice 03 : ft_strncat 8
VII Exercice 04 : ft_strstr 9
VIII Exercice 05 : ft_strlcat 10
IX Rendu et peer-evaluation 11
1
Chapitre I
Consignes
• Seule cette page servira de référence : ne vous fiez pas aux bruits de couloir.
• Relisez bien le sujet avant de rendre vos exercices. A tout moment le sujet peut
changer.
• Attention aux droits de vos fichiers et de vos répertoires.
• Vous devez suivre la procédure de rendu pour tous vos exercices.
• Vos exercices seront corrigés par vos camarades de piscine.
• En plus de vos camarades, vous serez corrigés par un programme appelé la Moulinette.
• La Moulinette est très stricte dans sa notation. Elle est totalement automatisée. Il
est impossible de discuter de sa note avec elle. Soyez d’une rigueur irréprochable
pour éviter les surprises.
• La Moulinette n’est pas très ouverte d’esprit. Elle ne cherche pas à comprendre le
code qui ne respecte pas la Norme. La Moulinette utilise le programme norminette
pour vérifier la norme de vos fichiers. Comprendre par là qu’il est stupide de rendre
un code qui ne passe pas la norminette.
• Les exercices sont très précisément ordonnés du plus simple au plus complexe.
En aucun cas nous ne porterons attention ni ne prendrons en compte un exercice
complexe si un exercice plus simple n’est pas parfaitement réussi.
• L’utilisation d’une fonction interdite est un cas de triche. Toute triche est sanctionnée
par la note de -42.
• Vous ne devrez rendre une fonction main() que si nous vous demandons un programme.
• La Moulinette compile avec les flags -Wall -Wextra -Werror, et utilise cc.
• Si votre programme ne compile pas, vous aurez 0.
• Vous ne devez laisser dans votre répertoire aucun autre fichier que ceux explicitement
specifiés par les énoncés des exercices.
• Vous avez une question ? Demandez à votre voisin de droite. Sinon, essayez avec
votre voisin de gauche.
2
Piscine C C 03
• Votre manuel de référence s’appelle Google / man / Internet / ....
• Pensez à discuter sur le forum Piscine de votre Intra, ainsi que sur le slack de votre
Piscine !
• Lisez attentivement les exemples. Ils pourraient bien requérir des choses qui ne
sont pas autrement précisées dans le sujet...
• Réfléchissez. Par pitié, par Odin ! Nom d’une pipe.
Pour cette journée, la norminette doit être lancée avec le flag -R
CheckForbiddenSourceHeader. La moulinette l’utilisera aussi.
3
Chapitre II
Préambule
Le livre Wuzazu contient la première mention connue du jeu "Papier-Caillou-Ciseau".
Il a été écrit par l’écrivain de la dynastie Ming Xie Zhaozhi, qui indique alors que ce jeu
date de la dynastie Han (206 BC - 220 AD). Dans le livre, le jeu s’appellait shoushiling. Le
livre Note of Liuyanzhai mentionne également le jeu, l’appelant shoushiling, huozhitou,
or huoquan.
Au travers de l’histoire japonaise, nous retrouverons des reférences fréquentes au jeux
"sansukumi-ken", "ken" signifiant jeu de poing, avec une impasse "sukumi" à trois voies
"san". C’est à lire dans le sens A bat B, B bat C et C bat A. Ce jeu est originaire de
Chine avant d’être importé au Japon et de devenir populaire.
Au début du 20ème siècle, papier caillou ciseaux s’est répandu au delà de l’Asie,
notamment grâce au contact augmenté entre le Jpaon et l’Ouest. Son nom anglais est
alors pris par traduction du nom japonais des gestes utilisés. Dans le reste de l’Asie,
le papier est remplacé par tissu. La forme des ciseaux est également adoptée du style
japonais.
En 1927, "La vie au patronage", un magazine pour en enfants en France, le décrivait
en détail, et le considérant comme un "jeu japonais" Son nom français alternatif ("chi-
fou-mi"), est basé sur les anciens mots japonais pour "un, deux, trois" ("hi, fu, mi").
Un article du New York Times de 1932 explique les règles pour les lecteurs américains,
indiquant que le jeu n’était alors pas très répandu. L’édition de 1933 du magazine
"Compton’s Pictured Encyclopedia" le décrivait comme un moyen commun de résolution
des conflits entre enfants lors de son article sur le Japon : "This is such a good way of
deciding an argument that American boys and girls might like to practice it too.”
4
Chapitre III
Exercice 00 : ft_strcmp
Exercice : 00
ft_strcmp
Dossier de rendu : ex00/
Fichiers à rendre : ft_strcmp.c
Fonctions Autorisées : Aucune
• Reproduire à l’identique le fonctionnement de la fonction strcmp (man strcmp).
• Elle devra être prototypée de la façon suivante :
int ft_strcmp(char *s1, char *s2);
5
Chapitre IV
Exercice 01 : ft_strncmp
Exercice : 01
ft_strncmp
Dossier de rendu : ex01/
Fichiers à rendre : ft_strncmp.c
Fonctions Autorisées : Aucune
• Reproduire à l’identique le fonctionnement de la fonction strncmp (man strncmp).
• Elle devra être prototypée de la façon suivante :
int ft_strncmp(char *s1, char *s2, unsigned int n);
6
Chapitre V
Exercice 02 : ft_strcat
Exercice : 02
ft_strcat
Dossier de rendu : ex02/
Fichiers à rendre : ft_strcat.c
Fonctions Autorisées : Aucune
• Reproduire à l’identique le fonctionnement de la fonction strcat (man strcat).
• Elle devra être prototypée de la façon suivante :
char *ft_strcat(char *dest, char *src);
7
Chapitre VI
Exercice 03 : ft_strncat
Exercice : 03
ft_strncat
Dossier de rendu : ex03/
Fichiers à rendre : ft_strncat.c
Fonctions Autorisées : Aucune
• Reproduire à l’identique le fonctionnement de la fonction strncat (man strncat).
• Elle devra être prototypée de la façon suivante :
char *ft_strncat(char *dest, char *src, unsigned int nb);
8
Chapitre VII
Exercice 04 : ft_strstr
Exercice : 04
ft_strstr
Dossier de rendu : ex04/
Fichiers à rendre : ft_strstr.c
Fonctions Autorisées : Aucune
• Reproduire à l’identique le fonctionnement de la fonction strstr (man strstr).
• Elle devra être prototypée de la façon suivante :
char *ft_strstr(char *str, char *to_find);
9
Chapitre VIII
Exercice 05 : ft_strlcat
Exercice : 05
ft_strlcat
Dossier de rendu : ex05/
Fichiers à rendre : ft_strlcat.c
Fonctions Autorisées : Aucune
• Reproduire à l’identique le fonctionnement de la fonction strlcat (man strlcat).
• Elle devra être prototypée de la façon suivante :
unsigned int ft_strlcat(char *dest, char *src, unsigned int size);
10
Chapitre IX
Rendu et peer-evaluation
Rendez votre travail sur votre dépot Git comme d’habitude. Seul le travail présent
sur votre dépot sera évalué en soutenance. Vérifiez bien les noms de vos dossiers et de
vos fichiers afin que ces derniers soient conformes aux demandes du sujet.
Vous ne devez rendre uniquement les fichiers demandés par le sujet de
ce projet.
11

21
C04/ex00/ft_strlen.c Executable file
View File

@ -0,0 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/11 13:04:29 by fgras-ca #+# #+# */
/* Updated: 2022/12/11 13:06:17 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_strlen(char *str)
{
int i;
i = 0;
while (str[i])
i++;
return (i);
}

25
C04/ex01/ft_putstr.c Executable file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putstr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/11 13:08:32 by fgras-ca #+# #+# */
/* Updated: 2022/12/13 11:22:07 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putstr(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
write(1, &str[i], 1);
i++;
}
}

40
C04/ex02/ft_putnbr.c Executable file
View File

@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/11 14:02:07 by fgras-ca #+# #+# */
/* Updated: 2022/12/11 17:23:13 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar(char c)
{
write(1, &c, 1);
}
void ft_putnbr(int nb)
{
if (nb == -2147483648)
{
write(1, "-2147483648", 11);
}
else if (nb >= 0 && nb < 10)
{
ft_putchar(nb + 48);
}
else if (nb < 0)
{
ft_putchar('-');
ft_putnbr(nb * (-1));
}
else
{
ft_putnbr (nb / 10);
ft_putnbr (nb % 10);
}
}

36
C04/ex03/ft_atoi.c Executable file
View File

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_atoi.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/13 10:11:50 by fgras-ca #+# #+# */
/* Updated: 2022/12/13 11:01:40 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_atoi(char *str)
{
int res;
int sign;
int i;
i = 0;
res = 0;
sign = 1;
while (str[i] == 32 || (str[i] >= 9 && str[i] <= 13))
i++;
while (str[i] == '-' || str[i] == '+')
{
if (str[i] == '-')
sign *= (-1);
i++;
}
while (str[i] >= '0' && str[i] <= '9')
{
res = res * 10 + str[i] - '0';
i++;
}
return (res * sign);
}

305
C04/fr.subject.pdf Normal file
View File

@ -0,0 +1,305 @@
Piscine C
C 04
Résumé: ce document est le sujet du module C 04 de la piscine C de 42.
Version: 4.2
Table des matières
I Consignes 2
II Préambule 4
III Exercice 00 : ft_strlen 5
IV Exercice 01 : ft_putstr 6
V Exercice 02 : ft_putnbr 7
VI Exercice 03 : ft_atoi 8
VII Exercice 04 : ft_putnbr_base 9
VIII Exercice 05 : ft_atoi_base 10
IX Rendu et peer-evaluation 11
1
Chapitre I
Consignes
• Seule cette page servira de référence : ne vous fiez pas aux bruits de couloir.
• Relisez bien le sujet avant de rendre vos exercices. A tout moment le sujet peut
changer.
• Attention aux droits de vos fichiers et de vos répertoires.
• Vous devez suivre la procédure de rendu pour tous vos exercices.
• Vos exercices seront corrigés par vos camarades de piscine.
• En plus de vos camarades, vous serez corrigés par un programme appelé la Moulinette.
• La Moulinette est très stricte dans sa notation. Elle est totalement automatisée. Il
est impossible de discuter de sa note avec elle. Soyez d’une rigueur irréprochable
pour éviter les surprises.
• La Moulinette n’est pas très ouverte d’esprit. Elle ne cherche pas à comprendre le
code qui ne respecte pas la Norme. La Moulinette utilise le programme norminette
pour vérifier la norme de vos fichiers. Comprendre par là qu’il est stupide de rendre
un code qui ne passe pas la norminette.
• Les exercices sont très précisément ordonnés du plus simple au plus complexe.
En aucun cas nous ne porterons attention ni ne prendrons en compte un exercice
complexe si un exercice plus simple n’est pas parfaitement réussi.
• L’utilisation d’une fonction interdite est un cas de triche. Toute triche est sanctionnée
par la note de -42.
• Vous ne devrez rendre une fonction main() que si nous vous demandons un programme.
• La Moulinette compile avec les flags -Wall -Wextra -Werror, et utilise cc.
• Si votre programme ne compile pas, vous aurez 0.
• Vous ne devez laisser dans votre répertoire aucun autre fichier que ceux explicitement
specifiés par les énoncés des exercices.
• Vous avez une question ? Demandez à votre voisin de droite. Sinon, essayez avec
votre voisin de gauche.
2
Piscine C C 04
• Votre manuel de référence s’appelle Google / man / Internet / ....
• Pensez à discuter sur le forum Piscine de votre Intra, ainsi que sur le slack de votre
Piscine !
• Lisez attentivement les exemples. Ils pourraient bien requérir des choses qui ne
sont pas autrement précisées dans le sujet...
• Réfléchissez. Par pitié, par Odin ! Nom d’une pipe.
Pour cette journée, la norminette doit être lancée avec le flag -R
CheckForbiddenSourceHeader. La moulinette l’utilisera aussi.
3
Chapitre II
Préambule
Voici les paroles du générique de Nicky Larson :
Une ombre file dans la nuit
C’est un assassin qui s’enfuit
Et comme un démon il sourit
Son crime restera impuni
Une voiture qui surgit
Un coup de frein, des pneus qui crient
Un coup de feu qui retentit
La justice s’appelle Nicky
[Refrain]
Dans la chaleur
De la nuit
Le mal est toujours puni
Aucun danger ne l’impressionne
Les coups durs il les affectionne
Et la justice le passionne
Nicky Larson ne craint personne
Lorsque les coups de feu résonnent
Comme un eclair il tourbillone
Surtout si la fille est mignonne
Nicky Larson ne craint personne
Comme un chasseur il suit sa proie
Pour que la justice et le droit
Triomphent, il est prêt à donner
Toute sa vie sans hésiter
Quand sa silhouette apparaît
Les méchants se mettent à trembler
Ils savent qu’ils ne pourront jamais
Echapper à ce justicier
[Refrain]
Ce sujet n’a, malheureusement, rien à voir avec Nicky Larson.
4
Chapitre III
Exercice 00 : ft_strlen
Exercice : 00
ft_strlen
Dossier de rendu : ex00/
Fichiers à rendre : ft_strlen.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui compte le nombre de caractères dans une chaîne de caractères
et qui retourne le nombre trouvé.
• Elle devra être prototypée de la façon suivante :
int ft_strlen(char *str);
5
Chapitre IV
Exercice 01 : ft_putstr
Exercice : 01
ft_putstr
Dossier de rendu : ex01/
Fichiers à rendre : ft_putstr.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche un à un les caractères d’une chaîne à l’écran.
• L’adresse du premier caractère de la chaîne est contenue dans le pointeur passé en
paramètre à la fonction.
• Elle devra être prototypée de la façon suivante :
void ft_putstr(char *str);
6
Chapitre V
Exercice 02 : ft_putnbr
Exercice : 02
ft_putnbr
Dossier de rendu : ex02/
Fichiers à rendre : ft_putnbr.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche un nombre passé en paramètre. La fonction devra
être capable d’afficher la totalité des valeurs possibles dans une variable de type
int.
• Elle devra être prototypée de la façon suivante :
void ft_putnbr(int nb);
• Par exemple :
◦ ft_putnbr(42) affiche "42".
7
Chapitre VI
Exercice 03 : ft_atoi
Exercice : 03
ft_atoi
Dossier de rendu : ex03/
Fichiers à rendre : ft_atoi.c
Fonctions Autorisées : Aucune
• Ecrire une fonction qui convertit le début de la chaîne pointée par str en entier de type
int
• str peut commencer par un nombre arbitraire de ‘white space‘ (comme defini par isspace(3))
• str peut ensuite être suivi par un nombre arbitraire de signe + et de signe -. Le signe -
fera changer le signe de l’entier retourné en fonction du nombre de signe - et si celui ci
est pair ou impair.
• Pour finir str devra être composée de chiffre de la base 10
• Votre fonction devra lire str tant que celle ci suit les règles au dessus et elle doit retourner
le nombre trouvé jusque là.
• Vous ne devriez pas prendre en compte les overflows et les underflows, le résultat est
considérer comme indéfini dans ces cas.
• Vous pouvez comparer votre fonction avec la vrai fonction atoi à part la partie sur les
signes ainsi que l’overflow.
• Voici l’exemple d’un programme qui affiche la valeur de retour de atoi :
$>./a.out " ---+--+1234ab567"
-1234
• Elle devra être prototypée de la façon suivante :
int ft_atoi(char *str);
8
Chapitre VII
Exercice 04 : ft_putnbr_base
Exercice : 04
ft_putnbr_base
Dossier de rendu : ex04/
Fichiers à rendre : ft_putnbr_base.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche un nombre dans le terminal dans une base donnée.
• Ce nombre est fourni sous la forme d’un int et la base sous la forme d’une chaîne
de caractères.
• La base contient tous les symboles utilisables pour afficher le nombre :
◦ 0123456789 est la base couramment utilisée pour représenter nos nombres
décimaux ;
◦ 01 est une base binaire ;
◦ 0123456789ABCDEF est une base hexadecimale ;
◦ poneyvif est une base octale.
• La fonction doit gérer les nombres négatifs.
• Si un paramètre contient une erreur la fonction n’affiche rien. Une erreur peut
être :
◦ base est vide ou est de taille 1 ;
◦ base contient deux fois le même caractère ;
◦ base contient les caractères + ou -.
• Elle devra être prototypée de la façon suivante :
void ft_putnbr_base(int nbr, char *base);
9
Chapitre VIII
Exercice 05 : ft_atoi_base
Exercice : 05
ft_atoi_base
Dossier de rendu : ex05/
Fichiers à rendre : ft_atoi_base.c
Fonctions Autorisées : Aucune
• Ecrire une fonction qui convertit le début de la chaîne pointée par str en entier de
type int.
• str est dans une base specifique passée en second argument de la fonction.
• A part le système de base, cette fonction doit reproduire le comportement de
ft_atoi.
• Si un paramètre contient une erreur la fonction renvoie 0. Une erreur peut être :
◦ la base est vide ou est de taille 1 ;
◦ la base contient deux fois le même caractère ;
◦ la base contient les caractères + ou - ou des whitespaces ;
• Elle devra être prototypée de la façon suivante :
int ft_atoi_base(char *str, char *base);
10
Chapitre IX
Rendu et peer-evaluation
Rendez votre travail sur votre dépot Git comme d’habitude. Seul le travail présent
sur votre dépot sera évalué en soutenance. Vérifiez bien les noms de vos dossiers et de
vos fichiers afin que ces derniers soient conformes aux demandes du sujet.
Vous ne devez rendre uniquement les fichiers demandés par le sujet de
ce projet.
11

32
C05/ex00/ft_iterative_factorial.c Executable file
View File

@ -0,0 +1,32 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_iterative_factorial.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/12 09:44:26 by fgras-ca #+# #+# */
/* Updated: 2022/12/12 11:00:06 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_iterative_factorial(int nb)
{
int resultat;
resultat = 1;
if (nb == 0)
{
return (1);
}
while (nb > 0)
{
resultat *= nb;
nb--;
}
if (nb < 0)
{
return (0);
}
return (resultat);
}

20
C05/ex01/ft_recursive_factorial.c Executable file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_recursive_factorial.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/12 11:02:42 by fgras-ca #+# #+# */
/* Updated: 2022/12/12 11:17:18 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_recursive_factorial(int nb)
{
if (nb < 0)
return (0);
if (nb == 0)
return (1);
return (nb * ft_recursive_factorial(nb - 1));
}

36
C05/ex02/ft_iterative_power.c Executable file
View File

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_iterative_power.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/12 11:42:46 by fgras-ca #+# #+# */
/* Updated: 2022/12/12 12:13:42 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_iterative_power(int nb, int power)
{
int resultat;
int i;
i = 0;
resultat = 1;
if (power == 0)
return (1);
if (nb == 0 && power == 0)
{
return (1);
}
if (power < 0)
{
return (0);
}
while (i < power)
{
resultat *= nb;
i++;
}
return (resultat);
}

25
C05/ex03/ft_recursive_power.c Executable file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_recursive_power.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/12 12:17:25 by fgras-ca #+# #+# */
/* Updated: 2022/12/12 13:20:33 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_recursive_power(int nb, int power)
{
if (nb == 0 && power == 0)
return (1);
if (power < 0)
return (0);
if (power == 0)
return (1);
else if (power == 1)
return (nb);
else
return (nb * ft_recursive_power(nb, power -1));
}

20
C05/ex04/ft_fibonacci.c Executable file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_fibonacci.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/12 13:26:04 by fgras-ca #+# #+# */
/* Updated: 2022/12/12 14:22:37 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_fibonacci(int index)
{
if (index < 0)
return (-1);
if (index == 0 || index == 1)
return (index);
return (ft_fibonacci(index - 1) + ft_fibonacci(index - 2));
}

35
C05/ex05/ft_sqrt.c Executable file
View File

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_sqrt.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/12 16:05:20 by fgras-ca #+# #+# */
/* Updated: 2022/12/14 15:58:40 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_sqrt(int nb)
{
int i;
if (nb < 0)
{
return (0);
}
if (nb == 1)
{
return (1);
}
i = 1;
while (i < nb / i && i < 46341)
{
i++;
}
if (i * i == nb)
{
return (i);
}
return (0);
}

30
C05/ex06/ft_is_prime.c Executable file
View File

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_is_prime.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/12 18:55:02 by fgras-ca #+# #+# */
/* Updated: 2022/12/13 13:38:38 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
int ft_is_prime(int nb)
{
int i;
i = 2;
if (nb <= 1)
return (0);
while (i <= nb / 2)
{
if (nb % i == 0)
{
return (0);
}
else
i++;
}
return (1);
}

342
C05/fr.subject.pdf Normal file
View File

@ -0,0 +1,342 @@
Piscine C
C 05
Résumé: ce document est le sujet du module C 05 de la piscine C de 42.
Version: 6.3
Table des matières
I Consignes 2
II Préambule 4
III Exercice 00 : ft_iterative_factorial 6
IV Exercice 01 : ft_recursive_factorial 7
V Exercice 02 : ft_iterative_power 8
VI Exercice 03 : ft_recursive_power 9
VII Exercice 04 : ft_fibonacci 10
VIII Exercice 05 : ft_sqrt 11
IX Exercice 06 : ft_is_prime 12
X Exercice 07 : ft_find_next_prime 13
XI Exercice 08 : Les dix dames 14
XII Rendu et peer-evaluation 15
1
Chapitre I
Consignes
• Seule cette page servira de référence : ne vous fiez pas aux bruits de couloir.
• Relisez bien le sujet avant de rendre vos exercices. A tout moment le sujet peut
changer.
• Attention aux droits de vos fichiers et de vos répertoires.
• Vous devez suivre la procédure de rendu pour tous vos exercices.
• Vos exercices seront corrigés par vos camarades de piscine.
• En plus de vos camarades, vous serez corrigés par un programme appelé la Moulinette.
• La Moulinette est très stricte dans sa notation. Elle est totalement automatisée. Il
est impossible de discuter de sa note avec elle. Soyez d’une rigueur irréprochable
pour éviter les surprises.
• La Moulinette n’est pas très ouverte d’esprit. Elle ne cherche pas à comprendre le
code qui ne respecte pas la Norme. La Moulinette utilise le programme norminette
pour vérifier la norme de vos fichiers. Comprendre par là qu’il est stupide de rendre
un code qui ne passe pas la norminette.
• Les exercices sont très précisément ordonnés du plus simple au plus complexe.
En aucun cas nous ne porterons attention ni ne prendrons en compte un exercice
complexe si un exercice plus simple n’est pas parfaitement réussi.
• L’utilisation d’une fonction interdite est un cas de triche. Toute triche est sanctionnée
par la note de -42.
• Vous ne devrez rendre une fonction main() que si nous vous demandons un programme.
• La Moulinette compile avec les flags -Wall -Wextra -Werror, et utilise cc.
• Si votre programme ne compile pas, vous aurez 0.
• Vous ne devez laisser dans votre répertoire aucun autre fichier que ceux explicitement
specifiés par les énoncés des exercices.
• Vous avez une question ? Demandez à votre voisin de droite. Sinon, essayez avec
votre voisin de gauche.
2
Piscine C C 05
• Votre manuel de référence s’appelle Google / man / Internet / ....
• Pensez à discuter sur le forum Piscine de votre Intra, ainsi que sur le slack de votre
Piscine !
• Lisez attentivement les exemples. Ils pourraient bien requérir des choses qui ne
sont pas autrement précisées dans le sujet...
• Réfléchissez. Par pitié, par Odin ! Nom d’une pipe.
Pour cette journée, la norminette doit être lancée avec le flag -R
CheckForbiddenSourceHeader. La moulinette l’utilisera aussi.
3
Chapitre II
Préambule
Voici des paroles extraite du premier livre de la saga Harry Potter :
Je n’suis pas d’une beauté suprême
Mais faut pas s’fier à ce qu’on voit
Je veux bien me manger moi-même
Si vous trouvez plus malin qu’moi.
Les hauts-d’forme, les chapeaux splendides,
Font pâl’figure auprès de moi
Car à Poudlard, quand je décide,
Chacun se soumet à mon choix.
Rien ne m’échapp’ rien ne m’arrête
Le Choixpeau a toujours raison
Mettez-moi donc sur votre tête
Pour connaitre votre maison.
Si vous allez à Gryffondor
Vous rejoindrez les courageux,
Les plus hardis et les plus forts
Sont rassemblés en ce haut lieu.
Si à Poufsouffle vous allez,
Comme eux vous s’rez juste et loyal
Ceux de Poufsouffle aiment travailler
Et leur patience est proverbiale.
Si vous êtes sage et réfléchi
Serdaigle vous accueillera peut-être
Là-bas, ce sont des érudits
Qui ont envie de tout connaître.
Vous finirez à Serpentard
Si vous êtes plutôt malin,
Car ceux-là sont de vrais roublards
Qui parviennent toujours à leurs fins.
4
Piscine C C 05
Sur ta tête pose-moi un instant
Et n’aie pas peur, reste serein
Tu seras en de bonnes mains
Car je suis un chapeau pensant !
Ce sujet n’a, malheureusement, rien à voir avec la série Harry Potter, et c’est dommage,
parce que votre rendu ne sera pas fait par magie.
5
Chapitre III
Exercice 00 : ft_iterative_factorial
Exercice : 00
ft_iterative_factorial
Dossier de rendu : ex00/
Fichiers à rendre : ft_iterative_factorial.c
Fonctions Autorisées : Aucune
• Écrire une fonction itérative qui renvoie un nombre. Ce nombre est le résultat de
l’opération factorielle à partir du nombre passé en paramètre.
• Si l’argument n’est pas valide, la fonction doit renvoyer 0.
• Il ne faut pas gerer les "int overflow", le retour de la fonction sera indefini.
• Elle devra être prototypée de la façon suivante :
int ft_iterative_factorial(int nb);
6
Chapitre IV
Exercice 01 : ft_recursive_factorial
Exercice : 01
ft_recursive_factorial
Dossier de rendu : ex01/
Fichiers à rendre : ft_recursive_factorial.c
Fonctions Autorisées : Aucune
• Écrire une fonction récursive qui renvoie la factorielle du nombre passé en paramètre.
• Si l’argument n’est pas valide, la fonction doit renvoyer 0.
• Il ne faut pas gerer les "int overflow", le retour de la fonction sera indefini.
• Elle devra être prototypée de la façon suivante :
int ft_recursive_factorial(int nb);
7
Chapitre V
Exercice 02 : ft_iterative_power
Exercice : 02
ft_iterative_power
Dossier de rendu : ex02/
Fichiers à rendre : ft_iterative_power.c
Fonctions Autorisées : Aucune
• Écrire une fonction itérative qui renvoie une puissance d’un nombre. Une puissance
inferieur à 0 renverra 0.
• Comme il n’y a pas de concensus sur 0 puissance 0, nous considererons que le
resultat sera 1.
• Il ne faut pas gerer les "int overflow", le retour de la fonction sera indefini.
• Elle devra être prototypée de la façon suivante :
int ft_iterative_power(int nb, int power);
8
Chapitre VI
Exercice 03 : ft_recursive_power
Exercice : 03
ft_recursive_power
Dossier de rendu : ex03/
Fichiers à rendre : ft_recursive_power.c
Fonctions Autorisées : Aucune
• Écrire une fonction récursive qui renvoie une puissance d’un nombre.
• Comme il n’y a pas de concensus sur 0 puissance 0, nous considererons que le
resultat sera 1.
• Il ne faut pas gerer les "int overflow", le retour de la fonction sera indefini.
• Elle devra être prototypée de la façon suivante :
int ft_recursive_power(int nb, int power);
9
Chapitre VII
Exercice 04 : ft_fibonacci
Exercice : 04
ft_fibonacci
Dossier de rendu : ex04/
Fichiers à rendre : ft_fibonacci.c
Fonctions Autorisées : Aucune
• Écrire une fonction ft_fibonacci qui renvoie le n-ième élément de la suite de
Fibonacci, le premier élément étant à l’index 0. Nous considererons que la suite de
Fibonacci commence par 0, 1, 1, 2.
• Les overflows ne devront pas être gerés.
• Elle devra être prototypée de la façon suivante :
int ft_fibonacci(int index);
• Évidemment, ft_fibonacci devra être récursive.
• Si index est inférieur à 0, la fonction renverra -1.
10
Chapitre VIII
Exercice 05 : ft_sqrt
Exercice : 05
ft_sqrt
Dossier de rendu : ex05/
Fichiers à rendre : ft_sqrt.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui renvoie la racine carrée entière d’un nombre si elle existe,
0 si la racine carrée n’est pas entière.
• Elle devra être prototypée de la façon suivante :
int ft_sqrt(int nb);
11
Chapitre IX
Exercice 06 : ft_is_prime
Exercice : 06
ft_is_prime
Dossier de rendu : ex06/
Fichiers à rendre : ft_is_prime.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui renvoie 1 si le nombre est premier et 0 si le nombre ne l’est
pas.
• Elle devra être prototypée de la façon suivante :
int ft_is_prime(int nb);
0 et 1 ne sont pas des nombres premiers.
12
Chapitre X
Exercice 07 : ft_find_next_prime
Exercice : 07
ft_find_next_prime
Dossier de rendu : ex07/
Fichiers à rendre : ft_find_next_prime.c
Fonctions Autorisées : Aucune
• Écrire une fonction qui renvoie le nombre premier immédiatement supérieur ou
égal au nombre passé en paramètre.
• Elle devra être prototypée de la façon suivante :
int ft_find_next_prime(int nb);
13
Chapitre XI
Exercice 08 : Les dix dames
Exercice : 08
Les dix dames
Dossier de rendu : ex08/
Fichiers à rendre : ft_ten_queens_puzzle.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche toutes les possibilités de placer dix dames sur un
échiquier de 10x10 sans qu’elles ne puissent s’atteindre en un seul coup.
• La recursivité devra être utilisée.
• La valeur de retour de votre fonction devra être le nombre de solutions affichées
• Elle devra être prototypée de la façon suivante :
int ft_ten_queens_puzzle(void);
• L’affichage se fera de la façon suivante :
$>./a.out | cat -e
0257948136$
0258693147$
...
4605713829$
4609582731$
...
9742051863$
$>
• La suite se lit de gauche à droite. Le premier chiffre correspond à la position de
la première dame dans la première colonne (l’index commençant à 0). Le énième
chiffre correspond à la position de la énième dame dans la énième colonne.
14
Chapitre XII
Rendu et peer-evaluation
Rendez votre travail sur votre dépot Git comme d’habitude. Seul le travail présent
sur votre dépot sera évalué en soutenance. Vérifiez bien les noms de vos dossiers et de
vos fichiers afin que ces derniers soient conformes aux demandes du sujet.
Vous ne devez rendre uniquement les fichiers demandés par le sujet de
ce projet.
15

39
C06/ex00/ft_print_program_name.c Executable file
View File

@ -0,0 +1,39 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_print_program_name.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/13 14:01:59 by fgras-ca #+# #+# */
/* Updated: 2022/12/13 14:56:15 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar(char c)
{
write(1, &c, 1);
}
void ft_putstr(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
write(1, &str[i], 1);
i++;
}
}
int main(int argc, char **argv)
{
if (argc > 0)
{
ft_putstr(argv[0]);
ft_putchar('\n');
}
}

46
C06/ex01/ft_print_params.c Executable file
View File

@ -0,0 +1,46 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_print_params.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/13 14:01:59 by fgras-ca #+# #+# */
/* Updated: 2022/12/13 15:39:06 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar(char c)
{
write(1, &c, 1);
}
void ft_putstr(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
write(1, &str[i], 1);
i++;
}
}
int main(int argc, char **argv)
{
int i;
i = 1;
while (argv[i])
{
if (argc > 1)
{
ft_putstr(argv[i]);
ft_putchar('\n');
i++;
}
}
}

43
C06/ex02/ft_rev_params.c Executable file
View File

@ -0,0 +1,43 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_rev_params.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/13 14:01:59 by fgras-ca #+# #+# */
/* Updated: 2022/12/13 16:48:28 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar(char c)
{
write(1, &c, 1);
}
void ft_putstr(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
write(1, &str[i], 1);
i++;
}
}
int main(int argc, char **argv)
{
int i;
i = argc -1;
while (i > 0)
{
ft_putstr(argv[i]);
ft_putchar('\n');
i--;
}
}

69
C06/ex03/ft_sort_params.c Executable file
View File

@ -0,0 +1,69 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_sort_params.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/13 16:50:23 by fgras-ca #+# #+# */
/* Updated: 2022/12/14 09:36:30 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_putchar(char c)
{
write(1, &c, 1);
}
void ft_putstr(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
write(1, &str[i], 1);
i++;
}
}
int ft_strcmp(char *s1, char *s2)
{
int i;
i = 0;
while ((s1[i] == s2[i]) && ((s1[i] != '\0') || (s2[i] != '\0')))
{
i++;
}
return (s1[i] - s2[i]);
}
int main(int argc, char **argv)
{
int i;
char *swap;
i = 1;
while (i < argc -1)
{
if (ft_strcmp(argv[i], argv[i + 1]) > 0)
{
swap = argv[i];
argv[i] = argv[i + 1];
argv[i +1] = swap;
i = 0;
}
i++;
}
i = 1;
while (i < argc)
{
ft_putstr(argv[i]);
ft_putchar('\n');
i++;
}
return (0);
}

218
C06/fr.subject.pdf Normal file
View File

@ -0,0 +1,218 @@
Piscine C
C 06
Staff 42 pedago@42.fr
Résumé: Ce document est le sujet du module C 06 de la piscine C de 42.
Version: 7.3
Table des matières
I Consignes 2
II Préambule 4
III Exercice 00 : ft_print_program_name 5
IV Exercice 01 : ft_print_params 6
V Exercice 02 : ft_rev_params 7
VI Exercice 03 : ft_sort_params 8
VII Rendu et peer-evaluation 9
1
Chapitre I
Consignes
• Seule cette page servira de référence : ne vous fiez pas aux bruits de couloir.
• Relisez bien le sujet avant de rendre vos exercices. A tout moment le sujet peut
changer.
• Attention aux droits de vos fichiers et de vos répertoires.
• Vous devez suivre la procédure de rendu pour tous vos exercices.
• Vos exercices seront corrigés par vos camarades de piscine.
• En plus de vos camarades, vous serez corrigés par un programme appelé la Mou-
linette.
• La Moulinette est très stricte dans sa notation. Elle est totalement automatisée. Il
est impossible de discuter de sa note avec elle. Soyez d’une rigueur irréprochable
pour éviter les surprises.
• La Moulinette n’est pas très ouverte d’esprit. Elle ne cherche pas à comprendre le
code qui ne respecte pas la Norme. La Moulinette utilise le programme norminette
pour vérifier la norme de vos fichiers. Comprendre par là qu’il est stupide de rendre
un code qui ne passe pas la norminette.
• Les exercices sont très précisément ordonnés du plus simple au plus complexe.
En aucun cas nous ne porterons attention ni ne prendrons en compte un exercice
complexe si un exercice plus simple n’est pas parfaitement réussi.
• L’utilisation d’une fonction interdite est un cas de triche. Toute triche est sanc-
tionnée par la note de -42.
• Vous ne devrez rendre une fonction main() que si nous vous demandons un programme.
• La Moulinette compile avec les flags -Wall -Wextra -Werror, et utilise cc.
• Si votre programme ne compile pas, vous aurez 0.
• Vous ne devez laisser dans votre répertoire aucun autre fichier que ceux explicite-
ment specifiés par les énoncés des exercices.
• Vous avez une question ? Demandez à votre voisin de droite. Sinon, essayez avec
2
Piscine C C 06
votre voisin de gauche.
• Votre manuel de référence s’appelle Google / man / Internet / ....
• Pensez à discuter sur le forum Piscine de votre Intra, ainsi que sur le slack de votre
Piscine !
• Lisez attentivement les exemples. Ils pourraient bien requérir des choses qui ne
sont pas autrement précisées dans le sujet...
• Réfléchissez. Par pitié, par Odin ! Nom d’une pipe.
Pour cette journée, la norminette doit être lancée avec le flag -R
CheckForbiddenSourceHeader. La moulinette l’utilisera aussi.
3
Chapitre II
Préambule
Dialogue issue du film The Big Lebowski :
Walter : Excuse-moi Smokey, t’as mordu la ligne : y’a faute.
Smokey : Mon cul ! Tu me mets huit, Duc...
Walter : Je te demande pardon, mets lui zéro, jeu suivant.
Smokey : Tu fais chier Walter, tu me mets huit Duc...
Walter : Smokey on est pas au Viet-nâm, on est au bowling, on joue
selon les règles...
Le Duc : Allez, déconne pas Walter, on est là merde : son pied a légèrement
mordu, il a un peu glissé... C’est qu’un sport, là !
Walter : Oui. Et il est homologué, c’est une partie qui compte pour le tournoi,
j’ai pas raison ?
Smokey : Ouais, mais j’ai pas...
Walter : J’ai pas raison ?
Smokey : Ouais, mais j’ai pas mordu... Allez ! Vas-y Duc, mets moi un huit.
Walter : [Sort son flingue] Smokey mon ami, si t’as jamais souffert,
tu vas comprendre...
Le Duc : Walter, fais pas le con !
Walter : [Menaçant] Vas-y, mets-toi un huit et tu vas comprendre !
Smokey : J’ai pas m...
Walter : Tu vas comprendre ta douleur, Smokey !
Smokey : Duc ? C’est ton partenaire...
Walter : Le monde est en train de DEVENIR CINGLÉ ! [Se lève] Y’A PERSONNE ICI À
PART MOI QUI SE SOUCIE ENCORE DE RESPECTER LES RÈGLES ? METS-TOI ZÉRO !
Le Duc : Ils sont en train d’appeler les flics Walter remets ça dans...
Walter : [Braque son flingue sur Smokey] METS-TOI ZÉRO !
Le Duc : Range ca Walter...
Smokey : ...
Le Duc : Walter...
Walter : [Arme son flingue] TU CROIS PEUT-ÊTRE QUE JE PLAISANTE ?
METS-TOI ZÉRO!
Smokey : Voila, je me suis mis zéro... T’es content ? Espèce de malade !
Walter : [Se calme] ... C’est un sport homologué.
4
Chapitre III
Exercice 00 :
ft_print_program_name
Exercice : 00
ft_print_program_name
Dossier de rendu : ex00/
Fichiers à rendre : ft_print_program_name.c
Fonctions Autorisées : write
• Il s’agit ici d’un programme, vous devrez donc avoir une fonction main dans votre
fichier.c.
• Écrire un programme qui affiche le nom du programme, suivi d’une nouvelle ligne..
• Exemple :
$>./a.out
./a.out$
$>
5
Chapitre IV
Exercice 01 : ft_print_params
Exercice : 01
ft_print_params
Dossier de rendu : ex01/
Fichiers à rendre : ft_print_params.c
Fonctions Autorisées : write
• Il s’agit ici d’un programme, vous devrez donc avoir une fonction main dans votre
fichier.c.
• Écrire un programme qui affiche les arguments reçus en ligne de commande.
• Un par ligne dans le même ordre que la ligne de commande
• Vous devez afficher tous les arguments, sauf argv[0].
• Exemple :
$>./a.out test1 test2 test3
test1
test2
test3
$>
6
Chapitre V
Exercice 02 : ft_rev_params
Exercice : 02
ft_rev_params
Dossier de rendu : ex02/
Fichiers à rendre : ft_rev_params.c
Fonctions Autorisées : write
• Il s’agit ici d’un programme, vous devrez donc avoir une fonction main dans votre
fichier.c.
• Écrire un programme qui affiche les arguments reçus en ligne de commande.
• Un par ligne dans l’ordre inverse de la ligne de commande.
• Vous devez afficher tous les arguments, sauf argv[0].
7
Chapitre VI
Exercice 03 : ft_sort_params
Exercice : 03
ft_sort_params
Dossier de rendu : ex03/
Fichiers à rendre : ft_sort_params.c
Fonctions Autorisées : write
• Il s’agit ici d’un programme, vous devrez donc avoir une fonction main dans votre
fichier.c.
• Écrire un programme qui affiche les arguments reçus en ligne de commande triés
par ordre ascii.
• Vous devez afficher tous les arguments, sauf argv[0].
• Un argument par ligne.
8
Chapitre VII
Rendu et peer-evaluation
Rendez votre travail sur votre dépot Git comme d’habitude. Seul le travail présent
sur votre dépot sera évalué en soutenance. Vérifiez bien les noms de vos dossiers et de
vos fichiers afin que ces derniers soient conformes aux demandes du sujet.
Vous ne devez rendre uniquement les fichiers demandés par le sujet de
ce projet.
9

43
C07/ex00/ft_strdup.c Executable file
View File

@ -0,0 +1,43 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strdup.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/14 13:53:46 by fgras-ca #+# #+# */
/* Updated: 2022/12/18 08:21:14 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
int ft_strlen(char *str)
{
int i;
i = 0;
while (str[i])
i++;
return (i);
}
char *ft_strdup(char *src)
{
char *copy;
int i;
i = 0;
copy = (char *) malloc(sizeof(char) * (ft_strlen(src) + 1));
if (copy == 0)
{
return (0);
}
while (src [i])
{
copy[i] = src[i];
i++;
}
copy[i] = '\0';
return (copy);
}

36
C07/ex01/ft_range.c Executable file
View File

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_range.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/14 16:38:46 by fgras-ca #+# #+# */
/* Updated: 2022/12/15 10:05:03 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
int *ft_range(int min, int max)
{
int *tab;
int i;
if (min >= max)
{
return (0);
}
tab = (int *) malloc(sizeof(int) * (max - min));
if (tab == 0)
{
return (0);
}
i = 0;
while (i < max - min)
{
tab[i] = min + i;
i++;
}
return (tab);
}

54
C07/ex02/ft_ultimate_range.c Executable file
View File

@ -0,0 +1,54 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_ultimate_range.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/14 17:31:36 by fgras-ca #+# #+# */
/* Updated: 2022/12/15 10:48:55 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
int *ft_range(int min, int max)
{
int *tab;
int i;
if (min >= max)
{
return (0);
}
tab = (int *) malloc(sizeof(int) * (max - min));
if (tab == 0)
{
return (0);
}
i = 0;
while (i < max - min)
{
tab[i] = min + i;
i++;
}
return (tab);
}
int ft_ultimate_range(int **range, int min, int max)
{
if (min >= max)
{
*range = 0;
return (0);
}
else
{
*range = ft_range(min, max);
if (*range == 0)
{
return (-1);
}
}
return (max - min);
}

88
C07/ex03/ft_strjoin.c Executable file
View File

@ -0,0 +1,88 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strjoin.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/18 10:50:07 by fgras-ca #+# #+# */
/* Updated: 2022/12/18 11:45:43 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
int ft_strlen(char *str)
{
int i;
i = 0;
while (str[i])
i++;
return (i);
}
char *ft_strcat(char *dest, char *src)
{
int i;
int dest_len;
i = 0;
dest_len = ft_strlen(dest);
while (src[i] != '\0')
{
dest[dest_len + i] = src[i];
i++;
}
dest[dest_len + i] = '\0';
return (dest);
}
int malloc_size(int size, char **strs, char *sep)
{
int i;
int resultat;
if (size == 0)
{
return (1);
}
i = 0;
resultat = 0;
while (i < size)
{
resultat += ft_strlen(strs[i]);
i++;
}
resultat += ft_strlen(sep) * (size - 1);
return (resultat + 1);
}
char *ft_strjoin(int size, char **strs, char *sep)
{
char *resultat;
int i;
resultat = malloc((sizeof(char)) * malloc_size(size, strs, sep));
if (resultat == 0)
{
return (0);
}
resultat[0] = 0;
if (size == 0)
{
return (resultat);
}
i = 0;
while (i < size)
{
ft_strcat(resultat, strs[i]);
if (i != size -1)
{
ft_strcat(resultat, sep);
}
i++;
}
resultat[ft_strlen(resultat)] = '\0';
return (resultat);
}

330
C07/fr.subject.pdf Normal file
View File

@ -0,0 +1,330 @@
Piscine C
C 08
Résumé: Ce document est le sujet du module C 08 de la piscine C de 42.
Version: 12.2
Table des matières
I Consignes 2
II Préambule 4
III Exercice 00 : ft.h 5
IV Exercice 01 : ft_boolean.h 6
V Exercice 02 : ft_abs.h 8
VI Exercice 03 : ft_point.h 9
VII Exercice 04 : ft_strs_to_tab 10
VIII Exercice 05 : ft_show_tab 12
IX Rendu et peer-evaluation 13
1
Chapitre I
Consignes
• Seule cette page servira de référence : ne vous fiez pas aux bruits de couloir.
• Relisez bien le sujet avant de rendre vos exercices. A tout moment le sujet peut
changer.
• Attention aux droits de vos fichiers et de vos répertoires.
• Vous devez suivre la procédure de rendu pour tous vos exercices.
• Vos exercices seront corrigés par vos camarades de piscine.
• En plus de vos camarades, vous serez corrigés par un programme appelé la Moulinette.
• La Moulinette est très stricte dans sa notation. Elle est totalement automatisée. Il
est impossible de discuter de sa note avec elle. Soyez d’une rigueur irréprochable
pour éviter les surprises.
• La Moulinette n’est pas très ouverte d’esprit. Elle ne cherche pas à comprendre le
code qui ne respecte pas la Norme. La Moulinette utilise le programme norminette
pour vérifier la norme de vos fichiers. Comprendre par là qu’il est stupide de rendre
un code qui ne passe pas la norminette.
• Les exercices sont très précisément ordonnés du plus simple au plus complexe.
En aucun cas nous ne porterons attention ni ne prendrons en compte un exercice
complexe si un exercice plus simple n’est pas parfaitement réussi.
• L’utilisation d’une fonction interdite est un cas de triche. Toute triche est sanctionnée
par la note de -42.
• Vous ne devrez rendre une fonction main() que si nous vous demandons un programme.
• La Moulinette compile avec les flags -Wall -Wextra -Werror, et utilise cc.
• Si votre programme ne compile pas, vous aurez 0.
• Vous ne devez laisser dans votre répertoire aucun autre fichier que ceux explicitement
specifiés par les énoncés des exercices.
• Vous avez une question ? Demandez à votre voisin de droite. Sinon, essayez avec
votre voisin de gauche.
2
Piscine C C 08
• Votre manuel de référence s’appelle Google / man / Internet / ....
• Pensez à discuter sur le forum Piscine de votre Intra, ainsi que sur le slack de votre
Piscine !
• Lisez attentivement les exemples. Ils pourraient bien requérir des choses qui ne
sont pas autrement précisées dans le sujet...
• Réfléchissez. Par pitié, par Odin ! Nom d’une pipe.
3
Chapitre II
Préambule
L’encyclopédie collaborative Wikipédia a ceci à dire sur l’ornithorynque :
L’ornithorynque (Ornithorhynchus anatinus) est une espèce de petits mammifères
semi-aquatiques endémique de l’est de l’Australie, y compris la Tasmanie. C’est
l’une des cinq espèces de l’ordre des monotrèmes, seul ordre de mammifères qui
ponde des œufs au lieu de donner naissance à des petits complètement formés
(les quatre autres espèces sont des échidnés). C’est la seule espèce survivante
de la famille des Ornithorhynchidae et du genre Ornithorhynchus bien qu’un
grand nombre de fragments d’espèces fossiles de cette famille et de ce genre
aient été découverts.
L’apparence bizarre de ce mammifère pondant des œufs, muni d’aiguillons venimeux,
à la mâchoire cornée ressemblant au bec d’un canard, à queue évoquant un castor,
qui lui sert à la fois de gouvernail dans l’eau et de réserve de graisse,
et à pattes de loutre a fortement surpris les premiers explorateurs
qui l’ont découvert ; bon nombre de naturalistes européens ont cru à une
plaisanterie. C’est l’un des rares mammifères venimeux : le mâle porte sur les
pattes postérieures un aiguillon qui peut libérer du venin capable d’infliger de
vives douleurs à un être humain. Les traits originaux de l’ornithorynque
en font un sujet d’études important pour mieux comprendre l’évolution
des espèces animales et en ont fait un des symboles de l’Australie :
il a été utilisé comme mascotte pour de nombreux évènements nationaux et il
figure au verso de la pièce de 20 cents australiens.
Jusqu’au début du XXe siècle, il a été chassé pour sa fourrure mais il est
protégé à l’heure actuelle. Bien que les programmes de reproduction en captivité
aient eu un succès très limité et qu’il soit sensible aux effets de la pollution,
l’espèce n’est pas encore considérée comme en danger.
Ce sujet ne traite pas de l’ornithorynque.
4
Chapitre III
Exercice 00 : ft.h
Exercice : 00
ft.h
Dossier de rendu : ex00/
Fichiers à rendre : ft.h
Fonctions Autorisées : Aucune
• Écrire votre fichier ft.h
• Il contient tous les prototypages des fonctions :
void ft_putchar(char c);
void ft_swap(int *a, int *b);
void ft_putstr(char *str);
int ft_strlen(char *str);
int ft_strcmp(char *s1, char *s2);
5
Chapitre IV
Exercice 01 : ft_boolean.h
Exercice : 01
ft_boolean.h
Dossier de rendu : ex01/
Fichiers à rendre : ft_boolean.h
Fonctions Autorisées : Aucune
• Écrire un fichier ft_boolean.h qui fera compiler et fonctionner correctement le
main suivant :
#include "ft_boolean.h"
void ft_putstr(char *str)
{
while (*str)
} write(1, str++, 1);
t_bool ft_is_even(int nbr)
{ return ((EVEN(nbr)) ? TRUE : FALSE);
}
int main(int argc, char **argv)
{
(void)argv;
if (ft_is_even(argc - 1) == TRUE)
ft_putstr(EVEN_MSG);
else
ft_putstr(ODD_MSG);
return (SUCCESS);
}
• Ce programme devra afficher
I have an even number of arguments.
• ou
I have an odd number of arguments.
6
Piscine C C 08
• suivi d’un retour à la ligne, dans le cas adéquat.
Pour cette exercice, la norminette doit être lancée avec le flag -R
CheckDefine. La moulinette l’utilisera aussi.
7
Chapitre V
Exercice 02 : ft_abs.h
Exercice : 02
ft_abs.h
Dossier de rendu : ex02/
Fichiers à rendre : ft_abs.h
Fonctions Autorisées : Aucune
• Écrire une macro ABS qui remplace son paramètre par sa valeur absolue :
#define ABS(Value)
Pour cette exercice, la norminette doit être lancée avec le flag -R
CheckDefine. La moulinette l’utilisera aussi.
8
Chapitre VI
Exercice 03 : ft_point.h
Exercice : 03
ft_point.h
Dossier de rendu : ex03/
Fichiers à rendre : ft_point.h
Fonctions Autorisées : Aucune
• Écrire un fichier ft_point.h qui fera compiler le main suivant :
#include "ft_point.h"
void set_point(t_point *point)
{
point->x = 42;
} point->y = 21;
int main(void)
{
t_point point;
set_point(&point);
return (0);
}
9
Chapitre VII
Exercice 04 : ft_strs_to_tab
Exercice : 04
ft_strs_to_tab
Dossier de rendu : ex04/
Fichiers à rendre : ft_strs_to_tab.c
Fonctions Autorisées : malloc, free
• Ecrire une fonction qui prend en parametre un tableau de chaîne de caractères
ainsi que la taille de ce tableau et renvoie un tableau de structure.
• Elle devra être prototypée de la façon suivante :
struct s_stock_str *ft_strs_to_tab(int ac, char **av);
• Elle doit transformer chaque element du tableau de chaîne de caractères en structure.
• La structure sera définie dans le fichier ft_stock_str.h comme suit :
typedef struct s_stock_str
{
int size;
char *str;
char *copy;
} t_stock_str;
◦ size étant la taille de la chaîne de caractères ;
◦ str étant la chaîne de caractères ;
◦ copy étant une copie de la chaîne de caractères ;
• Elle doit garder l’ordre des elements de av.
• Le tableau de structures devra être alloué et le dernièr element aura 0 pour valeur
de str, ceci afin de signifier la fin du tableau.
10
Piscine C C 08
• Si une erreur d’allocation arrive elle doit renvoyer un pointeur NULL.
• Nous testons votre fonction avec notre ft_show_tab (exercice suivant). Prenez les
mesures nécessaires pour que cela fonctionne !
11
Chapitre VIII
Exercice 05 : ft_show_tab
Exercice : 05
ft_show_tab
Dossier de rendu : ex05/
Fichiers à rendre : ft_show_tab.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche le contenu d’un tableau créé par la fonction précédente.
• Elle devra être prototypée de la façon suivante :
void ft_show_tab(struct s_stock_str *par);
• La structure est la même que l’éxercice précédent et sera dans le fichier ft_stock_str.h
que nous vous fournirons, :
• Pour chaque élément du tableau :
◦ la chaîne de caractères suivi d’un retour à la ligne
◦ la taille suivi d’un retour à la ligne
◦ la copie de la chaîne de caractères (qui aura pu être modifiée) suivi d’un retour
à la ligne
• Nous testons votre fonction avec notre ft_strs_to_tab (exercice précédent). Prenez
les mesures nécessaires pour que cela fonctionne !
12
Chapitre IX
Rendu et peer-evaluation
Rendez votre travail sur votre dépot Git comme d’habitude. Seul le travail présent
sur votre dépot sera évalué en soutenance. Vérifiez bien les noms de vos dossiers et de
vos fichiers afin que ces derniers soient conformes aux demandes du sujet.
Vous ne devez rendre uniquement les fichiers demandés par le sujet de
ce projet.
13

25
C08/ex01/ft_boolean.h Executable file
View File

@ -0,0 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_boolean.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/15 14:30:45 by fgras-ca #+# #+# */
/* Updated: 2022/12/18 12:24:26 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FT_BOOLEAN_H
# define FT_BOOLEAN_H
# include <unistd.h>
# define EVEN(n) n % 2 == 0
typedef int t_bool;
# define FALSE 0
# define TRUE 1
# define EVEN_MSG "I have an even number of arguments.\n"
# define ODD_MSG "I have an odd number of arguments.\n"
# define SUCCESS 0
#endif

16
C08/ex02/ft_abs.h Executable file
View File

@ -0,0 +1,16 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_abs.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/18 12:25:59 by fgras-ca #+# #+# */
/* Updated: 2022/12/18 12:40:44 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FT_ABS_H
# define FT_ABS_H
# define ABS(x) (((x) < 0) ? -(x) : (x))
#endif

20
C08/ex03/ft_point.h Executable file
View File

@ -0,0 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_point.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/18 12:51:34 by fgras-ca #+# #+# */
/* Updated: 2022/12/18 12:53:57 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FT_POINT_H
# define FT_POINT_H
typedef struct point{
int x;
int y;
}t_point;
#endif

68
C08/ex04/ft_strs_to_tab.c Executable file
View File

@ -0,0 +1,68 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strs_to_tab.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/21 09:54:48 by fgras-ca #+# #+# */
/* Updated: 2022/12/21 11:15:13 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "ft_stock_str.h"
#include <stdlib.h>
int ft_strlen(char *str)
{
int i;
i = 0;
while (str[i])
i++;
return (i);
}
char *ft_strdup(char *src)
{
char *dest;
int i;
i = 0;
dest = (char *) malloc(sizeof(char) * (ft_strlen(src) + 1));
if (dest == 0)
{
return (0);
}
while (src[i])
{
dest[i] = src[i];
i++;
}
dest[i] = 0;
return (dest);
}
struct s_stock_str *ft_strs_to_tab(int ac, char **av)
{
int i;
t_stock_str *tab;
if (ac < 1)
ac = 0;
tab = malloc(sizeof(t_stock_str) * (ac + 1));
if (tab == 0)
{
return (0);
}
i = 0;
while (i < ac)
{
tab[i].size = ft_strlen (av[i]);
tab[i].str = av[i];
tab[i].copy = ft_strdup (tab[i].str);
i++;
}
tab[i].str = 0;
return (tab);
}

72
C08/ex05/ft_show_tab.c Executable file
View File

@ -0,0 +1,72 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_show_tab.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2022/12/21 10:43:27 by fgras-ca #+# #+# */
/* Updated: 2022/12/21 11:44:58 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
#include "ft_stock_str.h"
struct s_stock_str *ft_strs_to_tab(int ac, char **av);
void ft_putchar(char c)
{
write(1, &c, 1);
}
void ft_putstr(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
{
write(1, &str[i], 1);
i++;
}
}
void ft_putnbr(int nb)
{
if (nb == -2147483648)
{
write(1, "-2147483648", 11);
}
else if (nb >= 0 && nb < 10)
{
ft_putchar(nb + 48);
}
else if (nb < 0)
{
ft_putchar('-');
ft_putnbr(nb * (-1));
}
else
{
ft_putnbr (nb / 10);
ft_putnbr (nb % 10);
}
}
void ft_show_tab(struct s_stock_str *par)
{
int i;
i = 0;
while (par[i].str)
{
ft_putstr(par[i].str);
ft_putchar('\n');
ft_putnbr(par[i].size);
ft_putchar('\n');
ft_putstr(par[i].copy);
ft_putchar('\n');
i++;
}
}

330
C08/fr.subject.pdf Normal file
View File

@ -0,0 +1,330 @@
Piscine C
C 08
Résumé: Ce document est le sujet du module C 08 de la piscine C de 42.
Version: 12.2
Table des matières
I Consignes 2
II Préambule 4
III Exercice 00 : ft.h 5
IV Exercice 01 : ft_boolean.h 6
V Exercice 02 : ft_abs.h 8
VI Exercice 03 : ft_point.h 9
VII Exercice 04 : ft_strs_to_tab 10
VIII Exercice 05 : ft_show_tab 12
IX Rendu et peer-evaluation 13
1
Chapitre I
Consignes
• Seule cette page servira de référence : ne vous fiez pas aux bruits de couloir.
• Relisez bien le sujet avant de rendre vos exercices. A tout moment le sujet peut
changer.
• Attention aux droits de vos fichiers et de vos répertoires.
• Vous devez suivre la procédure de rendu pour tous vos exercices.
• Vos exercices seront corrigés par vos camarades de piscine.
• En plus de vos camarades, vous serez corrigés par un programme appelé la Moulinette.
• La Moulinette est très stricte dans sa notation. Elle est totalement automatisée. Il
est impossible de discuter de sa note avec elle. Soyez d’une rigueur irréprochable
pour éviter les surprises.
• La Moulinette n’est pas très ouverte d’esprit. Elle ne cherche pas à comprendre le
code qui ne respecte pas la Norme. La Moulinette utilise le programme norminette
pour vérifier la norme de vos fichiers. Comprendre par là qu’il est stupide de rendre
un code qui ne passe pas la norminette.
• Les exercices sont très précisément ordonnés du plus simple au plus complexe.
En aucun cas nous ne porterons attention ni ne prendrons en compte un exercice
complexe si un exercice plus simple n’est pas parfaitement réussi.
• L’utilisation d’une fonction interdite est un cas de triche. Toute triche est sanctionnée
par la note de -42.
• Vous ne devrez rendre une fonction main() que si nous vous demandons un programme.
• La Moulinette compile avec les flags -Wall -Wextra -Werror, et utilise cc.
• Si votre programme ne compile pas, vous aurez 0.
• Vous ne devez laisser dans votre répertoire aucun autre fichier que ceux explicitement
specifiés par les énoncés des exercices.
• Vous avez une question ? Demandez à votre voisin de droite. Sinon, essayez avec
votre voisin de gauche.
2
Piscine C C 08
• Votre manuel de référence s’appelle Google / man / Internet / ....
• Pensez à discuter sur le forum Piscine de votre Intra, ainsi que sur le slack de votre
Piscine !
• Lisez attentivement les exemples. Ils pourraient bien requérir des choses qui ne
sont pas autrement précisées dans le sujet...
• Réfléchissez. Par pitié, par Odin ! Nom d’une pipe.
3
Chapitre II
Préambule
L’encyclopédie collaborative Wikipédia a ceci à dire sur l’ornithorynque :
L’ornithorynque (Ornithorhynchus anatinus) est une espèce de petits mammifères
semi-aquatiques endémique de l’est de l’Australie, y compris la Tasmanie. C’est
l’une des cinq espèces de l’ordre des monotrèmes, seul ordre de mammifères qui
ponde des œufs au lieu de donner naissance à des petits complètement formés
(les quatre autres espèces sont des échidnés). C’est la seule espèce survivante
de la famille des Ornithorhynchidae et du genre Ornithorhynchus bien qu’un
grand nombre de fragments d’espèces fossiles de cette famille et de ce genre
aient été découverts.
L’apparence bizarre de ce mammifère pondant des œufs, muni d’aiguillons venimeux,
à la mâchoire cornée ressemblant au bec d’un canard, à queue évoquant un castor,
qui lui sert à la fois de gouvernail dans l’eau et de réserve de graisse,
et à pattes de loutre a fortement surpris les premiers explorateurs
qui l’ont découvert ; bon nombre de naturalistes européens ont cru à une
plaisanterie. C’est l’un des rares mammifères venimeux : le mâle porte sur les
pattes postérieures un aiguillon qui peut libérer du venin capable d’infliger de
vives douleurs à un être humain. Les traits originaux de l’ornithorynque
en font un sujet d’études important pour mieux comprendre l’évolution
des espèces animales et en ont fait un des symboles de l’Australie :
il a été utilisé comme mascotte pour de nombreux évènements nationaux et il
figure au verso de la pièce de 20 cents australiens.
Jusqu’au début du XXe siècle, il a été chassé pour sa fourrure mais il est
protégé à l’heure actuelle. Bien que les programmes de reproduction en captivité
aient eu un succès très limité et qu’il soit sensible aux effets de la pollution,
l’espèce n’est pas encore considérée comme en danger.
Ce sujet ne traite pas de l’ornithorynque.
4
Chapitre III
Exercice 00 : ft.h
Exercice : 00
ft.h
Dossier de rendu : ex00/
Fichiers à rendre : ft.h
Fonctions Autorisées : Aucune
• Écrire votre fichier ft.h
• Il contient tous les prototypages des fonctions :
void ft_putchar(char c);
void ft_swap(int *a, int *b);
void ft_putstr(char *str);
int ft_strlen(char *str);
int ft_strcmp(char *s1, char *s2);
5
Chapitre IV
Exercice 01 : ft_boolean.h
Exercice : 01
ft_boolean.h
Dossier de rendu : ex01/
Fichiers à rendre : ft_boolean.h
Fonctions Autorisées : Aucune
• Écrire un fichier ft_boolean.h qui fera compiler et fonctionner correctement le
main suivant :
#include "ft_boolean.h"
void ft_putstr(char *str)
{
while (*str)
} write(1, str++, 1);
t_bool ft_is_even(int nbr)
{ return ((EVEN(nbr)) ? TRUE : FALSE);
}
int main(int argc, char **argv)
{
(void)argv;
if (ft_is_even(argc - 1) == TRUE)
ft_putstr(EVEN_MSG);
else
ft_putstr(ODD_MSG);
return (SUCCESS);
}
• Ce programme devra afficher
I have an even number of arguments.
• ou
I have an odd number of arguments.
6
Piscine C C 08
• suivi d’un retour à la ligne, dans le cas adéquat.
Pour cette exercice, la norminette doit être lancée avec le flag -R
CheckDefine. La moulinette l’utilisera aussi.
7
Chapitre V
Exercice 02 : ft_abs.h
Exercice : 02
ft_abs.h
Dossier de rendu : ex02/
Fichiers à rendre : ft_abs.h
Fonctions Autorisées : Aucune
• Écrire une macro ABS qui remplace son paramètre par sa valeur absolue :
#define ABS(Value)
Pour cette exercice, la norminette doit être lancée avec le flag -R
CheckDefine. La moulinette l’utilisera aussi.
8
Chapitre VI
Exercice 03 : ft_point.h
Exercice : 03
ft_point.h
Dossier de rendu : ex03/
Fichiers à rendre : ft_point.h
Fonctions Autorisées : Aucune
• Écrire un fichier ft_point.h qui fera compiler le main suivant :
#include "ft_point.h"
void set_point(t_point *point)
{
point->x = 42;
} point->y = 21;
int main(void)
{
t_point point;
set_point(&point);
return (0);
}
9
Chapitre VII
Exercice 04 : ft_strs_to_tab
Exercice : 04
ft_strs_to_tab
Dossier de rendu : ex04/
Fichiers à rendre : ft_strs_to_tab.c
Fonctions Autorisées : malloc, free
• Ecrire une fonction qui prend en parametre un tableau de chaîne de caractères
ainsi que la taille de ce tableau et renvoie un tableau de structure.
• Elle devra être prototypée de la façon suivante :
struct s_stock_str *ft_strs_to_tab(int ac, char **av);
• Elle doit transformer chaque element du tableau de chaîne de caractères en structure.
• La structure sera définie dans le fichier ft_stock_str.h comme suit :
typedef struct s_stock_str
{
int size;
char *str;
char *copy;
} t_stock_str;
◦ size étant la taille de la chaîne de caractères ;
◦ str étant la chaîne de caractères ;
◦ copy étant une copie de la chaîne de caractères ;
• Elle doit garder l’ordre des elements de av.
• Le tableau de structures devra être alloué et le dernièr element aura 0 pour valeur
de str, ceci afin de signifier la fin du tableau.
10
Piscine C C 08
• Si une erreur d’allocation arrive elle doit renvoyer un pointeur NULL.
• Nous testons votre fonction avec notre ft_show_tab (exercice suivant). Prenez les
mesures nécessaires pour que cela fonctionne !
11
Chapitre VIII
Exercice 05 : ft_show_tab
Exercice : 05
ft_show_tab
Dossier de rendu : ex05/
Fichiers à rendre : ft_show_tab.c
Fonctions Autorisées : write
• Écrire une fonction qui affiche le contenu d’un tableau créé par la fonction précédente.
• Elle devra être prototypée de la façon suivante :
void ft_show_tab(struct s_stock_str *par);
• La structure est la même que l’éxercice précédent et sera dans le fichier ft_stock_str.h
que nous vous fournirons, :
• Pour chaque élément du tableau :
◦ la chaîne de caractères suivi d’un retour à la ligne
◦ la taille suivi d’un retour à la ligne
◦ la copie de la chaîne de caractères (qui aura pu être modifiée) suivi d’un retour
à la ligne
• Nous testons votre fonction avec notre ft_strs_to_tab (exercice précédent). Prenez
les mesures nécessaires pour que cela fonctionne !
12
Chapitre IX
Rendu et peer-evaluation
Rendez votre travail sur votre dépot Git comme d’habitude. Seul le travail présent
sur votre dépot sera évalué en soutenance. Vérifiez bien les noms de vos dossiers et de
vos fichiers afin que ces derniers soient conformes aux demandes du sujet.
Vous ne devez rendre uniquement les fichiers demandés par le sujet de
ce projet.
13

1
rush00 Submodule

@ -0,0 +1 @@
Subproject commit f7ebcfcccdaefe23883327d95e2606fbfdbf12a3