Minimum Index of a Valid Split - Practice Coding Problems

Minimum Index of a Valid Split - Problem

You're given an integer array where one element dominates more than half the positions. Your task is to find the minimum index where you can split this array into two parts, such that both parts have the same dominant element.

A dominant element is one that appears in more than half the positions of an array. For example, in [3, 3, 3, 2, 2], the number 3 is dominant because it appears 3 times out of 5 positions (more than 2.5).

Goal: Find the smallest index i where splitting at position i creates two subarrays that both have the same dominant element as the original array.

Input: An integer array nums with exactly one dominant element

Output: The minimum valid split index, or -1 if no valid split exists

Example: nums = [1,1,1,2,2,2,2] → The dominant element is 2. We need to find where to split so both parts are dominated by 2.

Input & Output

example_1.py — Basic Split

$ Input: nums = [1,1,1,2,2,2,2]

› Output: 4

💡 Note: The dominant element is 2 (appears 4/7 times). Split at index 4: Left=[1,1,1,2,2] has 2 appearing 2/5 times (dominant), Right=[2,2] has 2 appearing 2/2 times (dominant). Both sides have the same dominant element 2.

example_2.py — Early Split

$ Input: nums = [2,1,3,1,1,1,7,1,2,1]

› Output: 4

💡 Note: The dominant element is 1 (appears 6/10 times). Split at index 4: Left=[2,1,3,1,1] has 1 appearing 3/5 times (dominant), Right=[1,7,1,2,1] has 1 appearing 3/5 times (dominant). This is the minimum valid split.

example_3.py — No Valid Split

$ Input: nums = [3,3,3,3,7,2,2]

› Output: -1

💡 Note: The dominant element is 3 (appears 4/7 times). However, no split creates two subarrays where both have 3 as dominant. For example, at any split, either the left or right side won't have enough 3's to be dominant.

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
nums contains exactly one dominant element

Visualization

Tap to expand

Understanding the Visualization

Identify the Champions

Walk through the crowd and use Boyer-Moore voting to efficiently identify which team has the most fans without counting everyone individually

Find the Perfect Split

Move through the crowd from left to right, keeping track of how many champion fans are on each side of potential split points

Verify Dominance

For each potential split, check if the champion team has more than half the fans on both the left and right sides

Choose Minimum Split

Return the earliest (leftmost) position where both sections have the champion team as dominant

Key Takeaway

🎯 Key Insight: We only need to track the dominant element's count. If it has majority on both sides of a split, then no other element can dominate either side, making it a valid split. Use Boyer-Moore to find the dominant element efficiently, then find the minimum split in a single pass.

Asked in

G Google 42 ⊞ Microsoft 38 a Amazon 31 f Meta 28

The optimal approach uses the Boyer-Moore Majority Vote algorithm to find the dominant element in O(n) time and O(1) space, then performs a single pass to find the minimum valid split index. Key insight: we only need to track the dominant element's count - if it dominates both sides of a split, the split is valid since no other element can dominate either side.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(1)	Find dominant element using Boyer-Moore, then check splits in single pass
Brute Force (Check Every Split)	O(n³)	O(n)	For each possible split index, count elements in both subarrays to verify dominance
Two-Pass Optimized	O(n)	O(k)	First pass finds dominant element and counts, second pass finds minimum valid split

One-Pass Hash Table (Optimal) — Algorithm Steps

Use Boyer-Moore algorithm to find the dominant element candidate
Verify it's truly dominant by counting (or trust problem guarantee)
Iterate through array maintaining left count of dominant element
For each position, calculate if both left and right sides have dominance
Return the first valid split index
All in optimal O(n) time and O(1) extra space

Visualization

Tap to expand

Step-by-Step Walkthrough

Boyer-Moore Phase

Find dominant element candidate using voting algorithm in O(n) time, O(1) space

Verification Phase

Count total occurrences of candidate (optional if guaranteed dominant exists)

Split Detection

Single pass to find minimum split where both sides have dominant majority

Optimal Result

Return first valid split index with optimal time and space complexity

Code -

solution.c — C

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

int minimumIndex(int* nums, int numsSize) {
    if (numsSize < 2) return -1;
    
    // Boyer-Moore Majority Vote
    int candidate = nums[0];
    int count = 1;
    
    for (int i = 1; i < numsSize; i++) {
        if (count == 0) {
            candidate = nums[i];
            count = 1;
        } else if (nums[i] == candidate) {
            count++;
        } else {
            count--;
        }
    }
    
    // Count total occurrences
    int totalCount = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] == candidate) totalCount++;
    }
    
    // Find minimum valid split
    int leftCount = 0;
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i] == candidate) {
            leftCount++;
        }
        
        int rightCount = totalCount - leftCount;
        int leftSize = i + 1;
        int rightSize = numsSize - leftSize;
        
        if (leftCount > leftSize / 2 && rightCount > rightSize / 2) {
            return i;
        }
    }
    
    return -1;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to find dominant element + single pass to find split = O(n)

✓ Linear Growth

Space Complexity

O(1)

Only constant extra space for counters and variables

✓ Linear Space

42.4K Views

Medium Frequency

~22 min Avg. Time

1.8K 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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler