The hallway was silent, save for the low, rhythmic hum of the server room fans and the frantic tapping of mechanical keyboards. It was 8:00 AM on a Tuesday, but inside the cluster known as "The Fishbowl," time had ceased to matter.
This was Exam 01.
For the cohort of "Piscineurs"—the hopeful students undergoing the intensive 26-day bootcamp known as the Piscine—this wasn't just a test. It was the first true gatekeeper. The first monster to slay.
Lucas sat at cluster 3, row 2. His eyes were rimmed with the red glaze of a man who had survived on coffee and four hours of sleep. His git status was clean, his Norminette (the school’s notoriously strict code linter) was silent, and his heart was hammering against his ribs.
"Begin," the proctor’s voice echoed, though no one needed the announcement.
Lucas typed grademe into his terminal. The screen flickered, and the assignment appeared.
Assignment: ft_strncpy
A breath he didn’t know he was holding escaped his lungs. Easy. He cracked his knuckles. The muscle memory took over. He didn't even need to look at the man pages. He knew the prototype: char *ft_strncpy(char *dest, char *src, unsigned int n). He knew the catch: strncpy doesn't guarantee null-termination if the source string is longer than n. He typed furiously, the clack-clack-clack of the keys sounding like a machine gun.
Compile. Test. Pass.
The green text flashed on the screen: Success. The level gauge on his exam profile ticked up. Level 0 complete.
Next: ft_str_is_alpha
He grinned. He was in the zone. He navigated the logic checks. Does the string contain only alphabetical characters? Return 1 if yes, 0 if no. Empty string? Return 1. He handled the edge cases, navigating the labyrinth of ASCII values (65 to 90, 97 to 122).
Compile. Test. Pass.
He glanced around. To his left, Sarah was staring blankly at a segmentation fault, her hands hovering motionless over the keyboard. To his right, a student named Ben was furiously erasing a whiteboard diagram. The pressure in the room was palpable, a physical weight pressing down on their shoulders.
Lucas advanced. ft_strlcpy. The beast that confused everyone. The return value was the length of the source, not the destination. It had to copy safely. He wrote it, double-checked the man pages, and passed.
He was on a roll. He hit Level 2. He was moving out of the beginner zone.
Then, the exam server threw a curveball.
Assignment: ft_putstr_non_printable
The instructions were simple: Print a string. If a character is non-printable (less than 32 or equal to 127), display it in hexadecimal, prefixed by a backslash.
Example: Hello\nWorld -> Hello\0aWorld.
Lucas paused. Hexadecimal conversion. He needed a helper function. He opened a new file.
"Think," he muttered. He needed to take a char, cast it to an unsigned char, divide it by 16 for the first digit, and modulo 16 for the second. He needed a base string: "0123456789abcdef".
He wrote the logic.
void ft_putchar(char c)
write(1, &c, 1);
void ft_putstr_non_printable(char *str)
int i;
char *hex;
hex = "0123456789abcdef";
i = 0;
while (str[i])
if (str[i] >= 32 && str[i] != 127)
ft_putchar(str[i]);
else
ft_putchar('\\');
ft_putchar(hex[str[i] / 16]);
ft_putchar(hex[str[i] % 16]);
i++;
He hit compile. No errors. He ran the test cases. He checked the output.
Coucou\ntu vas bien ?
His output: Coucou\0atu vas bien ?
He frowned. Wait. The newline character is decimal 10.
10 / 16 = 0.
10 % 16 = 10 (which is 'a').
The output should be \0a.
He stared at his screen. It looked correct. But he had a nagging feeling. What about the highest value? What about char 127 (DEL)?
127 / 16 = 7.
127 % 16 = 15 (f).
Output: \7f.
"Wait," he whispered. "Two digits. Does it handle leading zeros correctly?"
If the value is 10, it prints \0a.
If the value is 1, it should print \01.
He checked the subject again. The examples showed two digits always. His logic held.
He typed grademe.
The screen paused. The connection to the correction server felt like an eternity. Checking... Norminette... OK Compilation... OK Tests...
A red line appeared. FAILED.
Lucas felt a cold spike of adrenaline. Failed? Where?
He looked at the error trace. It was a segmentation fault on a specific test case. He realized he hadn't fully protected against an empty string? No, the while loop handled that.
Then he saw it. In his rush, he had declared hex inside the loop scope in a way the strict correction compiler didn't like, or perhaps he had a typo in the header inclusion.
No, wait. The write function. He forgot to include <unistd.h> in his submission file, even though his local compiler let it slide because of the headers in the main test file.
He quickly added the include. He re-read the code. He realized he needed to cast str[i] to (unsigned char) before the math operations to handle negative values correctly if the char was signed by default. Exam 01 Piscine 42
He fixed the cast.
He typed grademe again.
Success.
Level 2 validated. He exhaled, leaning back in the ergonomic chair. The pressure in his chest eased slightly. He looked at the clock. Two hours had passed in what felt like five minutes.
He wasn't done. There were higher levels to conquer—recursive functions, pointer arithmetic that twisted the brain into knots. But for now, he had cleared the hurdle that had washed out half the class the previous week.
He looked over at Sarah. She had just seen the green "Success" text on her screen. She slumped back, a wide, exhausted smile breaking across her face. They locked eyes for a second and gave a slight nod.
Welcome to 42, the nod said.
Lucas turned back to his screen and typed grademe again, ready for the next challenge.
Moral of the Story:
In the Piscine, the code isn't just about syntax; it's about resilience. Exam 01 teaches you that failure is just a step toward the solution, and that a single missing unsigned cast can be the difference between defeat and glory.
The "Piscine" at 42 is a legendary rite of passage for aspiring software engineers. It is a four-week, high-intensity C programming bootcamp where sleep is a luxury and logic is your only lifeline. While the daily exercises are grueling, the true test of your progress (and your nerves) is Exam 01.
If you are staring down the calendar at your first Friday exam, here is everything you need to know to survive and succeed. What is Exam 01?
Exam 01 is the first formal assessment in the 42 Piscine. After a week of struggling with norminette, peer evaluations, and Shell/C basics, the school removes the training wheels.
For four hours, you are isolated in the cluster. No internet, no peers, no notes, and no "Moulinette" feedback until you submit your code for a final grade. It is just you, a terminal, and a series of increasingly difficult coding problems. The Mechanics of the Exam
The exam uses a custom automated system. Here is the workflow:
The Login: You log into a restricted session that only allows access to the terminal and a local exam command.
The Assignment: You type grademe. The system assigns you a random problem from a predefined level.
The Code: You write your solution in C (usually a single .c file) following the exact requirements (function name, allowed headers, etc.).
The Push: You commit and push your code to the local Git repository. The Rite of Passage The hallway was silent,
The Verdict: You type grademe again. The system compiles your code and runs it against secret test cases. Success: You move to a harder level.
Failure: You are assigned a new problem at the same level, and a "wait time" is applied before you can try again. What to Expect: Level 0 and Level 1
For Exam 01, the system typically tests your grasp of the absolute basics. You won't be asked to build a complex engine; you'll be asked to manipulate characters and integers.
Standard Problems: You might see only_a, maff_alpha, hello, or ft_countdown.
Strings & Loops: Be ready for ft_putstr, ft_strlen, or rev_print.
The "First Boss": The most common hurdle in Exam 01 is first_word or fizzbuzz. These require you to handle loops, conditionals, and write functions simultaneously. Key Strategies for Success 1. Master the write Function
In the Piscine, printf is often forbidden. You must be comfortable using write(1, &char, 1);. Practice converting integers to characters (the classic nb + '0') so you aren't fumbling with ASCII math during the countdown. 2. Read the Subject Twice
The exam system is pedantic. If the subject asks for a newline (\n) at the end and you forget it, you fail. If you misspell the function name by one letter, you fail. Read the requirements like a lawyer. 3. Don't Panic Over the Clock
Four hours is a long time for the level of problems assigned in Exam 01. If you get a "Failure," take a five-minute walk, drink some water, and clear your head. The "wait time" between attempts is a feature, not a bug—it’s designed to stop you from "brute-forcing" the grader. 4. Test Your Own Edge Cases
Since you don't have the Moulinette to tell you why you failed, you must become your own tester. What happens if the input string is empty? What if there are multiple spaces? Does it handle the maximum integer value? The Mindset: "Pool" Logic
Remember, the goal of Exam 01 isn't necessarily to get a 100%. The goal is to prove you have learned how to learn. Many students fail their first exam and still go on to pass the Piscine. The staff is looking for your growth curve.
If you get a 0, don't quit. Analyze the problems you missed, go back to the clusters, and practice those logic gates until they become muscle memory.
Are you preparing for a specific level or problem right now that I can help you debug or explain?
Level 2 is where most people fail. You will likely get ft_atoi (string to int).
'-' is not a number; you just set a flag..c file. Write a quick main() (not required for grading but vital for your sanity) to test edge cases: " ---+--+1234ab567" should return -1234.Reproduce these without external help:
| Exercise type | Example | Key skill |
|---------------|-----------------------------|--------------------------|
| String length | int ft_strlen(char *s) | Loops, pointer iteration |
| String copy | char *ft_strcpy(char *dst, char *src) | Pointer manipulation |
| Compare strings | int ft_strcmp(char *s1, char *s2) | Lexicographic logic |
| Print numbers | void ft_putnbr(int n) | Handling INT_MIN/positive/negative |
| Power | int ft_iterative_power(int nb, int power) | Edge cases (power=0, nb=0) |
| Prime check | int ft_is_prime(int nb) | Efficiency up to sqrt(nb) |
| FizzBuzz style| Print 1 to 100 with replacements | Modulo & conditionals |
| argv handling | ./program "hello" → print each char | Accessing argv[1] |