FRQ Overview
Sprint 9 – FRQ Learning Reflection (Individual Summary)
Overview
During Sprint 9, I worked through a lot of AP CSA FRQ-style problems that honestly pushed me to think differently about Java. At first, these problems felt really long and confusing, but over time I started noticing patterns in how they are structured.
Most FRQs are not actually “hard coding problems” — they are more like breaking down a story into steps and then translating that into code. By practicing multiple FRQs, I got better at understanding what the question is really asking instead of getting overwhelmed by all the wording.
My FRQ Experience (What it actually felt like)
When I first started these, I would usually try to jump straight into coding and end up stuck halfway through. For example, with ArrayList problems, I would forget that removing items while looping actually breaks things unless you are careful.
Later on, I started slowing down and doing something that helped a lot:
- I would read the prompt twice
- Then write quick pseudocode before touching Java
- Then build the solution step-by-step
That made a huge difference in how accurate my answers were.
Key FRQ Topics I Practiced
ArrayLists and Lists
These were probably the most common FRQs I saw. I worked on problems where I had to filter, update, or search through lists.
What I struggled with at first:
- Removing elements while looping (caused skipped values)
- Confusing index vs value logic
What improved over time:
- Using for-loops more carefully
- Thinking about how the list changes as I modify it
Strings and Parsing
String FRQs were tricky because small mistakes would break everything.
I had to:
- Split strings correctly
- Handle edge cases like empty inputs
- Fix off-by-one errors (this happened a lot)
I think I got better at slowing down and checking each substring step instead of rushing.
Classes / Object-Oriented FRQs
These were actually the most interesting ones because they felt more like “real programming.”
I practiced:
- Writing constructors
- Using private variables properly
- Building methods that update object state
At first I forgot why encapsulation mattered, but FRQs made it clearer because everything depends on keeping data organized inside a class.
Algorithm Thinking / Multi-step Problems
These FRQs were the hardest but also the most useful.
They usually required:
- loops inside loops
- condition tracking
- breaking problems into steps
I learned that most FRQs are just:
“take input → process step-by-step → return result”
Once I started seeing that pattern, they became way less scary.
FRQ Homework Issues (Real Practice + Progress)
Here are the actual FRQ-related issues I worked through and how they helped me improve:
| Issue | Topic | What I Worked On | What I Learned |
|---|---|---|---|
| Issue #3 | ArrayList FRQ | Filtering + updating list values | Be careful when modifying lists during loops |
| Issue #4 | String Parsing FRQ | Splitting and extracting data | Off-by-one errors are super common |
| Issue #5 | Class Design FRQ | Creating constructors + methods | Object state actually matters a lot |
| Issue #6 | 2D Array / Logic FRQ | Nested loops and grid logic | Always break down row vs column separately |
| Issue #7 | Mixed FRQ Practice | Multi-step reasoning problems | Write pseudocode first before coding |
What Improved for Me
Over time, I noticed a few clear improvements:
- I don’t immediately panic when I see long FRQs anymore
- I can usually identify the topic (ArrayList, class, string, etc.) quickly
- I make fewer small syntax/logic mistakes
- I rely more on structured thinking instead of guessing
Challenges I Still Had
Even though I improved, I still struggled with:
- debugging small logic errors
- keeping track of variables in long loops
- rushing into code too fast sometimes
What helped was going back and comparing my solution with older FRQs and fixing patterns instead of just fixing one problem at a time.
Connection to Sprint 9
This FRQ practice connects directly to Sprint 9 goals because it helped me build:
- stronger problem decomposition skills
- better understanding of Java data structures
- improved object-oriented thinking
- more confidence with AP-style questions
Final Reflection
Looking back, FRQs felt really overwhelming at the beginning, but now they feel more structured. I still need more practice to be fully confident, but I definitely understand how to approach them in a more organized way instead of just jumping in blindly.
I think the biggest change for me is that I now see FRQs as patterns, not random problems.