Most Frequent Even Element - Practice Coding Problems

Most Frequent Even Element - Problem

Find the Champion Even Number!

You're given an array of integers, and your mission is to find the most frequent even element. Think of it as a popularity contest, but only even numbers are allowed to participate!

The Rules:

🏆 Return the even number that appears most frequently
🤝 If there's a tie, return the smallest even number among the tied winners
❌ If no even numbers exist in the array, return -1

Example: In [0, 1, 2, 2, 4, 4, 1], both 2 and 4 appear twice, but we return 2 because it's smaller!

Input & Output

example_1.py — Basic Case

$ Input: [0,1,2,2,4,4,1]

› Output: 2

💡 Note: The even elements are 0, 2, 2, 4, 4. Among these, both 2 and 4 appear twice. Since there's a tie, we return the smaller value, which is 2.

example_2.py — Clear Winner

$ Input: [4,4,4,9,2,4]

› Output: 4

💡 Note: The even elements are 4, 4, 4, 2, 4. The element 4 appears 4 times while 2 appears only once. Therefore, 4 is the most frequent even element.

example_3.py — No Even Elements

$ Input: [29,47,21,41,13,37,25,7]

› Output: -1

💡 Note: There are no even elements in this array, so we return -1.

Constraints

1 ≤ nums.length ≤ 2000
-10⁵ ≤ nums[i] ≤ 10⁵
The array contains at least one integer

Visualization

Tap to expand

Understanding the Visualization

Eligibility Check

Only students with even ID numbers can participate (filter even elements)

Vote Counting

Count votes for each eligible candidate using a hash table

Declare Winner

The candidate with most votes wins. In case of tie, the one with smaller ID wins

Optimization

Instead of counting all votes first, we can track the current winner while counting!

Key Takeaway

🎯 Key Insight: We can optimize by tracking the current winner while counting, eliminating the need for a separate search phase. This transforms a two-pass algorithm into an elegant single-pass solution!

Asked in

G Google 42 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses a one-pass hash table approach with O(n) time complexity. While iterating through the array, we count frequencies of even elements and simultaneously track the winner. This eliminates the need for a second pass, making it more efficient than the two-pass approach. The key insight is that we can update the champion immediately when we encounter a better candidate (higher frequency or same frequency but smaller value).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Count frequency of each even element by scanning the entire array for each element
One-Pass Hash Table (Optimal)	O(n)	O(k)	Count frequencies and track the winner simultaneously in a single pass
Two-Pass Hash Table	O(n)	O(k)	First pass counts all even element frequencies, second pass finds the winner

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each element in the array
If the element is even, count its total occurrences in the array
Track the element with maximum frequency (smallest value breaks ties)
Return the most frequent even element or -1 if none exists

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Even Element

Identify an even number in the array

Count Occurrences

Scan entire array to count this element

Update Best

Compare with current best candidate

Repeat

Continue for all elements

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int mostFrequentEven(int* nums, int numsSize) {
    int maxFreq = 0;
    int result = -1;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] % 2 == 0) { // Only consider even numbers
            int count = 0;
            for (int j = 0; j < numsSize; j++) {
                if (nums[j] == nums[i]) {
                    count++;
                }
            }
            
            // Update result if we found a better candidate
            if (count > maxFreq || (count == maxFreq && (result == -1 || nums[i] < result))) {
                maxFreq = count;
                result = nums[i];
            }
        }
    }
    
    return result;
}

int main() {
    int nums[1000];
    int size = 0;
    char c;
    int num = 0;
    int sign = 1;
    
    while ((c = getchar()) != '\n' && c != EOF) {
        if (c >= '0' && c <= '9') {
            num = num * 10 + (c - '0');
        } else if (c == '-') {
            sign = -1;
        } else if (c == ',' || c == ']') {
            nums[size++] = num * sign;
            num = 0;
            sign = 1;
        }
    }
    
    printf("%d\n", mostFrequentEven(nums, size));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of the n elements, we scan the entire array of n elements to count occurrences

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track the result and current counts

✓ Linear Space

28.5K Views

Medium Frequency

~15 min Avg. Time

1.2K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler