Beaver Computing Challenge guide for 2026

CEMC's own wording for the blank rule: "Each unanswered question is worth 2 up to a maximum of 5 unanswered questions at the Grade 5/6 level and a maximum of 6 unanswered questions at the Grade 7/8 and 9/10 levels." The contest site adds that "Incorrectly answered questions are worth 0 marks", and that a student can clear a choice with an "Erase" option, which "will appear as the fifth choice in all multiple choice questions".

Our check that the parts add up, labelled as ours: at Grade 7/8 and 9/10, 5 x 8 + 5 x 6 + 5 x 4 = 40 + 30 + 20 = 90; at Grade 5/6, 4 x 6 + 4 x 5 + 4 x 4 = 24 + 20 + 16 = 60. Part A alone carries 24 of the 60 marks at Grade 5/6 and 40 of the 90 at the upper levels, which is why careful work on the first questions matters more than heroics on the last.

Sources: CEMC's BCC page (supervisor steps, 2025 averages and statistics) and the instructions on the BCC contest site, read 22 October 2026. CEMC printed 14 260, 16 344 and 7827 contestants for the three 2025 levels; we show them separately and do not add them.

Task 1: Canoe Dock (Part A). Four canoes, numbered 3, 1, 4 and 2, sit in a row on a dock in that order. The camp counsellor wants them in the order 1, 2, 3, 4. The only move allowed is to swap two canoes that are side by side. What is the fewest number of swaps needed? (A) 2 (B) 3 (C) 4 (D) 5

Answer: (B) 3. Count the pairs that are in the wrong order relative to each other: 3 before 1, 3 before 2, and 4 before 2. That is three pairs. Each swap of neighbours fixes exactly one such pair, so at least three swaps are needed, and three are enough: 3 1 4 2 becomes 1 3 4 2, then 1 3 2 4, then 1 2 3 4. The computer science idea: these out-of-order pairs are called inversions, and counting them tells you exactly how much work a neighbour-swapping sort, such as bubble sort, must do.

Task 2: Trail Lanterns (Part A). Each post on a winter trail has three lanterns in a row. Each lantern is either on or off, and rangers read the pattern as a signal. A post with all three lanterns off cannot be seen at night, so it is not used as a signal. How many different signals can one post show? (A) 3 (B) 6 (C) 7 (D) 8

Answer: (C) 7. Each lantern has two states, so three lanterns make 2 x 2 x 2 = 8 patterns. Removing the all-off pattern leaves 7. The trap is answer (D), which forgets the rule in the last sentence, and answer (A), which counts lanterns instead of patterns. The computer science idea: each lantern is a bit; three bits give eight values, and real systems often reserve one value, as here, to mean "nothing".

Task 3: Plough Route (Part B). A plough must clear a path from cabin A to cabin F, using the trails in the table. Trails can be used in either direction. What is the shortest total ploughing time from A to F? (A) 12 (B) 13 (C) 14 (D) 15

Answer: (B) 13. Work outward from A and keep the quickest time to each cabin. C is 2. B is 3, because A to C to B (2 + 1) beats the direct trail (4). D is 8 (B plus 5), which beats C to D (2 + 8 = 10). E is 10 by way of D (8 + 2), better than the direct C to E route (2 + 10 = 12). F is then the smaller of D to F (8 + 6 = 14) and E to F (10 + 3 = 13), so 13, by A, C, B, D, E, F. The trap is (C): stopping at the direct trail from D. The computer science idea: keeping the quickest known time to every place, and improving it as you go, is the heart of Dijkstra's shortest-path algorithm, used in every map app.

Task 4: Rover Commands (Part B). A rover starts on a square of a grid, facing north. F moves it forward one square, R turns it right on the spot and L turns it left on the spot. Which program brings the rover back to the square where it started? (A) F R F R F R F (B) F F R F F R F F (C) F L F L F R F (D) F R R F F

Answer: (A). Trace each program on a sketch. (A) goes north, east, south and west, one square each: a small square that closes on the start. (B) ends two squares east of the start. (C) ends two squares west of the start: its last turn is R, which points the rover west, where an L would have closed the loop. (D) turns around and overshoots the start by one square. The computer science idea: tracing a program by hand, one instruction at a time, is how programmers check code before trusting it; the "turn on the spot" detail matters as much as a semicolon does.

Task 5: Portage Pack (Part C). A canoe trip can carry at most 10 kg in the last pack. The choices are a tent (6 kg, worth 10 points to the group), a food barrel (5 kg, 7 points), a canoe pack (5 kg, 7 points) and a map case (1 kg, 1 point). What is the most points the pack can carry? (A) 11 (B) 12 (C) 14 (D) 17

Answer: (C) 14. The obvious move is to take the tent, the most valuable item, first. That leaves 4 kg, enough only for the map case: 11 points, which is trap (A). Leaving the tent behind and taking the food barrel and the canoe pack fills the 10 kg exactly and scores 14. Answer (D) adds everything and ignores the limit. The computer science idea: this is a tiny knapsack problem, and it shows why a "greedy" rule (always grab the biggest first) can lose to a careful look at combinations.

Task 6: Library Check Digit (Part C). A school library writes each card number as four digits, a dash, and a check digit. The check digit is the last digit of the sum of the first four. For example, 4096-9 is correct because 4 + 0 + 9 + 6 = 19. One of these cards was copied wrongly. Which one? (A) 4096-9 (B) 1234-0 (C) 2026-1 (D) 7310-1

Answer: (C) 2026-1. The digits 2, 0, 2 and 6 add to 10, whose last digit is 0, so the check digit should be 0. The others pass: 1 + 2 + 3 + 4 = 10 (check 0) and 7 + 3 + 1 + 0 = 11 (check 1). A follow-up our teachers always ask: if someone swaps two digits, for example writing 1243-0, does this rule notice? It does not, because the sum stays the same. The computer science idea: check digits catch copying mistakes, and real schemes give each position a different weight precisely so that swapped digits are caught too.

# Our answer checker for practice tasks 3 and 5 (our tasks, not CEMC's)
from itertools import combinations

# Task 3: every trail and its ploughing time in minutes
trails = {("A", "B"): 4, ("A", "C"): 2, ("B", "C"): 1, ("B", "D"): 5,
          ("C", "D"): 8, ("C", "E"): 10, ("D", "E"): 2, ("D", "F"): 6,
          ("E", "F"): 3}
roads = {}
for (x, y), t in trails.items():
    roads.setdefault(x, []).append((y, t))
    roads.setdefault(y, []).append((x, t))

def routes(here, goal, seen, time):
    if here == goal:
        yield time, seen
        return
    for nxt, t in roads[here]:
        if nxt not in seen:
            yield from routes(nxt, goal, seen + [nxt], time + t)

fastest = min(routes("A", "F", ["A"], 0))
print("Task 3:", fastest[0], "minutes via", "-".join(fastest[1]))

# Task 5: weight in kg and points for each item; the pack holds 10 kg
gear = {"tent": (6, 10), "food barrel": (5, 7),
        "canoe pack": (5, 7), "map case": (1, 1)}
top = (0, ())
for r in range(len(gear) + 1):
    for pick in combinations(gear, r):
        kg = sum(gear[g][0] for g in pick)
        points = sum(gear[g][1] for g in pick)
        if kg <= 10 and points > top[0]:
            top = (points, pick)
print("Task 5:", top[0], "points with", " + ".join(top[1]))

Task 3: 13 minutes via A-C-B-D-E-F
Task 5: 14 points with food barrel + canoe pack

Source: CEMC contests overview, 2026/27 dates, and the past contests archive, which holds BCC papers and solutions from the last ten years, read 22 October 2026.