FRQ 1 – Methods and Control Structures

Overview

AP CSA FRQ 1 is the Methods and Control Structures question, the first of four free-response questions on the AP Computer Science A exam. It's worth 7 points out of the 25 total FRQ points, and the whole free-response section gives you 90 minutes and counts for 45% of your exam score. You'll write two methods (or one constructor and one method) of a given class based on specifications and examples, which means you'll need loops, conditionals, and calls to other methods in the class.

The question comes in two parts. Part A (4 points) asks you to write a method or constructor using iterative or conditional statements (or both), plus statements that call methods in the specified class. Part B (3 points) asks you to write a method or constructor that calls String methods. The method headers are given to you. Your job is to fill in the body that matches the specification exactly.

FRQ 1 is designed to be the most accessible of the four FRQs. It's not testing whether you can invent clever algorithms. It's testing whether you can read a spec carefully, use the tools the question hands you, and write clean control flow.

How AP CSA FRQ 1 Is Scored

FRQ 1 is worth 7 points, split 4 points for Part A and 3 points for Part B. Each part has its own mini-rubric, and graders award points for specific behaviors in your code, not for overall vibes.

A few scoring realities worth knowing. Graders award points independently, so a mistake in your loop condition doesn't automatically wipe out your other points. The "algorithm" point in each part checks whether your overall solution produces the right result, including details like spacing in output strings and not modifying variables the postcondition says must stay unchanged. And small syntax slips (a missing semicolon, for instance) generally don't sink you if your logic is clearly correct, but wrong method calls and wrong comparisons do cost specific points.

You'll have the Java Quick Reference available during the exam, which lists the library methods that can appear on the exam. The exam is fully digital, so you'll type your code rather than handwrite it.

For the full Section II picture (all four FRQs, 90 minutes, 45% of your score), see the AP Computer Science A exam page.

How to Answer AP CSA FRQ 1, Step by Step

The winning approach is systematic: read everything first, use what they give you, and write straightforward code. With 90 minutes for four FRQs, budgeting about 18-22 minutes for FRQ 1 keeps you on pace.

Step 1: Read the whole question before coding (3-4 minutes)

Read both Part A and Part B before writing anything. This feels uncomfortably long when you're anxious to start coding, but Part B often hints at how the class is supposed to work overall, and a variable you track in Part A may matter for Part B. While you read, identify three things: the helper methods provided, what the examples show, and any postconditions (like "the value of message is unchanged").

Step 2: Write Part A carefully (8-10 minutes)

The actual code for Part A is usually only 5-10 lines, so most of this time is thinking and verifying, not typing. Two habits earn points here.

First, use the provided methods. When the class gives you a helper method, the question is basically screaming "call this." There is typically a rubric point specifically for calling the helper method correctly. Don't reimplement what it does, just call it with the right argument.

Second, let the spec write your loop condition. If a helper method "returns null when there are no more words," your loop condition is while (w != null). Sentinel values like null or -1 in a method description are almost always your termination condition. Don't overthink it.

Step 3: Write Part B (6-8 minutes)

Part B centers on String methods, so precision matters. Two details cost points constantly. substring(start, end) does NOT include the character at index end. And indexOf returns -1 when it can't find something, not null and not 0. Get those two facts cold before exam day.

Also check the postconditions. If the spec says a variable must be unchanged, never reassign it. Copy it first (String temp = message;) if you need to chop it up.

Step 4: Review (2-3 minutes)

Reread the spec and trace your code against the provided example. This catches the small errors that cost points: a forgotten assignment to an instance variable, an extra space at the start of a built string, a loop that runs one time too many.

One more strategic note. Parts A and B are independent. If you're stuck on Part A, jump to Part B and grab those 3 points, then come back. Points are points, wherever they come from.

Worked Example: How the Rubric Plays Out

Here's how a typical FRQ 1 rubric breaks down, using a sample "MessageBuilder" scenario: a constructor builds a message by repeatedly calling a getNextWord helper (which returns null when words run out) while counting words, and a Part B method builds an abbreviation from the first letter of each word. This is an illustrative example, not an official rubric, but it mirrors how points are typically awarded.

Part A (4 points)

Point 1 checks that you call getNextWord correctly. Writing getNextWord(startingWord) earns it, but incorrect calls elsewhere (like getNextWord() with no argument) can lose it. Graders check both that you made the right call and that you didn't make wrong ones.

Point 2 checks your loop. It should run until getNextWord returns null. Use != null, never .equals(null). Null isn't an object, so calling a method on it crashes.

Point 3 checks that you increment a count each time you process a word. Helpfully, this point is often still earnable even if you forget to assign the count to the instance variable at the end. Assign it anyway, because the algorithm point needs it.

Point 4 is the algorithm point. The full solution has to work: words joined with single spaces, no extra space before the first word or after the last, and the correct count stored. Initializing your message as " " instead of "" is a classic way to lose this point. The algorithm point is often still available even when you fumbled an earlier point, so never give up on a part just because you know one piece is off.

Part B (3 points)

Point 5 checks that your loop structure would access every part of the message it needs, whether you go character by character or jump between spaces.

Point 6 checks String method usage: can you find each space and correctly grab the character after it? Watch the off-by-one with substring, and remember the first word has no space before it.

Point 7 is the algorithm point. The method must return the right result without violating constraints. If the spec says message is unchanged and you write message = message.substring(...), you just gave this point away.

Common FRQ 1 Patterns

The same patterns show up year after year, just dressed in new scenarios. Recognize them and a brand-new question will feel familiar.

Constructor questions almost always combine three things: initializing instance variables from parameters, calling a helper method in a loop to build up data, and counting something along the way. The point is to test whether you understand that constructors often process data to set up an object's state, not just copy parameters into fields.

String manipulation in Part B usually means building a new string from an existing one (like an abbreviation) or searching a string for a pattern. Expect indexOf, substring, and concatenation. When the spec says "each word is separated by a single space," that's your cue to use spaces as delimiters.

Helper methods are half the algorithm. When the class provides a method, your job is to call it correctly in a loop. Its sentinel return value (null, -1) is your loop's exit condition.

Postconditions are point traps. "The value of message is unchanged" is tested by the algorithm point. Make a copy of anything you need to modify.

Common Mistakes

• Starting Part A without reading Part B. Part B often reveals how the class works and what your Part A variables should do. Read the entire question first, then code.
• Reimplementing a provided helper method. There's usually a rubric point for calling it correctly, so rewriting its logic wastes time and risks losing that point. Trust the tools you're given.
• Using .equals(null) or sloppy null checks. Compare with == null or != null. Calling any method on a null reference is an error, and "incorrect comparison to null" is explicitly penalized.
• Off-by-one errors with substring. substring(start, end) excludes the character at end. Trace one concrete example by hand before moving on.
• Modifying variables a postcondition says must stay unchanged. Reassigning message when the spec says it's unchanged costs the algorithm point. Copy first, then manipulate the copy.
• Spending 25+ minutes here. FRQ 1 is the warm-up. If it's eating your time, you're overcomplicating it. Finishing in about 17-20 minutes banks time for FRQ 4, the 2D array question, which often runs long.

Practice and Next Steps

The fastest way to improve at FRQ 1 is writing real code against real rubrics under time pressure. Set a 20-minute timer and work problems from the FRQ question bank, then try FRQ practice with instant scoring so you can see exactly which rubric points your code earns and which it misses. Working through past exam questions is the best way to internalize the patterns, since the helper-method-in-a-loop and String-manipulation structures repeat constantly.

Once FRQ 1 feels routine, move on to the other question types: FRQ 2 (Class Design) and FRQ 3 (Data Analysis with ArrayList). When you're ready to simulate the full 3-hour experience, take a full-length practice exam and check where your score lands with the AP score calculator.