CSP-J Round 1 vs Round 2: What Each Tests and How to Prepare for Both

Many parents hearing about CSP-J for the first time assume it's a single exam — you sign up, sit it once, and you're done. It isn't. CSP-J runs in two rounds, and the two rounds differ so much in format, content, and required skills that they're almost separate exams. The first round (commonly called the "preliminary") is mostly multiple-choice and true/false questions done at a desk, testing general computer knowledge and the ability to read code. The second round (the "final") requires writing complete C++ programs on a computer, graded automatically by a judging system. Prepare for only one of them, and it's easy to stumble on the other.

This guide is written for parents and students starting from scratch. It lays out the differences between the two rounds: what each tests, how they differ in difficulty, how they're scored, and how to prepare for each specifically. At the end there's an original, final-level sample problem so you can get a concrete feel for the difficulty of Round 2.

First, why two rounds?

CSP-J is the entry-level (Junior) track of the "Certified Software Professional (Non-professional Level)" run by the CCF (China Computer Federation). It's held once a year. The reason it splits into two rounds is essentially a layered selection: screen for knowledge breadth first, then test real skill.

• Round 1 (preliminary): Objective questions — multiple-choice and true/false (written or on-computer) — testing basic computer knowledge and code-reading ability. You don't write full programs. It works like a threshold, filtering out those whose knowledge base is clearly too thin.
• Round 2 (final): All on-computer programming problems, writing complete C++ programs on the spot, graded automatically by an OJ (online judge). This is the round that actually decides the awards.

The two rounds are connected by promotion: you must reach your province's cutoff in Round 1 to advance to Round 2, and the first-, second-, and third-place awards are decided by Round 2 scores. In other words, Round 1 is the ticket in; Round 2 is the main event.

One caveat: the number of questions, time limits, and cutoff scores are all set by the CCF and may change year to year, with each province drawing its own line. So this article only describes the structural and format differences between the two rounds — it does not list specific scores. Always follow the CCF's official rules and the current year's announcement.

Round 1 (preliminary): knowledge breadth and code-reading

Round 1 involves no coding, but that doesn't make it easy. It tests breadth — whether the knowledge base is wide enough and the fundamentals are solid. It mainly covers:

• General computer knowledge: history of computing, hardware components, basic concepts of operating systems and networks;
• Number systems and encoding: conversion between binary, octal, and hexadecimal, and the concepts of sign-magnitude, ones' complement, and two's complement;
• Math and logic: permutations and combinations, simple probability, logical operations and propositional reasoning;
• Reading programs: given a piece of C++ code, determine its output or fill in a missing part — this is where the biggest gaps open up. At its core it tests solid syntax fundamentals and the ability to mentally trace a program's execution by hand.

Round 1 is characterized by many questions, little time per question, and broad coverage. If you don't know a question, you simply don't know it — unlike a programming problem, you can't "think for a while and find an idea." So Round 1 rewards steady accumulation: whether concepts are firmly memorized, whether base conversions are fluent, whether you can trace a snippet of code line by line in your head and get the right result.

Where points are most easily lost in Round 1

• General knowledge questions rely on long-term accumulation — last-minute cramming helps little, so keep an eye on hardware, network, and OS terminology over time;
• Base conversion and two's complement trip up many students, and are easy to miscalculate under exam pressure — they need repeated practice until they become muscle memory;
• Code-reading questions are the most draining and the most decisive — loop boundaries, variable values in each iteration, the order of recursive calls: one misread step and everything after it is wrong. Points lost here are usually not from "not knowing" but from "not having the patience to trace line by line."

Round 2 (final): actually writing programs on a computer

Round 2 is a completely different exam from Round 1. The student sits at a computer and writes complete C++ programs on the spot. The program must compile, run, and produce correct output for all test data to earn points. Core topics include:

• Simulation and enumeration: simulating a process directly per the problem, or brute-forcing all possible cases;
• Greedy: making locally optimal choices, often after sorting;
• Recurrence and recursion: sequence recurrences, recursive function design, simple memoization;
• Sorting and binary search: common sorting ideas, binary search and binary search on the answer;
• Simple search: entry-level depth-first search (DFS) and breadth-first search (BFS) problems;
• Basic data structures: arrays, strings, structs, stacks, queues, and common STL containers.

Round 2 problems are usually ordered by increasing difficulty: the earlier ones lean on syntax and simulation, and only the later ones truly test algorithms. For the entry-level track, solving the earlier problems solidly and grabbing as much partial credit as possible on the later ones often earns a good ranking.

How Round 2 is graded: the OJ decides, not "I think it's right"

The most crucial — and most often overlooked — point about Round 2 is how it's graded. Unlike a school exam where a teacher marks your work, it's judged automatically by an OJ (Online Judge). Your program is fed a set of prepared test cases, and only if it produces completely correct output for every case, within the time and memory limits, does it pass.

This means several things:

• "I think it's right" doesn't count — you only score by passing test cases, and one mishandled edge case can mean zero points;
• Partial credit matters — many problems have multiple tiers of data, so even if you can't produce the full-mark algorithm, a correct brute-force solution can still earn part of the score;
• Timeouts and memory overflows are also failures — an algorithm that isn't efficient enough won't pass the large test cases.

This feedback mechanism is completely different from the "feels right, submit it" habit of homework, and it takes getting used to in advance.

Where points are most easily lost in Round 2

• Unhandled edge cases: an array declared too small, a loop that runs one iteration short, special inputs (like 0, the maximum value, or empty cases) not considered;
• Only brute force, afraid to grab partial credit: giving up on hard problems entirely, when a brute-force solution that passes small data could still earn valuable partial points;
• Poor time allocation: grinding too long on one hard problem, leaving no time for problems you could have solved;
• Not enough hands-on practice: with too little practice, students waste time on the exam debugging code that won't even compile.

Round 1 vs Round 2: the differences at a glance

(The table is a general description; specific rules and scores follow the CCF's official announcement for the current year.)

How to prepare for each round

Since the two rounds test differently, the focus of preparation naturally differs too. The biggest mistake is preparing only one side. Drill only programming and neglect Round 1 knowledge, and you may never make it into Round 2; memorize only concepts and never practice coding, and even if you scrape through Round 1, you'll be helpless in Round 2. The sensible approach is to run both lines in parallel, each with its own emphasis.

Round 1 prep: fill knowledge gaps + drill objective questions + practice reading code

• Systematically fill in the knowledge base: computer basics, number systems and encoding, logic and math — these accumulate bit by bit over time, with a concentrated review before the exam;
• Drill plenty of past Round 1 papers: Round 1 question types are relatively fixed, so working through past papers reveals the question style and exposes blind spots;
• Practice "reading programs" specifically: this is the highest-leverage question type — practice until you can patiently trace loops and recursion line by line on paper, writing out every variable's value at each step;
• Revisit mistakes: note the concept questions you got wrong and the base conversions you miscalculated, redo them a week or two later, until they become reflexive.

Round 2 prep: attack algorithm topics + hands-on practice + use a matching judge environment

Round 2 relies on genuine programming ability, which can only be built by doing. Work topic by topic: simulation/enumeration → sorting → greedy → recurrence/recursion → binary search → DFS/BFS → stacks and queues, with each topic following "one worked example, 5-10 independent problems of the same type, then revisit mistakes." This progressive order is the same algorithm-learning sequence we lay out in the CSP-J roadmap.

More important than the drilling order is practicing in a judge environment that matches Round 2. The biggest difference between competitive-programming prep and ordinary homework is that code must pass the OJ's automatic grading. Build the habit of "submit every exercise to the OJ, with passing all test cases as the only standard" — edge cases and timeouts will force the student to write rigorous code. AdaCpp's GESP past-paper practice has a large bank of graded, leveled problems to drill by topic, and its judging system matches the way CSP-J Round 2 is graded, so getting used to this "no points until the test cases pass" feedback in advance is genuinely worthwhile. For everyday coding and debugging, you can also use the install-free online IDE — open a browser and start writing, with an AI assistant on hand to explain compile errors.

A final-level sample problem

Talking about difficulty is abstract, so here's an original problem at entry-level Round 2 difficulty to give you a concrete feel for what the final round tests.

The "trap" here is the negative numbers — you can't just add up all the positive ones. The naive idea is to enumerate every start and end point, but that times out when n is large. Round 2 wants the student to arrive at an O(n) linear approach: scan left to right, maintaining "the maximum subarray sum ending at the current number," and if the accumulated sum so far is negative, drop it and start fresh. Reference code:

#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;

    long long best = 0;      // global maximum subarray sum
    long long cur = 0;       // maximum subarray sum ending at the current element
    bool first = true;

    for (int i = 0; i < n; i++) {
        long long x;
        cin >> x;

        // if the running sum is negative, discard and restart; otherwise extend
        if (cur < 0) {
            cur = x;
        } else {
            cur = cur + x;
        }

        // update the global answer (seed with the first element so all-negative inputs work)
        if (first || cur > best) {
            best = cur;
            first = false;
        }
    }

    cout << best << endl;
    return 0;
}

This problem distills several typical features of Round 2: you need an algorithm better than brute force (or the large cases time out), you must handle edge cases (when every number is negative, the answer should be the largest negative number, not 0 — the first flag guarantees this), and you must use the exact input/output format the OJ expects. Real final-round problems are longer with more elaborate story framing, but the core is the same: understand the problem → devise a correct and fast enough algorithm → write code that passes all test cases.

FAQ

Does passing Round 1 mean I'm set?

No. Round 1 is only the threshold to advance; the final awards depend entirely on Round 2. Many students score well in Round 1 but, having practiced little hands-on coding, can't write the programs in Round 2. Clearing Round 1 just gets you the ticket to the main event — the algorithm and coding ability in Round 2 is what decides the ranking.

If I don't clear Round 1, was the whole half-year wasted?

No. The computer basics and code-reading skills Round 1 tests are part of learning to program anyway; and the algorithm training you did for Round 2 genuinely improved your ability, whether or not you advanced. CSP-J happens every year, and in between you can keep momentum with GESP grading, so coming back next year is a perfectly normal rhythm. For how GESP and CSP-J connect, see how GESP, CSP-J, and NOI relate.

Which round should I prepare first?

Treat Round 2 (algorithms and hands-on coding) as the long-term main line, since its skills are the hardest, most time-consuming, and most fundamental; the Round 1 knowledge base and code reading can be woven in and pushed hard in the month or two before the exam. In other words, practice Round 2 day to day, top up Round 1 before the exam is a steady rhythm — but neither side can be dropped entirely.

What's the deal with partial credit in Round 2?

Round 2 problems usually have multiple tiers of test data, from small to large scale. Even if you can't devise the efficient algorithm needed for full marks, a correctly written brute-force solution that runs on the small data earns the points for those tiers. So don't give up on hard problems outright — grabbing partial credit first is a very important exam strategy in Round 2.

Wrapping up

CSP-J has two rounds testing two different abilities: Round 1 rewards breadth of knowledge and careful code reading, while Round 2 rewards algorithmic foundations and hands-on execution. Understanding this difference keeps your preparation from misfiring — you won't get stuck in Round 2 from drilling only concept questions, nor fail to reach the main event by neglecting Round 1. Treat Round 2's algorithm ability as the long-term main line, use Round 1's knowledge base as a pre-exam sprint, and build hands-on feel in a judge environment that matches Round 2 — that's the steadiest path. The specific rules, question counts, and cutoff scores may change every year, so before registering, follow the CCF's official announcement for the current year.