Majority Element II

The problem

Find all elements in the array that appear more than n/3 times, where n is the array length.

There can be at most two distinct elements that appear strictly more than n / 3 times. Canceling out three mutually distinct elements simultaneously reduces the size of the array without changing which elements hold a strict majority threshold, allowing Boyer-Moore voting to track at most two candidates at once.

Full solution

Extended Boyer-Moore voting with two candidates: at most two values can appear more than n/3 times, so two counters plus one verification pass give O(n) time in O(1) extra space, which the hash-map count cannot.

def majority_element_ii(nums: list[int]) -> list[int]:
    # At most two values can exceed n/3, so two Boyer-Moore candidates suffice.
    cand1, cand2 = None, None
    count1, count2 = 0, 0
    for x in nums:
        if x == cand1:
            count1 += 1
        elif x == cand2:
            count2 += 1
        elif count1 == 0:
            cand1, count1 = x, 1
        elif count2 == 0:
            cand2, count2 = x, 1
        else:
            count1 -= 1
            count2 -= 1
    # Candidates are only possible majorities; verify with a real count.
    threshold = len(nums) // 3
    return [c for c in (cand1, cand2) if c is not None and nums.count(c) > threshold]

function majorityElementIi(nums) {
  // At most two values can exceed n/3, so two Boyer-Moore candidates suffice.
  let cand1 = null, cand2 = null;
  let count1 = 0, count2 = 0;
  for (const x of nums) {
    if (x === cand1) count1++;
    else if (x === cand2) count2++;
    else if (count1 === 0) { cand1 = x; count1 = 1; }
    else if (count2 === 0) { cand2 = x; count2 = 1; }
    else { count1--; count2--; }
  }
  // Candidates are only possible majorities; verify with a real count.
  const threshold = Math.floor(nums.length / 3);
  return [cand1, cand2].filter(
    (c) => c !== null && nums.filter((v) => v === c).length > threshold,
  );
}

The theory behind it

Arrays — the ground this problem stands on. All Arrays problems

What Arrays is

An array is a row of fixed boxes laid side by side in computer memory, like numbered lockers in a hallway. Because each box occupies identical space and sits directly next to its neighbors, jumping to locker zero or locker ten thousand takes the exact same tiny fraction of time. Every box holds an item of the same type, addressed by an offset number called an index.

When to reach for it

Reach for an array when items arrive in a known sequence and need immediate retrieval by position number. Problems asking for running totals, prefix accumulations, cyclic rotations, or in-place rearrangements signal array mechanics. Whenever constraints require constant-time random lookups or contiguous cache scans across fixed collections, a flat sequence is the default container.

How the pattern works

Visualize a tape with zero-indexed slots stretching from start to end. Keep track of write and read cursors when modifying contents without allocating helper buffers. For running computations, maintain an invariant such as having processed all elements left of the current index while pending elements wait to the right. When modifying entries in place, consider scanning backwards from the end so unread data is not overwritten.

What each operation costs

Which roles need this problem

Arrays is a core topic for these 25 roles — if you're targeting one of them, this problem is early in your path, not optional.

Secondary for 3 more roles, including Database Engineer, Bioinformatics Engineer, Networking Engineer.