Majority Element Moore's Voting Algorithm in DSA Javascript - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Moore's Voting Algorithm on an array

What is the output of the following JavaScript code that uses Moore's Voting Algorithm to find the majority element?

DSA Javascript

function majorityElement(nums) {
  let count = 0;
  let candidate = null;
  for (const num of nums) {
    if (count === 0) {
      candidate = num;
    }
    count += (num === candidate) ? 1 : -1;
  }
  return candidate;
}

console.log(majorityElement([2,2,1,1,1,2,2]));

A null

B 1

C undefined

D 2

💡 Hint

Think about which number appears more than half the time in the array.

The algorithm picks 2 as the candidate because it appears more than half the time (4 out of 7). The count increments and decrements to track the majority candidate.

❓ Predict Output

intermediate

Result when no majority element exists

What will the following code output when there is no majority element in the array?

DSA Javascript

function majorityElement(nums) {
  let count = 0;
  let candidate = null;
  for (const num of nums) {
    if (count === 0) {
      candidate = num;
    }
    count += (num === candidate) ? 1 : -1;
  }
  return candidate;
}

console.log(majorityElement([1,2,3,4,5]));

A 1

B 5

C 3

D 4

💡 Hint

The algorithm returns a candidate but it may not be a true majority if none exists.

The algorithm returns 5 as candidate because it ends as the last candidate after count adjustments, but no majority element exists in the array.

🧠 Conceptual

advanced

Why Moore's Voting Algorithm works

Which statement best explains why Moore's Voting Algorithm correctly finds the majority element?

A It counts the frequency of all elements and returns the one with the highest count.

B It sorts the array and picks the middle element as the majority.

C It pairs different elements and cancels them out, leaving the majority element at the end.

D It uses recursion to divide the array and find the majority element in each half.

💡 Hint

Think about how the algorithm reduces the problem by canceling out pairs.

The algorithm cancels out pairs of different elements, so the majority element remains because it appears more than half the time.

❓ Predict Output

advanced

Output after verifying candidate is majority

What will the following code output after verifying the candidate is actually the majority element?

DSA Javascript

function majorityElement(nums) {
  let count = 0;
  let candidate = null;
  for (const num of nums) {
    if (count === 0) {
      candidate = num;
    }
    count += (num === candidate) ? 1 : -1;
  }
  // Verify candidate
  count = 0;
  for (const num of nums) {
    if (num === candidate) count++;
  }
  return count > nums.length / 2 ? candidate : null;
}

console.log(majorityElement([1,2,3,2,2]));

A 2

B null

C 3

D 1

💡 Hint

Check if the candidate appears more than half the time.

The candidate is 2, and it appears 3 times out of 5, which is more than half, so the function returns 2.

🔧 Debug

expert

Identify the bug in Moore's Voting Algorithm implementation

What error will the following code produce when run?

DSA Javascript

function majorityElement(nums) {
  let count = 0;
  let candidate;
  for (const num of nums) {
    if (count === 0) {
      candidate = num;
    }
    count += (num === candidate) ? 1 : -1;
  }
  return candidate;
}

console.log(majorityElement([1,1,2,2,2]));

A Returns wrong candidate

B TypeError

C Infinite loop

D SyntaxError

💡 Hint

Look carefully at the if condition inside the loop.

The condition uses assignment (=) instead of comparison (===), so count is set to 0 every time, causing candidate to be reset incorrectly and returning wrong candidate.

Practice

1. What is the main purpose of Moore's Voting Algorithm in arrays?

easy

A. To find the element that appears more than half the time

B. To sort the array in ascending order

C. To find the smallest element in the array

D. To reverse the array elements

Solution

1. Step 1: Understand the problem Moore's Voting Algorithm solves

   It is designed to find the majority element, which is the element that appears more than half the times in the array.

2. Step 2: Compare with other options

   Sorting, finding smallest, or reversing are unrelated to majority element detection.

3. Final Answer:

   To find the element that appears more than half the time -> Option A

4. Quick Check:

   Majority element = element appearing > n/2 times [OK]

Hint: Majority element appears more than half the array length [OK]

Common Mistakes:

• Confusing majority element with most frequent element
• Thinking it sorts the array
• Assuming it finds smallest or largest element

2. Which of the following is the correct initialization step in Moore's Voting Algorithm in JavaScript?

easy

A. let count = 1, candidate = 0;

B. let count = 0, candidate = null;

C. let candidate = 0, count = null;

D. let count = null, candidate = 1;

Solution

1. Step 1: Identify correct variable initialization

   Moore's Voting Algorithm starts with count = 0 and candidate = null (or undefined) to indicate no candidate chosen yet.

2. Step 2: Check other options for correctness

   Options A, C, and D initialize count or candidate incorrectly, which can cause logic errors.

3. Final Answer:

   let count = 0, candidate = null; -> Option B

4. Quick Check:

   Initialize count=0 and candidate=null [OK]

Hint: Start count at 0 and candidate as null before loop [OK]

Common Mistakes:

• Starting count at 1 instead of 0
• Assigning candidate a number before selection
• Swapping count and candidate initialization

3. What will be the output of the following JavaScript code?

function majorityElement(nums) {
  let count = 0, candidate = null;
  for (const num of nums) {
    if (count === 0) candidate = num;
    count += (num === candidate) ? 1 : -1;
  }
  return candidate;
}
console.log(majorityElement([2,2,1,1,1,2,2]));

medium

A. Error

B. 1

C. null

D. 2

Solution

1. Step 1: Trace the loop and candidate updates

   Initial count=0, candidate=null. Iteration updates candidate and count as follows:
   - num=2: count=0, candidate=2, count=1
   - num=2: count=1, same candidate, count=2
   - num=1: count=2, different candidate, count=1
   - num=1: count=1, different candidate, count=0
   - num=1: count=0, candidate=1, count=1
   - num=2: count=1, different candidate, count=0
   - num=2: count=0, candidate=2, count=1

2. Step 2: Final candidate after loop

   The candidate is 2 after the loop ends, which is the majority element.

3. Final Answer:

   2 -> Option D

4. Quick Check:

   Majority element found = 2 [OK]

Hint: Track count changes; candidate updates when count hits zero [OK]

Common Mistakes:

• Assuming candidate never changes
• Confusing count increments and decrements
• Returning count instead of candidate

4. Identify the bug in this Moore's Voting Algorithm implementation:

function majorityElement(nums) {
  let count = 1, candidate = nums[0];
  for (let i = 1; i < nums.length; i++) {
    if (nums[i] === candidate) {
      count++;
    } else {
      count--;
      if (count === 0) {
        candidate = nums[i];
        count = 1;
      }
    }
  }
  return candidate;
}

medium

A. Initialization of count should be 0, not 1

B. Candidate should be initialized to null, not nums[0]

C. No bug, code is correct

D. Loop should start from i = 0, not i = 1

Solution

1. Step 1: Analyze initialization and loop

   Starting count at 1 and candidate as nums[0] is a valid approach. Loop starts at i=1 to compare remaining elements.

2. Step 2: Check logic inside loop

   Count increments if current equals candidate, else decrements. When count hits zero, candidate updates and count resets to 1. This matches Moore's Voting Algorithm logic.

3. Final Answer:

   No bug, code is correct -> Option C

4. Quick Check:

   Initialization and loop logic correct [OK]

Hint: Starting count=1 with first element candidate is valid [OK]

Common Mistakes:

• Thinking count must start at 0
• Assuming candidate must be null initially
• Starting loop at wrong index

5. Given an array where no element appears more than half the time, what will Moore's Voting Algorithm return?
Example: [1, 2, 3, 4]

hard

A. An incorrect majority element

B. null or undefined (no majority element)

C. The first element of the array

D. The element with the highest frequency

Solution

1. Step 1: Understand Moore's Voting Algorithm assumption

   The algorithm assumes a majority element exists (appears more than half the time). If none exists, it still returns a candidate but it may not be a true majority.

2. Step 2: Analyze example array [1, 2, 3, 4]

   No element appears more than 2 times (half of 4). The algorithm will return a candidate but it is not a valid majority element.

3. Final Answer:

   An incorrect majority element -> Option A

4. Quick Check:

   No majority means algorithm returns wrong candidate [OK]

Hint: Algorithm assumes majority exists; else result may be wrong [OK]

Common Mistakes:

• Assuming algorithm returns null if no majority
• Thinking it returns highest frequency element always
• Believing it returns first element by default