Shuffle the Array

Shuffle the Array - Problem

Array Easy

Given an array nums consisting of 2n elements in the form [x1,x2,...,xn,y1,y2,...,yn].

Return the array in the form [x1,y1,x2,y2,...,xn,yn].

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,5,1,3,4,7], n = 3

› Output: [2,3,5,4,1,7]

💡 Note: First half is [2,5,1] and second half is [3,4,7]. Alternate: 2,3,5,4,1,7

Example 2 — Smaller Array

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

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

💡 Note: First half [1,2,3,4], second half [4,3,2,1]. Result: [1,4,2,3,3,2,4,1]

Example 3 — Minimum Size

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

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

💡 Note: First half [1,1], second half [2,2]. Alternate: [1,2,1,2]

Constraints

1 ≤ n ≤ 500
nums.length == 2n
1 ≤ nums[i] ≤ 10³

Visualization

Tap to expand

Asked in

a Amazon 15 🍎 Apple 12

The key insight is to recognize the alternating pattern between two halves of the array. The optimal approach uses direct index mapping where even positions take from the first half and odd positions take from the second half. Time: O(n), Space: O(n)

Common Approaches

✓ Direct Index Mapping

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

Instead of creating a new array, calculate where each element should go in the final result using index transformation.

Two-Pass Array Construction

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

Split the array conceptually into two halves and iterate through both simultaneously, placing elements alternately in the result array.

Direct Index Mapping — Algorithm Steps

Step 1: For each position i in result
Step 2: If i is even, take from first half
Step 3: If i is odd, take from second half

Visualization

Tap to expand

Step-by-Step Walkthrough

Even Indices

Even positions (0,2,4) take from first half

Odd Indices

Odd positions (1,3,5) take from second half

Result

Direct mapping creates shuffled array

Code -

solution.c — C

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

void solution(int* nums, int numsSize, int n, int* result) {
    for (int i = 0; i < 2 * n; i++) {
        if (i % 2 == 0) {
            result[i] = nums[i / 2];
        } else {
            result[i] = nums[n + i / 2];
        }
    }
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int nums[1000];
    int count = 0;
    char* ptr = line;
    
    // Skip opening bracket
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++;
    
    // Parse numbers
    while (*ptr && *ptr != ']') {
        while (*ptr == ' ' || *ptr == ',') ptr++;
        if (*ptr && *ptr != ']') {
            nums[count++] = atoi(ptr);
            while (*ptr && *ptr != ',' && *ptr != ']') ptr++;
        }
    }
    
    int n;
    scanf("%d", &n);
    
    int result[1000];
    solution(nums, count, n, result);
    
    printf("[");
    for (int i = 0; i < 2 * n; i++) {
        printf("%d", result[i]);
        if (i < 2 * n - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through 2n elements

✓ Linear Growth

Space Complexity

O(n)

Result array stores 2n elements

⚡ Linearithmic Space

180.0K Views

Medium Frequency

~15 min Avg. Time

3.5K 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

Direct Index Mapping — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler