AP Computer Science Principles 2026 Exam Reference Guide

Exam Reference General Information

• This document pertains to the AP® Computer Science Principles 2026 EXAM REFERENCE INFORMATION.
• Blank space in the exam booklet may be used for scratch work during the exam.
• Proctors are required to collect this reference information at the conclusion of the exam.
• Copyright is held by © 2025 College Board.

Assignment, Display, and Input

• Assignment:   - Text: $a \leftarrow \text{expression}$   - Block: $a \leftarrow \text{expression}$   - Explanation: This operation evaluates the given $\text{expression}$ and then assigns a copy of the resulting value to the variable $a$.
• Display:   - Text: $\text{DISPLAY}(\text{expression})$   - Block: $\text{DISPLAY expression}$   - Explanation: This displays the value of the $\text{expression}$, followed by a single space.
• Input:   - Text: $\text{INPUT}()$   - Block: $\text{INPUT}$   - Explanation: This command accepts a value from the user and returns the input value.

Arithmetic Operators and Numeric Procedures

• Basic Arithmetic:   - Text and Block: $a + b$, $a - b$, $a \times b$, $a / b$   - Explanation: The arithmetic operators are used to perform arithmetic on variables $a$ and $b$.   - Division Example: The operation $17 / 5$ evaluates to the value $3.4$.   - Order of Operations: The standard order of operations used in mathematics applies when evaluating these expressions.
• Modulus Operator:   - Text and Block: $a \text{ MOD } b$   - Explanation: This evaluates to the remainder when the integer $a$ is divided by the integer $b$.   - Assumptions: It is assumed that $a$ is an integer greater than or equal to $0$ and $b$ is an integer greater than $0$.   - Precedence: The $\text{MOD}$ operator has the same precedence as the multiplication ($\times$) and division ($/$) operators.   - Example: The operation $17 \text{ MOD } 5$ evaluates to the value $2$.
• Random Interger Generation:   - Text: $\text{RANDOM}(a, b)$   - Block: $\text{RANDOM } a, b$   - Explanation: This procedure generates and returns a random integer from $a$ to $b$, including both the values of $a$ and $b$.   - Probability: Each possible integer result is equally likely to occur.   - Example: The call $\text{RANDOM}(1, 3)$ could return the values $1$, $2$, or $3$.

Relational and Boolean Operators

• Relational Operators:   - Text and Block Formats: $a = b$, $a \neq b$, a > b, a < b, $a \geq b$, $a \leq b$   - Explanation: These operators are used to test the relationship between two variables, expressions, or values.   - Return Type: A comparison using these operators evaluates to a Boolean value ($\text{true}$ or $\text{false}$).   - Example: The expression $a = b$ evaluates to $\text{true}$ if $a$ and $b$ are equal; otherwise, it evaluates to $\text{false}$.
• Boolean Logic:   - NOT:     - Text: $\text{NOT condition}$     - Block: $\text{NOT condition}$     - Explanation: Evaluates to $\text{true}$ if the $\text{condition}$ is $\text{false}$; otherwise, it evaluates to $\text{false}$.   - AND:     - Text: $\text{condition1 AND condition2}$     - Block: $\text{condition1 AND condition2}$     - Explanation: Evaluates to $\text{true}$ if both $\text{condition1}$ and $\text{condition2}$ are $\text{true}$; otherwise, it evaluates to $\text{false}$.   - OR:     - Text: $\text{condition1 OR condition2}$     - Block: $\text{condition1 OR condition2}$     - Explanation: Evaluates to $\text{true}$ if $\text{condition1}$ is $\text{true}$, or if $\text{condition2}$ is $\text{true}$, or if both are $\text{true}$. It evaluates to $\text{false}$ only if both conditions are $\text{false}$.

Selection (Conditional Statements)

• Simple IF Statement:     - Text: IF(condition) { <block of statements> } &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;     - Block: $\text{IF condition}$     - Explanation: The code within the $\text{block of statements}$ is executed only if the Boolean expression $\text{condition}$ evaluates to $\text{true}$. If the condition is $\text{false}$, no action is taken.
• IF-ELSE Statement:     - Text: IF(condition) { <first block of statements> } ELSE { <second block of statements> } &nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;     - Block: $\text{IF condition}$, $\text{ELSE}$     - Explanation: If the Boolean expression $\text{condition}$ evaluates to $\text{true}$, the code in the $\text{first block of statements}$ is executed. If the condition evaluates to $\text{false}$, the code in the $\text{second block of statements}$ is executed.

Iteration (Loops)

• REPEAT n TIMES:   - Text: REPEAT n TIMES { <block of statements> } &nbsp;&nbsp;&nbsp;&nbsp;   - Block: $\text{REPEAT } n \text{ TIMES}$   - Explanation: The code within the $\text{block of statements}$ is executed exactly $n$ times.
• REPEAT UNTIL:   - Text: REPEAT UNTIL(condition) { <block of statements> } &nbsp;&nbsp;&nbsp;&nbsp;   - Block: $\text{REPEAT UNTIL condition}$   - Explanation: The code in the $\text{block of statements}$ is repeated until the Boolean expression $\text{condition}$ evaluates to $\text{true}$.

List Operations

• Error Handling: For all list operations, if a list index is less than $1$ or greater than the current length of the list, an error message is produced and the program terminates.
• List Initialization:   - Text: $\text{aList} \leftarrow [\text{value1, value2, value3, …}]$   - Block: $\text{aList} \leftarrow \text{value1, value2, value3}$   - Explanation: Creates a new list containing specified values at indices $1$, $2$, $3$, and so on, and assigns it to $\text{aList}$.
• Empty List Creation:   - Text: $\text{aList} \leftarrow []$   - Block: $\text{aList} \leftarrow []$   - Explanation: Creates an empty list and assigns it to $\text{aList}$.
• List Copying:   - Text: $\text{aList} \leftarrow \text{bList}$   - Block: $\text{aList} \leftarrow \text{bList}$   - Explanation: Assigns a copy of the list $\text{bList}$ to the list $\text{aList}$.   - Example: If $\text{bList}$ contains $[20, 40, 60]$, then $\text{aList}$ will also contain $[20, 40, 60]$ after assignment.
• Accessing Elements:   - Text: $\text{aList}[i]$   - Block: $\text{aList } i$   - Explanation: Accesses the element of $\text{aList}$ at the specified index $i$.   - First Element: The first element is always at index $1$ and is accessed as $\text{aList}[1]$.
• Assigning from a List:   - Text: $x \leftarrow \text{aList}[i]$   - Block: $x \leftarrow \text{aList } i$   - Explanation: Assigns the value found at $\text{aList}[i]$ to the variable $x$.
• Assigning to a List:   - Text: $\text{aList}[i] \leftarrow x$   - Block: $\text{aList } i \leftarrow x$   - Explanation: Assigns the value of $x$ to the component at $\text{aList}[i]$.
• Assigning Between List Indices:   - Text: $\text{aList}[i] \leftarrow \text{aList}[j]$   - Block: $\text{aList } i \leftarrow \text{aList } j$   - Explanation: Assigns the value of $\text{aList}[j]$ to the position $\text{aList}[i]$.
• Inserting Elements:   - Text: $\text{INSERT}(\text{aList}, i, \text{value})$   - Block: $\text{INSERT aList, } i, \text{ value}$   - Explanation: Any values in $\text{aList}$ at indices greater than or equal to $i$ are shifted one position to the right. The length of the list increases by $1$, and the new $\text{value}$ is placed at index $i$.
• Appending Elements:   - Text: $\text{APPEND}(\text{aList, value})$   - Block: $\text{APPEND aList, value}$   - Explanation: The length of $\text{aList}$ is increased by $1$, and the $\text{value}$ is placed at the end of the list.
• Removing Elements:   - Text: $\text{REMOVE}(\text{aList}, i)$   - Block: $\text{REMOVE aList, } i$   - Explanation: Removes the item at index $i$ in $\text{aList}$ and shifts to the left any values at indices greater than $i$. The length of the list is decreased by $1$.
• List Length:   - Text: $\text{LENGTH}(\text{aList})$   - Block: $\text{LENGTH aList}$   - Explanation: Evaluates to the total number of elements currently in $\text{aList}$.
• List Traversal:   - Text: FOR EACH item IN aList { <block of statements> } &nbsp;&nbsp;&nbsp;&nbsp;   - Block: $\text{FOR EACH item IN aList}$   - Explanation: The variable $\text{item}$ is assigned the value of each element of $\text{aList}$ sequentially from first to last. The code in the $\text{block of statements}$ executes once for each assignment of $\text{item}$.

Procedures and Procedure Calls

• Procedure Definition without Return Value:   - Text: PROCEDURE procName(parameter1, parameter2, ...) { <block of statements> } &nbsp;&nbsp;&nbsp;&nbsp;   - Block: $\text{PROCEDURE procName parameter1, parameter2, …}$   - Explanation: Defines $\text{procName}$ as a procedure taking zero or more arguments. To call it, use $\text{procName}(\text{arg1, arg2, …})$.
• Procedure Definition with Return Value:   - Text: PROCEDURE procName(parameter1, parameter2, ...) { <block of statements> RETURN(expression) } &nbsp;&nbsp;&nbsp;&nbsp;   - Block: $\text{PROCEDURE procName parameter1, parameter2, … RETURN expression}$   - Explanation: Defines a procedure that returns the value of $\text{expression}$. The result can be assigned to a variable: $\text{result} \leftarrow \text{procName}(\text{arg1, arg2, …})$.
• RETURN Statement:   - Text: $\text{RETURN}(\text{expression})$   - Block: $\text{RETURN expression}$   - Explanation: Returns control flow to the point where the procedure was called and returns the evaluated $\text{expression}$ value. It causes an immediate return from the procedure.

Robot Operations

• Collision and Boundary Rules: If the robot attempts to move to a square that is not open or is beyond the grid edge, the robot stays in its current location and the program terminates.
• Move Forward:   - Text: \text{MOVE_FORWARD}()   - Block: \text{MOVE_FORWARD}   - Explanation: The robot moves one square forward in its current facing direction.
• Rotate Left:   - Text: \text{ROTATE_LEFT}()   - Block: \text{ROTATE_LEFT}   - Explanation: The robot rotates $90$ degrees counterclockwise in place.
• Rotate Right:   - Text: \text{ROTATE_RIGHT}()   - Block: \text{ROTATE_RIGHT}   - Explanation: The robot rotates $90$ degrees clockwise in place.
• Sensing Boundaries (CAN_MOVE):   - Text: \text{CAN_MOVE}(\text{direction})   - Block: \text{CAN_MOVE direction}   - Explanation: Evaluates to $\text{true}$ if there is an open square one square away in the specified $\text{direction}$ relative to where the robot is facing; otherwise, it evaluates to $\text{false}$.   - Valid Directions: The value of $\text{direction}$ can be $\text{left}$, $\text{right}$, $\text{forward}$, or $\text{backward}$.