1470. Shuffle the Array - Explanation

Description

The array nums has exactly 2 * n elements. Split it into two halves of length n, preserving the order within each half. Return a new array that alternates between the halves: first the first element of the first half, then the first element of the second half, then the second element of each half, and so on.

Example 1:

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

Output: [1,3,2,4]

Explanation: The halves are [1,2] and [3,4]. Alternating their elements gives [1,3,2,4].

Example 2:

Input: nums = [8,9]
n = 1

Output: [8,9]

Explanation: Each half has one element, so the output is [8,9].

Example 3:

Input: nums = [5,5,7,7,9,9]
n = 3

Output: [5,7,5,9,7,9]

Explanation: The halves are [5,5,7] and [7,9,9]. Their successive pairs are (5,7), (5,9), and (7,9), giving [5,7,5,9,7,9].

Constraints:

1 <= n <= 500
nums.length == 2 * n
1 <= nums[i] <= 1000

Topics

Array

Company Tags

Please upgrade to NeetCode Pro to view company tags.

Prerequisites

Before attempting this problem, you should be comfortable with:

Array Indexing - Calculating source and destination indices based on position formulas
Bit Manipulation - Packing and unpacking multiple values in a single integer for in-place solutions
Modular Arithmetic - Using multiplication and modulo to encode/decode values without overflow

1. Iteration (Extra Space)

Intuition

The array is given as [x1, x2, ..., xn, y1, y2, ..., yn] and we need to rearrange it to [x1, y1, x2, y2, ..., xn, yn]. The simplest approach is to iterate through the first half of the array and alternate between picking elements from the first half (x values at index i) and the second half (y values at index i + n). We build the result in a new array.

Algorithm

Create an empty result array.
Loop i from 0 to n - 1:
- Append nums[i] (the x value) to the result.
- Append nums[i + n] (the corresponding y value) to the result.
Return the result array.

class Solution:
    def shuffle(self, nums: List[int], n: int) -> List[int]:
        res = []
        for i in range(n):
            res.append(nums[i])
            res.append(nums[i + n])
        return res

class Solution {
public:
    vector<int> shuffle(vector<int>& nums, int n) {
        vector<int> res;
        for (int i = 0; i < n; i++) {
            res.push_back(nums[i]);
            res.push_back(nums[i + n]);
        }
        return res;
    }
};

class Solution {
    /**
     * @param {number[]} nums
     * @param {number} n
     * @return {number[]}
     */
    shuffle(nums) {
        const res = [];
        for (let i = 0; i < n; i++) {
            res.push(nums[i]);
            res.push(nums[i + n]);
        }
        return res;
    }
}

class Solution {
    fun shuffle(nums: IntArray, n: Int): IntArray {
        val res = IntArray(2 * n)
        var idx = 0
        for (i in 0 until n) {
            res[idx++] = nums[i]
            res[idx++] = nums[i + n]
        }
        return res
    }
}

class Solution {
    func shuffle(_ nums: [Int], _ n: Int) -> [Int] {
        var res = [Int]()
        for i in 0..<n {
            res.append(nums[i])
            res.append(nums[i + n])
        }
        return res
    }
}

impl Solution {
    pub fn shuffle(nums: Vec<i32>, n: i32) -> Vec<i32> {
        let n = n as usize;
        let mut res = Vec::with_capacity(2 * n);
        for i in 0..n {
            res.push(nums[i]);
            res.push(nums[i + n]);
        }
        res
    }
}

Time & Space Complexity

Time complexity: $O(n)$
Space complexity: $O(n)$ extra space.

2. Multiplication And Modulo

Intuition

To shuffle in-place without extra space, we can encode two values in a single array element. Since values are at most 1000, we pick a base M > 1000. For each position i in the result, we determine which original element belongs there and encode it by adding original_value * M to nums[i]. The original value is retrieved using nums[index] % M (since we have not yet divided), and the new value is stored in the upper part. After encoding all positions, we divide each element by M to extract the shuffled values.

Algorithm

Choose M = max(nums) + 1 or a constant like 1001.
For each index i from 0 to 2n - 1:
- If i is even, the value should come from position i / 2 (an x value).
- If i is odd, the value should come from position n + i / 2 (a y value).
- Add (nums[source] % M) * M to nums[i].
Divide each element by M to get the final shuffled array.
Return the modified array.

class Solution:
    def shuffle(self, nums: List[int], n: int) -> List[int]:
        M = max(nums) + 1
        for i in range(2 * n):
            if i % 2 == 0:
                nums[i] += (nums[i // 2] % M) * M
            else:
                nums[i] += (nums[n + i // 2] % M) * M

        for i in range(2 * n):
            nums[i] //= M

        return nums

class Solution {
    /**
     * @param {number[]} nums
     * @param {number} n
     * @return {number[]}
     */
    shuffle(nums) {
        const M = Math.max(...nums) + 1;
        for (let i = 0; i < 2 * n; i++) {
            if (i % 2 === 0) {
                nums[i] += (nums[i >> 1] % M) * M;
            } else {
                nums[i] += (nums[n + (i >> 1)] % M) * M;
            }
        }
        for (let i = 0; i < 2 * n; i++) {
            nums[i] = Math.floor(nums[i] / M);
        }
        return nums;
    }
}

class Solution {
    fun shuffle(nums: IntArray, n: Int): IntArray {
        val M = 1001
        for (i in 0 until 2 * n) {
            if (i % 2 == 0) {
                nums[i] += (nums[i / 2] % M) * M
            } else {
                nums[i] += (nums[n + i / 2] % M) * M
            }
        }
        for (i in 0 until 2 * n) {
            nums[i] /= M
        }
        return nums
    }
}

impl Solution {
    pub fn shuffle(mut nums: Vec<i32>, n: i32) -> Vec<i32> {
        let n = n as usize;
        let m = 1001;
        for i in 0..2 * n {
            if i % 2 == 0 {
                nums[i] += (nums[i / 2] % m) * m;
            } else {
                nums[i] += (nums[n + i / 2] % m) * m;
            }
        }
        for i in 0..2 * n {
            nums[i] /= m;
        }
        nums
    }
}

Time & Space Complexity

Time complexity: $O(n)$
Space complexity: $O(1)$ extra space.

3. Bit Manipulation

Intuition

Similar to the multiplication approach, we can use bit manipulation to pack two values into one integer. Since values fit in 10 bits (max 1000 < 1024 = 2^10), we can store one value in the lower 10 bits and another in the upper bits. First, we pack each x and its corresponding y into the first half of the array. Then we unpack them from back to front into their final interleaved positions, ensuring we do not overwrite values we still need.

Algorithm

For each i from 0 to n - 1:
- Combine nums[i] (x) and nums[i + n] (y) into nums[i] using: nums[i] = (nums[i] << 10) | nums[i + n].
Starting from i = n - 1 down to 0, and using a pointer j starting at 2n - 1:
- Extract y = nums[i] & ((1 << 10) - 1).
- Extract x = nums[i] >> 10.
- Place nums[j] = y and nums[j - 1] = x.
- Decrement j by 2.
Return the modified array.

class Solution:
    def shuffle(self, nums: List[int], n: int) -> List[int]:
        for i in range(n):
            nums[i] = (nums[i] << 10) | nums[i + n]  # Store x, y in nums[i]

        j = 2 * n - 1
        for i in range(n - 1, -1, -1):
            y = nums[i] & ((1 << 10) - 1)
            x = nums[i] >> 10
            nums[j] = y
            nums[j - 1] = x
            j -= 2

        return nums

public class Solution {
    public int[] shuffle(int[] nums, int n) {
        for (int i = 0; i < n; i++) {
            nums[i] = (nums[i] << 10) | nums[i + n]; // Store x, y in nums[i]
        }

        int j = 2 * n - 1;
        for (int i = n - 1; i >= 0; i--) {
            int y = nums[i] & ((1 << 10) - 1);
            int x = nums[i] >> 10;
            nums[j] = y;
            nums[j - 1] = x;
            j -= 2;
        }

        return nums;
    }
}

class Solution {
public:
    vector<int> shuffle(vector<int>& nums, int n) {
        for (int i = 0; i < n; i++) {
            nums[i] = (nums[i] << 10) | nums[i + n]; // Store x, y in nums[i]
        }

        int j = 2 * n - 1;
        for (int i = n - 1; i >= 0; i--) {
            int y = nums[i] & ((1 << 10) - 1);
            int x = nums[i] >> 10;
            nums[j] = y;
            nums[j - 1] = x;
            j -= 2;
        }

        return nums;
    }
};

class Solution {
    /**
     * @param {number[]} nums
     * @param {number} n
     * @return {number[]}
     */
    shuffle(nums) {
        for (let i = 0; i < n; i++) {
            nums[i] = (nums[i] << 10) | nums[i + n]; // Store x, y in nums[i]
        }

        let j = 2 * n - 1;
        for (let i = n - 1; i >= 0; i--) {
            let y = nums[i] & ((1 << 10) - 1);
            let x = nums[i] >> 10;
            nums[j] = y;
            nums[j - 1] = x;
            j -= 2;
        }

        return nums;
    }
}

public class Solution {
    public int[] Shuffle(int[] nums, int n) {
        for (int i = 0; i < n; i++) {
            nums[i] = (nums[i] << 10) | nums[i + n]; // Store x, y in nums[i]
        }

        int j = 2 * n - 1;
        for (int i = n - 1; i >= 0; i--) {
            int y = nums[i] & ((1 << 10) - 1);
            int x = nums[i] >> 10;
            nums[j] = y;
            nums[j - 1] = x;
            j -= 2;
        }

        return nums;
    }
}

class Solution {
    fun shuffle(nums: IntArray, n: Int): IntArray {
        for (i in 0 until n) {
            nums[i] = (nums[i] shl 10) or nums[i + n] // Store x, y in nums[i]
        }

        var j = 2 * n - 1
        for (i in n - 1 downTo 0) {
            val y = nums[i] and ((1 shl 10) - 1)
            val x = nums[i] shr 10
            nums[j] = y
            nums[j - 1] = x
            j -= 2
        }

        return nums
    }
}

class Solution {
    func shuffle(_ nums: [Int], _ n: Int) -> [Int] {
        var nums = nums
        for i in 0..<n {
            nums[i] = (nums[i] << 10) | nums[i + n] // Store x, y in nums[i]
        }

        var j = 2 * n - 1
        for i in stride(from: n - 1, through: 0, by: -1) {
            let y = nums[i] & ((1 << 10) - 1)
            let x = nums[i] >> 10
            nums[j] = y
            nums[j - 1] = x
            j -= 2
        }

        return nums
    }
}

Time & Space Complexity

Time complexity: $O(n)$
Space complexity: $O(1)$ extra space.

Common Pitfalls

Using Wrong Index for the Y Values

The array is structured as [x1, x2, ..., xn, y1, y2, ..., yn], where the y values start at index n, not index n-1. A common mistake is using nums[n + i - 1] instead of nums[n + i] when pairing x[i] with its corresponding y value, resulting in incorrect pairings.

Overwriting Values in In-Place Solutions

When attempting an in-place shuffle without extra space, a frequent error is overwriting values before they have been used. The bit manipulation and multiplication/modulo approaches carefully encode two values in one element to avoid this, but implementing them incorrectly (such as reading from a position after it has already been modified) corrupts the data and produces wrong results.