Codestin Search App

Split the Array - Problem

You are given an integer array nums of even length. You have to split the array into two parts nums1 and nums2 such that:

nums1.length == nums2.length == nums.length / 2
nums1 should contain distinct elements
nums2 should also contain distinct elements

Return true if it is possible to split the array, and false otherwise.

Input & Output

Example 1 — Basic Valid Split

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

› Output: true

💡 Note: We can split into [1,2] and [1,2]. Both groups have distinct elements.

Example 2 — Impossible Split

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

› Output: false

💡 Note: Element 1 appears 4 times. Cannot split into two distinct groups of size 2.

Example 3 — Mixed Frequencies

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

› Output: true

💡 Note: Can split into [1,2] and [1,3]. Each group has distinct elements.

Constraints

2 ≤ nums.length ≤ 100
nums.length is even
-100 ≤ nums[i] ≤ 100

Visualization

Tap to expand

Understanding the Visualization

Input

Array [1,1,2,2] of even length

Process

Check if we can split into two distinct groups

Output

Return true if splitting is possible

Key Takeaway

🎯 Key Insight: If any element appears more than twice, splitting into two distinct groups is impossible

Asked in

a Amazon 15 M Microsoft 12

The key insight is that if any element appears more than twice in the array, it's impossible to split into two distinct groups. The optimal approach uses frequency counting with a hash map. Time: O(n), Space: O(n)

Common Approaches

Approach	Time	Space	Notes
✓ Generate All Possible Splits	O(2^n)	O(n)	Try every possible way to split the array into two equal parts
Frequency Counting	O(n)	O(n)	Count element frequencies and check if splitting is mathematically possible

Generate All Possible Splits — Algorithm Steps

Generate all ways to choose n/2 elements for first group
Check if first group has all distinct elements
Check if remaining elements form distinct second group

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Combinations

Try all ways to choose n/2 elements for first group

Check Distinctness

Verify both groups have only distinct elements

Result

Return true if any valid split is found

Code -

solution.c — C

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

bool generateCombinations(int* nums, int numsSize, int start, int* current, int currentSize, int remaining) {
    if (remaining == 0) {
        // Check distinctness of both groups
        int group1[1000] = {0}, group2[1000] = {0};
        int g1count = 0, g2count = 0;
        bool selected[numsSize];
        memset(selected, false, sizeof(selected));
        
        for (int i = 0; i < currentSize; i++) {
            selected[current[i]] = true;
        }
        
        for (int i = 0; i < numsSize; i++) {
            if (selected[i]) {
                bool found = false;
                for (int j = 0; j < g1count; j++) {
                    if (group1[j] == nums[i]) {
                        found = true;
                        break;
                    }
                }
                if (!found) group1[g1count++] = nums[i];
            } else {
                bool found = false;
                for (int j = 0; j < g2count; j++) {
                    if (group2[j] == nums[i]) {
                        found = true;
                        break;
                    }
                }
                if (!found) group2[g2count++] = nums[i];
            }
        }
        
        return g1count == numsSize/2 && g2count == numsSize/2;
    }
    
    for (int i = start; i <= numsSize - remaining; i++) {
        current[currentSize] = i;
        if (generateCombinations(nums, numsSize, i + 1, current, currentSize + 1, remaining - 1)) {
            return true;
        }
    }
    
    return false;
}

bool solution(int* nums, int numsSize) {
    int half = numsSize / 2;
    int current[numsSize];
    return generateCombinations(nums, numsSize, 0, current, 0, half);
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Simple array parsing
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    bool result = solution(nums, numsSize);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Need to check C(n,n/2) combinations which is exponential

⚠ Quadratic Growth

Space Complexity

O(n)

Storage for current split being tested

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

890 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

Generate All Possible Splits — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler