One week. That's enough time to make a real difference on the AP Computer Science Principles exam, if you use it well. The Create Task is already submitted, so your entire focus now is the multiple-choice section: 70 questions in 2 hours covering all 5 Big Ideas.
This plan tells you exactly what to study each day, how long to spend, and what to prioritize. It's built around the actual exam weight of each topic, so you're spending the most time where the most points are.
Know the Exam Before You Study for It
The multiple-choice section is 70% of your final AP score (the Create Task is the other 30%, already done). You have 120 minutes for 70 questions, which works out to about 1 minute and 43 seconds per question. That's tight. Speed and confidence matter as much as knowledge.
Here's how the 70 questions are distributed across the 5 Big Ideas:
| Big Idea | Approximate Questions | Main Topics |
|---|---|---|
| 1: Creative Development | 5–8 | Iterative design, collaboration, program documentation |
| 2: Data | 13–17 | Binary, compression, metadata, data analysis |
| 3: Algorithms and Programming | 20–26 | Pseudocode, procedures, lists, searching, efficiency |
| 4: Computer Systems and Networks | 11–15 | The internet, protocols, fault tolerance, parallel computing |
| 5: Impact of Computing | 13–17 | Privacy, bias, cybersecurity, digital divide, crowdsourcing |
Big Idea 3 is the largest and most technical. Big Idea 1 is the smallest and most straightforward. This matters for how you allocate your week.
The 7-Day Plan
Each day is 60 to 90 minutes. Sundays are for rest; this plan runs Monday through Sunday with the exam on the following week. Adjust the days to match when your exam actually falls.
Day 1: Big Idea 3, Part 1 — Pseudocode and Variables
Big Idea 3 is worth the most questions and requires the most active practice, so it gets two days. Start here.
Review (20 minutes): go through the AP pseudocode reference. Focus on assignment (x ← 5), conditionals (IF / ELSE), REPEAT n TIMES, REPEAT UNTIL, and list operations. Pay attention to 1-based indexing: the first element of aList is aList[1], not aList[0].
Practice (40 minutes): trace 8 to 10 pseudocode problems by hand. For each one, make a table with a column for each variable and update values line by line. Don't trace in your head; write it down. Use problems from the College Board's released practice materials or from the AP Classroom question bank.
Key concepts to confirm you understand:
- The difference between
REPEAT n TIMES(runs exactly n times) andREPEAT UNTIL(runs until condition becomes true, checks before each iteration). - How
MODworks:13 MOD 5is 3. It gives the remainder, not the quotient. - List operations:
APPENDadds to the end;INSERTshifts elements right;REMOVEshifts elements left. All are 1-indexed. - How procedures with parameters work: the parameter is a local variable inside the procedure. Changing it inside the procedure does not change the variable that was passed in.
Day 2: Big Idea 3, Part 2 — Algorithms and Efficiency
Review (20 minutes): linear search vs. binary search. Reasonable vs. unreasonable time (polynomial vs. exponential growth). What a heuristic is and when it's used.
Practice (40 minutes): do 10 more pseudocode problems, focusing on procedures that use parameters, return values, and list traversals. Then practice 5 algorithm-comparison questions: given two code segments, determine which is more efficient or whether they produce the same result.
Key concepts to confirm you understand:
- Binary search requires a sorted list. Linear search works on any list. Binary search is faster but has a prerequisite.
- An algorithm that runs in n2 steps is "reasonable." An algorithm that runs in 2n steps is "unreasonable" because it becomes impractical very quickly as n grows.
- Procedural abstraction: calling a procedure without knowing how it works internally. You only need to know what it takes as input and what it returns.
- Two code segments are equivalent only if they produce the same output for every possible input, not just one test case.
Day 3: Big Idea 2 — Data
Review (25 minutes): binary representation, bit and byte definitions, how many values n bits can represent (2n), overflow and roundoff errors, lossless vs. lossy compression, metadata, and how to analyze data to find patterns.
Practice (35 minutes): do 10 binary conversion problems (decimal to binary and back). Then do 8 data-focused MCQ questions, including at least 2 on compression and 2 on data analysis scenarios with tables or charts.
Key concepts to confirm you understand:
- With n bits you can represent 2n different values, ranging from 0 to 2n−1. Eight bits can represent 256 values (0–255).
- Lossless compression: original can be perfectly reconstructed. Lossless is used when exact accuracy matters (ZIP files, text). Lossy compression: some data is permanently lost. Lossy achieves smaller file sizes (JPEG, MP3).
- Overflow: a number exceeds the maximum representable value in a fixed number of bits, wrapping around unexpectedly. Roundoff: decimal values that can't be represented exactly in binary cause small calculation errors.
- Correlation does not imply causation. Two variables trending together doesn't mean one causes the other.
- Metadata is data about data: file size, creation date, GPS location in a photo, author of a document.
Day 4: Big Idea 5 — Impact of Computing
Review (20 minutes): digital divide, algorithmic bias, crowdsourcing, intellectual property, Creative Commons licenses, privacy and PII, cybersecurity threats (phishing, malware, ransomware), encryption (symmetric vs. public-key), and multi-factor authentication.
Practice (40 minutes): do 12 impact-of-computing MCQ questions. These questions are usually scenario-based, so practice reading the scenario carefully before looking at the answer choices. Eliminate answers with extreme language ("always," "never," "completely eliminates") unless the claim is genuinely absolute.
Key concepts to confirm you understand:
- The digital divide describes unequal access to computing and the internet based on geography, income, age, or disability. It has real consequences for education and economic opportunity.
- Algorithmic bias occurs when training data underrepresents certain groups, causing the algorithm to perform worse for those groups. Bias can also come from design choices.
- Symmetric encryption uses one shared key for both encryption and decryption. Public-key (asymmetric) encryption uses a public key to encrypt and a private key to decrypt.
- PII (Personally Identifiable Information) is any data that can identify an individual: name, Social Security number, location data, email address.
- Multi-factor authentication uses something you know (password), something you have (phone), or something you are (fingerprint). Any two of these together is MFA.
Day 5: Big Idea 4 — Computer Systems and Networks
Review (20 minutes): how the internet works (packets, routers, redundancy), key protocols (IP, TCP, HTTP/HTTPS, DNS), fault tolerance, and the difference between sequential, parallel, and distributed computing.
Practice (40 minutes): do 10 networks-and-systems MCQ questions. Pay particular attention to network diagram questions that ask whether device A can still reach device B if a specific connection is removed. Then do 5 parallel-computing questions that ask you to calculate total execution time when tasks run simultaneously.
Key concepts to confirm you understand:
- Data is sent in packets that travel independently and are reassembled at the destination. Packets can take different routes.
- DNS translates domain names (like examreadyusa.com) into IP addresses. TCP ensures reliable, ordered delivery. IP handles addressing and routing. HTTPS adds encryption to HTTP.
- A network is fault-tolerant if there are multiple paths between two points. If all paths between A and B go through one router and that router fails, the network is not fault-tolerant for that connection.
- Parallel computing: total time is determined by the longest task, not the sum of all tasks. But not everything can be parallelized; tasks with dependencies must run sequentially.
- Distributed computing spreads computation across multiple networked computers. It enables processing of data sets too large for one machine.
Day 6: Big Idea 1 + Full Timed Practice Exam
Big Idea 1 review (15 minutes): iterative development (design, test, refine, repeat), the benefits of collaboration and diverse perspectives, how user testing improves programs, and what program documentation is for. This Big Idea has the fewest questions and the most straightforward content.
Full practice exam (75 minutes): do a complete set of 70 MCQ questions under timed conditions. No breaks, no looking things up. Set a timer for 120 minutes and stop when it goes off, even if you haven't finished. Record how many questions you completed and how many you got right.
After the timed session, note:
- Which Big Idea produced the most wrong answers?
- Were there questions you got right but weren't confident about? Those are just as important to review.
- Did you run out of time? If so, which question types took the longest?
Day 7: Targeted Review and Light Consolidation
Don't try to cover new material today. Use this day entirely based on what the practice exam revealed.
First 45 minutes: go through every wrong answer from the practice exam. For each one, figure out exactly why you got it wrong. Was it a concept gap? A misread? A tracing error? A careless mistake on a multiple-select question? The category matters for what you do next.
- Concept gap: re-read the relevant section of your notes and do 3 to 5 more questions on that topic.
- Tracing error: redo the pseudocode problem slowly with a variable table. If you made the same type of tracing error multiple times, that's a habit to break before exam day.
- Misread: practice reading questions more carefully. Multiple-select questions tell you exactly how many answers to choose; re-read them twice before answering.
- Careless mistake: note what it was and move on. Don't spend 20 minutes on something you actually know.
Final 20 minutes: skim your key concept notes for Big Ideas 2 and 3 one more time. These are the highest-weighted sections. Don't read passively; quiz yourself. Cover the explanation and try to recall it before looking. Then stop. More cramming at this point produces diminishing returns.
Pseudocode Cheat Sheet: The 10 Things You Must Know Cold
The exam provides a pseudocode reference sheet, but you shouldn't need to consult it constantly. The faster you recognize these constructs, the more time you have for harder questions.
| Construct | Syntax | Key Detail |
|---|---|---|
| Assignment | x ← 5 | Arrow, not equals sign |
| Display | DISPLAY(x) | Prints value to screen |
| Input | x ← INPUT() | Reads value from user |
| If/else | IF (cond) { } ELSE { } | Condition must be boolean |
| Repeat fixed | REPEAT n TIMES { } | Runs body exactly n times |
| Repeat until | REPEAT UNTIL (cond) { } | Stops when condition becomes true; checks before each iteration |
| For each | FOR EACH item IN aList { } | Iterates every element in order |
| Procedure | PROCEDURE name(param) { RETURN val } | Parameter is local to the procedure |
| List access | aList[i] | 1-indexed: first element is aList[1] |
| Random | RANDOM(a, b) | Returns a random integer from a to b, inclusive of both |
The Highest-Value Topics by Question Type
Not all topics are equal. Based on released exams and the College Board's topic weighting, these are the areas most likely to appear on your exam and most likely to trip up unprepared students:
| Topic | Why It's High Value | What to Focus On |
|---|---|---|
| Pseudocode tracing | Most common question type in Big Idea 3 (the largest section) | Write a variable table; trace one line at a time; watch loop boundaries |
| Binary and bits | Appears in multiple question formats in Big Idea 2 | Convert between binary and decimal; know that n bits = 2n values |
| Network fault tolerance | Diagram questions appear on nearly every exam | A path exists as long as one unbroken route connects the two devices |
| Privacy and PII | Multiple questions in Big Idea 5, often scenario-based | Know what counts as PII; know the difference between encryption and authentication |
| Parallel computing time | Calculation questions appear regularly | Total time = longest parallel task; tasks with dependencies add to that sequentially |
| Lossless vs. lossy compression | Appears in both direct questions and scenario comparisons | Lossy = smaller file, permanent quality loss; lossless = larger file, perfect reconstruction |
What Not to Do This Week
- Don't re-read your textbook cover to cover. Passive reading gives you the feeling of studying without the results. Every hour of re-reading is better spent doing practice questions.
- Don't skip pseudocode practice because it feels slow. Pseudocode tracing is the most tested skill on the exam. The discomfort of working through it carefully is exactly what builds speed and accuracy.
- Don't cram new topics on Day 6 or 7. Starting a new topic in the final two days almost always hurts more than it helps. You add anxiety and confusion without enough time to consolidate the material. Stick to review and practice.
- Don't ignore multiple-select questions. The exam includes questions that tell you to "select two answers." Students often lose points here by either choosing one or choosing three. Read the prompt carefully every time.
- Don't leave any question blank. There is no penalty for wrong answers. A guess is always better than a blank. If you run out of time, fill in something for every remaining question.
Exam Day Protocol
The night before: do nothing more than a 20-minute skim of the pseudocode reference sheet and your Big Idea 3 notes. Eat a real dinner. Get 8 hours of sleep. Sleep debt is one of the most underrated factors in exam performance.
The morning of: eat breakfast with protein, not just sugar. Arrive early enough that you're not rushing. Bring two pencils and your student ID.
During the exam: use a two-pass strategy.
- First pass (55–60 minutes): work through the exam at a steady pace. Answer questions you're confident about immediately. For pseudocode tracing questions that look long or complex, note the question number and skip them for now. Don't let one hard question eat four minutes.
- Second pass (50–55 minutes): return to skipped questions. Work through pseudocode tracing carefully with a variable table. For any question you truly don't know, eliminate the most obviously wrong choices and select from what remains.
- Final check (5–10 minutes): confirm no questions are blank. Check any answers you flagged as uncertain.
On multiple-select questions: the prompt will tell you exactly how many answers to choose, typically "select two." Evaluate each answer choice independently before deciding. Don't let your confidence in one choice affect your evaluation of another.
On scenario questions (Big Idea 5): read the scenario before reading the answer choices. Form a rough sense of what the right answer should say before you look at the options. Then eliminate choices that are too extreme, too vague, or clearly off-topic.
One Week Is Enough
Students who use the week intentionally — practicing pseudocode daily, reviewing concepts actively rather than passively, and simulating exam conditions before the real thing — consistently see meaningful score improvements. The material is learnable. The exam is predictable. The plan above gives you everything you need to walk in prepared.
If you want expert guidance through the final stretch, ExamReadyUSA's AP CSP Crash Course includes a dedicated final-week review session with graded MCQ practice, pseudocode tracing drills, and personalized feedback from Namrata Poladia, a College Board AP Reader who scores real AP CSP exams.