CSPIQ · AP Computer Science Principles · Lesson 25 of 25
CSPIQ · AP Computer Science Principles

Lesson 25: Exam Strategy & Full-Course Review

Phase 6 · Synthesis

Objectives

The Shape of Your Exam Day

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.

Pacing: the 100-second economy

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%.

The multi-select protocol (Q63–70)

Eight questions, two correct answers each, both-or-nothing scoring. The discipline:

  1. Evaluate all four choices independently — true or false, each on its own merits.
  2. You must end with exactly two trues. Three trues = you misjudged one; re-examine the shakiest.
  3. Mark both. Verify you marked both (the #1 clerical error: finding both, bubbling one).
  4. These reward precision over speed — they're mostly conceptual (packets, effects of innovations, list-operation truths), so the 100-second budget is comfortable if you don't rush the fourth choice.

Retrieval sprint — the whole course in one table

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

Create PT + written-response final checklist

Section II is 30% — bank it before exam day:


Mixed Review Set — 20 Questions at Exam Weights

(≈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.)

Question 1
A program runs without crashing but displays a total that is too large by exactly one item's value. This error is best classified as:
Question 2
A team gathers user feedback after each weekly build and revises its design before adding features, testing each addition before the next. Their process is:
Question 3
What is 110010₂ in decimal?
Question 4
A program must assign a unique binary ID to each of 300 products. Minimum bits per ID:
Question 5
An archive must store master audio recordings so that engineers can later reconstruct every original bit; a companion podcast app streams episodes to phones over cellular data. The appropriate compression pairing is:
Question 6
A dataset of city service requests shows more requests from neighborhoods with younger residents. A defensible conclusion is:
Question 7

What is displayed?

x ← 3
y ← 8
x ← y − x
y ← y − x
DISPLAY (x + y)
Question 8
L ← [4, 9, 1, 6]. After REMOVE(L, 2) then INSERT(L, 1, 9), the list is:
Question 9
For which integer values of n is NOT (n < 12) true?
Question 10

How many times does this loop's body run?

k ← 20
REPEAT UNTIL (k ≤ 5)
{
    k ← k − 4
}
Question 11

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)
}
Question 12
A sorted list holds 128 entries. The maximum number of entries binary search examines is closest to:
Question 13
Which expression evaluates to a random even number from 10 to 30 inclusive, all outcomes equally likely?
Question 14
When a router along a path fails, the Internet typically:
Question 15
A web page loads over TCP. Two packets arrive out of order and one is lost. The user sees:
Question 16
A program requires 8 seconds of unavoidable sequential setup, then independent tasks of 12, 9, and 15 seconds. On three processors (one task each), total time is:
Question 17
A homework platform is app-only, and a district's students without smartphones fall behind. This outcome primarily illustrates:
Question 18
A photo app's auto-tagging was trained on images from one demographic and mislabels others' photos at higher rates. The bias entered through:
Question 19
(Select two answers.) Which statements about the AP pseudocode are true?
Question 20
(Select two answers.) Which actions follow the safe-computing practices of Big Idea 5?

Show answer key & explanations

(c) Answer Key (with lesson pointers — missed one? that lesson tonight)

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.


(d) Final Word

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.)

← All lessons
Mock Exam 1 ›
Score: 0/0 correct