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.