Split the Array

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

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

✓ Frequency Counting

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

Count how many times each element appears. If any element appears more than twice, it's impossible to split into two distinct groups.

Generate All Possible Splits

⏱️ Time: O(2^n) Space: O(n)

Generate all possible combinations of splitting the array into two equal halves and check if both halves contain only distinct elements.

Frequency Counting — Algorithm Steps

Count frequency of each element using hash map
Check if any element appears more than twice
If all elements appear ≤ 2 times, splitting is possible

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Frequencies

Count how many times each element appears

Check Constraint

If any element appears > 2 times, return false

Result

All elements appear ≤ 2 times, so splitting is possible

Code -

solution.c — C

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

bool solution(int* nums, int numsSize) {
    // Simple frequency counting using arrays (assuming reasonable range)
    int freq[2001] = {0}; // Assuming values in range [-1000, 1000]
    
    for (int i = 0; i < numsSize; i++) {
        freq[nums[i] + 1000]++; // Offset by 1000 for negative numbers
    }
    
    // If any element appears more than twice, impossible to split
    for (int i = 0; i < 2001; i++) {
        if (freq[i] > 2) {
            return false;
        }
    }
    
    return true;
}

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(n)

Single pass through array to count frequencies

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map to store frequency of each unique element

⚡ 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

Frequency Counting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler