Computer science prerequisites at Canadian universities

Sources, all read 22 October 2026: Waterloo, Computer Science requirements for Ontario; U of T Future Students, Computer Science; McMaster admission requirements tool (Computer Science, Ontario); UBC requirements for Canadian high schools (Vancouver, Ontario, Science); UBC Computer Science, admission processes. We have no affiliation with any of these universities.

Sources, read 22 October 2026: Waterloo’s requirements tool, Computer Science, British Columbia and Alberta; McMaster’s requirements tool, Computer Science, both provinces; UBC’s requirements tool, Vancouver, Science, both provinces; SFU Computing Science requirements (BC high school). SFU’s Alberta page was not read.

We do not fill a gap from memory or from third-party summaries, because a requirement list quoted wrongly does real damage to a student’s timetable. If your teen is considering one of these universities, its own page is the only source to plan from.

Each label means something slightly different: an individual-selection range, an anticipated range, a competitive average, an approximate requirement. None is a promise in either direction, several programs also read supplementary forms, and every one can move from year to year. Nobody here will turn a range into a forecast for your teen, and we never promise an admission result.

1. 20 comparisons. After k comparisons at most n divided by 2 to the k items remain, so we need the smallest k with 2 to the k at least 1,000,001. Since 2 to the 19 is 524,288 and 2 to the 20 is 1,048,576, k is 20. Twenty steps for a million items is why logarithms matter in computing.
2. About 17 minutes. Ten more items means ten doublings: 2 to the 10 is 1,024, so 1,024 seconds, a little over 17 minutes. Ten more after that would be about 12 days. Exponential algorithms stop being usable very quickly.
3. n(n − 1)/2, so 4,950. The inner loop runs 0 times, then 1, then 2, up to n − 1 times: an arithmetic series whose sum is n(n − 1)/2. For n = 100 that is 100 times 99 divided by 2, or 4,950. Doubling n roughly quadruples the work.
4. k = 0.00000002, and 0.5 seconds. From 0.02 = k(1,000)², k = 2 × 10 to the −8. The second measurement agrees: k(2,000)² = 0.08. Then k(5,000)² = 2 × 10 to the −8 × 25,000,000 = 0.5 seconds. Checking a model against a second data point before predicting is the habit to keep.
5. (12, 0.5), speed about 4.12. Position is start plus time times velocity: (2 + 4 × 2.5, 3 − 1 × 2.5) = (12, 0.5). Speed is the length of the velocity vector, the square root of 16 + 1, which is the square root of 17, about 4.12 units per second.
6. Yes, perpendicular. The dot product is 3 × 4 + 4 × (−3) = 12 − 12 = 0, so the directions are at right angles. A game engine uses exactly this to find the wall’s normal, the direction a ball bounces off along.
7. x = 1.5, then 2.25, approaching 3. The derivative is 2x − 6. From 0: 0 − 0.25 × (−6) = 1.5. Then 1.5 − 0.25 × (−3) = 2.25. Each step halves the distance to 3, where the derivative is zero and the error is smallest. This is the idea behind how many machine learning models are trained.
8. About 12.61, against an exact 12. The secant slope is (2.1³ − 2³)/0.1 = (9.261 − 8)/0.1 = 12.61. The derivative 3x² at 2 is 12. Shrinking the gap to 0.01 gives 12.0601, closer still: the limit idea computers use when they estimate derivatives numerically.

# Checking three of the practice answers by brute force (ours)
import math

def search_steps(n):
    """Worst-case comparisons for binary search on n sorted items."""
    steps, size = 0, n
    while size > 0:
        steps += 1
        size //= 2                 # each comparison keeps at most half
    return steps

def nested_count(n):
    count = 0
    for i in range(n):
        for j in range(i):         # j runs 0 .. i-1
            count += 1
    return count

def descend(x, rate, steps):
    """Gradient descent on f(x) = x**2 - 6x + 10, whose derivative is 2x - 6."""
    path = [x]
    for _ in range(steps):
        x = x - rate * (2 * x - 6)
        path.append(x)
    return path

print("Q1:", search_steps(1_000_000), "comparisons; log2 gives", math.ceil(math.log2(1_000_001)))
print("Q3:", nested_count(100), "and n(n-1)/2 gives", 100 * 99 // 2)
print("Q7:", descend(0, 0.25, 4))