AP Computer Science A Exam Guide

The AP CSA Multiple Choice Section

AP CSA MC Unit Descriptions

Multiple Choice Tips

The Multiple Choice from the Course and Exam Description

The AP CSA Free Response Questions

Types of FRQs

1. Methods and Control Structures
   This FRQ asks you to write methods and master control structures such as loops and branching (if/else if/else).
2. Class Writing
   This FRQ asks you to write an entire class, given specifications of what the class should do, and including any variables and methods the class should include.
3. Array/ArrayList
   This FRQ asks you to write methods that use an array or ArrayList, including filtering and traversal. In recent years, the questions tend to be more about ArrayLists than standard arrays.
4. 2D Arrays
   This FRQ asks you to write methods that use a 2D array, including traversal of arrays.

AP CSA FRQ Task Verbs

• Assume: Suppose that the statement is true without any further information. For example, in later parts of a question, we can assume that the code written in earlier parts works as intended.
• Complete (program code): Sometimes, there is code that is partially filled. It is your job to finish the code so that it works as intended.
• Implement/Write: When doing this, we write a whole class or method, given what it is supposed to do.

FRQ Tips

Solving the 2019 AP CSA FRQs

1. Methods and Control Structures


Answer to 1a
/** Returns the number of leap years between year1 and year 2 inclusive * Precondition: 0 <= year1 <= year2 */ public static int numberOfLeapYears(int year1, int year2) { /* Pseudocode: start looping from year 1 to year 2 inclusive, set a counter and add to the counter if isLeapYear(year) is true */ int counter = 0; for (int i = year1; i <= year2; i++) { if isLeapYear(i) { counter++; } } return counter; }



Answer to 1b
/** Returns the value representing the day of the week for the given date
* (month, day, year), where 0 denotes Sunday, 1 denotes Monday, ..., and 6 denotes Saturday
* Precondition: The date is a valid date.
*/
public static int dayOfWeek(int month, int day, int year) {
/* Pseudocode first attempt: Use dayOfYear to figure out how many days of the year it has been
in the year, and then modulo 7 to figure out how many days it has been,
then subtract 1 because January 1st is 1 and not 0 and add firstDayOfYear()
However, this may return a value larger than 6, which is outside our
desired range for the output so we should add firstDayOfYear()
and subtract 1 first before doing modulo to get the correct answer
*/
return (dayOfYear(month, day, year) - 1 + firstDayOfYear(year)) % 7;
}
2. Class Writing


Answer to 2
/** Tracks steps walked
*/
public class StepTracker {
private int totalDays;
private final int ACTIVESTEPS;
private int activeDayCount;
private int totalSteps;
/** Creates a StepTracker with activeSteps specified and other necessary instance
* variables, including total steps, active days, and total days.
*/
public StepTracker(int activeSteps) {
ACTIVESTEPS = activeSteps;
totalDays = 0;
activeDayCount = 0;
totalSteps = 0;
}
/** Adds a day of steps to total steps and also checks if there is an active
* day. Also increments the total number of days
*/
public void addDailySteps(int stepsInDay) {
totalDays++;
totalSteps += stepsInDay;
if (stepsInDay >= ACTIVESTEPS) {
activeDayCount++;
}
}
/** Returns the number of active days
*/
public int activeDays() {
return activeDayCount;
}
/** Returns the average steps a day
*/
public double averageSteps() {
return (double) totalSteps / totalDays;
}
3. Array/Array List





Answer to 3a
/** Returns an ArrayList of delimiters from the array tokens
*/
public ArrayList<String> getDelimitersList(String[] tokens) {
/* Traverse through the array, if a token is a delimiter, add it to the ArrayList
*/
ArrayList<String> delimiterList = new ArrayList<String>()
for (String token: tokens) {
if (token.equals(openDel) || token.equals(closeDel)) {
delimiterList.add(token);
}
}
return delimiterList;
}




Answer to 3b
/** Returns true if the delimiters are balanced and false otherwise
Precondition: delimiters contains only valid open and close delimiters.
*/
public boolean isBalanced(ArrayList<String> delimiters) {
/* Pseudocode: Set a counter, which represents the number of unpaired
delimiters to 0 and for every open delimiter, add 1,
for every close delimiter, subtract 1, representing an open
delimiter has been paired return false if there is a close
delimiter when the counter is 0 (no open to pair with) or the counter
is not 0 in the end (not equal), else, return true
*/
int openCount = 0;
for (String delimiter: delimiters) {
if (delimiter.equals(openDel)) {
openCount++;
} else {
if (openCount == 0) {
return false;
} else {
openCount--;
}
}
}
return openCount == 0;
}
4. 2D Array


Answer to 4a
/** Constructs a LightBoard object having numRows rows and numCols columns.
* Precondition: numRows > 0, numCols > 0
* Postcondition: each light has a 40% probability of being set to on.
*/
public LightBoard(int numRows, int numCols) {
/* Traverse through each cell in the 2D array, for each cell, generate a random
integer from 0 to 9, if this integer < 4, set to true, else set to false
*/
import java.util.Random;
Random rand = new Random();
lights = new boolean[numRows][numCols];
for (int i = 0; i < numRows, i++) {
for (int j = 0; j < numCols; j++) {
if (rand.nextInt(10) < 4) {
lights[i][j] = true;
}
}
}
}



Answer to 4b
/** Evaluates a light in row index row and column index col and returns a status
* Precondition: row and col are valid indexes in lights.
*/
public boolean evaluateLight(int row, int col) {
/* First count the ons on the column, then check the status of the light in question
and proceed from there as in the instructions
*/
int columnCount = 0;
for (boolean[] row: lights) {
if (row[col]) {
columnCount++;
}
if (lights[row][col] && columnCount % 2 == 0) {
return false;
} else if (!lights[row][col] && columnCount % 3 == 0) {
return true;
}
return lights[row][col];
}