Shuffling arrays in NumPy - Time & Space Complexity

Time Complexity: Shuffling arrays

O(n)

Understanding Time Complexity

We want to understand how the time it takes to shuffle an array changes as the array gets bigger.

Specifically, how does the work grow when we shuffle more items?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

import numpy as np

arr = np.arange(1_000_000)
np.random.shuffle(arr)

This code creates an array of one million numbers and then shuffles them randomly.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Swapping elements in the array during the shuffle.
• How many times: Each element is visited once to swap with another element.

How Execution Grows With Input

As the array size grows, the number of swaps grows roughly the same way.

Input Size (n)	Approx. Operations
10	About 10 swaps
100	About 100 swaps
1000	About 1000 swaps

Pattern observation: The work grows linearly with the number of elements.

Final Time Complexity

Time Complexity: O(n)

This means the time to shuffle grows directly in proportion to the array size.

Common Mistake

[X] Wrong: "Shuffling takes the same time no matter how big the array is."

[OK] Correct: Actually, each element must be swapped once, so bigger arrays take more time.

Interview Connect

Knowing how shuffling scales helps you understand data preparation steps in real projects and shows you can analyze common array operations.

Self-Check

"What if we shuffled a 2D array instead of a 1D array? How would the time complexity change?"

Practice

1. What does np.random.shuffle() do to a NumPy array?

easy

A. Randomly rearranges the elements of the array in-place

B. Sorts the array elements in ascending order

C. Creates a new shuffled copy of the array without changing the original

D. Reverses the order of elements in the array

Solution

1. Step 1: Understand the function purpose

   np.random.shuffle() is designed to mix elements randomly within the array.

2. Step 2: Check how it modifies the array

   This function changes the original array directly (in-place), not creating a new one.

3. Final Answer:

   Randomly rearranges the elements of the array in-place -> Option A

4. Quick Check:

   Shuffle = random in-place rearrangement [OK]

Hint: Shuffle mixes elements inside the same array [OK]

Common Mistakes:

• Thinking shuffle returns a new array
• Confusing shuffle with sorting
• Assuming shuffle reverses elements

2. Which of the following is the correct syntax to shuffle a 1D NumPy array named arr?

easy

A. np.random.shuffle(arr, axis=1)

B. np.shuffle(arr)

C. arr.shuffle()

D. np.random.shuffle(arr)

Solution

1. Step 1: Identify the correct function call

   The shuffle function is inside the np.random module, so it must be called as np.random.shuffle().

2. Step 2: Check the parameters

   It takes the array as the only argument. The axis parameter is not valid for 1D arrays.

3. Final Answer:

   np.random.shuffle(arr) -> Option D

4. Quick Check:

   Correct shuffle syntax = np.random.shuffle(array) [OK]

Hint: Use np.random.shuffle(array) to shuffle in-place [OK]

Common Mistakes:

• Using np.shuffle instead of np.random.shuffle
• Calling shuffle as a method on the array
• Passing axis parameter incorrectly

3. What will be the output of the following code?

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
np.random.shuffle(arr)
print(arr)

medium

A. [1 2 3 4 5]

B. [5 4 3 2 1]

C. A randomly shuffled version of [1 2 3 4 5]

D. Error because shuffle returns a new array

Solution

1. Step 1: Understand shuffle effect on array

   np.random.shuffle(arr) rearranges elements randomly in-place, so arr changes order.

2. Step 2: Predict output of print

   Since shuffle is random, the printed array will be a shuffled version of the original, not sorted or reversed.

3. Final Answer:

   A randomly shuffled version of [1 2 3 4 5] -> Option C

4. Quick Check:

   Shuffle output = random order of original array [OK]

Hint: Shuffle changes order randomly, output varies each run [OK]

Common Mistakes:

• Expecting original order after shuffle
• Thinking shuffle returns a new array
• Assuming shuffle sorts or reverses

4. Identify the error in the following code snippet:

import numpy as np
arr = np.array([[1, 2], [3, 4]])
np.random.shuffle(arr, axis=1)
print(arr)

medium

A. shuffle does not accept an axis argument

B. arr must be 1D to shuffle

C. shuffle returns a new array, so assignment is needed

D. np.random.shuffle cannot shuffle 2D arrays

Solution

1. Step 1: Check shuffle function parameters

   np.random.shuffle() only accepts the array argument; it does not have an axis parameter.

2. Step 2: Understand shuffle behavior on 2D arrays

   Shuffle works in-place on the first axis of multi-dimensional arrays by default, no axis argument needed.

3. Final Answer:

   shuffle does not accept an axis argument -> Option A

4. Quick Check:

   shuffle axis param invalid = error [OK]

Hint: np.random.shuffle has no axis parameter [OK]

Common Mistakes:

• Passing axis argument to shuffle
• Thinking shuffle returns a new array
• Believing shuffle only works on 1D arrays

5. You have a 2D NumPy array representing 5 samples with 3 features each:

data = np.array([[10, 20, 30],
                 [40, 50, 60],
                 [70, 80, 90],
                 [15, 25, 35],
                 [45, 55, 65]])

You want to shuffle the samples (rows) but keep the feature order intact. Which code correctly does this?

hard

A. np.random.shuffle(data.T)

B. np.random.shuffle(data)

C. np.random.permutation(data)

D. np.random.shuffle(data, axis=1)

Solution

1. Step 1: Understand shuffle on 2D arrays

   np.random.shuffle() shuffles along the first axis (rows) in-place, which is what we want.

2. Step 2: Evaluate other options

   np.random.shuffle(data.T) shuffles columns (wrong axis), np.random.permutation(data) returns a new shuffled array (not in-place), np.random.shuffle(data, axis=1) is invalid (axis param not accepted).

3. Final Answer:

   np.random.shuffle(data) -> Option B

4. Quick Check:

   Shuffle rows in-place = np.random.shuffle(data) [OK]

Hint: Shuffle rows by calling np.random.shuffle on 2D array [OK]

Common Mistakes:

• Trying to shuffle columns by transposing
• Expecting shuffle to return a new array
• Passing axis parameter to shuffle