AP CSA Practice Exam 1 – Reflection and Performance Analysis

by Shriya Paladugu

CSA Performance Review

Exam Stats
Total Questions: 42 Correct: 28
Total Time: 1 h 47 m 59 s Average per Question: 2 m 34 s

I. Overview

This practice exam evaluated AP CSA Units 1–4: objects and methods, control flow, class design, and data collections.
My results showed strong fluency in Java fundamentals and class structure, with consistent syntax accuracy.
Most errors came from Unit 4 and Unit 2, especially recursion, 2D array traversal, file parsing, and loop conversion.
Future review will emphasize visualizing logic flow rather than raw memorization.

II. Accuracy by Unit

IV. Topic-Level Breakdown

Question	Topic	AP Unit / Subtopic	Result
Q9	Private variable access	3.2 – Encapsulation	Incorrect
Q16	Reliability vs Security	2.9 – Software Design	Incorrect
Q21	Nested iteration pattern	4.12 – 2D Arrays	Incorrect
Q28	minOfThree logic	2.7 – Conditionals	Incorrect
Q29	Recursive printNums method	4.16 – Recursion	Incorrect
Q33	2D index modification (r == c)	4.12 – Iteration	Incorrect
Q34	File reading + split()	4.6 – Text Processing	Incorrect
Q38	for/while equivalence	2.8 – Iteration	Incorrect
Q40	Character frequency logic	4.9 – Loops & Arrays	Incorrect
Q42	Loop translation	2.8 – Iteration	Incorrect

V. Deep Analysis and Corrections

Q9 – Private Variable Access

My Approach: Assumed instance variables could be accessed directly anywhere.
Correct Approach: Only class methods can access private fields; outside code must use getters/setters.
Correction: Reinforce encapsulation—state should never be public. This mistake shows I need to review class scope and practice using accessor methods properly.

Q16 – Reliability vs Security

My Approach: Linked reliability with encryption.
Correct Approach: Reliability = consistent functionality; security = protection. Testing under varied conditions improves reliability.
Correction: I confused performance consistency with data safety; understanding this distinction helps in designing more stable programs.

Q21 – Nested Iteration Pattern

My Approach: Reversed both row and column order.
Correct Approach: Only columns reverse; rows stay in order.

for (int r = 0; r < mat.length; r++) {
    for (int c = mat[0].length - 1; c >= 0; c--) {
        result.add(mat[r][c]);
    }
}

Correction: I’ll sketch 2D traversal directions before coding next time to visualize which dimension actually changes.

Q29 – Recursive printNums Method

My Approach: Ignored print placement and recursion order.
Correct Approach: Print happens after recursion (post-order).
Output: -80 40 -20 10
Correction: I’ll trace recursive calls step-by-step to understand stack order and ensure I know whether code executes before or after recursion.

Q33 – 2D Array Diagonal Modification

My Approach: Modified both diagonals.
Correct Approach: Only cells where r == c.

{ {0,0,0},
  {0,1,0},
  {0,0,2},
  {0,0,0} }

Correction: I mixed up diagonal conditions; I’ll test small 2D examples to confirm logic before writing loops.

Q34 – File Reading & String.split()

My Approach: Used two loops for each list.
Correct Approach: Read both values in one loop.

while (sc.hasNext()) {
    String[] temp = sc.next().split("_");
    firstList.add(temp[0]);
    secondList.add(temp[1]);
}

Correction: Combining tasks into a single loop avoids errors and improves efficiency, something I’ll apply to future file-parsing problems.

Q38 – for/while Equivalence

My Approach: Ignored the extra j++ inside the loop.
Correct Approach: Move increment into loop header and adjust bounds.

for (int j = 1; j <= 6; j++) {
    sum += j;
}

Correction: Translating between loops requires matching update steps exactly; I’ll pay attention to where increments occur to prevent off-by-one errors.

VI. Quantitative Trends

Unit	Questions	Avg Time	Accuracy
1	10	1 m 45 s	90 %
2	11	2 m 15 s	65 %
3	7	2 m 30 s	78 %
4	14	2 m 55 s	60 %

Observation: Time increased steadily from Units 1–4 as conceptual complexity rose.
Extra time in Unit 4 reflects conceptual struggle rather than pacing.

VII. Strengths & Weaknesses

Strengths

Confident syntax and logical control flow.
Strong understanding of constructors and class design.
Accurate debugging in loop and conditional logic.

Weaknesses

Visualizing recursive flow and stack behavior.
2D array direction logic.
Scanner and file token parsing.
Translating while↔for loops without semantic loss.

VIII. Action Plan

Focus Area	Method	Metric of Mastery	Target Date
Recursion Tracing	Trace 15 examples and verify with IDE	100 % output match	Nov 10
2D Traversals	Diagram 10 row/col patterns	Zero direction errors	Nov 12
File Parsing	Practice 5 split() exercises	100 % list accuracy	Nov 14
Loop Translation	Convert 10 while↔for pairs	No logic change	Nov 16

IX. Conclusion

This exam proved that my coding fluency is solid but my conceptual visualization needs polish.
Strengthening recursion and 2D logic will turn these mistakes into automatic successes.
With focused practice on flow tracing and data pattern reasoning, I’m on track for full readiness for the AP CSA exam.