Minimum Index of a Valid Split

Minimum Index of a Valid Split - Problem

An element x of an integer array arr of length m is dominant if more than half the elements of arr have a value of x.

You are given a 0-indexed integer array nums of length n with one dominant element.

You can split nums at an index i into two arrays nums[0, ..., i] and nums[i + 1, ..., n - 1], but the split is only valid if:

0 <= i < n - 1
nums[0, ..., i], and nums[i + 1, ..., n - 1] have the same dominant element.

Return the minimum index of a valid split. If no valid split exists, return -1.

Input & Output

Example 1 — Basic Valid Split

$ Input: nums = [10,5,2,10,10]

› Output: 2

💡 Note: Split at index 2: left=[10,5,2] has dominant 10 (count=1 > 3/2), right=[10,10] has dominant 10 (count=2 > 2/2). Both parts have the same dominant element 10.

Example 2 — No Valid Split

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

› Output: -1

💡 Note: The dominant element is 1 (appears 6 times > 10/2). However, no split position creates two parts where 1 is dominant in both parts simultaneously.

Example 3 — Early Valid Split

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

› Output: 0

💡 Note: Split at index 0: left=[3] has dominant 3, right=[3,3,3,7,2,2] has dominant 3 (count=3 > 6/2). Valid split found at the earliest possible position.

Constraints

1 ≤ nums.length ≤ 10⁵
-10⁹ ≤ nums[i] ≤ 10⁹
nums has exactly one dominant element

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is that the dominant element of the entire array must remain dominant in both parts of any valid split. The optimal approach tracks the count of the dominant element incrementally as we try each split position. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Check All Splits

⏱️ Time: O(n²) Space: O(1)

For each possible split index, count occurrences of each element in both left and right parts to determine their dominant elements. Check if both parts have the same dominant element.

Optimized - Precompute with Single Pass

⏱️ Time: O(n²) Space: O(n)

First identify the dominant element of the entire array, then incrementally build left and right parts while tracking element counts. This avoids recounting elements for each split position.

Brute Force - Check All Splits — Algorithm Steps

Find the dominant element of the entire array
For each split index i from 0 to n-2
Count elements in left part [0..i] and right part [i+1..n-1]
Check if both parts have the same dominant element
Return the first valid split index

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Split at Index 0

Left: [10], Right: [5,2,10,10] - check dominance

Try Split at Index 1

Left: [10,5], Right: [2,10,10] - check dominance

Find Valid Split

Continue until both parts have same dominant element

Code -

solution.c — C

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

int solution(int* nums, int n) {
    if (n < 2) return -1;
    
    // Try each split position
    for (int i = 0; i < n - 1; i++) {
        // Count in left part [0..i]
        int leftSize = i + 1;
        int leftDominant = -1;
        int maxLeftCount = 0;
        
        for (int k = 0; k <= i; k++) {
            int count = 0;
            for (int j = 0; j <= i; j++) {
                if (nums[j] == nums[k]) count++;
            }
            if (count > leftSize / 2 && count > maxLeftCount) {
                leftDominant = nums[k];
                maxLeftCount = count;
            }
        }
        
        // Count in right part [i+1..n-1]
        int rightSize = n - i - 1;
        int rightDominant = -1;
        int maxRightCount = 0;
        
        for (int k = i + 1; k < n; k++) {
            int count = 0;
            for (int j = i + 1; j < n; j++) {
                if (nums[j] == nums[k]) count++;
            }
            if (count > rightSize / 2 && count > maxRightCount) {
                rightDominant = nums[k];
                maxRightCount = count;
            }
        }
        
        // Check if both parts have same dominant element
        if (leftDominant != -1 && leftDominant == rightDominant) {
            return i;
        }
    }
    
    return -1;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int nums[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strspn(token, " \t\n\r") != strlen(token)) {
            nums[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(nums, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n split positions, we count elements in both parts taking O(n) time

⚠ Quadratic Growth

Space Complexity

O(1)

Only using variables to track counts and dominant elements

✓ Linear Space

8.5K Views

Medium Frequency

~15 min Avg. Time

234 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 - Check All Splits — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler