Big Idea 3: Algorithms and Programming

Overview

Big Idea 3: Algorithms and Programming is the largest part of AP CSP, making up 30-35% of the AP exam. It covers everything about how programs actually work: variables, conditionals, loops, lists, procedures, and how to judge whether an algorithm is efficient or even solvable. If Big Ideas 1 and 2 are about why we build programs and what data they use, Big Idea 3 is the actual building.

Here's something that trips people up at first. AP CSP has no required programming language. Your teacher might use Python, JavaScript, Scratch, or App Lab, but the exam uses its own simplified pseudocode (defined on the exam reference sheet you get during the test). That's why this unit focuses on structures every language shares, like sequencing, selection, and iteration, instead of the syntax of any one language. Learn the logic once and it transfers everywhere.

What Big Idea 3 Covers

Big Idea 3 spans 18 topics that build from storing a single value to deciding whether a problem can be solved by a computer at all. The Unit 3 hub has a full study guide for each topic; here's the map.

A useful way to think about the unit is in four threads:

Storing data (3.1-3.4, 3.10). Variables hold one value at a time, and that value can be a number, Boolean, string, or list. Lists are the big deal here. They let you treat a whole collection of related items as a single value, which is the heart of data abstraction.

Controlling flow (3.5-3.9). Every algorithm, no matter how complicated, is built from just three structures: sequencing (do steps in order), selection (choose a path with conditionals), and iteration (repeat with loops). Boolean expressions are the switches that drive selection and iteration.

Reusing code (3.12-3.14). Procedures package a set of instructions under one name so you can call it anywhere instead of copy-pasting code. Parameters make a procedure general enough to handle different inputs. Libraries take this further by letting you import code other people already wrote.

Thinking about limits (3.11, 3.15-3.18). Binary search shows why algorithm choice matters for speed. Efficiency formalizes that: polynomial-time algorithms run in a reasonable amount of time, while exponential or factorial ones don't, which is when a heuristic (a good-enough approximation) becomes the smart move. And some problems, like the famous halting problem, are undecidable. No algorithm solves them in all cases.

Key Concepts and Vocabulary

These terms come up constantly in Big Idea 3 questions. The full AP CSP key terms glossary has more.

• Variable: an abstraction that holds one value at a time; the value can itself be a list containing many values.
• Assignment operator (←): changes the value a variable represents; the variable keeps the most recent value assigned.
• List: an ordered sequence of elements. On the AP exam, list indices start at 1, not 0.
• Element and index: an element is one value in a list; its index is the natural number used to reference it.
• String: an ordered sequence of characters; you can concatenate strings or take substrings.
• Algorithm: a finite set of instructions that accomplishes a specific task. Every algorithm can be built from sequencing, selection, and iteration.
• Boolean expression: evaluates to true or false, often using relational operators (=, ≠, >, <, ≥, ≤) or logical operators (NOT, AND, OR).
• Selection (conditionals): IF and IF/ELSE statements that execute different code depending on a condition.
• Iteration: repeating code with REPEAT n TIMES or REPEAT UNTIL(condition).
• Procedure: a named group of code statements you can call, often with parameters (in the definition) and arguments (in the call).
• Procedural abstraction: writing procedures so you can use code without knowing how it works internally, and fix a procedure without breaking the rest of the program.
• Data abstraction: giving a collection of data one name (usually a list) without referencing the details of its representation.
• Binary search: repeatedly eliminates half of a sorted dataset until the target is found. The data must be sorted first.
• Simulation: a simplified model of a real-world phenomenon; simplification can introduce bias based on what the creator includes or leaves out.
• Heuristic: an approach that finds an approximate solution when an exact one would take an unreasonable amount of time.
• Undecidable problem: a problem for which no algorithm can produce a correct answer in every case, even though some instances may be solvable.

How Big Idea 3 Shows Up on the AP CSP Exam

At 30-35% of the exam, Big Idea 3 carries more weight than any other Big Idea, and it dominates the multiple-choice section. The most common question style asks you to determine the result of a code segment written in the exam's pseudocode: trace the variables, follow the loops, and figure out what gets displayed. Other questions ask you to compare two algorithms (do they produce the same result?), pick the code that completes a task correctly, or reason about efficiency and binary search.

The pseudocode itself is defined on the exam reference sheet, which you get during the test. It covers both text and block forms of assignment, arithmetic (including MOD), relational and logical operators, IF/ELSE, REPEAT loops, list operations, and procedures. You don't have to memorize the sheet, but you should be so comfortable reading it that you never lose time decoding notation. Tracing code by hand, then checking your prediction by running it, is the single best practice habit for this unit.

Big Idea 3 is also the backbone of the Create performance task. Your Create program must use the concepts from this unit, including a list (data abstraction), a student-developed procedure with a parameter (procedural abstraction), selection, and iteration. The written responses are completed independently, so you need to genuinely understand how your own code works, not just that it runs. Practicing the kind of code analysis this unit demands pays off twice: on the multiple-choice section and in your Create write-up.

Common Mistakes

• Treating list indices like Python's. AP pseudocode lists start at index 1, and going below 1 or past the list's length produces an error that terminates the program. If you code in Python (index 0) or another language, consciously switch modes on exam questions.
• Misreading REPEAT UNTIL. The condition is checked before the loop body runs, so if it's true initially, the body executes zero times. And if the condition can never become true, you've got an infinite loop. Read "until" as "stop when this is true," not "while this is true."
• Losing track of variable values during tracing. Remember a ← 1, b ← a, a ← 2 leaves b equal to 1, because assignment copies the value at that moment. Write out a variable table for every trace question.
• Mixing up parameters and arguments. Parameters are the placeholders in a procedure's definition; arguments are the actual values you pass when you call it. Exam questions about procedures lean on this distinction.
• Assuming similar-looking algorithms do the same thing. Two code segments that differ only in the order of statements or the placement of an IF can produce different results. Trace both rather than eyeballing.
• Forgetting binary search's requirement. Binary search only works on sorted data. If a question hands you an unsorted list, binary search isn't an option until it's sorted.

Practice and Next Steps

Start with the topics where you're shakiest and work through the individual study guides on the Unit 3 page. Topics 3.1-3.8 are the foundation; if variables, Booleans, conditionals, and loops feel solid, the later topics on lists, procedures, and efficiency come together much faster.

Then make tracing code a daily habit. Use guided practice questions to drill the "determine the result of this code segment" format, and check yourself against past exam questions to see exactly how the pseudocode appears on the real test. When you're ready to see where you stand across all five Big Ideas, take a full-length practice exam and run your results through the AP score calculator. Because Big Idea 3 is a third of the exam, improvement here moves your score more than improvement anywhere else.