Distribute Elements Into Two Arrays I - Practice Coding Problems

Distribute Elements Into Two Arrays I - Problem

Array Simulation Easy

Distribute Elements Into Two Arrays I

You are given a 1-indexed array of distinct integers nums of length n. Your task is to distribute all elements between two dynamic arrays arr1 and arr2 following a specific pattern.

Distribution Rules:
1. First operation: append nums[1] to arr1
2. Second operation: append nums[2] to arr2
3. For the i-th operation (i ≥ 3):
• If the last element of arr1 > last element of arr2, append nums[i] to arr1
• Otherwise, append nums[i] to arr2

Goal: Return the result array formed by concatenating arr1 and arr2.

Example: If arr1 = [1,2,3] and arr2 = [4,5,6], then result = [1,2,3,4,5,6]

Input & Output

example_1.py — Basic Distribution

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

› Output: [2, 3, 1]

💡 Note: Step 1: arr1 = [2], arr2 = []. Step 2: arr1 = [2], arr2 = [1]. Step 3: Since 2 > 1, add 3 to arr1. Final: arr1 = [2, 3], arr2 = [1]. Result = [2, 3, 1].

example_2.py — Alternating Pattern

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

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

💡 Note: Step 1: arr1 = [5], arr2 = []. Step 2: arr1 = [5], arr2 = [4]. Step 3: Since 5 > 4, add 3 to arr1, so arr1 = [5, 3]. Step 4: Since 3 < 4, add 8 to arr2, so arr2 = [4, 8]. Result = [5, 3, 4, 8].

example_3.py — Minimum Input

$ Input: nums = [1]

› Output: [1]

💡 Note: Only one element, so arr1 = [1], arr2 = []. Result = [1].

Visualization

Tap to expand

Understanding the Visualization

Setup

Initialize two empty arrays arr1 and arr2

Mandatory Picks

First element goes to arr1, second element goes to arr2

Comparison

Compare the last elements of both arrays

Decision

Add next element to the array with larger last element

Concatenate

Combine arr1 and arr2 to form the final result

Key Takeaway

🎯 Key Insight: This is a straightforward simulation problem - no complex algorithms needed, just follow the rules step by step!

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each element exactly once, with constant time operations for each

✓ Linear Growth

Space Complexity

O(n)

We store all elements in the two arrays plus the result array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
All integers in nums are distinct

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 5

This problem is a pure simulation that requires following the distribution rules step by step. The optimal approach is to directly simulate the process by maintaining two arrays and comparing their last elements at each step. Time complexity is O(n) as we process each element exactly once.

Common Approaches

Approach	Time	Space	Notes
✓ Direct Simulation	O(n)	O(n)	Follow the distribution rules step by step using simple array operations

Direct Simulation — Algorithm Steps

Initialize two empty arrays arr1 and arr2
Add nums[1] to arr1 and nums[2] to arr2
For each remaining element nums[i] (i >= 3):
Compare arr1[-1] with arr2[-1]
Append nums[i] to arr1 if arr1[-1] > arr2[-1], otherwise to arr2
Concatenate arr1 and arr2 to form the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Create two empty arrays arr1 and arr2

First Element

Add nums[1] to arr1 automatically

Second Element

Add nums[2] to arr2 automatically

Compare & Distribute

For remaining elements, compare last elements and append accordingly

Code -

solution.c — C

int* solution(int* nums, int numsSize, int* returnSize) {
    *returnSize = numsSize;
    if (numsSize == 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 = 1, arr2Size = 0;
    
    arr1[0] = nums[0];
    if (numsSize > 1) {
        arr2[0] = nums[1];
        arr2Size = 1;
    }
    
    // Process remaining elements
    for (int i = 2; i < numsSize; i++) {
        if (arr1[arr1Size - 1] > arr2[arr2Size - 1]) {
            arr1[arr1Size++] = nums[i];
        } else {
            arr2[arr2Size++] = nums[i];
        }
    }
    
    // Combine arrays
    for (int i = 0; i < arr1Size; i++) result[i] = arr1[i];
    for (int i = 0; i < arr2Size; i++) result[arr1Size + i] = arr2[i];
    
    free(arr1);
    free(arr2);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We process each element exactly once, with constant time operations for each

✓ Linear Growth

Space Complexity

O(n)

We store all elements in the two arrays plus the result array

⚡ Linearithmic Space

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ nums[i] ≤ 10⁵
All integers in nums are distinct

28.4K Views

Medium Frequency

~12 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Direct Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler