Exam 01 Piscine 42 Exclusive Guide

Exam 01 of the 42 Piscine is a four-hour high-stakes test that takes place on the first Friday of the program

. It is designed to test your knowledge of C programming and the Shell basics you've learned during the first week. Survival Guide: Your First Dive into Exam 01

The first exam at 42 is often described as a "shock to the system." You'll be cut off from the internet and your peers, forced to rely entirely on what you've actually absorbed. The "Zero" Initiation:

Don't panic if you get a 0. It is incredibly common for first-timers to fail because the process of launching the environment is never explicitly explained. The Exam Flow:

You must solve each task to unlock the next. If you fail an exercise with the Moulinette (the automated grader), you cannot progress further. Key Skills to Master:

Focus on C00 through C01 exercises. Expect tasks like printing the alphabet using ft_putchar or simple arithmetic functions. Preparation Strategy: examshell practice

tools available online to familiarize yourself with the interface. Exam 01 Structure at a Glance 4 Hours (typically 2 PM – 6 PM) Environment Dedicated Linux mode with no internet Real-time by the Moulinette; must pass to advance Shell commands (Shell00/01) and basic C (C00/C01)

To see a first-hand account of the stress and common pitfalls of the first exam:

Final Truth

Exam 01 is not a test of your C skills. It is a test of stress tolerance under constraint.

The student who knows ft_split perfectly but panics and forgets free() → fails.
The student who knows only ft_strlen but stays calm, writes perfect code, and methodically solves Level 0 and Level 1 → passes with a 2.

Your goal: Grade 3.
Grade 4 is for the gods. Grade 2 is passing. Grade 3 is excellent.

Breathe. Read the subject twice. Write the prototype on the paper. Code. Test. Push. Grade. Repeat.

You have this. Now go write ft_putstr from memory.

Exam 01 of the 42 Piscine is the second exam in the intensive four-week coding bootcamp. It primarily tests your understanding of Command Line Arguments (

alongside fundamental concepts from the first week, such as loops, conditionals, and basic string manipulation. Core Exam Topics exam 01 piscine 42 exclusive

To succeed in Exam 01, you should be comfortable with the following: Argument Handling : Working with char **argv to capture and use data passed via the terminal. Fundamental C Logic : Standard loops ( ), conditionals ( ), and basic arithmetic. String Manipulation

: Iterating through strings and basic comparisons or replacements. Standard Functions : Typically, only the function is allowed for output. Common Exercise Types

The exam system randomly assigns problems. Based on common patterns in the 42 curriculum, you might encounter: Display Tasks : Simple programs like (print 'z' followed by a newline) or Search and Replace

: Writing a program that replaces a character in a string with another character provided as an argument.

: Manipulating string arguments by rotating words or changing their order. Input Validation

: Handling cases where the number of arguments provided is incorrect (e.g., displaying only a newline if arguments are missing). Preparation Checklist

42 School Piscine Exam 01 is a high-stakes, 4-hour technical challenge that serves as the second major test in the intensive C programming bootcamp. While Exam 00 covers the basics of the shell and simple functions, Exam 01 adds command-line arguments ( and more complex logic. The Story: A Friday in the Cluster 1. The Pre-Exam Tension

Friday at 42 is "Exam Day." The energy in the cluster shifts from collaborative chaos to a heavy, nervous quiet. At exactly 2:00 PM, all students are logged out, and the machines reboot into a specialized, restricted Linux environment. You have exactly 10 minutes to log in to the

using the generic "exam" credentials; failure to do so results in an immediate 0. 2. Entering the Exam Shell Once you launch the

command, the real game begins. The interface is text-only. You must log in again with your personal intranet ID and password. The environment is designed to be isolated—no internet, no notes, and no peer help. 3. Solving Level by Level

The exam is structured like a video game: you must pass one exercise to unlock the next.

Often a basic output task, such as printing the last command-line argument using only the Level 1-2:

Tasks move into string manipulation, such as writing your own version of (string copy) or (string comparison). Exam 01 of the 42 Piscine is a

If you fail an exercise, you might be given a different task at the same difficulty level, but it will be worth fewer points. 4. The Dreaded

To submit your work, you move your C file into the designated folder, commit it, and type in the shell. Then, you wait. The Moulinette

(the automated grading system) tests your code against edge cases. If there is even one extra space or a minor logic flaw, it returns a "FAILURE" message, and your score for that attempt remains 0. 5. The Aftermath

At 6:00 PM, the session ends abruptly. For many, the first exam is a lesson in humility, with some students scoring as low as 30 due to stress or minor syntax errors. However, at 42, failure is part of the curriculum—the school looks for resilience and growth over the four weeks rather than perfect scores on day one. Summary of Key Exam 01 Topics Focus Area Basic Logic Loops, conditionals, and character manipulation Command Line to process inputs Iterating through arrays and handling the null-terminator ( System Calls Outputting data exclusively using the Are you preparing for a specific exercise like for your next exam? 42-piscine/README.md at main - GitHub

Exam 01 of the 42 Piscine is often described as the "wake-up call" following the chaotic first week of Shell exercises. It is the second exam in the sequence (after Exam 00) and usually takes place on the second Friday. The Experience: "The First Real Test"

For many "swimmers," Exam 01 is where the reality of the C language truly sets in. While Exam 00 often involves basic Shell commands or environment setup, Exam 01 requires writing functional C code under strict time pressure.

The Psychological Barrier: Participants often report feeling a mix of frustration and "power" after the exam. It is common for students to fail early exams due to "stupid things" they thought they knew but couldn't reproduce without resources.

The Environment: The exam is held in a "cluster" (computer lab) under strict rules. There is no internet access, no peer help, and no personal notes—just the student, the terminal, and the automated grading system. Common Challenges & Content

Exam 01 is your first true test of the 42 Piscine marathon. It typically focuses on the fundamentals of C programming Unix shell commands introduced during your first week. Typical Exam 01 Content

The exam is progressive; you must pass each exercise to unlock the next. You will likely encounter: Shell Basics : Simple commands like , or basic permissions. Simple Output : Exercises like (printing a 'z') or ft_print_alphabet (using loops). String Manipulation : Basic functions like (string length) or (printing a string). Pointers & Integers : Simple tasks like (setting a pointer to 42) or Exclusive Rules & Guidelines

To succeed, you must follow the strict machine-graded environment (the

42-Piscine/exams/0-1-only_z/subject.en.txt at master - GitHub

4. Handle the "NULL" Exclusively

The Renderium tests edge cases viciously. For any function taking a pointer (e.g., char *str), the first three lines of your code should check if (str == NULL) return (NULL or 0). If you forget this, you fail the exclusive edge-case tests. The student who knows ft_split perfectly but panics

What Happens After Exam 01?

Passing Exam 01 (above 50% on both functions) grants you access to the next level: Exam 02, which introduces ft_swap, ft_atoi, and pointer manipulation. However, failing Exam 01 is not the end. The 42 paradigm allows retakes, but each failed attempt reduces your final admission rank.

Most importantly, surviving Exam 01 changes how you code. You will never look at printf the same way again. You will understand that a string is just a pointer to characters until a \0.

🛠️ Quick Reference Code Snippet (Read Loop)

If you need to print a string (char *str) manually:

int i = 0;
while (str[i])
write(1, &str[i], 1);
    i++;
write(1, "\n", 1);

Phase 4: The `norminette` Demon

Before you even think about grademe, run:

norminette ft_putstr.c
norminette ft_strlen.c

If Norminette complains about:

Too many functions (you have only one, so fine)
Too many lines (max 25 lines per function)
for loops (not allowed if a while is possible)
Missing header comments

Fix it immediately. A Norm error equals instant failure.

Phase 2: The Skeleton Code (Copy-Paste Law)

In the 42 exam environment, you cannot copy-paste from the internet, but you can copy-paste within your own terminal. Write a standard template:

#include <unistd.h>
// Function here
int main(void) // Hidden from Moulinette, but useful for your own testing
ft_putstr("Hello Exam 01");
return (0);

Exclusive trick: Comment out your main before grademe. Moulinette expects only the function. If you leave main in, you get a compilation error (score -42).

🎯 Exam 01 Review: The "Reality Check" (Piscine 42)

Difficulty: ⭐⭐⭐⭐ (Medium/Hard for Week 1) Time: 4 hours Type: Shell & C (No internet, no peers, no copy/paste)