ft_putnbr because it appears often.Move to next exercise. You can return if time permits.
Exam 01 is the second major written examination during the Piscine (typically occurring at the end of the second week). Unlike the first exam, which focuses on basic functions and familiarity with C, Exam 01 demands a genuine grasp of memory, pointers, and string manipulation.
The exam is conducted in a strictly controlled environment:
Q: Can I use my own .c and .h files from previous days?
No – empty environment. You type everything from scratch.
Q: What if my program prints extra newline?
Usually fails unless subject says trailing newline is acceptable (rare). Match exactly.
Q: Are there bonus points?
No. Either correct or incorrect (partial points possible only if some tests pass, but aim for 100%).
Q: What’s the passing score?
Not published but usually ≥ 50% of available points to continue Piscine. However, aim for 100% to feel safe.
Exam 01 of the 42 Piscine typically focuses on handling command-line arguments (argc/argv) and building upon basics like loops and logic. Because the exam system is randomized for every student, there is no single "paper," but rather a set of potential problems across different difficulty levels. 📋 Exam Structure & Logistics Duration: Usually 4 hours.
System: You log in via examshell using "exam" as the username and password.
Levels: Questions progress from Level 0 to Level 4+; you must pass a level to advance.
Grading: Submit using the grademe command; you can only move on if your code passes the automated tester. 🧠 Core Topics & Requirements
Command Line Arguments: Understanding how to use argc and argv is critical for most Level 1+ problems.
Standard Output: Proficiency with the write function (as printf is usually forbidden).
Data Types: Managing strings (char arrays) and basic integer arithmetic.
Memory: Basic understanding of the stack; malloc is generally not needed until Exam 02. 🛠️ Common Problem Types
Below are examples of problems frequently seen in Level 0 and Level 1 repositories: Level 0 (Basics): only_a / only_z: Print a single character and a newline.
maff_alpha: Print the alphabet with alternating cases (e.g., aBcDe...). Level 1 (Manipulation): ft_swap: Swap the values of two integers using pointers.
rot_13 / rotone: Shift characters in a string by a specific number of positions.
search_and_replace: Replace all occurrences of one character with another in a string. Higher Levels:
rostring: Rotate a string so the first word becomes the last. first_word: Display the first word of a given string. 💡 Strategy Tips
An interesting feature of in the 42 Piscine is the "First Blood" pressure
, where the automated grading system (the Moulinette) creates a high-stakes environment where your first ever "real" grade in the program is determined by absolute precision.
Here are a few unique aspects that make Exam 01 a defining moment for "Pisciners": The "VOG-SPHERE" Isolation
: Unlike the daily rushes where you can collaborate, Exam 01 is your first time being completely cut off. You are pushed to a specific seat, all external internet is blocked, and you must rely entirely on your own memory of the syntax and shell commands learned in the first week. The Leveling System Exam 01 Piscine 42
: The exam uses a "level" mechanic. You start at Level 0 with a very simple task (like displaying a character). If you pass, you move to Level 1. If you fail a level, the system often gives you a
problem of the same difficulty, preventing you from simply memorizing a specific solution. The "0 or 100" Rule
: There is no partial credit. If your code has a single extra space in the output or a minor memory leak, the Moulinette gives you a 0 for that exercise. This forces a mindset shift from "it mostly works" to "it is technically perfect." Psychological Barrier
: For many, Exam 01 is the first time they realize that the Piscine isn't just about coding—it's about stamina. Seeing peers leave the cluster early (either because they finished or gave up) creates a unique mental challenge while you are trying to debug a pointer. specific C concepts are usually tested in this first exam to help you prepare?
Survival Guide: Navigating Exam 01 of the 42 Piscine The first exam of the 42 Piscine is often described as a rite of passage—a high-stakes, 4-hour sprint that tests not just your C programming skills, but your ability to handle pressure and follow precise instructions. Held on the first Friday, Exam 01 is the first time many "pisciners" face the school’s automated grading system in a controlled, isolated environment. The Technical Setup: Entering the "Shell"
Before the exam begins, the staff and "grizzlies" (student volunteers) often set a supportive mood with music, but once you sit down, you are on your own.
Environment: You will log into a custom Linux environment using a specific exam username and password provided on the day.
Accessing Tasks: To start, you must open the terminal and enter the command examshell. This launches the custom shell where you will receive tasks one by one.
Isolation: You are cut off from the internet and your peers. Your only resources are your knowledge, the man pages, and potentially a local ASCII table. How the Exam Works: One Level at a Time
The structure of Exam 01 is linear and unforgiving. You are assigned tasks randomly from a pool, but everyone starts at the same difficulty level.
Solve to Unlock: You must successfully pass a task to see the next one. If you fail a task, you often have to wait for a timer to cooldown before you can try again or move forward.
Automated Grading: Just like your daily projects, your code is graded by a system often called "Grademe" or similar. It checks for exact output matching and strictly follows the 42 Norm.
No Partial Credit: If your code has a minor error—like an extra space or a missing newline—the entire task is marked as 0. What to Expect on the Test
Exam 01 typically covers the foundational concepts introduced in the first week (usually Shell00, Shell01, and C00).
Basic C Syntax: Creating simple functions, using write, and basic loops.
ASCII Manipulation: Understanding how to print characters and numbers based on their ASCII values is critical.
Common Pitfalls: Many students fail because they include a main function in their submission when the task only asks for a specific function. Tips for Success 42 Abu Dhabi – Piscine Day 11 (Exam01)
Survival Guide: Conquering Exam 01 of the 42 Piscine So, you’ve survived the first week of the 42 Piscine. You’ve figured out how to use ls, you’ve had your first fight with Norminette, and you’ve realized that sleep is a luxury. Now, the first real hurdle has arrived: Exam 01.
If you're feeling nervous, that's normal. Here is everything you need to know to walk into that exam room and come out with a passing grade. 1. The Environment: Total Lockdown
When you log into the exam session, your computer transforms. No internet, no Slack, no peer to help you. It is just you, a terminal, and the Exam Shell.
The Command: You’ll likely start the exam by typing examshell.
The Goal: You receive one exercise at a time. You must push your code to the specific git repository provided, then type grademe to have the automated system check it. 2. What to Expect: The Syllabus
Exam 01 usually covers the basics of C programming found in the early Piscine days (C00 through parts of C02). Expect variations of: Time yourself – give 15–20 min max per simple exercise
Displaying Characters: Using write to output strings or numbers (e.g., ft_putchar, ft_putstr).
Basic Loops: Exercises like ft_print_numbers or ft_countdown.
String Manipulation: Simple tasks like ft_strlen or ft_strcpy.
The "Level" System: Exams are tiered. If you fail a Level 0 problem, you stay at Level 0. You need to pass the current level to see the next, more difficult exercise. 3. Critical Tips for Success
Read the Subject Twice: The most common way to fail is by misnaming a file or a function. If the subject asks for ft_putstr.c, do not name it ft_putstring.c.
The 10-Minute Rule: When you submit a project via grademe, there is a "wait time" before you can try again if you fail. Use this time to double-check your logic rather than rushing to submit.
Manual Testing: Since you don’t have Moulinette during the exam, write your own main functions to test your code before submitting. Just remember to remove or comment out the main before you push!
Norminette: Depending on your campus rules, the exam might not strictly enforce Norminette, but it’s best practice to keep your code clean to avoid "stupid" errors. 4. The Mindset: Don't Panic
The first exam is as much a test of your nerves as it is your coding skills. If you get stuck on a simple if statement, take a deep breath.
Failing is okay: Many successful 42 students failed their first few exams. It’s part of the learning curve.
Focus on the points: You don't need a 100/100 to progress in the Piscine. Getting those first few levels right is a massive win. Final Checklist Know how to use git add, git commit, and git push by heart. Understand how the write function works (unistd.h).
Practice common Level 0 and Level 1 problems on 42Exam or similar simulators. Good luck, Piscineur. Go get that "Success" message!
The first exam of the 42 Piscine (Exam 01) typically takes place at the end of the first week and covers the fundamental C programming concepts introduced in projects like C00 and C01. Exam Basics
Environment: You must log in with the exam user and run the examshell command to begin [0.5.6, 0.5.11].
Submission: Use the command grademe within the examshell to submit your code for correction [0.5.8].
Rules: Unlike standard projects, you do not need the 42 Header or to run Norminette during exams [0.5.8]. Common Level 0 & 1 Exercises These are frequent starting tasks for the first exam:
only_z: Write a program that displays only the character 'z' on the standard output [0.5.5].
ft_print_alphabet: Create a function that displays the lowercase alphabet in ascending order [0.5.1, 0.5.3].
search_and_replace: A program that takes a string and two characters, replacing every instance of the first character with the second [0.5.14].
first_word: A program that displays the first word of a given string [0.5.22]. Preparation Tips
Master write: Most early exam problems require you to use the write function from the
Practice VIM: You may not have access to VS Code or other IDEs during the exam, so being comfortable with VIM is critical [0.5.8].
Handle Failures: If you fail a question, you may have to wait for a "timeout" before the next attempt, and you might receive a different question entirely. Move to next exercise
Exam 01 of the 42 Piscine typically covers fundamental concepts introduced in the first week, specifically focusing on Shell commands and the beginning of C programming (Modules C00 and C01). While the exact pool of questions can vary by campus and year, it generally tests your ability to manipulate data and the environment without relying on standard libraries. Core Content & Tested Concepts
Basic C Syntax: Displaying characters and numbers using write. Expect variations of ft_putchar or ft_putstr.
Control Structures: Implementing basic loops (while) and conditional statements (if/else) to solve simple logic problems like FizzBuzz.
Simple Math & Logic: Generating combinations of numbers (e.g., print_comb) or calculating factorials and powers.
Pointers & Memory Basics: Understanding basic pointer assignments (e.g., ft_ft or ft_ultimate_ft involving multiple pointers) and value swapping.
Shell Proficiency: Basic navigation, file manipulation, and possibly simple scripts involving commands like find, ls, and permissions.
The ASCII Table: You must know how to manipulate characters using their decimal values (e.g., lowercase 'a' is 97, 'z' is 122). Typical Exercises
Common early-level exam exercises found in repositories and student guides include: print_combn piscine school 42
For many "Pisciners" at 42 School, Exam 01 is the first true moment of truth. While the previous week's projects (Shell00 to C01) provide a taste of the learning curve, the first Friday exam is where the pressure of a timed, isolated environment truly begins. What is Exam 01?
Exam 01 is a four-hour practical coding test held every Friday during the Piscine. It is designed to test your mastery of basic C programming concepts, specifically focusing on what you should have learned during the first week and a half of the program.
Unlike the projects where you can ask peers for help, the exam is strictly solo. You are placed in a controlled "exam mode" environment on a Linux machine with no internet access and no external resources. Key Topics to Master
The difficulty of the exam is cumulative. To succeed in Exam 01, you should be comfortable with:
The Basics: Recreating standard library functions like ft_putchar or ft_putstr using only the write function.
Control Flow: Mastering if/else statements and while loops for simple logic.
Strings and Arrays: Handling character arrays, which are the bread and butter of the early Piscine.
Command Line Arguments: A common "gatekeeper" topic for Exam 01 is understanding argc and argv to write programs that respond to terminal input.
Functions vs. Programs: Knowing when a subject asks for a function (do not include main) versus a program (must include main and be compilable). The Exam Environment: How It Works
Accessing the exam is an exercise in following instructions ("RTFM"):
Login: You log into the machine with a special exam username and password. Launch: You open a terminal and run the examshell command.
The Process: You receive one exercise at a time. You must solve it, push it to the rendu directory, and run grademe to have it checked by the "Moulinette" (the automated grading system).
Progression: You only see the next exercise if you pass the current one. If you fail, the point value for that exercise often decreases on the next attempt. Expert Tips for Passing
42-Piscine-C/Exam/Exam01/4-0-rostring/subject.en.txt at master
Here’s a concise yet detailed write-up for Exam 01 of the 42 Piscine, aimed at helping candidates understand its structure, challenges, and how to prepare.
Before submitting, run through these cases in your head: