FRQ workshop: the 4 question types

The free-response section

• The AP CSA exam has two parts. Part 1 is multiple choice. Part 2 is free response (you write Java by hand).
• There are always 4 free-response questions (FRQs), and they come in the same 4 types every year.
• This lesson is a quick map of the 4 types. Knowing the pattern makes the exam much less scary. You can do this!

Type 1: Methods and Control Structures

• You write one or two methods using loops, if, and simple math on int, double, boolean, and String.
• No class to design — the class is given. You just fill in the method body.
• This is the most "plain coding" question. Lessons 1–8 cover everything you need.

public class Grades {
    // Count the scores that are 60 or more.
    public static int countPassing(int[] scores) {
        int count = 0;
        for (int s : scores) {
            if (s >= 60) {
                count = count + 1;
            }
        }
        return count;
    }

    public static void main(String[] args) {
        int[] scores = {72, 40, 95, 60, 33};
        System.out.println(countPassing(scores));   // 3
    }
}

Type 2: Class Design

• You are given a description of a class and must write the whole class.
• That means: instance variables, a constructor, and the methods they ask for.
• Remember private fields, the constructor with the same name as the class, and this.field = field. Lesson 6 covers this.

public class Student {
    private String name;
    private int score;

    public Student(String name, int score) {
        this.name = name;
        this.score = score;
    }

    public int getScore() {
        return score;
    }
}

Type 3: Array / ArrayList

• You work with an ArrayList (or sometimes an array) and write code that traverses it.
• Common jobs: find a value, count items, remove items, or build a new list.
• Watch the index carefully when you remove while looping. Lessons 9–11 cover this.

// Count the Strings longer than 3 letters.
int count = 0;
for (int i = 0; i < words.size(); i++) {
    if (words.get(i).length() > 3) {
        count++;
    }
}
return count;

Type 4: 2-D Array

• You work with a 2-D array (a grid of rows and columns).
• You use nested loops: an outer loop for rows, an inner loop for columns.
• Common jobs: sum a row, sum a column, find the largest value, or count matches. Lesson 12 covers this.

// Add up every value in the grid.
int total = 0;
for (int r = 0; r < grid.length; r++) {
    for (int c = 0; c < grid[r].length; c++) {
        total += grid[r][c];
    }
}
return total;

Exam strategy: read carefully

• Read the whole question first. Underline what the method must return and what its parameters are.
• Look at the example table they give. It shows exactly what your code should produce.
• Copy the method header they give you. Do not change its name, parameters, or return type.

Exam strategy: write methods that work

• Write the base of a loop first, then fill in the body. Get it running in your head step by step.
• Traverse correctly: start the index at 0, stop at length (or size()); check the edges.
• Use return with the right type. If the header says int, return an int.

Exam strategy: small wins add up

• You get points for parts that work, even if the whole method is not perfect. Always write something.
• Use only Java you know from this course. Simple, correct code beats clever code.
• Check your work with the example values from the question before you move on.

You are ready

• The 4 types never change: methods, class design, array/ArrayList, and 2-D array.
• Every skill you need for these four FRQ types is in lessons 1–12. Practice each type a few times and the pattern becomes familiar.
• Stay calm, read carefully, and write the code you know. Good luck on the exam!

Now you try

• Try one FRQ-style method yourself — the same shape as Type 1 above.
• Press Check answer to compile and run it on the server.