Section I (the sit-down exam): 70 multiple-choice questions, 120 minutes.
| Block | Questions | Format |
|---|---|---|
| Q1–57 | 57 | Single-select, 4 choices |
| Q58–62 | 5 | One reading passage (computing innovation) + 5 single-select |
| Q63–70 | 8 | Multiple-select: "Select two answers" — both required, no partial credit |
Section II (already underway): your Create PT (program + video + Personalized Project Reference, submitted by the spring deadline — April 30 for 2026; confirm your year's date) plus two written-response questions answered during the exam using your PPR. Together: 30% of your score.
No calculator — none needed. The Exam Reference Sheet (all the AP pseudocode: operators, list procedures, robot commands) is provided in the exam. You memorized nothing syntactic; you trained behaviors — 1-indexing, UNTIL polarity, RETURN's trapdoor.
120 minutes ÷ 70 questions ≈ 103 seconds each. But questions aren't priced equally:
Triage rules: First pass — answer everything answerable; any question stalled past ~2.5 minutes gets your best elimination guess, a circle in the booklet, and your departure. Second pass — return to circles with the remaining clock. Never leave blanks — there's no wrong-answer penalty; a 25% shot beats a 0% blank, and elimination usually makes it 50%.
Eight questions, two correct answers each, both-or-nothing scoring. The discipline:
One line each. Cover the right column; recite; check. Anything you miss, reread that lesson's (b) section tonight.
| # | The line |
|---|---|
| L1 | Purpose = why it exists; function = what it does; diverse teams → less bias |
| L2 | Ran-but-wrong = logic; crash mid-run = run-time; won't run = syntax; too big = overflow; test boundaries |
| L3 | n bits → 2ⁿ values (max value 2ⁿ − 1); same bits, meaning from interpretation |
| L4 | Lossless = perfect restoration, less shrink; lossy = more shrink, no going back; purpose decides |
| L5 | Correlation ≠ causation; metadata = data about data; big data needs cleaning; collection bias survives scale |
| L6 | Filter then aggregate; sorting keeps all rows; tables join on a shared field |
| L7 | ← copies now, no links; MOD = remainder, binds like ×; trace tables always |
| L8 | Lists start at index 1; INSERT shifts right, REMOVE shifts left; one name, many values, code survives data changes |
| L9 | AND = both, OR = at least one (inclusive); NOT(x > 5) ⟺ x ≤ 5 — boundary flips sides |
| L10 | One branch runs; most-specific condition first; robot: rotations don't move, left/right are the ROBOT's |
| L11 | UNTIL stops when TRUE (runs while false); condition true at entry → zero iterations; FOR EACH visits all, in order |
| L12 | Silhouettes: sum/count/max/search; init max from the list, not 0; filtered average needs filtered count |
| L13 | Binary search needs SORTED data, halves per step; polynomial = reasonable, exponential = unreasonable; heuristic = good-enough fast; undecidable = no algorithm ever, for all inputs |
| L14 | Arguments copy into parameters; RETURN exits now; abstraction = manage complexity, fix once |
| L15 | RANDOM(a,b): a..b inclusive, count b−a+1; two dice = two calls; range-match ≠ distribution-match |
| L16 | Simulations simplify on purpose; assumptions bias results; more trials steady the estimate |
| L17 | IP addresses/routes; TCP guarantees order+delivery; UDP is fast, unguaranteed; DNS: names → addresses; open protocols → scale |
| L18 | Fault tolerance via redundancy; route-count by first hop; one shared link = single point of failure |
| L19 | Sequential = sum; parallel = sequential part + LONGEST branch; speedup = seq ÷ par, floored by the sequential part |
| L20 | Every innovation: benefit AND harm, unevenly distributed; unintended ≠ malicious; crowdsourcing = many people via Internet, verify the data |
| L21 | Divide = access + skills gaps, within and between countries; bias enters via data/design/testing — no intent required |
| L22 | Created = copyrighted, automatically; CC pre-grants terms; open source = code freedom; credit everything regardless |
| L23 | PII aggregates; phishing deceives, keyloggers record, rogue APs intercept; public key encrypts, private decrypts; MFA = different categories |
| L24 | Passage is the authority; five-question frame: purpose, data, benefit, harm, privacy |
Section II is 30% — bank it before exam day:
(≈2 CRD, 4 DAT, 7 AAP, 3 CSN, 4 IOC — matching the real form's proportions. Budget: 33 minutes. No notes, no peeking; this is your Mock-1 readiness gauge. Q19–20 are multi-select.)
1. (C). Ran, finished, wrong value = logic error — likely a loop boundary. (L2; the off-by-one flavor: L11.)
2. (B). Weekly feedback cycles = iterative; piece-at-a-time testing = incremental. Real processes are both. (L2.)
110010₂ in decimal?3. (A). 32 + 16 + 2 = 50. (L3.)
4. (B). 2⁸ = 256 < 300 ≤ 512 = 2⁹ → 9 bits. (L3.)
5. (B). Reconstruct-every-bit = lossless; cellular streaming = lossy's home. Purpose decides, per use. (L4.)
6. (B). Association + a collection-bias alternative, properly hedged. (L5.)
What is displayed?
x ← 3
y ← 8
x ← y − x
y ← y − x
DISPLAY (x + y)
7. (A). x ← 8−3 = 5; y ← 8−5 = 3; display 5 + 3 = 8. Sequential assignments use current values. (L7.)
L ← [4, 9, 1, 6]. After REMOVE(L, 2) then INSERT(L, 1, 9), the list is:8. (A). REMOVE(L,2) drops the 9 → [4, 1, 6]; INSERT at 1 puts 9 in front → [9, 4, 1, 6]. (L8.)
n is NOT (n < 12) true?9. (C). NOT(<) flips to ≥ — equality changes sides. (L9.)
How many times does this loop's body run?
k ← 20
REPEAT UNTIL (k ≤ 5)
{
k ← k − 4
}
10. (B). k: 20→16→12→8→4; checks before each run: 20,16,12,8 all > 5 (run), then 4 ≤ 5 stops. 4 runs. (L11.)
What does mystery([2, 7, 5, 7], 7) return?
PROCEDURE mystery(list, v)
{
n ← 0
FOR EACH x IN list
{
IF (x = v)
{
n ← n + 1
}
}
RETURN (n)
}
11. (B). Count-matches silhouette; two 7s. (L12, L14.)
12. (A). 128 halves: 128→64→32→16→8→4→2→1 ≈ 8 examinations. (L13.)
13. (B). RANDOM(5,15) → 5..15 (11 values), ×2 → 10, 12, ..., 30: the eleven even values, equally likely. (A) includes odds; (C) ranges 20–60. (L15.)
14. (C). Redundancy + adaptive routing; never a central administrator. (L18, L17.)
15. (A). Reordering and retransmission are TCP's job description. (L17.)
16. (B). 8 + max(12, 9, 15) = 8 + 15 = 23. (L19.)
17. (B). Access-presuming design converts the divide into grades. (L21.)
18. (B). Data composition — no intent required. (L21.)
19. (A) and (C). 1-indexing; zero-iteration UNTIL. (B): RANDOM(1,4) has 4 values (the +1 works the other way); (D): rotations never move. (L8, L11, L15, L10.)
20. (A) and (C). True MFA (know + have); phishing skepticism with the navigate-directly protocol. (B) is one breach from disaster; (D) inverts the key rule — private stays private. (L23.)
Scoring your gauge: 17–20: take Mock 1 cold, full timing. 13–16: reread the (d) Common Mistakes of your missed lessons first. Below 13: re-run this set in three days after targeted review — the lesson pointers are your syllabus.
Answer letter distribution check: C, B, A, B, B, B, A, A, C, B, B, A, B, C, A, B, B, B, A+C, A+C — singles: A×5, B×9, C×3, D×0. B-heavy in this set; acceptable for a review sampler (correct answers placed for pedagogy), and the mocks' keys are engineered to exam-realistic balance.
1. (C). Ran, finished, wrong value = logic error — likely a loop boundary. (L2; the off-by-one flavor: L11.) 2. (B). Weekly feedback cycles = iterative; piece-at-a-time testing = incremental. Real processes are both. (L2.) 3. (A). 32 + 16 + 2 = 50. (L3.) 4. (B). 2⁸ = 256 < 300 ≤ 512 = 2⁹ → 9 bits. (L3.) 5. (B). Reconstruct-every-bit = lossless; cellular streaming = lossy's home. Purpose decides, per use. (L4.) 6. (B). Association + a collection-bias alternative, properly hedged. (L5.) 7. (A). x ← 8−3 = 5; y ← 8−5 = 3; display 5 + 3 = 8. Sequential assignments use current values. (L7.) 8. (A). REMOVE(L,2) drops the 9 → [4, 1, 6]; INSERT at 1 puts 9 in front → [9, 4, 1, 6]. (L8.) 9. (C). NOT(<) flips to ≥ — equality changes sides. (L9.) 10. (B). k: 20→16→12→8→4; checks before each run: 20,16,12,8 all > 5 (run), then 4 ≤ 5 stops. 4 runs. (L11.) 11. (B). Count-matches silhouette; two 7s. (L12, L14.) 12. (A). 128 halves: 128→64→32→16→8→4→2→1 ≈ 8 examinations. (L13.) 13. (B). RANDOM(5,15) → 5..15 (11 values), ×2 → 10, 12, ..., 30: the eleven even values, equally likely. (A) includes odds; (C) ranges 20–60. (L15.) 14. (C). Redundancy + adaptive routing; never a central administrator. (L18, L17.) 15. (A). Reordering and retransmission are TCP's job description. (L17.) 16. (B). 8 + max(12, 9, 15) = 8 + 15 = 23. (L19.) 17. (B). Access-presuming design converts the divide into grades. (L21.) 18. (B). Data composition — no intent required. (L21.) 19. (A) and (C). 1-indexing; zero-iteration UNTIL. (B): RANDOM(1,4) has 4 values (the +1 works the other way); (D): rotations never move. (L8, L11, L15, L10.) 20. (A) and (C). True MFA (know + have); phishing skepticism with the navigate-directly protocol. (B) is one breach from disaster; (D) inverts the key rule — private stays private. (L23.)
Scoring your gauge: 17–20: take Mock 1 cold, full timing. 13–16: reread the (d) Common Mistakes of your missed lessons first. Below 13: re-run this set in three days after targeted review — the lesson pointers are your syllabus.
Answer letter distribution check: C, B, A, B, B, B, A, A, C, B, B, A, B, C, A, B, B, B, A+C, A+C — singles: A×5, B×9, C×3, D×0. B-heavy in this set; acceptable for a review sampler (correct answers placed for pedagogy), and the mocks' keys are engineered to exam-realistic balance.
Twenty-five lessons ago, colors[2] was a trick. Now you trace procedures calling procedures, count binary-search steps, argue both sides of any innovation, and read a passage like an analyst. The exam ahead is 70 questions built from a finite, known catalog — every one of them a costume on a concept you've now met by name.
Take Mock Exam 1 under full conditions (120 minutes, one sitting, no notes). Review every miss with its lesson. Take Mock 2 the following week. Then trust the preparation — and go collect what you've earned.
(Heading to AP Computer Science A next year? CompSciIQ picks up where the pseudocode ends and the Java begins.)