AP CSP Exam: Reference Sheet Summary

Jan 16, 2026 by Editorial Team 37 views

AP Computer Science Principles Exam: Reference Sheet Summary

Alright, future AP Computer Science Principles superstars! Let's break down the AP CSP Exam Reference Sheet – your trusty sidekick for the big day. This isn't just a list of stuff; it's the only set of rules you need to know for the exam. Forget fancy coding tricks or obscure syntax; if it's not on this sheet, it's not on the test. We're going to go through everything, from the basics like assigning values and displaying results to more complex topics like loops, lists, procedures, and even robot commands. This guide will make sure you understand the core concepts and can ace that exam. Let's get started, shall we?

Assignment, Display, and Input: The Building Blocks

First up, let's talk about the fundamentals: how we get data into our programs, how we show the results, and how we store values. It's like the ABCs of coding, and once you get these down, the rest will follow much easier. Let’s dive in and dissect each one. This section is all about getting data in, displaying what we've got, and holding onto information so we can use it.

Assignment

Think of assignment like giving a name to something. You're taking an expression (a calculation or a value) and saying, "Hey, I want to call this 'a' and store it." The left arrow (←) is your best friend here. It points to where the value is going. For example, if you see a ← 5, it means the variable a now holds the value 5. Super simple, right? It's the equivalent of setting a variable in many programming languages. If the expression is more complex, such as a ← 2 + 3, the code will calculate the result (5) and then assign it to 'a'.

Display

DISPLAY() is how your program talks back to you. It takes what you tell it (an expression, a variable's value, or even a message) and shows it on the screen. It is your program's way of showing you the result. DISPLAY(a) will show you the value stored in the variable a. If a holds 5, then the display will show 5. Remember, everything displayed is followed by a space, which is critical for formatting your output so it's readable.

Input

INPUT() is how your program listens to the outside world. It lets the user enter information that the program can then use. Think of it as a question: “Hey, user, give me a value!” Whatever the user types is then returned, usually to be used in an expression or assigned to a variable. This is how you allow your program to be dynamic and react to user interaction. You can prompt the user with a message before using INPUT(), providing context for the input.

Arithmetic Operators and Numeric Procedures: Math Time

Now, let's get into the math. Coding is all about calculations, and knowing how to do them correctly is a cornerstone of the exam. This section covers all the standard operators you'll need, plus some cool tricks to handle remainders and generate random numbers.

Arithmetic Operators

You'll use these operators every day: + (addition), - (subtraction), * (multiplication), and / (division). These guys follow the standard order of operations (PEMDAS/BODMAS), so parentheses are your friends if you need to control the calculation order. Division will return decimal values if necessary. It’s important to understand the hierarchy to get the right answers. Always make sure that you get the right answers.

MOD Operator

The MOD operator is a handy one for finding the remainder after integer division. If you want to know what's left over after dividing, use MOD. For example, 10 MOD 3 equals 1 (because 10 divided by 3 is 3 with a remainder of 1). The MOD operator is useful for tasks like determining if a number is even or odd or for cyclical behavior. For instance, in an array, you could use MOD to loop from index 0 to array.length.

RANDOM Procedure

RANDOM(a, b) generates a random integer. The cool thing is that the generated integer falls between the values of a and b, inclusive. This means it can return a, b, or any whole number in between. This is super useful for simulations, games, or any situation where you need an element of chance. When using RANDOM, make sure your values for a and b are appropriate for the context of your program.

Relational and Boolean Operators: Making Decisions

Now let's talk about how your code makes decisions. Relational operators compare values, and Boolean operators let you combine and manipulate those comparisons. This is where your code gets its smarts, where the logic of the code starts.

Relational Operators

Relational operators compare values and evaluate to either true or false. These are used to compare two values. Here they are: =, ≠, >, <, ≥, ≤. For example, 5 > 3 evaluates to true, while 2 = 7 evaluates to false. These operators are essential for the IF and REPEAT UNTIL statements, making your code react to different situations. Make sure you use them correctly! Getting these operators correct is crucial for the logical flow of your program.

Boolean Operators

Boolean operators combine or change conditions. They deal with true or false values. The NOT operator reverses a condition (if something is true, NOT makes it false, and vice versa). AND requires both conditions to be true for the combined expression to be true. OR requires at least one condition to be true for the combined expression to be true. Understanding these operators is important for combining conditions in conditional statements. They are crucial for creating complex decision-making processes.

Selection (Conditionals): Making Choices

Conditional statements are like the decision-makers in your code. They allow you to execute different blocks of code based on whether certain conditions are met. This allows your code to adapt based on conditions and user input.

IF Statements

An IF statement checks if a condition is true. If it is, the code inside the curly braces {} is executed. If the condition is false, the code is skipped. This is your basic, one-way decision. This is useful when you want to execute a section of code only when a specific criterion is met. An example: IF(score > 100) { DISPLAY("High Score!") }. This allows you to give feedback or perform actions based on conditions.

IF/ELSE Statements

IF/ELSE statements provide an alternative path. If the condition in the IF part is true, the first block of code is executed. If the condition is false, the code in the ELSE block is executed. This is a two-way decision, giving you control over what happens in both scenarios. For example: IF(age >= 18) { DISPLAY("You can vote.") } ELSE { DISPLAY("You can't vote yet.") }. This allows the program to react differently depending on the input or the current state.

Iteration (Loops): Repeating Actions

Loops are the workhorses of programming. They let you repeat a block of code multiple times, which is essential for automating tasks and handling large amounts of data. REPEAT statements are your go-to tools for repeating actions efficiently.

REPEAT n TIMES

This loop repeats a block of code a specific number of times. The n specifies how many times the code inside the curly braces will run. This is excellent when you know exactly how many times you need to do something. Example: REPEAT 5 TIMES { DISPLAY("Hello") } will display "Hello" five times. This is perfect for tasks where you need to perform an action a set number of times, like processing a list of items.

REPEAT UNTIL

This loop repeats a block of code until a condition becomes true. The condition is checked after each iteration. This is ideal when you don’t know how many times you need to loop, but you have a condition that will eventually be met. Example: REPEAT UNTIL(counter = 10) { counter ← counter + 1 }. This is suitable for waiting for a certain condition to be met, like a user entering a specific value or a calculation reaching a specific result. The condition determines when the loop stops.

List Operations: Working with Collections

Lists are ordered collections of data. You'll use them to store and manipulate multiple values as a single entity. They are incredibly useful for everything from storing game scores to managing data in your programs. Knowing how to use these efficiently is a must-have skill.

List Creation and Access

Lists are created with square brackets []. You can create a list directly, assign it to another list, or initialize it as empty. Accessing elements in a list is done using an index number, with the first element at index 1 (not 0, as in some languages!). aList[i] refers to the element at the ith position in the list aList. You can both read and modify elements in this way. For example: myList ← [1, 2, 3] creates a list and x ← myList[2] assigns the value 2 (the second element) to the variable x. Changing values is just as simple: myList[1] ← 10 would change the first element to 10.

List Procedures

These procedures let you manipulate lists dynamically. You can add, remove, and get the length of the list, as well as iterate over its elements using FOR EACH loops.

INSERT(aList, i, value)

This adds a value at position i in the list aList, shifting existing elements to the right. INSERT is helpful when you need to insert an item in the middle of a list, maintaining the order. INSERT(myList, 2, 5) would add 5 at the second position in myList, moving the existing elements at the second position and onward to the next positions.

APPEND(aList, value)

This adds a value to the end of the list aList. The simplest way to add an item to the end of a list. APPEND(myList, 7) would add 7 to the end of the list myList, effectively growing the list by one element.

REMOVE(aList, i)

This removes the element at position i in the list aList, and shifts the following elements to the left, closing the gap. REMOVE allows you to remove unwanted elements in the list. REMOVE(myList, 3) would remove the element at the third position in myList.

LENGTH(aList)

This returns the number of elements in the list aList. Use LENGTH to find out the size of a list, allowing you to iterate over it or avoid out-of-bounds errors. Useful for looping through the list, etc. x ← LENGTH(myList) will store the number of elements of myList in variable x.

FOR EACH item IN aList

This loop iterates through each element in the list aList. This is a handy way to process each item in a list without needing to manually manage indices. This is useful when you want to perform the same actions on each element in your list without needing to access them by index. FOR EACH item IN myList { DISPLAY(item) } will display each element of myList one by one.

Procedures and Procedure Calls: Reusable Code

Procedures are blocks of code that you can define and reuse. This makes your code more organized, efficient, and easier to understand. They can take inputs (parameters) and optionally return a value.

PROCEDURE Definition

This is where you define a procedure: PROCEDURE procName(parameter1, parameter2, ...) creates a named procedure. Inside the curly braces {} you put the code that the procedure will execute. Procedures can take parameters that are used inside the block. RETURN(expression) is how a procedure can send back a result. Procedures help organize your code and make it easier to read and maintain. For example, PROCEDURE add(a, b) { RETURN(a + b) } defines a procedure to add two numbers. When the RETURN statement is executed, the procedure stops and returns the value.

Procedure Calls

To use a procedure, you call it by using its name and any required arguments. If the procedure returns a value, you can assign that value to a variable, like this: result ← procName(arg1, arg2). If it doesn't return a value, you just call it by name. Procedure calls make your code modular and reusable. For instance, sum ← add(5, 3) calls the add procedure and stores the returned sum in the variable sum.

Robot Commands: Bringing Code to Life

Get ready to control a virtual robot! These commands let you program a robot to move around a grid. It’s a great way to understand how instructions translate into actions, adding an interactive element to the coding experience.

Robot Command Overview

These commands control the robot's movement and actions on a grid. You'll be able to move it around, rotate it, and even check if it can move in a particular direction. The program will terminate if the robot tries to move off the grid or into a blocked square.

MOVE_FORWARD()

This makes the robot move one step forward in its current direction. Essential for getting the robot to move from point A to point B. This function is the robot's means to advance.

ROTATE_LEFT()

This turns the robot 90 degrees to the left. Critical for changing the robot's orientation. Useful for changing the direction it is facing.

ROTATE_RIGHT()

This turns the robot 90 degrees to the right. Also critical for changing the robot's orientation. Equally useful as the other rotation command.

CAN_MOVE(direction)

This checks if the robot can move in a specified direction (left, right, forward, or backward). It doesn't move the robot; it simply tells you if the move is possible (i.e., not blocked and within the grid boundaries). This helps avoid errors and allows for conditional movement. Example: IF (CAN_MOVE(FORWARD)) { MOVE_FORWARD() }.

Final Notes: Key Reminders for Exam Success

Alright, you've made it through the Reference Sheet! Let's wrap up with a few crucial points to keep in mind as you prep for the exam.

Stick to the Syntax: The exam only uses the syntax on this sheet. Don’t try to get fancy or use tricks from other languages. Stick to what you’ve learned! It's better to be safe than sorry.
Indexing Starts at 1: Always remember that lists and arrays start their indexing at 1, not 0. This is different from some other programming languages, so it's a critical detail to get right.
Booleans are True or False: Boolean expressions must evaluate to either true or false. If it doesn't, it’s not valid.
Procedures and Returns: Procedures may or may not return values. Make sure you understand how the specific procedure you're using is defined.

That's it, guys! You're now ready to use the AP Computer Science Principles Exam Reference Sheet. Stay calm, study well, and you'll do great on the exam. Good luck! You've got this!