AP Computer Science a Quiz: Algorithms With Selection And Repetition

What this quiz covers

This quiz focuses on Algorithms With Selection And Repetition, giving you a quick way to practice the rules, question types, and explanations that matter most for AP Computer Science a.

How to use this quiz

Try each quiz question before looking at the correct answer. Use the explanations to review missed ideas, then come back to similar questions until the pattern feels familiar.

Question 1

1. Sequencing and selection.
2. Repetition and selection. (correct answer)
3. Repetition and sequencing only.
4. Selection and abstraction.

Explanation: The process is performed "for each letter" until the stack is empty, which is repetition. Inside that repetition, a decision is made based on the ZIP code ("If the ZIP code is..."), which is selection. Therefore, the algorithm's main structure combines repetition and selection.

Question 2

1. Sequencing followed by selection. (correct answer)
2. Repetition followed by sequencing.
3. Selection followed by repetition.
4. Sequencing followed by repetition.

Explanation: "Read the entire essay" is the first step in a sequence. "If the essay contains any spelling errors, deduct 5 points" is a single decision based on a condition, which is selection. The process does not describe repeating any action in a loop structure. Therefore, it is a sequence followed by a selection.

Question 3

1. A sequence of three independent steps.
2. A selection statement that chooses one of two final actions.
3. A repetition loop that continues until valid input is received. (correct answer)
4. Two separate sequences determined by an initial choice.

Explanation: The diagram shows a loop. If the input is not valid, the process returns to getting input again. This is repetition. The diamond shape represents the decision that controls the loop. Therefore, the structure is a repetition loop designed to validate user input.

Question 4

1. Repetition, because an action is performed continuously based on a condition. (correct answer)
2. Selection, because a single decision is made about whether to turn the heat on.
3. Sequencing, because checking the temperature must happen before running the heat.
4. Data Abstraction, because the specific temperature is represented as a single value.

Explanation: The process involves "repeatedly" checking and performing an action "as long as" a condition is true. This is the definition of repetition, or a loop. Choice (B) is incorrect because the check is continuous, not a one-time decision. While sequencing (C) is a component of the process, the overarching structure that defines the algorithm is repetition. Data abstraction (D) is a valid concept but does not describe the algorithmic structure.

Question 5

String state = startState;
for (int c = 0; c < cycles; c++) {
    for (int t = 0; t < 3; t++) {
        System.out.println(state);
        if (state.equals("GREEN")) state = "YELLOW";
        else if (state.equals("YELLOW")) state = "RED";
        else state = "GREEN";
    }
}

1. $O(1)$ because there are only three states
2. $O(c)$ because the inner loop is constant size (correct answer)
3. $O(c^2)$ because two loops always imply quadratic time
4. $O(3^c)$ because the state changes exponentially

Explanation: This question tests AP Computer Science A skills: understanding algorithms with selection and repetition, specifically analyzing time complexity of nested loops. Time complexity measures how execution time grows with input size, and nested loops often multiply their iteration counts. In this traffic light algorithm, the outer loop runs 'cycles' times, and the inner loop always runs exactly 3 times (once for each light state). Choice B is correct because the inner loop has constant size (3 iterations), making the total iterations 3c, which simplifies to O(c) linear time complexity. Choice C is incorrect because two loops don't always imply quadratic time - it depends on whether both loops scale with input size. To help students: Emphasize that constant-size inner loops don't change the order of growth. Practice calculating iterations by multiplying loop counts and identifying which variables affect runtime.

Question 6

String state = startState;
for (int s = 1; s <= totalSeconds; s++) {
    System.out.println(state);
    if (s % 5 == 0) {
        if (state.equals("GREEN")) state = "YELLOW";
        else if (state.equals("YELLOW")) state = "RED";
        else state = "GREEN";
    }
}

1. GREEN printed 4 times, then YELLOW once
2. GREEN printed 5 times, then the state changes after printing (correct answer)
3. GREEN printed once, then YELLOW printed 4 times
4. YELLOW printed 5 times because s % 5 triggers immediately

Explanation: This question tests AP Computer Science A skills: understanding algorithms with selection and repetition, focusing on modulo operations for periodic events. The modulo operator (%) helps detect when counters reach specific intervals, useful for implementing timed state changes. In this traffic light simulation, the condition 's % 5 == 0' triggers state changes every 5 seconds, but the state change occurs after printing the current state. Choice B is correct because GREEN is printed 5 times (when s = 1, 2, 3, 4, 5), then the state changes to YELLOW after the 5th print when s % 5 == 0 evaluates to true. Choice A is incorrect because it miscounts - GREEN is printed 5 times, not 4. To help students: Emphasize that loop body execution order matters - printing happens before the state change check. Practice tracing loops with modulo conditions to understand periodic behavior.

Question 7

int sum = 0;
int validCount = 0;
for (int i = 0; i < gradeList.length; i++) {
    if (gradeList[i] >= 0) {
        sum += gradeList[i];
        validCount++;
    }
}
double average = (validCount == 0) ? 0.0 : (double) sum / validCount;
System.out.println(average + "," + validCount);

1. Add a second full loop after averaging to count above-threshold
2. Add an if inside the existing loop to increment countAbove (correct answer)
3. Replace the loop with a single if to check one grade only
4. Move sum and validCount inside the loop to reset each iteration

Explanation: This question tests AP Computer Science A skills: understanding algorithms with selection and repetition, focusing on efficient algorithm modification. Efficient algorithms minimize redundant operations by combining related tasks within existing loops rather than creating additional passes through data. To count grades above a threshold while already iterating through the array, the most efficient approach is to add the counting logic within the existing loop. Choice B is correct because adding an if statement inside the existing loop to increment countAbove allows both tasks (summing valid grades and counting above-threshold grades) to be accomplished in a single pass through the data. Choice A is incorrect because adding a second full loop would double the time complexity unnecessarily. To help students: Emphasize the efficiency gained by combining related operations in a single loop. Practice identifying opportunities to merge similar tasks that process the same data.

Question 8

1. Sequencing, because it is one step in a specific order of instructions.
2. Selection, because a decision is made to perform an action based on a specific condition. (correct answer)
3. Repetition, because the instruction might need to be followed multiple times.
4. Abstraction, because the details of how to add the milk are not specified.

Explanation: The step involves making a choice (to add milk or not) based on a condition (the batter's thickness). This is the definition of selection. While the step is part of a larger sequence (A), the core concept illustrated within the step is selection. The instruction is a one-time check, not a loop, so it is not repetition (C). Abstraction (D) is a broader concept; the most precise answer is selection.

Question 9

1. Sequencing followed by a single selection.
2. Repetition that contains selection. (correct answer)
3. Selection that contains repetition.
4. Sequencing with no selection or repetition.

Explanation: The overall process is repeated ("repeat the process..."), making it a form of repetition. Within each repetition, a choice is made (go to the first half, second half, or stop) based on comparing the names, which is selection. Therefore, the algorithm is best described as a repetition structure that contains selection logic to guide the next step.

Question 10

1. The car entering the wash bay and moving forward on the conveyor belt.
2. The system checking for the "undercarriage spray" option and activating it if selected.
3. Processing the car by performing a function at each of the three washing stations. (correct answer)
4. The entire car wash process from start to finish for a single car.

Explanation: Step 5 describes performing a similar action (pausing and applying a treatment) for a set of items (the three stations). This is a form of repetition, equivalent to a fixed loop that executes three times. Step 2 (and 3) describes selection (B). The other actions are part of the overall sequence (A, D).

Question 11

1. Repetition to examine each score in the list, and selection to determine if a particular score is 90 or above. (correct answer)
2. Only selection is needed, to check each score and decide if it is 90 or above without requiring a loop.
3. Only repetition is needed, to iterate through the list of scores from beginning to end without making decisions.
4. Only sequencing is needed, to process the scores one after another in the order they appear in the list.

Explanation: To solve the problem, the algorithm must look at every score, which requires repetition (a loop). For each score, it must make a decision: is this score 90 or greater? This requires selection (an if-statement). Both are essential. The other options are incomplete because they omit one of the necessary components.

Question 12

1. The algorithm uses selection (Step 1) and repetition (Step 3) within an overall sequence. (correct answer)
2. The algorithm uses repetition (Step 1) and selection (Step 3) within an overall sequence.
3. The algorithm consists only of a sequence of steps without any selection or repetition.
4. The algorithm consists only of repetition to determine when the alarm should be played.

Explanation: Step 1 ("If it is a weekday...") is a decision based on a condition, which is selection. Step 3 ("...repeatedly play the alarm sound until...") is an action that is repeated based on a condition, which is repetition. These steps occur in a specific order, which is sequencing. Therefore, the algorithm combines all three concepts.

Question 13

1. Sequencing and selection only.
2. Sequencing and repetition only.
3. Repetition and selection only.
4. Sequencing, selection, and repetition. (correct answer)

Explanation: The algorithm has a clear order of operations (sequencing). It involves repeatedly rolling a die until a condition is met (repetition). Within each roll, it makes a decision based on the number rolled (selection). Therefore, all three fundamental building blocks are present.

Question 14

1. The order is irrelevant because both algorithms use the same two selection steps.
2. Algorithm X uses repetition then selection, while Algorithm Y uses selection then repetition.
3. The algorithms are different sequences of selection steps; one may reject an applicant earlier than the other. (correct answer)
4. Only one algorithm correctly uses sequencing, while the other is logically flawed.

Explanation: Both algorithms use two selection steps within a sequence. However, the order of these steps is different. An applicant could be rejected by the first check in Algorithm X (low credit score) but pass the first check in Algorithm Y (high income). This change in sequence can affect when an application is rejected, impacting efficiency. Both algorithms are logically valid, just structured differently.

Question 15

1. Steps 2 and 3 are selection, and Step 4 is repetition. (correct answer)
2. Steps 2, 3 and 4 are all examples of selection.
3. Steps 2, 3 and 4 are all examples of repetition.
4. Step 2 is selection, and Steps 3 and 4 are repetition.

Explanation: Steps 2 and 3 involve making a decision to perform a single action based on a condition ("if the customer wants..."), which is selection. Step 4 involves performing an action for a list of items ("for every topping..."), which is repetition.

Question 16

1. Selection, because the algorithm ultimately selects a winner based on the final score.
2. Repetition, because rounds of kicks are repeated based on the condition of a tied score. (correct answer)
3. Sequencing, because the additional rounds of kicks must happen in a specific order.
4. Abstraction, because the details of each kick are hidden within the concept of a "round".

Explanation: The phrase "continues with additional rounds as long as" indicates a loop or repetition. The shootout process is repeated until the condition (a tied score) is no longer true. This is a clear example of repetition controlling the flow of the algorithm.

Question 17

1. A repetitive structure that confirms each requirement one at a time until one fails.
2. A sequential structure with no decisions, where each step is executed unconditionally.
3. A selection structure that evaluates if all three distinct conditions are met. (correct answer)
4. A selection structure that evaluates if at least one of the three conditions is met.

Explanation: The core of this algorithm is making decisions. It must check three conditions and act based on whether all are true. This is a selection structure, likely implemented with if statements and logical AND operators. Choice (A) is incorrect as there is no looping or repetition. Choice (B) is incorrect because decisions are central to the process. Choice (D) describes the wrong logic (an OR condition instead of an AND condition).

Question 18

1. Repetition, as it could be performed again if the user starts another transaction.
2. Sequencing, as it is a step that must follow selecting a withdrawal amount.
3. Selection, as an action is performed only if a certain condition about the balance is met. (correct answer)
4. Input, as the machine must get the account balance data before making a decision.

Explanation: This step describes a decision point. The action of dispensing cash is conditional upon the account balance. This is a clear example of selection. While it is part of a sequence (B) and uses data that could be considered a form of input (D), the core algorithmic concept being illustrated by the "if...then" structure is selection.

Question 19

1. It is a selection nested within a repetition. (correct answer)
2. It is a repetition nested within a selection.
3. It is a simple selection statement without repetition.
4. It is a simple sequence without selection or repetition.

Explanation: The overall process is repeated 100 times, making repetition the outer structure. Within each repetition, the robot performs a check ("check it for defects") and makes a decision, which is selection. Therefore, the algorithm is best described as a selection nested within a repetition.

Question 20

// Compute average and count grades at or above threshold
int sum = 0;
int countAbove = 0;
for (int i = 0; i < gradeList.length; i++) {
    sum += gradeList[i];
    if (gradeList[i] >= threshold) {
        countAbove++;
    }
}
double average = (double) sum / gradeList.length;
System.out.println(average + "," + countAbove);

1. The cast to double ensures each grade is checked once
2. The for-loop header iterates once per index in gradeList (correct answer)
3. The sum variable prevents skipping grades during iteration
4. The if-statement repeats until countAbove equals threshold

Explanation: This question tests AP Computer Science A skills: understanding algorithms with selection and repetition, focusing on loop control and iteration mechanics. The for-loop structure ensures systematic traversal through arrays by using an index variable that increments from 0 to the array length minus one. In this problem, the for-loop header 'for (int i = 0; i < gradeList.length; i++)' controls the iteration, visiting each array element exactly once. Choice B is correct because the loop header specifically iterates once per index in gradeList, ensuring every grade is accessed through gradeList[i] and compared to the threshold exactly once. Choice A is incorrect because the cast to double only affects the average calculation, not the iteration count. To help students: Emphasize that for-loop headers control iteration count, not the loop body. Practice tracing through loops with index variables to see how each element is accessed exactly once.