This question tests AP Computer Science A skills in implementing selection and iteration algorithms, specifically focusing on selection sort implementation and understanding its state after partial execution. Selection sort works by finding the minimum element in the unsorted portion and swapping it into the next sorted position, building the sorted array from left to right. In this scenario, the array {5, 2, 9, 1} undergoes selection sort, and we need to determine the first two elements after the algorithm completes. Choice A (1 2) is correct because in the first pass (i=0), the algorithm finds the minimum 1 at index 3 and swaps it with 5, giving {1, 2, 9, 5}; in the second pass (i=1), it finds minimum 2 already at index 1 so no swap occurs; after all passes, the sorted array is {1, 2, 5, 9}, so a[0]=1 and a[1]=2. Choice D (1 5) might tempt students who think only one pass occurs, but the loop continues for all necessary passes. To help students: Trace selection sort step-by-step, showing the array state after each outer loop iteration. Emphasize that selection sort makes n-1 passes for an n-element array, progressively building the sorted portion from the left.

This question tests AP Computer Science A skills in implementing selection and iteration algorithms, specifically focusing on do-while loop conditions for menu-driven programs within Java coding tasks. A do-while loop executes its body at least once and continues while the condition is true, so for a quit command 'Q', the loop should continue while the command is NOT 'Q'. In this scenario, the program needs to keep running until the user enters 'Q', which means the loop condition should check that cmd is not equal to 'Q'. Choice B (cmd != 'Q') is correct because it properly implements the loop to continue while the command is anything other than 'Q', allowing the program to process 'A' and 'S' commands and only exit when 'Q' is entered. Choice A (cmd == 'Q') is incorrect because it would cause the loop to continue only when cmd equals 'Q', immediately exiting after any other command. To help students: Emphasize the difference between while and do-while loops, and clarify that do-while conditions determine continuation, not termination. Practice writing menu-driven programs with various exit conditions to build familiarity with the pattern.

This question tests AP Computer Science A skills in implementing selection and iteration algorithms, specifically focusing on edge case handling with conditional operators within Java coding tasks. The program must handle the special case where n=0 to avoid division by zero, using the ternary operator to set avg to 0.0 when n equals 0. In this scenario, when n=0, the for loop doesn't execute at all (since i < 0 is immediately false), leaving sum and passing at their initial values of 0, and the conditional expression correctly evaluates to 0.0 for the average. Choice A is correct because the code properly handles the n=0 case: the ternary operator returns 0.0, printf formats it as '0.0' with one decimal place, and passing remains 0, producing the exact output specified. Choice D is incorrect because the code explicitly prevents division by zero using the conditional operator. To help students: Emphasize the importance of edge case testing, especially with empty inputs, and demonstrate how conditional operators can elegantly handle special cases. Practice tracing code with boundary values like 0, 1, and maximum values.

This question tests AP Computer Science A skills in implementing selection and iteration algorithms, specifically focusing on binary search boundary updates within Java coding tasks. Binary search narrows the search space by comparing the target with the middle element and adjusting either the low or high boundary accordingly, eliminating half of the remaining elements each iteration. In this scenario, when the target is less than arr[mid], we know the target must be in the left half of the current range, so we need to update high to exclude the right half including mid itself. Choice A (high = mid - 1) is correct because it properly implements the search space reduction by setting high to one position before mid, excluding all elements from mid onwards since they are all greater than or equal to arr[mid]. Choice B (high = mid + 1) is incorrect as it would expand the search range rightward instead of narrowing it leftward when target is smaller. To help students: Use visual representations of arrays with low, mid, and high pointers to show how the search space shrinks, and emphasize that we can exclude mid itself since we've already checked it. Practice tracing binary search with specific examples to understand boundary movements.

This question tests AP Computer Science A skills in implementing selection and iteration algorithms, specifically focusing on state machine logic using if-else chains within a for loop in Java coding tasks. The traffic light cycles through states GREEN→YELLOW→RED→GREEN in a fixed pattern, with the current state printed before transitioning to the next. In this scenario, starting from GREEN and running 5 iterations: print GREEN then change to YELLOW, print YELLOW then change to RED, print RED then change to GREEN, print GREEN then change to YELLOW, print YELLOW then change to RED. Choice A is correct because it accurately traces the execution where each iteration prints the current state before the if-else chain updates it, producing the sequence GREEN, YELLOW, RED, GREEN, YELLOW. Choice D is incorrect because it suggests the pattern reverses or changes in some way, but the code implements a consistent one-way cycle. To help students: Use state diagrams to visualize transitions and trace execution with a table showing iteration number, printed state, and next state. Encourage students to distinguish between printing current state versus next state in their trace tables.

This question tests AP Computer Science A skills in implementing selection and iteration algorithms, specifically focusing on the inner loop logic of insertion sort for shifting elements. Insertion sort maintains a sorted portion and inserts each new element by shifting larger elements right until finding the correct position. In this scenario, the task requires implementing the shifting phase where elements larger than the key are moved one position right, starting from position j and moving leftward. Choice A (while (j>=0 && a[j]>key) { a[j+1]=a[j]; j--; }) is correct because it checks j>=0 to avoid array bounds errors, uses && to ensure both conditions are met, checks a[j]>key to shift only larger elements, correctly shifts with a[j+1]=a[j], and decrements j to move left. Choice C is incorrect because || would cause array access errors when j<0, and Choice D incorrectly assigns a[j]=a[j+1] which moves elements left instead of right. To help students: Visualize insertion sort as making space for the key by shifting elements right. Practice tracing the algorithm with small arrays and emphasize the importance of && versus || in compound conditions.

This question tests AP Computer Science A skills in implementing selection and iteration algorithms, specifically focusing on grade assignment using if-else chains and average calculation within Java coding tasks. The program processes an array of scores {88, 59, 90}, assigning letter grades based on threshold conditions and computing the integer average. In this scenario, the loop processes each score: 88 falls in the 80-89 range (B), 59 is below 60 (F), and 90 is exactly 90 (A), while the sum 237 divided by 3 gives 79 using integer division. Choice A is correct because it properly traces the execution: score 88 prints 'B', score 59 prints 'F', score 90 prints 'A', and the average calculation (88+59+90)/3 = 237/3 = 79 in integer division. Choice B is incorrect because integer division of 237/3 yields 79, not 80, as the decimal portion is truncated. To help students: Practice tracing through if-else chains with boundary values, and emphasize the difference between integer and floating-point division. Encourage students to manually calculate averages and verify their understanding of integer truncation.

This question tests AP Computer Science A skills in implementing selection and iteration algorithms, specifically focusing on the correct loop condition for binary search implementation. Binary search requires maintaining a valid search range and must handle the case where low and high indices meet at the target element. In this scenario, the task requires implementing binary search which repeatedly narrows the search range by comparing the middle element with the target and adjusting low or high accordingly. Choice B (while (low <= high)) is correct because it continues searching while there's at least one element in the range (when low equals high, there's still one element to check), and properly terminates when low > high indicates an empty range meaning the target wasn't found. Choice A (while (low < high)) is incorrect because it would miss checking the case where low equals high, potentially failing to find elements that happen to be at that single remaining position. To help students: Trace binary search with small arrays, especially edge cases with 1-2 elements. Emphasize that low <= high maintains the invariant that the search range is valid and non-empty.

This question tests AP Computer Science A skills in implementing selection and iteration algorithms, specifically focusing on do-while loop continuation conditions for input validation within Java coding tasks. A do-while loop for input validation should continue (repeat) when the input is invalid, meaning the condition should be true for invalid inputs and false for valid inputs. In this scenario, valid choices are 1-5 inclusive, so invalid choices are those less than 1 OR greater than 5, and the loop should continue while the choice remains invalid. Choice A is correct because choice < 1 || choice > 5 evaluates to true for all invalid values (0, -1, 6, 7, etc.) and false for valid values (1, 2, 3, 4, 5), causing the loop to repeat for invalid input and exit for valid input. Choice B is incorrect because it represents the condition for valid input, which would cause the loop to continue when input is valid and exit when invalid - the opposite of the desired behavior. To help students: Draw number lines showing valid and invalid ranges, and practice negating conditions to switch between 'is valid' and 'is invalid' logic. Encourage students to test boundary values (0, 1, 5, 6) to verify their conditions work correctly.

This question tests AP Computer Science A skills in implementing selection and iteration algorithms, specifically focusing on linear search with early termination using break statements. Linear search examines elements sequentially until finding the target or reaching the end, and the break statement provides efficient early exit when the target is found. In this scenario, the task requires finding the first occurrence of target value 7 in the array {3, 7, 7, 2, 9}, which appears at index 1 (0-based indexing). Choice B (1) is correct because the loop starts at i=0, checks a[0]=3 (not equal to 7), then checks a[1]=7 (equals target), sets idx=1, and breaks out of the loop, resulting in output 1. Choice A (0) would be incorrect as that's where 3 is located, and Choice C (2) would be the second occurrence of 7, but break ensures we stop at the first. To help students: Trace through the code step-by-step with actual values, emphasizing how break immediately exits the loop. Practice distinguishing between finding first occurrence versus all occurrences of a target value.