Variables store information that can change during a program. They allow algorithms to track state, update values, and compute results.

Key ideas:

• Assignment uses ←, not equals
• Variables update based on the sequence of instructions
• The exam often tests variable tracing

score ← 0
score ← score + 5

The new value replaces the old value — variables do not “remember” past values.

Conditionals let algorithms make decisions by evaluating Boolean expressions (true/false).

Boolean operators:

• AND — both must be true
• OR — at least one must be true
• NOT — reverses true/false

IF (age ≥ 18)
{
    DISPLAY("Adult")
}
ELSE
{
    DISPLAY("Minor")
}

Only the first true condition runs — later branches are ignored.

Loops repeat instructions multiple times. Understanding loop flow is crucial for the AP CSP exam.

Loop types:

• REPEAT n TIMES — fixed number of iterations
• WHILE (condition) — repeats until condition becomes false
• FOR EACH — iterates through all items in a list

Example:

counter ← 0
REPEAT 5 TIMES
{
    counter ← counter + 2
}

counter ends at 10.

Lists are one of the most important data abstractions in AP CSP.

Common list operations:

• APPEND(list, value)
• INSERT(list, index, value)
• REMOVE(list, index)
• LENGTH(list)
• list[i] — accessing an element

Traversal example:

sum ← 0
FOR EACH num IN numbers
{
    sum ← sum + num
}

Filtering example:

evens ← []
FOR EACH n IN nums
{
    IF (n MOD 2 = 0)
    {
        APPEND(evens, n)
    }
}

Functions allow code reuse and abstraction — hiding details so the user only focuses on what the function does.

Two kinds of functions:

• Procedures — perform actions
• Functions — return values

PROCEDURE Square(x)
{
    RETURN (x * x)
}

Many exam questions ask: “What value is returned?” — not displayed.

Many AP CSP questions use the same algorithmic building blocks.

Key patterns:

• Traversal — visit each element
• Accumulation — track a running total
• Filtering — build a new list based on a condition
• Searching — look for a specific value
• Mapping — transform each element

AP CSP does not require Big-O notation, but efficiency concepts still appear.

• Fewer operations → more efficient
• Loops inside loops (nested loops) are less efficient
• Binary search is more efficient than linear search
• Removing list items repeatedly can reduce efficiency

Question 1

What value is displayed by the following code?

x ← 2
y ← 1
REPEAT UNTIL (x > 10)
{
    x ← x * 2
    y ← y + 1
}
DISPLAY(y)

Answer: 4

Question 2

What does this procedure return?

PROCEDURE Mystery(list)
{
    sum ← 0
    FOR EACH n IN list
    {
        IF (n > 5)
        {
            sum ← sum + n
        }
    }
    RETURN(sum)
}

Answer: The sum of all values in the list that are greater than 5.

Question 3

What is printed by this code?

count ← 0
nums ← [3, 6, 1, 8, 2]
FOR EACH n IN nums
{
    IF (n MOD 2 = 0)
    {
        count ← count + 1
    }
}
DISPLAY(count)

Answer: 3 (Even values are 6, 8, and 2)

Question 4

What does this procedure return?

PROCEDURE DoubleEvens(list)
{
    result ← []
    FOR EACH x IN list
    {
        IF (x MOD 2 = 0)
        {
            APPEND(result, x * 2)
        }
    }
    RETURN(result)
}

Answer: A list containing all even numbers from the input list, each doubled. Example: [2, 3, 8] → [4, 16]

Question 5

What value is returned?

PROCEDURE Mystery(x)
{
    IF (x < 10)
    {
        RETURN(x * 3)
    }
    RETURN(x - 4)
}

Answer: If x < 10 → returns x * 3 Otherwise → returns x − 4 (This tests conditional branching.)