GESP C++ Levels 2 & 3: What's New After Level 1 and How to Prepare

Plenty of families whose child has just passed GESP C++ Level 1 are getting ready to move on to Levels 2 and 3 — and finding that the difficulty seems to jump. Level 1 was about writing small programs like "read two numbers and decide which is larger." Level 2 starts asking the child to process data repeatedly with loops, and Level 3 brings in two-dimensional arrays and nested loops, concepts that sound tangled just to describe. The most common state at this stage is a child who "understands every explanation but freezes the moment they try to write it themselves."

This article is for families who already know what GESP is and are planning to guide their child from Level 1 up to Levels 2 and 3. It lays out, in one place, what each level newly covers, how the question difficulty changes, and the few pain points worth watching most closely. One reminder: this article discusses the scope of knowledge and how to study — for the exact syllabus, registration, and exam schedule of each level, always follow the latest announcements on the official CCF GESP website.

From Level 1 to Levels 2 & 3: How Big Is the Jump?

First, the big picture. GESP C++ Levels 1-8 form a gradual staircase, and Levels 1 through 3 belong to the "laying the syntax foundation" stage. But the gap between Level 1 and Level 3 is larger than many parents imagine.

Level 1 essentially tests one idea: a program is a list of instructions executed in order — variables, input/output, arithmetic, simple if branches. As long as a child can translate a problem into a few lines that run in sequence, they score. By Levels 2 and 3, the focus shifts from "can write a few lines" to "can control the program's flow and its data": using loops to repeat automatically, arrays to store data in bulk, functions to package repeated logic, and then using those tools to solve problems that require a little thinking.

An analogy helps. Level 1 is like learning to write a single sentence. Level 2 is learning to organize many sentences using "repetition" and "lists." Level 3 is starting to write structured, layered paragraphs. The jump shows up mainly in three places:

• From "sequence" to "loops": the program gains, for the first time, the ability to "repeat many times automatically," and the child has to understand how a loop runs and when it stops.
• From "single variable" to "a batch of data": arrays let a child store and retrieve data in bulk, which brings new issues like indices and out-of-bounds access.
• From "copying" to "thinking it through": problems no longer spell out every step. They give a scenario and let the child break it down into loops and conditions themselves. This is where programming thinking truly begins to form — and it is the first real hurdle.

What Level 2 Adds

Level 2 is where a child first meets the two core tools of "loops" and "arrays." Compared with Level 1, the new topics roughly include the following.

Loops: for and while

Loops are the undisputed centerpiece of Level 2. A child needs to master the two most basic loop forms:

• for loops: suited to "we know exactly how many times to repeat" — summing 1 to 100, reading in 10 numbers one by one.
• while loops: suited to "we don't know the exact count and stop only when a condition is met" — reading data until a 0 is entered.

The real difficulty isn't the syntax but the loop boundary: start from 0 or from 1? Loop up to n or n-1? Counting one too many or one too few (the classic "off-by-one error") is the single most frequent bug at this stage.

One-Dimensional Arrays

Arrays let a child manage a whole "row" of data under one name and process it in bulk with a loop. Common Level 2 array tasks include: reading n numbers into an array, finding the maximum and minimum, computing a sum or average, printing in reverse, and counting how many values meet a condition.

The new trap here is going out of bounds: for an array of length n, the valid indices are 0 to n-1, and it's easy to accidentally access the n-th slot, causing errors or bizarre results.

String Basics

Level 2 introduces strings — that is, "a sequence of characters." Basic operations include reading a string, getting its length, accessing a character by position, and scanning the whole string to count a certain kind of character. The relationship between characters and numbers (for example, the characters '0' through '9' map to consecutive codes inside the computer) is a concept that starts to seep in at this stage.

Simple Functions

The child begins to meet the idea of "packaging a commonly used piece of logic into a function and calling it when needed." Functions at Level 2 are usually simple — a small function to test whether a number is prime, or to return the larger of two numbers — and the point is to understand the basic model of "pass arguments in, get a result back."

The First Seeds of Enumeration and Simulation

With loops in hand, a child gains, for the first time, the ability to "try every possible case" — the embryo of enumeration thinking. And "following the problem's steps exactly, reproducing them in code one at a time" is the beginning of simulation thinking. Level 2 is far from complex algorithms, but these two most elementary problem-solving approaches are already appearing, planting seeds for what comes later.

What Level 3 Adds

Level 3 "adds a dimension and adds depth" on top of Level 2. If Level 2 is learning single loops and one-dimensional arrays, Level 3 is stacking them together and putting them to work on problems that demand more thought.

Nested Loops (Multiple Loops)

The most defining new topic at Level 3 is the nested loop — a loop inside another loop. Classic scenarios include printing shapes (triangles, multiplication tables), traversing a two-dimensional table, and comparing data pairwise.

Nested loops are a real test of a child's thinking: for each single turn of the outer loop, the inner loop must run all the way through, and the inner and outer loop variables must not be confused. Many children can follow what a double loop is doing, yet when writing one themselves they can't keep straight "which variable controls the row and which controls the column."

Two-Dimensional Arrays

A two-dimensional array can be pictured as a "table" or a "grid," using row and column indices to locate each cell. Common Level 3 problems include finding the maximum in a matrix, summing by row or by column, counting cells that meet a condition, and simple grid filling. It almost always appears together with nested loops.

Functions, Going Deeper — Parameters

Level 3 asks more of functions than Level 2: not only defining and calling them, but designing parameters and return values more fluently, splitting a somewhat larger problem into several functions that each do part of the work. The idea of scope — that "variables inside a function don't interfere with those outside" — also starts to take shape here.

More Complex Enumeration and Early Algorithmic Thinking

Enumeration at Level 3 is no longer as plain as "count from 1 to n." It may require double enumeration (for example, enumerating all pairs of numbers), or doing some checking and accumulating while enumerating. Combined with simulation, a child begins to handle problems that require "reading a longer problem statement and then translating it into multi-step code." This is the crucial transition from "syntax practice" toward "the start of algorithms."

Character Processing

Building on Level 2's string basics, Level 3 does more processing at the character level: converting case, deciding whether a character is a letter or a digit, counting different kinds of characters, and simple character-shifting ciphers (for example, moving each letter forward by a few positions). These problems look simple but really test a child's understanding that "a character is, at bottom, just a kind of code you can do arithmetic on."

How the Question Difficulty Changes

The exam format at Levels 2 and 3 is the same as Level 1 — a computer-based test split into objective questions (multiple choice and true/false) and programming questions. The change shows up mainly in two ways.

First, programming questions carry more weight and demand more thinking. Level 1 programming tasks often take just a few lines. Level 2 requires fluent use of loops and arrays; Level 3 frequently needs nested loops and two-dimensional arrays together, and you must think through your approach before writing. In other words, memorizing syntax is no longer enough — the child needs enough practice actually writing and debugging code on a computer.

Second, objective questions start testing "reading code." Beyond syntax concepts, objective questions give a snippet of code and ask the child to predict its output or explain what it does. This really tests the ability to "manually simulate a program's execution in your head (or on paper)" — children shaky on loops and arrays visibly lose points here.

The table below roughly contrasts where Level 2 and Level 3 place their emphasis (for understanding only; it does not represent official weightings):

Two Illustrative Examples: Feeling the Gap Between Levels 2 and 3

Below are two illustrative examples (self-written, only to suggest the question type) to help you feel the difficulty gap between Level 2 and Level 3 programming questions. These are not real exam problems; they only show roughly what the "jump in ability" looks like.

Illustrative example · Level 2 difficulty

Problem: Read an integer n, then read n integers, and output the difference between the largest and smallest of those n numbers.

A typical solution: store the data in an array (or compare as you read), scan once with a single loop, and track the maximum and minimum along the way. The core topics are loops + a one-dimensional array + processing while reading.

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    int maxv, minv, x;
    for (int i = 0; i < n; i++) {
        cin >> x;
        if (i == 0) {
            maxv = minv = x;   // the first number seeds both max and min
        } else {
            if (x > maxv) maxv = x;
            if (x < minv) minv = x;
        }
    }
    cout << maxv - minv << endl;
    return 0;
}

The thinking concentrates on "how to correctly initialize the max and min" and "maintaining two quantities in a single loop" — a very typical Level 2 intensity.

Illustrative example · Level 3 difficulty

Problem: Given an integer matrix with n rows and m columns, find every cell that is greater than all of its up/down/left/right neighbors (cells on the border only compare against the neighbors that exist), and output how many such cells there are.

This immediately shows Level 3's character: you need a two-dimensional array to hold the whole table, a nested loop to visit each cell, a check of the four directions around each cell, and careful handling of boundaries (cells on the outer ring have fewer neighbors).

#include <iostream>
using namespace std;

int a[105][105];

int main() {
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < n; i++)
        for (int j = 0; j < m; j++)
            cin >> a[i][j];

    // four directions: up, down, left, right
    int dx[4] = {-1, 1, 0, 0};
    int dy[4] = {0, 0, -1, 1};

    int count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            bool isPeak = true;
            for (int k = 0; k < 4; k++) {
                int ni = i + dx[k];
                int nj = j + dy[k];
                // only compare when the neighbor exists
                if (ni >= 0 && ni < n && nj >= 0 && nj < m) {
                    if (a[ni][nj] >= a[i][j]) {
                        isPeak = false;
                        break;
                    }
                }
            }
            if (isPeak) count++;
        }
    }
    cout << count << endl;
    return 0;
}

Put side by side, the gap is clear: the Level 2 problem needs only one loop and a one-dimensional array; the Level 3 problem asks the child to juggle a two-dimensional array, three levels of loops (over rows, over columns, over the four directions), and boundary checks all at once — a noticeably heavier cognitive load. This is exactly why many children sail through Level 2 and then start to "get stuck" at Level 3.

Where to Focus, and the Common Pain Points

Given the character of Levels 2 and 3, a few places deserve special attention from both parent and child.

Pain point 1: array out-of-bounds

This is the single most frequent error at Levels 2 and 3, bar none. Children slip up on indices: for an array of length n, valid indices run from 0 to n-1, and it's all too easy to reach the n-th slot. Two-dimensional arrays add a second index to manage, raising the error rate. Building the habit of "leave enough room when declaring an array, and think about the index range before accessing it" saves a huge number of baffling errors.

Pain point 2: loop boundaries (off-by-one)

Where a loop starts and where it ends is a bug hotspot at these levels. Is it i < n or i <= n? At which step inside the loop should the accumulation happen? These "off-by-one" mistakes usually don't throw an error — the result is simply wrong, and it's hard to trace. When practicing, take a tiny example (say n=3) and walk through the loop by hand on paper to check the result. That beats staring at the code and guessing.

Pain point 3: mistaking "understanding" for "being able to write it"

This is the one thing parents most need to grasp at this stage. A child nods along while reading an explanation or a solution — "I get it" — but closes the solution and has no idea where to start. This isn't laziness. "Reading code" and "writing code" are simply two different skills. There's only one cure: after understanding a solution, close it, and some time later rewrite the code from scratch yourself. Only when the child can write it independently and pass the tests does it count as truly learned.

Pacing suggestions

• Learn it thoroughly, then drill: for each new topic (loops, arrays, functions...), understand it systematically first, then reinforce with 5-10 similar small problems. Don't rush ahead half-digested.
• Verify everything on a computer: GESP programming questions are computer-based and auto-graded — "I think it's right" doesn't count. Only when the code actually runs and passes the test data do boundary problems surface. If setting up an environment at home is inconvenient, use a no-install online IDE: write and test right in the browser, with an AI assistant on hand to explain errors.
• Do timed past papers by level before the exam: as the exam nears, work through several years of past papers at the target level under real time limits, to train time management and expose weak spots. AdaCpp's GESP past-paper online practice collects past papers for each level, with programming questions you can submit online for automatic grading — the same experience as the real computer-based test.

If you'd rather have a teacher walk the whole path level by level, you can look into AdaCpp's structured courses designed around the GESP levels, where each level maps to clear knowledge modules and past-paper practice, sparing you the detours of piecing materials together yourself.

And After Levels 2 & 3?

Once Levels 2 and 3 are solid, moving up (Level 4 and beyond) gradually enters more advanced functions, richer string and array applications, and genuine "introductory algorithms" like recursion, sorting, and searching — with the link to CSP-J growing ever closer. For how the whole competitive-informatics path unfolds, see our CSP-J preparation roadmap.

A closing word for parents: Levels 2 and 3 are where many children first feel that "programming is a bit hard," and getting stuck at "I understand it but can't write it" is entirely normal — not a sign your child isn't cut out for this. GESP runs multiple times a year, so there's plenty of room for error: if one level doesn't pass, shore up the weak spots and try again a few months later. Rather than chasing level-skipping and speed, drilling the fundamentals of loops, arrays, and functions until they're solid — and letting your child build confidence through the cycle of "figured it out myself, wrote it myself, got it to run" — is the most valuable thing to gain at this stage. For the exact syllabus and registration details, please follow the latest announcements on the official CCF GESP website.