AP CSP Pseudocode: The Complete Guide with Practice Problems (2026)

Master every symbol, keyword, and pattern that appears on the AP Computer Science Principles exam — with hard MCQ practice built in.

Why College Board Pseudocode Trips Students Up

Here’s the uncomfortable truth: students who take AP CSP in Python, JavaScript, or Scratch all hit the same wall on exam day. The College Board writes every single algorithm question in its own pseudocode — not Python, not Java, not anything you coded with all year.

That pseudocode uses a left-pointing arrow (←) for assignment, angle brackets for list indexing, and specific keywords like REPEAT UNTIL that have no direct equivalent in most languages students know. If you have not drilled this syntax cold, you will misread questions under timed pressure.

The good news: the pseudocode is small. There are about a dozen keywords, three loop types, two Boolean operators, and one list structure. Once you own the reference table below, the logic of each question is the only thing left to solve.

The Complete Syntax Cheat Sheet

Print this out. Tape it above your desk. This is the only pseudocode on the AP CSP exam.

College Board Pseudocode vs. Python

If you learned Python, this side-by-side comparison will be the fastest way to lock in the differences. Pay close attention to assignment, list indexing, and loop exit conditions — those are where most students lose points.

Operators, Expressions & Assignment

The assignment arrow is the most visually distinctive part of College Board pseudocode. Every variable gets its value through ←, and you should read it as “gets the value of.” The right side is fully evaluated first, then stored in the variable on the left.

This means you can write things like:

count ← count + 1

This reads “count gets the current value of count plus one” — a standard increment. The old value of count is used on the right side before the new value is stored.

MOD in Depth

The MOD operator returns the remainder from integer division. It is one of the most tested operators on the exam because of its usefulness in determining divisibility, cycling through values, and extracting digits.

// Is x even?
IF(x MOD 2 = 0)
{
    DISPLAY("even")
}
ELSE
{
    DISPLAY("odd")
}

// Cycle through 0-4 (five positions) regardless of how large n grows
position ← n MOD 5

// Last digit of a number
lastDigit ← num MOD 10

Conditionals: IF / ELSE IF / ELSE

AP CSP pseudocode does not have a built-in ELSE IF keyword. Multi-branch logic is written by nesting an IF inside an ELSE block. This is an important distinction because the exam will show you nested structures and ask you to trace the exact path of execution.

IF(score ≥ 90)
{
    DISPLAY("A")
}
ELSE
{
    IF(score ≥ 80)
    {
        DISPLAY("B")
    }
    ELSE
    {
        DISPLAY("C or below")
    }
}

When tracing a conditional, identify the first condition that evaluates to true. Once a branch executes, none of the other branches run — execution jumps to the code after the entire IF/ELSE structure.

Loops: REPEAT TIMES vs. REPEAT UNTIL

There are two critical differences between the two loop types that the exam exploits constantly.

REPEAT n TIMES runs exactly n times. The count does not change based on what happens inside the loop. If n is 5, the block executes exactly 5 times, period.

REPEAT UNTIL(condition) checks its condition at the END of each iteration. This means the loop body always runs at least once, even if the condition starts out true. The loop continues while the condition is false and exits the moment the condition becomes true.

count ← 0
REPEAT 4 TIMES
{
    count ← count + 1
}
// count is now 4
DISPLAY(count)
// Output: 4

count ← 0
REPEAT UNTIL(count = 4)
{
    count ← count + 1
}
// Stops when count reaches 4
DISPLAY(count)
// Output: 4

FOR EACH in Practice

FOR EACH is the cleanest loop for processing every element of a list. The loop variable takes on each element’s value in order, from index 1 to the end.

scores ← [87, 94, 72, 88, 95]
total ← 0

FOR EACH score IN scores
{
    total ← total + score
}

average ← total / LENGTH(scores)
DISPLAY(average)
// Output: 87.2

Lists and List Procedures

Lists in College Board pseudocode are ordered, mutable, and 1-indexed. The four procedures — APPEND, INSERT, REMOVE, and LENGTH — are all tested on the exam, often in combination.

Tracing INSERT and REMOVE

INSERT and REMOVE shift elements, which changes the index of every element after the target position. This is a common source of off-by-one errors when students trace code.

letters ← ["A", "B", "C", "D"]
// letters[1]="A", letters[2]="B", letters[3]="C", letters[4]="D"

INSERT(letters, 2, "X")
// "X" goes to index 2, B/C/D shift right
// letters[1]="A", letters[2]="X", letters[3]="B", letters[4]="C", letters[5]="D"

REMOVE(letters, 3)
// "B" (now at index 3) is removed, C/D shift left
// letters[1]="A", letters[2]="X", letters[3]="C", letters[4]="D"

DISPLAY(letters[2])
// Output: X

Procedures and RETURN

A procedure is a named block of code that can be called by name. When a procedure includes a RETURN statement, it sends a value back to wherever it was called from and immediately stops executing. Any code after RETURN inside the procedure is unreachable.

PROCEDURE max(a, b)
{
    IF(a > b)
    {
        RETURN(a)
    }
    RETURN(b)
}

result ← max(14, 9)
DISPLAY(result)
// Output: 14

Robot Grid Problems

Robot problems appear on almost every AP CSP exam. The robot is represented by a triangle pointing in the direction it faces. All four procedures manipulate the robot’s position or orientation, and you must mentally simulate each step.

The key rules: ROTATE_LEFT and ROTATE_RIGHT change direction but do NOT move the robot. MOVE_FORWARD moves exactly one square in the current facing direction. CAN_MOVE checks for walls before moving and is typically used in conditional logic.

// Move robot to a gray square while navigating around walls
REPEAT UNTIL(CAN_MOVE(forward) = false)
{
    MOVE_FORWARD()
}
ROTATE_RIGHT()
MOVE_FORWARD()

num ← 2
REPEAT UNTIL(num = 10)
{
    IF(num MOD 2 = 0)
    {
        DISPLAY(num)
    }
    num ← num + 2
}

PROCEDURE mystery(numList)
{
    result ← 0
    FOR EACH val IN numList
    {
        IF(val MOD 2 ≠ 0)
        {
            result ← result + val
        }
    }
    RETURN(result)
}

items ← [10, 20, 30, 40]
temp ← items[1]
items[1] ← items[4]
items[4] ← items[1]
DISPLAY(items)

x ← 1
REPEAT UNTIL(x > 5)
{
    IF(x MOD 3 = 0)
    {
        DISPLAY(x)
    }
    x ← x + 1
}

PROCEDURE checkValue(n)
{
    IF(n < 0)
    {
        DISPLAY("negative")
        RETURN(0)
    }
    IF(n = 0)
    {
        RETURN(0)
    }
    DISPLAY("positive")
    RETURN(n * 2)
}

DISPLAY(checkValue(-3))

data ← [5, 10, 15, 20, 25]
INSERT(data, 3, 99)
REMOVE(data, 1)
APPEND(data, 0)

found ← false
i ← 1
REPEAT UNTIL(found OR i > LENGTH(myList))
{
    IF(myList[i] = target)
    {
        found ← true
    }
    i ← i + 1
}
DISPLAY(found)

Most Common Pseudocode Errors on the AP Exam

After reviewing thousands of student answers in my 11 years of teaching, these are the mistakes that appear most often on AP CSP pseudocode questions.

Forgetting that lists start at index 1. Students who code in Python instinctively write myList[0]. In College Board pseudocode, that index does not exist for a standard list. Always add 1 when translating your mental model.

Misreading REPEAT UNTIL exit timing. The condition is checked AFTER the block runs. If you need to know whether a value is displayed, trace through the entire body before checking the exit condition for that iteration.

Using = for assignment in comparisons. In pseudocode, = means equality check inside conditions. Assignment uses ←. The exam will show you conditionals with = and you must read it as a test, not an assignment.

Assuming code after RETURN executes. RETURN is an immediate exit. Anything written in the procedure body below a RETURN is dead code. The exam tests this directly with DISPLAY statements placed after RETURN.

Confusing AND with OR in range checks. To be inside a range, a value must satisfy both conditions — AND. To be outside a range, it fails at least one — OR. Students who mix these up produce logic errors that only manifest on edge cases, which is exactly what the exam uses.

Not accounting for element shifting after INSERT and REMOVE. After INSERT or REMOVE, all indices after the target position change. Trace list state step by step rather than trying to track everything in your head at once.