2021 MC Reflection

• 8 min read

📘 College Board Practice MC Exam Reflection

Taking the College Board Practice MC Exam taught me several important skills:

  • Managing my time effectively so I didn’t spend too long on any one question
  • Interpreting logic in pseudocode and analyzing data from tables

I scored 62 out of 70 on this exam. After reviewing my results, I looked at the topic breakdowns to identify which Big Ideas still need the most attention. I’ve improved across all areas compared to my previous two practice tests.

Previously, my main challenges were with data compression and the digital divide, but those areas have improved a lot. Now, my focus shifts to refining my understanding of:

  • Mathematical expressions
  • Working with lists
  • Binary Search
  • Developing Algorithms

I find it interesting that Binary Search and lists were areas that I struggled in, because generally I am confident in those areas, but I can see how being overconfident in those questions could lead to me making little mistakes that I didn’t notice.

❌ Question Correction: Q22 — Robot Movement Logic

🧠 Question:

The following code segment is used to move a robot in a 5x5 grid, starting at the center and facing up. Which of the given code segments moves the robot along the same path as the original?

🧾 Original Code:

count ← 1
REPEAT 4 TIMES {
  REPEAT count TIMES {
    MOVE_FORWARD()
  }
  ROTATE_LEFT()
  count ← count + 1
}

Correct Answer: A

Selected Answer: C

I chose C, which rotates count times and only moves forward once per loop. This changed the robot’s path too much.

I missed that in the original, MOVE_FORWARD() is inside the inner loop—so the robot moves more each round before turning.

❌ Question Correction: Q34 — Error in Science Simulation

🧠 Question:

The code is meant to simulate 100 trials of a science experiment where result X happens 25% of the time and result Y happens 75% of the time. But the output shows only 94 total trials. What change will fix the simulation?

🧾 Original Code:

xCount ← 0
yCount ← 0
REPEAT 100 TIMES {
  IF (RANDOM(1, 4) = 1) {
    xCount ← xCount + 1
  }
  IF (RANDOM(1, 4) > 1) {
    yCount ← yCount + 1
  }
}
DISPLAY("Result X occurred")
DISPLAY(xCount)
DISPLAY("times and result Y occurred")
DISPLAY(yCount)
DISPLAY("times.")

Correct Answer: B

Selected Answer: A

I chose A, which still uses two separate RANDOM(1, 4) calls—one for each condition. This led to the incorrect total of 94 trials.

The issue is that calling RANDOM twice in the loop can result in neither condition executing in some iterations.

Replacing the second IF with an ELSE ensures exactly one of the two outcomes (X or Y) happens per trial, making sure that all 100 trials are counted.

❌ Question Correction: Q42 — Iterate over integerList

🧠 Question:

What value is displayed as a result of executing the following code?

🧾 Original Code:

integerList ← [4, 2, 5, 4, 2, 3, 1]
result ← 0
FOR EACH item IN integerList {
  result ← result + (item MOD 2)
}
DISPLAY result

Correct Answer: A

Selected Answer: B

I chose B, which would be correct if the code counted the number of even values. However, item MOD 2 adds 1 for every odd number in the list, and 0 for even numbers.

The list [4, 2, 5, 4, 2, 3, 1] has three odd numbers: 5, 3, and 1.
So the correct result is 1 + 1 + 1 = 3, and that’s what gets displayed.

❌ Question Correction: Q52 — Binary Search on List of 128 Items

🧠 Question:

A sorted list of numbers contains 128 elements. Which of the following is closest to the maximum number of list elements that can be examined when performing a binary search for a value in the list?

🧾 Answer Choices:

  • A. 2
  • B. 8
  • C. 64 ❌ (Selected)
  • D. 128

Correct Answer: B
Selected Answer: C

I chose C, thinking that since binary search removes half the list each time, it might examine 64 elements. But that’s a misunderstanding of how binary search works.

Binary search cuts the list in half each time, so the maximum number of checks is about log₂(128) = 7, which is closest to 8.

So the correct answer is B.

❌ Question Correction: Q53 — Determine if Target Appears in List Multiple Times

🧠 Question:

A list of numbers has n elements, indexed from 1 to n. The following algorithm is intended to display true if the value target appears in the list more than once and to display false otherwise. The algorithm uses the variables position and count. Steps 4 and 5 are missing.

🧾 Partial Algorithm:

  1. Set count to 0 and position to 1
  2. If the value at index position is equal to target, increase count by 1
  3. Increase the value of position by 1
  4. ???
  5. ???

Which of the following could replace steps 4 and 5 so the algorithm works as intended?

💡 Answer Choices:

  • A.
    Step 4: Repeat steps 2 and 3 until position > n
    Step 5: If count ≥ 2, display true. Otherwise, display false.

  • B.
    Step 4: Repeat steps 2 and 3 until position > n
    Step 5: If count ≥ position, display true. Otherwise, display false. ❌ (Selected)

  • C.
    Step 4: Repeat steps 2 and 3 until count > 2
    Step 5: If position ≥ n, display true. Otherwise, display false.

  • D.
    Step 4: Repeat steps 2 and 3 until count > n
    Step 5: If count ≥ 2, display true. Otherwise, display false.

Correct Answer: A
Selected Answer: B

I chose B, which incorrectly checks if count is greater than or equal to position. That would only work if every element in the list equals target, which isn’t what we want.

The correct logic is to loop through the list and count how many times target appears. If it appears more than once, then display true.

Only Answer A checks each element and then evaluates if count ≥ 2, which is exactly what the algorithm is supposed to do.

❌ Question Correction: Q55 — Move Element from End of List to Beginning

🧠 Question:

A code segment is intended to transform the list utensils so that the last element of the list is moved to the beginning of the list.

Example:
Initial list: ["fork", "spoon", "tongs", "spatula", "whisk"]
Transformed list: ["whisk", "fork", "spoon", "tongs", "spatula"]

Which of the following code segments transforms the list as intended?

🧾 Answer Choices:

  • A.
    temp ← utensils[len]
    REMOVE(utensils, len)
    APPEND(utensils, temp)
  • B.
    REMOVE(utensils, len)
    temp ← utensils[len]
    APPEND(utensils, temp)
  • C.
    temp ← utensils[len]
    REMOVE(utensils, len)
    INSERT(utensils, 1, temp)
  • D.
    REMOVE(utensils, len)
    temp ← utensils[len]
    INSERT(utensils, 1, temp)

Correct Answer: C
Selected Answer: A

I chose A, which removes the last element and then appends it back to the end of the list. That doesn’t change the list at all.

The correct approach is to store the last item, remove it, and then insert it at the start of the list. Only C does this properly.

So Answer C is correct.

❌ Question Correction: Q64 — Error in ageGroup Procedure

🧠 Question:

The procedure ageGroup(age) is intended to return the name of the age group associated with age.

  • People under 18 → “minor”
  • People 65 and older → “senior citizen”
  • All others → “adult”

However, the procedure does not work as intended. Removing which two lines will fix the issue?

🧾 Code (Simplified):

Line 1:  PROCEDURE ageGroup(age)
Line 3:     result ← "adult"
Line 4:     IF(age ≥ 65)
Line 6:        result ← "senior citizen"
Line 8:     RETURN(result)
Line 10:    result ← "adult"
Line 11:    IF(age < 18)
Line 13:       result ← "minor"
Line 15:    RETURN(result)

Correct Answers: B (Line 8) and C (Line 10)
Selected Answer: B

I chose B, which correctly removes the early return on line 8. If this line is not removed, the check for age < 18 never runs.

However, I missed C. Line 10 resets the result to "adult" after the senior citizen check, which can override the correct value.

Removing both lines ensures the procedure runs all checks and returns the correct age group.

❌ Question Correction: Q66 — Set Bonus Points Based on Timer

🧠 Question:

In a video game, players are awarded bonus points based on the value of the integer variable timer:

  • timer < 30 → 500 points
  • 30 ≤ timer ≤ 60 → 1000 points
  • timer > 60 → 1500 points

Which of the following code segments correctly assigns the bonus for all possible timer values?

Select two correct answers.

💡 Answer Choices:

  • A.
    Start with bonus ← 500, then:
    • If timer ≥ 30, add 500
    • If timer > 60, add another 500
  • B.
    Start with bonus ← 1500, then:
    • If timer ≥ 30, subtract 500
    • If timer < 30, subtract another 500
  • C.
    Use 3 independent IF statements:
    • If timer > 60, set bonus ← 1500
    • If timer ≥ 30, set bonus ← 1000
    • If timer < 30, set bonus ← 500
  • D.
    Use 3 independent IF statements with combined condition for middle range:
    • If timer > 60, set bonus ← 1500
    • If 30 ≤ timer ≤ 60, set bonus ← 1000
    • If timer < 30, set bonus ← 500

Correct Answers: A and D
Selected Answer: A

I chose A, which correctly uses incremental logic: starts at 500, adds 500 if timer ≥ 30, and adds another 500 if timer > 60, resulting in the correct bonus amount.

However, I missed D. This version uses clear, non-overlapping conditional ranges with direct assignment, which also works correctly for all timer values.

So A and D both give the correct result.