Distribute Elements Into Two Arrays I - Practice Coding Problems

Distribute Elements Into Two Arrays I - Problem

Array Simulation Easy

You are given a 1-indexed array of distinct integers nums of length n. You need to distribute all the elements of nums between two arrays arr1 and arr2 using n operations.

In the first operation, append nums[1] to arr1. In the second operation, append nums[2] to arr2. Afterwards, in the i-th operation:

If the last element of arr1 is greater than the last element of arr2, append nums[i] to arr1.
Otherwise, append nums[i] to arr2.

The array result is formed by concatenating the arrays arr1 and arr2. For example, if arr1 == [1,2,3] and arr2 == [4,5,6], then result = [1,2,3,4,5,6].

Return the array result.

Input & Output

Example 1 — Basic Distribution

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

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

💡 Note: nums[0]=2 → arr1=[2]. nums[1]=1 → arr2=[1]. nums[2]=3: last(arr1)=2 > last(arr2)=1, so → arr1=[2,3]. nums[3]=3: last(arr1)=3 > last(arr2)=1, so → arr1=[2,3,3]. Result = [2,3,3] + [1] = [2,3,3,1]

Example 2 — Alternating Pattern

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

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

💡 Note: nums[0]=5 → arr1=[5]. nums[1]=4 → arr2=[4]. nums[2]=3: last(arr1)=5 > last(arr2)=4, so → arr1=[5,3]. nums[3]=8: last(arr1)=3 < last(arr2)=4, so → arr2=[4,8]. Result = [5,3] + [4,8] = [5,3,4,8]

Example 3 — Minimum Size

$ Input: nums = [1,2]

› Output: [1,2]

💡 Note: Only two elements: nums[0]=1 → arr1=[1], nums[1]=2 → arr2=[2]. Result = [1] + [2] = [1,2]

Constraints

3 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
All elements in nums are distinct

Visualization

Tap to expand

Understanding the Visualization

Input

1-indexed array of distinct integers

Process

Distribute elements based on last element comparison

Output

Concatenated result of arr1 and arr2

Key Takeaway

🎯 Key Insight: Simply simulate the distribution process - compare last elements to decide which array gets the next element

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to directly simulate the distribution process. First two elements go to arr1 and arr2 respectively, then compare last elements to decide placement. Best approach is simulation with Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Simulation Approach	O(n)	O(n)	Directly simulate the distribution process by comparing last elements

Simulation Approach — Algorithm Steps

Initialize two empty arrays arr1 and arr2
Add nums[0] to arr1 and nums[1] to arr2 (first two operations)
For remaining elements, compare last elements of arr1 and arr2
Add current element to the array whose last element is greater
Concatenate arr1 and arr2 to form result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Setup

nums[0] goes to arr1, nums[1] goes to arr2

Compare & Distribute

For each remaining element, compare last elements and assign

Concatenate

Join arr1 and arr2 to form final result

Code -

solution.c — C

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

int* solution(int* nums, int numsSize, int* returnSize) {
    if (numsSize == 0) {
        *returnSize = 0;
        return NULL;
    }
    
    int* result = (int*)malloc(numsSize * sizeof(int));
    int* arr1 = (int*)malloc(numsSize * sizeof(int));
    int* arr2 = (int*)malloc(numsSize * sizeof(int));
    int arr1Size = 0, arr2Size = 0;
    
    arr1[arr1Size++] = nums[0];  // First element to arr1
    if (numsSize == 1) {
        result[0] = arr1[0];
        *returnSize = 1;
        free(arr2);
        free(arr1);
        return result;
    }
    
    arr2[arr2Size++] = nums[1];  // Second element to arr2
    
    // Process remaining elements starting from index 2
    for (int i = 2; i < numsSize; i++) {
        if (arr1[arr1Size - 1] > arr2[arr2Size - 1]) {
            arr1[arr1Size++] = nums[i];
        } else {
            arr2[arr2Size++] = nums[i];
        }
    }
    
    // Concatenate arr1 and arr2
    int idx = 0;
    for (int i = 0; i < arr1Size; i++) {
        result[idx++] = arr1[i];
    }
    for (int i = 0; i < arr2Size; i++) {
        result[idx++] = arr2[i];
    }
    
    *returnSize = numsSize;
    free(arr1);
    free(arr2);
    return result;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    
    // Parse JSON array manually
    int nums[1000];
    int numsSize = 0;
    if (strlen(line) > 2) {
        char* ptr = line + 1; // Skip opening bracket
        char* token = strtok(ptr, ",]");
        while (token != NULL) {
            nums[numsSize++] = atoi(token);
            token = strtok(NULL, ",]");
        }
    }
    
    int returnSize;
    int* result = solution(nums, numsSize, &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)

Single pass through the array with constant time operations

✓ Linear Growth

Space Complexity

O(n)

Extra space for two arrays arr1 and arr2 plus result array

⚡ Linearithmic Space

12.5K Views

Medium Frequency

~15 min Avg. Time

425 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

Simulation Approach — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler