2025 AP AP Computer Science A Practice Paper with Answers

This question involves a bicycle tour organizer who coordinates group rentals from different bike hubs throughout a city. A network of bike hubs is represented by the BikeHubNetwork class.

public class BikeHubNetwork
{
/**
* Returns the number of functional bikes, always greater than 0, available
* at the hub specified by hubId
* Precondition: 0 <= hubId <= 50
/
public int numAvailableBikes(int hubId)
{ / implementation not shown */ }

/**
* Decreases the inventory of available bikes at hubId by bikesTaken
* Preconditions: 0 <= hubId <= 50
* bikesTaken > 0
/
public void checkoutBikes(int hubId, int bikesTaken)
{ / implementation not shown / }

/ There may be instance variables, constructors,
and methods that are not shown. */
}

A tour guide leads excursions and is represented by the TourGuide class. You will write two methods of the TourGuide class.

public class TourGuide
{
/** The maximum group capacity this guide can supervise per tour stop */
private int maxCapacity;

/** The hub network this guide operates within */
private BikeHubNetwork network;

/**
* Assigns max to maxCapacity and net to network
* Precondition: max > 0
/
public TourGuide(int max, BikeHubNetwork net)
{ / implementation not shown */ }

/**
* Reserves and retrieves bikes for a tour stop at the hub specified by hubId,
* as described in part (a)
* Preconditions: 0 <= hubId <= 50
* maxCapacity > 0
/
public int organizeTour(int hubId)
{ / to be implemented in part (a) */ }

/**
* Leads a sequence of tours from startHubId to endHubId, inclusive,
* and returns the total compensation earned, as described in part (b)
* Preconditions: 0 <= startHubId <= endHubId <= 50
* maxCapacity > 0
/
public int guideShift(int startHubId, int endHubId)
{ / to be implemented in part (b) / }

/ There may be instance variables, constructors,
and methods that are not shown. */
}



Part (a)

Write the organizeTour method, which updates hub inventory and returns the number of bikes reserved by the tour guide for the hub specified by hubId.

The helper method numAvailableBikes in BikeHubNetwork returns the number of bikes currently ready at a given hub. The tour guide takes as many bikes as are available at the hub, up to a maximum of maxCapacity.

The helper method checkoutBikes in BikeHubNetwork must be invoked to deduct the reserved bikes from the hub's inventory so that other guides cannot claim the same bikes.

Complete method organizeTour below. You must use numAvailableBikes and checkoutBikes appropriately to receive full credit.

/**
* Reserves and retrieves bikes for a tour stop at the hub specified by hubId,
* as described in part (a)
* Preconditions: 0 <= hubId <= 50
* maxCapacity > 0
*/
public int organizeTour(int hubId)



Part (b)

Write the guideShift method, which processes a series of tour stops across consecutive hub IDs from startHubId through endHubId, inclusive, and returns the total payment earned in dollars.

For each hub visited during the shift:

• The base compensation is $8 per bike organized at that hub.


• An additional bonus of $5 is awarded for that hub stop if at least one of the following is true:
  
  
  
  • The number of bikes organized equals maxCapacity.
  
  
  • The hubId falls within the downtown zone of 10 through 20, inclusive.
  
  
  
  

For example, if maxCapacity is 4, and the guide visits hubs 8 through 11 with the following bike counts:

• Hub 8: 4 bikes organized → \(4 \times 8 + 5 = 37\) dollars (capacity reached)


• Hub 9: 2 bikes organized → \(2 \times 8 = 16\) dollars


• Hub 10: 2 bikes organized → \(2 \times 8 + 5 = 21\) dollars (downtown zone)


• Hub 11: 4 bikes organized → \(4 \times 8 + 5 = 37\) dollars (both conditions met, bonus applied once)

Total compensation returned would be \(37 + 16 + 21 + 37 = 111\) dollars.

Complete method guideShift below. Assume that organizeTour works as specified, regardless of what you wrote in part (a). You must use organizeTour appropriately to receive full credit.

/**
* Leads a sequence of tours from startHubId to endHubId, inclusive,
* and returns the total compensation earned, as described in part (b)
* Preconditions: 0 <= startHubId <= endHubId <= 50
* maxCapacity > 0
*/
public int guideShift(int startHubId, int endHubId)

This question involves the `SecurityPass` class, which is used to manage access credentials for a secured facility. You will write the complete `SecurityPass` class, which contains a constructor and two methods.

The `SecurityPass` constructor takes two parameters: a `String` representing the pass ID and an `int` representing the access level. The length of the pass ID parameter is always greater than or equal to 2, and the access level is always greater than or equal to 1.

The `getCode` method takes no parameters and returns a formatted credential code string constructed from the pass ID and access level according to the following rules:
- If `accessLevel` is greater than or equal to 5, the returned code consists of the first two characters of `passId`, followed by `"-PRIORITY-"`, followed by the remainder of `passId`.
- If `accessLevel` is less than 5, the returned code consists of `passId`, followed by `"-"`, followed by `accessLevel`.

The `updatePass` method takes a `String` parameter `newId` and an `int` parameter `levelBoost`. The method updates the pass according to the following rules:
- If `newId` contains `passId` as a substring, then `passId` is updated to `newId`, `accessLevel` is increased by `levelBoost`, and the method returns `true`.
- If `newId` does not contain `passId` as a substring, no changes are made to the object's instance variables, and the method returns `false`.

The following table contains a sample code execution sequence and the corresponding results.

| Statement | Method Call Return Value (blank if none) | Explanation |
| :--- | :--- | :--- |
| `SecurityPass sp1 = new SecurityPass("AB123", 6);` | | The `SecurityPass` object `sp1` has `passId` `"AB123"` and `accessLevel` 6. |
| `String c1 = sp1.getCode();` | `"AB-PRIORITY-123"` | `accessLevel` is 6 (\(\ge 5\)). The first 2 characters (`"AB"`) are followed by `"-PRIORITY-"` and the remainder (`"123"`). |
| `SecurityPass sp2 = new SecurityPass("SEC99", 2);` | | The `SecurityPass` object `sp2` has `passId` `"SEC99"` and `accessLevel` 2. |
| `String c2 = sp2.getCode();` | `"SEC99-2"` | `accessLevel` is 2 (< 5). `passId` is followed by `"-"` and `accessLevel`. |
| `boolean b1 = sp2.updatePass("SEC99X", 2);` | `true` | `"SEC99X"` contains `"SEC99"`. `passId` becomes `"SEC99X"` and `accessLevel` becomes 4 (\(2 + 2\)). |
| `String c3 = sp2.getCode();` | `"SEC99X-4"` | `accessLevel` is 4 (< 5). |
| `boolean b2 = sp1.updatePass("ADMIN", 3);` | `false` | `"ADMIN"` does not contain `"AB123"`. No instance variables are changed. |

Write the complete `SecurityPass` class. Your implementation must meet all specifications and conform to the examples in the table.

This question involves organizing chemical specimens in a laboratory into paired testing groups. Specimen data, paired tests, and batch processing are represented by the `Specimen`, `TestPair`, and `BatchProcessor` classes.

The `Specimen` class represents an individual chemical specimen with a unique identifier and a concentration level.

```java
public class Specimen
{
private String sampleId;
private double concentration;

/**
* Constructs a Specimen with given id and conc.
* Preconditions: id is not null; conc > 0
/
public Specimen(String id, double conc)
{ / implementation not shown */ }

/** Returns the concentration of this specimen /
public double getConcentration()
{ / implementation not shown */ }

/** Returns the identifier of this specimen /
public String getId()
{ / implementation not shown / }

/ There may be instance variables, constructors,
and methods that are not shown. */
}
```

The `TestPair` class represents two specimens paired for combined testing.

```java
public class TestPair
{
/** Constructs a TestPair with two specimens /
public TestPair(Specimen first, Specimen second)
{ / implementation not shown / }

/ There may be instance variables, constructors,
and methods that are not shown. */
}
```

The `BatchProcessor` class manages a collection of specimens and organizes them into pairs.

```java
public class BatchProcessor
{
/** The list of specimens in this batch */
private ArrayList specimenList;

/** Initializes specimenList, as described in part (a) /
public BatchProcessor(String[] ids, double[] concs)
{ / to be implemented in part (a) */ }

/**
* Evaluates specimens paired from the outside inwards and returns
* a list of valid TestPair objects, as described in part (b).
* Preconditions: specimenList.size() >= 2;
* specimenList is ordered from lowest to highest concentration.
* Postcondition: specimenList is unchanged.
/
public ArrayList createBalancedPairs(double targetSum, double tolerance)
{ / to be implemented in part (b) / }

/ There may be instance variables, constructors,
and methods that are not shown. */
}
```

---

### Part (a)

Write the constructor for the `BatchProcessor` class. The constructor should initialize the instance variable `specimenList` to contain one `Specimen` object for each corresponding pair of elements in the `ids` and `concs` arrays.

The `Specimen` objects must appear in `specimenList` in the same order as their corresponding elements appear in the parameter arrays. You may assume `ids` and `concs` have the same non-zero length.

Complete the `BatchProcessor` constructor:

```java
/** Initializes specimenList, as described in part (a) */
public BatchProcessor(String[] ids, double[] concs)
```

---

### Part (b)

Write the `BatchProcessor` method `createBalancedPairs`. This method creates and returns an `ArrayList` by evaluating potential pairings of specimens from `specimenList`.

Potential pairings are formed by pairing the specimen with the lowest concentration (at index `0`) with the specimen with the highest concentration (at the last index), the specimen with the second-lowest concentration with the specimen with the second-highest concentration, and so on, moving inward towards the center of the list.

For each potential pair:
- Compute the sum of the concentrations of the two specimens.
- If the absolute difference between the combined concentration sum and `targetSum` is less than or equal to `tolerance`, construct a new `TestPair` object containing the two specimens and add it to the list to be returned.
- If the absolute difference is greater than `tolerance`, the pair is considered unbalanced and no `TestPair` is created for those two specimens.

If `specimenList` contains an odd number of elements, the single middle element is not paired with anything and is ignored. The original `specimenList` must not be modified.

Complete the `createBalancedPairs` method:

```java
/**
* Evaluates specimens paired from the outside inwards and returns
* a list of valid TestPair objects, as described in part (b).
* Preconditions: specimenList.size() >= 2;
* specimenList is ordered from lowest to highest concentration.
* Postcondition: specimenList is unchanged.
*/
public ArrayList createBalancedPairs(double targetSum, double tolerance)
```

This question involves reasoning about a game board represented as a two-dimensional array of positive integers called `grid`. Each integer represents the power level of a token on the grid.

You will write the constructor and one method of the `TokenGrid` class.

```java
public class TokenGrid
{
/** A 2D array representing tokens on the board */
private int[][] grid;

/**
* Creates a two-dimensional array and fills it with random integers,
* as described in part (a)
* Preconditions: numRows > 0; numCols > 0; maxValue >= 1
/
public TokenGrid(int numRows, int numCols, int maxValue)
{ / to be implemented in part (a) */ }

/**
* Identifies and removes a matching token from the grid that can pair with
* the token at position (row, col), as described in part (b)
* Preconditions: row and col are valid row and column indices in grid.
* grid[row][col] is between 1 and maxValue, inclusive.
* @return true if a valid match was found and cleared; false otherwise
/
public boolean neutralizeMatch(int row, int col)
{ / to be implemented in part (b) / }

/ There may be instance variables, constructors, and methods not shown. */
}
```

### Part (a)
Write the constructor for the `TokenGrid` class. The constructor initializes the instance variable `grid` to be a two-dimensional integer array with `numRows` rows and `numCols` columns. Each element of `grid` must be assigned a randomly generated integer from `1` to `maxValue`, inclusive, each with an equal probability of being selected.

Complete the constructor:
```java
/**
* Creates a two-dimensional array and fills it with random integers,
* as described in part (a)
* Preconditions: numRows > 0; numCols > 0; maxValue >= 1
*/
public TokenGrid(int numRows, int numCols, int maxValue)
```

### Part (b)
Write the `neutralizeMatch` method, which searches `grid` to find another token to pair with the token located at row `row` and column `col`. To make a valid pair, the second token must satisfy all of the following conditions:
- It is not the token at `(row, col)` itself.
- Its row index is greater than or equal to `row`.
- Its value is equal to the value of `grid[row][col]`.

If a matching token is found at position `(r, c)`:
- Both `grid[row][col]` and `grid[r][c]` are set to `0` (cleared).
- The method returns `true` immediately without modifying any other elements. (If multiple valid matching tokens exist, any one of them may be paired and cleared).

If no matching token is found:
- No elements in `grid` are modified.
- The method returns `false`.

Complete the `neutralizeMatch` method:
```java
/**
* Identifies and removes a matching token from the grid that can pair with
* the token at position (row, col), as described in part (b)
* Preconditions: row and col are valid row and column indices in grid.
* grid[row][col] is between 1 and maxValue, inclusive.
* @return true if a valid match was found and cleared; false otherwise
*/
public boolean neutralizeMatch(int row, int col)
```