GESP C++ Level 1 Explained: Syllabus, Question Types, and How to Prepare

GESP (the Grade Examination of Software Programming) is a youth programming certification run by CCF, the China Computer Federation. Its C++ track has eight levels, uses a computer-based (on-machine) exam, and runs multiple times a year. Level 1 is where almost every child begins. It tests only the most basic C++ syntax, and its goal isn't to trip kids up — it's to confirm that a child can independently write a small program that actually runs correctly.

If your child is just starting out with C++ and preparing for GESP Level 1, this article lays out where Level 1 sits in the full 1–8 progression, which topics the syllabus covers, what question types the exam uses, where absolute beginners most often stumble, and a concrete prep plan you can follow. For any exact figures, always defer to the official CCF GESP announcements; this piece is here to give parents the big picture.

Where Level 1 sits in the 1–8 progression

To understand what Level 1 tests, it helps to see where it falls on the whole path. The eight C++ levels build on one another, and Level 1 is the very foundation:

Notice that Level 1 covers only two of the most basic program structures — sequential execution and simple branching. Loops haven't even appeared yet. That's deliberate: the step is set low on purpose, so that a child who has never written a line of code can reach their first certificate within a few weeks to a couple of months, and build the belief that "I can actually learn to program."

In one sentence: Level 1 is an entry-level checkup that confirms a child has truly grasped the most fundamental building blocks of writing a program, and is ready to keep climbing.

Who is Level 1 for?

Based on what we see across many students, Level 1 is a good starting point for a child who:

• Has no background, or has only just met C++ — Level 1 assumes zero prior experience;
• Is roughly in grade 3 of primary school or above — some keyboard fluency and basic arithmetic (add, subtract, multiply, divide, compare) help;
• Can sit still and is willing to type — Level 1 is easy, but a child still has to write the code by hand and run it themselves.

One caveat: if your child can already write loops and arrays comfortably, it may make sense to start at Level 2 or higher (GESP allows skipping levels within limits; check the current official notice). Level 1's real value is giving a genuine beginner a steady start, not letting an already-capable child "collect a certificate." Very young children who can't yet sit still can begin with block-based programming (Scratch) and switch to C++ later.

The Level 1 syllabus: what to master

The Level 1 topic list is tight and clustered around two things: sequential structure and simple branching. Here's what a child needs to be solid on (defer to the official CCF GESP syllabus for specifics):

1. Variables and data types

• Understanding that a variable is a labeled box that stores data, with a name and a type;
• Common basic types: integer (int), floating point (double), character (char), boolean (bool);
• Declaring and assigning variables, and knowing what each type can hold (e.g. int for whole numbers, double for numbers with decimals).

2. Input and output

• Reading input with cin and printing results with cout;
• Reading several values at once, printing to a required format, and using endl for a new line;
• This is the "entrance and exit" of every programming problem — it needs to become muscle memory.

3. Arithmetic, relational, and logical operators

• Arithmetic: add +, subtract -, multiply *, divide /, modulo %, plus operator precedence;
• Relational: greater than >, less than <, equal ==, not equal !=, and so on — each yields true or false;
• Logical: and &&, or ||, not !, used to combine multiple conditions.

4. Sequential structure and simple branching

• Sequential structure: the program runs top to bottom, one statement at a time;
• Branching: if / if...else, choosing a path based on a condition;
• Translating a simple real-world question ("is this number odd or even?", "which of two numbers is larger?") into a branching program.

Put together, the core idea Level 1 wants a child to internalize is really just one sentence: a program is a sequence of instructions executed in order, and when it hits an if, it makes a choice based on a condition. Every later level simply stacks on top of that.

Exam format: objective questions plus programming

Like every other level, Level 1 is taken on a computer, and the questions fall into two broad types. Note: what follows describes the question types only. Exact counts, point values, and time limits are set by the current official CCF GESP announcement — this article makes no promises about numbers.

Objective questions (multiple choice + true/false)

• Multiple choice: single-answer questions on syntax details, concepts, and simple code reading — for example, showing a short snippet and asking what it outputs, or what an operator does;
• True/false: deciding whether a statement about a concept or a piece of code is correct.

Objective questions are "broad coverage, low difficulty per item," but they lean heavily on how clear the concepts are. Plenty of kids can write the programming problems yet lose points on the objective section — usually because they haven't fully grasped a syntax detail (like the difference between = and ==, or that integer division drops the decimal part).

Programming questions

• Writing a complete program live in the exam system, graded automatically by a judge;
• A Level 1 programming task is usually on the order of "read a few values → do a bit of arithmetic or a check → print the result";
• The key point: the code must actually run correctly and match the expected output exactly to earn points — "I think it's right" doesn't count.

This "objective questions plus real coding" combination means grinding concept questions alone isn't enough; a child needs plenty of hands-on coding practice. Conversely, only writing code without going back to shore up concepts costs points on the objective section. Both halves need practice.

Common beginner mistakes

Level 1 is simple, yet nearly every beginner trips on the same handful of spots. Knowing these traps in advance saves a lot of wasted effort:

1. Confusing = and ==: = assigns (puts the right-hand value into the left-hand variable); == tests for equality. Using = by mistake inside an if is the classic error.
2. Integer division drops the decimal: 7 / 2 is 3, not 3.5, because dividing two integers yields an integer. To get a decimal result, at least one operand must be a floating-point number.
3. Forgetting the int main() structure: code must live inside main, and don't forget the closing return 0; and the semicolons.
4. Input/output mismatch: the problem asks to read two numbers but the code reads only one; or the output has an extra/missing space or newline. The judge is strict about format.
5. Mixing full-width and half-width symbols: typing a Chinese-style semicolon or parentheses instead of the ASCII ; () causes an immediate compile error — the single most frequent beginner slip.
6. Watching videos without typing: understanding isn't the same as being able to write it. Programming is learned by doing; every concept should be verified by writing code by hand.

Individually these are tiny, but together they decide whether a child's code "runs on the first try." The best remedy while preparing is to let the child write and fix a lot in an environment that shows errors and results instantly. If setting up a local environment at home is a hassle, use a no-install online IDE: open a browser and you can write and run code right away, with an AI assistant to explain compile errors — a real help for beginners who get discouraged by red error messages.

Two illustrative problems to gauge Level 1 difficulty

Here are two illustrative examples (question-type demos, not real past papers) to give you a feel for the scale of a Level 1 programming problem. For the real exam, refer to the official system.

Example 1: Sum of two numbers (illustrative)

Reference solution:

#include <iostream>
using namespace std;

int main() {
    int a, b;
    cin >> a >> b;
    cout << a + b << endl;
    return 0;
}

This is about the smallest possible Level 1 program: read, compute, print — all in one breath. If a child can write it independently and error-free, the input/output hurdle is cleared.

Example 2: Odd or even (illustrative)

Reference solution:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    if (n % 2 == 0) {
        cout << "even" << endl;
    } else {
        cout << "odd" << endl;
    }
    return 0;
}

This one adds an if...else branch on top of Example 1, using the modulo operator % and the relational operator ==. It exercises nearly every core Level 1 topic at once: variables, input/output, arithmetic, relational operators, and simple branching. A child who can write this correctly on their own has a solid sense of what Level 1 programming problems feel like.

As you can see, the "difficulty" of Level 1 programming isn't in algorithms — it's in whether the basic syntax has truly been practiced until it's fluent and correct. That's exactly what this level is meant to check.

A workable Level 1 prep plan

Adapted to the realistic pace of a beginner, here's a solid plan for Level 1:

Step 1: Walk through the syntax, writing as you go (about 3–6 weeks)

Go through the topics in order: variables and types → input/output → operators → branching. After each topic, immediately write 5–10 small problems — this is the single most important rule for Level 1 prep. Don't let a child "watch without writing," because Level 1 is precisely a test of hands-on ability. Running code and seeing errors instantly in an online IDE is far more efficient at this stage than imagining it from a paper textbook.

Step 2: Practice by question type

• Objective questions: drill syntax details and code reading, and nail the error-prone concepts one by one (= vs ==, integer division, operator precedence);
• Programming questions: repeatedly practice the basic "read → compute/check → print" pattern until input/output is automatic. Always submit in an environment with an automatic judge, so "passing the test cases" is the only standard. AdaCpp's GESP online practice lets you drill by level and topic, with programming problems submitted and judged online, matching the feedback style of the real on-machine exam.

Step 3: Mock exams and gap-filling (1–2 weeks before)

Do a few full mocks in the real exam format to train the rhythm of finishing within the time limit. Focus on two things: whether objective points are lost to fuzzy concepts, and whether programming answers come up "just short" because of a formatting or symbol slip. Only a full mock surfaces these problems.

One reminder: don't rush to skip levels

Level 1 is easy, so some parents think about "just starting at Level 3." If a child genuinely handles loops and arrays with ease, skipping is reasonable — but if it's only a feeling of "this seems simple," it's better to start honestly at the level that matches their ability. A shaky Level 1 foundation (especially input/output and branching) tends to bite back later, in subtler ways, during the loops and arrays stage. A sensible pace is one level every 3–6 months, faster only if there's clear room to spare.

If you'd like a teacher to guide your child from zero through Level 1 and smoothly into Levels 2 and 3, take a look at AdaCpp's structured courses, designed around the GESP levels with clear modules and graded practice for each. To learn more about what Levels 2 and 3 cover, see What GESP C++ Levels 2 and 3 test; if you still have questions about signing up, the GESP registration guide goes into more detail.

A final word

GESP C++ Level 1 looks "easy," but it carries a job that isn't: helping a child who has never written code take a steady first step into programming. Get that step solid — variables, input/output, arithmetic, and branching written fluently — and the loops, arrays, and algorithms that follow have something to stack onto.

So there's no need to fear the difficulty of Level 1, nor to dismiss it. Treat it as a friendly entry checkup: write a lot, run the code often, get the most basic syntax to the point of no mistakes, and passing follows naturally. What's genuinely valuable is the first time a child feels "the program I wrote actually ran" — that sense of accomplishment is what will carry them a long way.