Distribute Elements Into Two Arrays II - Practice Coding Problems

Distribute Elements Into Two Arrays II - Problem

You're tasked with distributing elements from an array into two separate arrays using a greedy algorithm based on counting strategy!

Given a 1-indexed array nums, you need to distribute all elements between two arrays arr1 and arr2 following these rules:

Operation 1: Add nums[1] to arr1
Operation 2: Add nums[2] to arr2
Operation i (i ≥ 3): Count elements strictly greater than nums[i] in both arrays using function greaterCount(arr, val)

For each subsequent element, choose the array with:

Higher count of elements greater than current element
If counts are equal, choose array with fewer elements
If still tied, choose arr1

Example: If nums = [2,1,3,3]

Step 1: arr1 = [2], arr2 = []
Step 2: arr1 = [2], arr2 = [1]
Step 3: For nums[3] = 3: greaterCount(arr1, 3) = 0, greaterCount(arr2, 3) = 0 → tie, but arr1 and arr2 same size → choose arr1
Final: concatenate arrays to get result

Input & Output

example_1.py — Basic Distribution

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

› Output: [2,3,1,3]

💡 Note: Step 1: arr1=[2], arr2=[]. Step 2: arr1=[2], arr2=[1]. Step 3: For 3, count1=0, count2=0, sizes equal → choose arr1. Step 4: For 3, count1=0, count2=0, arr1 has more elements → choose arr2.

example_2.py — Count-based Decision

$ Input: [5,4,3,8]

› Output: [5,3,4,8]

💡 Note: Step 1: arr1=[5], arr2=[]. Step 2: arr1=[5], arr2=[4]. Step 3: For 3, count1=1 (5>3), count2=1 (4>3), sizes equal → choose arr1. Step 4: For 8, count1=0, count2=0, arr2 smaller → choose arr2.

example_3.py — Single Element

$ Input: [1]

› Output: [1]

💡 Note: Only one element, goes directly to arr1. Final result is just [1].

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
nums is 1-indexed in the problem statement

Visualization

Tap to expand

Understanding the Visualization

Initial Setup

Place first player in Team 1, second player in Team 2

Count Stronger Players

For each new player, count existing stronger players in each team

Make Decision

Join team with more stronger players, break ties by smaller team size

Optimize Counting

Use Binary Indexed Tree instead of linear counting for efficiency

Key Takeaway

🎯 Key Insight: Transform the O(n) counting problem into O(log n) range queries using Binary Indexed Trees, dramatically improving efficiency from O(n²) to O(n log n).

Asked in

f Meta 45 G Google 38 a Amazon 32 ⊞ Microsoft 28

This problem is optimally solved using Binary Indexed Trees (Fenwick Trees) with coordinate compression. The key insight is that instead of counting elements greater than current value with O(n) linear scans, we can use a BIT to answer range queries in O(log n) time, achieving overall O(n log n) complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Linear Counting)	O(n²)	O(1)	For each element, count greater elements in both arrays by scanning linearly
Binary Indexed Tree (Optimal)	O(n log n)	O(n)	Use Binary Indexed Tree (Fenwick Tree) to efficiently count elements greater than current value

Brute Force (Linear Counting) — Algorithm Steps

Initialize arr1 and arr2, add first element to arr1, second to arr2
For each remaining element, iterate through arr1 counting elements > current
Iterate through arr2 counting elements > current
Compare counts and decide which array to append to
Concatenate arrays at the end

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Place first element in arr1, second in arr2

Linear Count

For each new element, scan both arrays counting greater elements

Decision

Choose array with higher count, break ties by size then default to arr1

Concatenate

Combine arr1 and arr2 to form final result

Code -

solution.c — C

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

int* resultArray(int* nums, int numsSize, int* returnSize) {
    if (numsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int* arr1 = (int*)malloc(numsSize * sizeof(int));
    int* arr2 = (int*)malloc(numsSize * sizeof(int));
    int size1 = 1, size2 = 0;
    
    arr1[0] = nums[0];
    if (numsSize > 1) {
        arr2[0] = nums[1];
        size2 = 1;
    }
    
    for (int i = 2; i < numsSize; i++) {
        int count1 = 0, count2 = 0;
        
        for (int j = 0; j < size1; j++) {
            if (arr1[j] > nums[i]) count1++;
        }
        for (int j = 0; j < size2; j++) {
            if (arr2[j] > nums[i]) count2++;
        }
        
        if (count1 > count2) {
            arr1[size1++] = nums[i];
        } else if (count2 > count1) {
            arr2[size2++] = nums[i];
        } else {
            if (size1 <= size2) {
                arr1[size1++] = nums[i];
            } else {
                arr2[size2++] = nums[i];
            }
        }
    }
    
    int* result = (int*)malloc(numsSize * sizeof(int));
    memcpy(result, arr1, size1 * sizeof(int));
    memcpy(result + size1, arr2, size2 * sizeof(int));
    
    *returnSize = numsSize;
    free(arr1);
    free(arr2);
    
    return result;
}

int main() {
    int nums[1000];
    int n = 0;
    
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        nums[n++] = atoi(token);
        token = strtok(NULL, "[],\n");
    }
    
    int returnSize;
    int* result = resultArray(nums, n, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize-1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n elements, we scan both arrays which can contain up to n elements total

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space apart from output arrays

✓ Linear Space

37.4K Views

Medium-High Frequency

~25 min Avg. Time

1.6K 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 (Linear Counting) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler