Browse All FRQs

An Account class needs a constructor that picks an available username by retrying a requested name with increasing numeric suffixes until one is free, and a method that removes every hyphen from the chosen username along with the character immediately before each one.

A Bottle class, designed entirely from scratch, needs to track how much liquid is left after each use and automatically refill itself back to full whenever that amount would drop below a quarter of its capacity.

An Attendance class holding two separate lists of course attendance records needs a single method that finds students appearing in both lists and counts how many of them were absent more often in the history class than in the math class.

A GameBoard class wrapping a 2D grid of colored, point-valued spaces needs a single method that totals the points in one row and doubles that total if every space in the row shares the same color.

A DogWalker class needs a method that walks as many available dogs as possible in a given hour without exceeding the walker's personal limit, and a second method that runs a walker through a range of hours and totals their pay, including bonus conditions.

A SignedText class, built entirely from scratch, needs to generate a signature from a person's first and last name, then attach that signature to a piece of text: appending it if it's missing, leaving it alone if it's already at the end, or moving it from the front to the end if it's there instead.

A Round class needs a constructor that turns an array of competitor names into a ranked list, and a method that pairs competitors for the next round from best against worst working inward, leaving a lone top-ranked competitor unpaired when the field is odd.

A SumOrSameGame class needs a constructor that fills a 2D grid with random single-digit values, and a method that searches from a given cell forward through the grid for another cell that either matches its value or sums with it to 10, clearing both if one is found.

A Feeder class tracking how much food is left needs a method that simulates one day of birds eating, with a small chance a bear empties it entirely, and a second method that runs many days in a row and counts how many of them started with food actually available.

A Scoreboard class, designed entirely from scratch, needs to track two teams' scores and whose turn is active, switching the active team whenever a play scores zero points and reporting both scores plus the active team's name.

A WordChecker class holding a list of words needs one method to check whether each word, after the first, contains the previous word somewhere inside it, and another that collects the words starting with a given prefix, stripping that prefix off each one it keeps.

A GridPath class wrapping a 2D array of distinct numbers needs a method that picks the smaller of the neighbor to the right or below a given cell, and a second method that follows that choice repeatedly from a starting cell to the grid's last cell, totaling every value visited along the way.

An appointment-booking class needs a method that searches a single class period's minutes for the first available block long enough for a given duration, and a second method that searches across a range of periods to actually reserve the first such block found.

A Sign class, written entirely from scratch, needs to split a message into fixed-width lines and report both how many lines the message needs and those lines joined together with semicolons.

A WeatherData class holding a list of daily temperatures needs one method to strip out any values outside a given range, and another to find the length of the longest run of consecutive days above a temperature threshold.

A BoxOfCandy class stores a 2D grid where empty spots are null; one method needs to make sure a given column has candy in its first row, moving a piece up if needed, and another needs to search the grid from the last row to the first for a candy of a given flavor and remove it.

A Game class with three levels needs a method that tallies a player's score based on how far they got, with a bonus multiplier for a bonus round, and a second method that plays the game repeatedly to find the best score achieved.

A Book class stores a title and price behind private fields, and a new Textbook subclass needs an edition number added, its book-info method extended to include that edition, and a method that decides whether one textbook edition can substitute for another of the same title.

A ReviewAnalysis class holding an array of Review objects, each with a rating and comment, needs one method to compute the average rating and another to build a list of index-labeled comments, keeping only the ones containing an exclamation point.

A Data class holding a 2D grid of integers needs one method that refills every cell with a randomized value meeting several numeric constraints at once, and another that counts how many columns increase from top to bottom.

A guessed word needs to be scored by counting how many times it appears, including overlapping occurrences, inside a hidden secret word, weighted by the guess's length, and then two guesses need to be compared to pick the one with the better score.

A class representing two restaurant tables pushed together needs to be built from scratch, reporting a combined seating capacity and a desirability score that keeps reflecting the individual tables' current view quality even after they change.

A batch of new members needs to be added to a club roster from an array of names, and separately every graduated member needs to be removed from the roster while collecting just the graduated members still in good standing into their own list.

A single row of a 2D array needs to be checked for whether it contains any zeros, and that check needs to be used to build a smaller replacement 2D array keeping only the rows that had none.

A range of years needs to be counted for how many of them are leap years, and separately a given date's day of the week needs to be worked out by combining two already-written calendar helper methods.

A fitness-tracking class needs to be designed from scratch to record each day's step count, tally how many days met an activity threshold, and report the average steps per day recorded so far.

An array of text tokens needs to be filtered down to just the opening and closing delimiter symbols it contains, and that resulting sequence of delimiters needs to be checked for whether it's properly balanced and never closes before it opens.

A grid of lights needs to be randomly switched on with a 40% chance per light when it's created, and a single light's new status needs to be recomputed based on how many lights are currently on elsewhere in its column.

A single frog-hopping attempt toward a goal distance needs to be simulated with a loop that can stop for three different reasons, and then that simulation needs to be repeated many times to estimate what fraction of attempts succeed.

Every possible pairing of words from an array needs to be generated exactly once and stored as objects, and then that stored list of pairs needs to be counted for how many of them repeat the same word on both sides.

A code-word validity checker needs to be built from an interface, with two different constructors (one specifying exact length bounds, one defaulting to standard ones) and a rule requiring both a length range and the absence of a forbidden substring.

A single column needs to be pulled out of a 2D grid of numbers as its own array, and that extraction is then combined with other given checks to decide whether the whole grid qualifies as a Latin square.

An integer needs to have its individual digits pulled out and stored in their original left-to-right order, then that list of digits needs to be checked for whether each one is strictly greater than the one before it.

A multiplication-practice class needs to be built from an interface's two-method contract, holding one number that stays fixed and a second number that increases by one every time a new practice problem is requested.

One specific numbered occurrence of a substring inside a phrase needs to be replaced with new text, and separately the position of that substring's very last occurrence needs to be found, both built on top of a given helper that locates any numbered occurrence.

A specific value's row and column need to be located inside a 2D grid of consecutive integers, and then a whole new grid needs to be built mapping every cell to the position of that cell's value-plus-one.

A class needs to hand back random strings from a starting collection one at a time with no repeats until none are left, then a subclass needs to reuse that same behavior to hand back random individual letters of a word instead.

A log message string needs its machine ID and description split apart at a colon, and a list of log messages needs to be searched so entries whose description contains a given keyword are pulled out into a separate list.

A crossword grid's squares need consecutive numbers assigned to the white squares that start a new word, based on whether each one has no white square directly above or directly to its left.

A list of words needs to be arranged into a single line of exact target length, with the space between words split as evenly as possible and any leftover spaces handed out one at a time starting from the left.

A set of three related array methods needs to be written together: one that sums a one-dimensional array, one that sums each row of a two-dimensional array by reusing that first method, and one that checks whether all of those row sums are distinct from each other.

A `HiddenWord` class needs to be built from scratch for a word-guessing game, comparing a guessed word to the hidden word letter by letter and returning a hint string that shows the letter itself for an exact match, a plus sign for a letter that's in the word but in the wrong spot, and an asterisk for a letter that isn't in the word at all.

A `SparseArray` class stores only the non-zero cells of a grid as a list of immutable row/column/value entries, needing one method to look up the value at a given position (defaulting to zero when nothing is stored there) and another to delete an entire column, shifting every entry to its right over by one.

A `NumberGroup` interface needs to be designed from scratch around a single contains-this-number method, then implemented by a `Range` class that checks whether a number falls between a minimum and maximum, and used by a `MultipleGroups` class that checks whether any group in a list of mixed number groups contains a given value.

A word-scrambling method needs to scan a word for an 'A' immediately followed by a different letter and swap that pair, skipping past any letters already swapped, and a second method applies that scramble across a list of words, dropping any word that comes back unchanged.

A `SeatingChart` needs a constructor that fills a 2D grid of student seats column by column from a roster list, leaving extra seats empty, and a method that clears out the seats of any student whose absence count exceeds a given limit, returning how many were cleared.

A `Trio` class needs to be built from scratch to implement a `MenuItem` interface, bundling a sandwich, salad, and drink into one combo whose name joins all three items' names and whose price is the sum of the two higher-priced items, with the cheapest one free.

A `MusicDownloads` class tracks a list of songs and their download counts, needing one method to find a song's record by title and another that processes a batch of newly downloaded titles, incrementing existing songs' counts or adding new entries for titles not seen before.

A `TokenPass` class models a circular token-passing game where each player holds a random number of tokens, needing a constructor that randomly fills the board and picks a starting player, and a method that collects the current player's tokens and redistributes them one at a time to the following positions, wrapping back to the start of the board.

A `SkyView` class reconstructs a telescope's raw scan readings into a 2D grid, where alternating rows were scanned in opposite directions and need to be unscrambled accordingly, plus a method to average the values in an arbitrary rectangular section of that grid.

A `ClimbingClub` keeps a list of climb records, and needs two different versions of an add method — one that always appends new entries, another that inserts them to keep the list sorted alphabetically by peak name — plus reasoning about whether a given duplicate-counting method works correctly under each ordering.

A `HorseBarn` stores horses in an array of numbered stalls where empty stalls are `null`, needing one method to search for a horse by name and another to shift all the horses toward the front of the array to close up any empty gaps, without changing their order.

A `GrayImage` class stores a grid of pixel brightness values, needing one method to count how many pixels are pure white and another to darken every pixel by subtracting the value of a neighbor two rows and two columns away, clamped so it never goes negative.

A `Sound` class stores audio as an array of integer samples, needing one method that clamps values exceeding a given amplitude limit while counting how many were changed, and another that removes any leading zero-valued samples from the front of the array.

A `FuelDepot` manages a list of fuel tanks and a robot that only moves forward in whatever direction it's facing, requiring one method to find the neediest tank below a fuel threshold and another to turn and move the robot to a specific tank's location.

A `RouteCipher` class fills a 2D grid of letters in row-major order from a string, then has to repeatedly fill and encrypt fixed-size chunks of a longer message until the whole thing has been processed.

A `MasterOrder` class tracks a list of cookie orders, and needs one method to total the number of boxes across every order and another to remove all orders of a given variety while reporting how many boxes were removed.

An `APLine` class has to be built entirely from scratch to represent the equation ax + by + c = 0, with methods to compute its slope and to check whether a given (x, y) point actually lies on the line.

A `Trail` class stores elevation readings from a hiking trail in an array, and needs one method to check whether a stretch between two markers stays within a 10-meter elevation range and another to count how many consecutive markers change elevation by 30 meters or more.

Repeated rolls of a six-sided number cube need to be collected into an array in the order they were rolled, and a separate method has to scan that array for the starting index of its longest run of consecutive, equal values.

An electric car charger has a 24-hour table of hourly electricity rates, and this FRQ needs a method that totals the cost of charging for a given number of hours starting at a given hour (wrapping past midnight if needed), plus a method that finds whichever starting hour makes that cost as low as possible.

Numbered puzzle tiles need to be slotted into a row so that any two touching edges show the same number, first checking whether a tile fits in its current orientation, then trying all four of its possible rotations before giving up on placing it.

A trip's list of connecting flights needs a method that computes the whole trip's total duration from the first departure to the last arrival, and another that finds the shortest layover between any two consecutive flights.

A shared master string is used to encode words as lists of substring references, and this FRQ asks for a method that rebuilds the original word from such a list, plus a method that breaks a new word down into matching references one piece at a time using a given helper method.

A family of string-checking classes all implement the same interface — one accepts text containing a given substring, another combines two checkers so both must accept, and the last part asks for combining existing checkers (with a given negating checker) so a string is only accepted when it contains neither of two given words.

A number is a self-divisor if every one of its digits evenly divides it, and this FRQ asks for a method to test a single number for that property, plus another that collects the first several self-divisors at or above a given starting number.

A multiple-choice answer sheet needs to be scored against an answer key with a penalty for wrong answers and no penalty for blanks, and a separate method has to scan a whole class's answer sheets to find whichever student scored highest.

A game-playing Player subclass needs to pick a random move from whatever options a given game state currently allows, and a separate driver method has to run a full game loop of alternating turns until someone wins or the game ends in a draw.

A daily schedule of appointments needs a method to check whether two appointments' times conflict, another to clear out anything on the schedule that conflicts with a given appointment, and a booking method that rejects a conflicting appointment unless it's flagged as an emergency.

An abstract TaxableItem class needs a purchasePrice() method that adds tax onto whatever list price a subclass supplies, and a new Vehicle subclass has to compute its own list price from a dealer cost and a markup that can be changed after the vehicle is created.

A Customer class needs a method that orders customers by name, breaking ties by ID number, and a separate method merges two already-sorted arrays of customers into a fixed-size result array without letting a customer who appears in both show up twice.

A hotel's array of rooms needs to be searched for an empty one to assign a new guest, falling back to a waiting list once the hotel is full, and a cancellation method has to hand a freed room to whoever is next in line.

A theater-ticket class hierarchy needs an Advance subclass whose price depends on how many days ahead it was purchased, plus a StudentAdvance subclass built on top of it whose price is always half of whatever the equivalent Advance ticket would cost.

A student's array of scores needs a method to average a given range of them, a check for whether the scores never decrease from one to the next, and a final average that uses only the second half of the scores when they improved.

A list of words stored in an ArrayList needs to be searched for entries of a given length, counting how many match and then removing all of them while preserving the order of the rest.

An abstract Pet class and its Cat, Dog, and LoudDog subclasses each need their own speak() method, plus a Kennel method that loops through a list of pets and calls each one's speak() through the shared supertype.

A tile-cleaning robot moving along a row of hallway tiles needs to detect a wall directly ahead, clean and advance when possible, and reverse direction when blocked, repeating until every tile is empty.