Reshape NumPy Array

1. Background Knowledge

NumPy arrays are the foundational data structure for numerical computing in Python, enabling efficient vectorized operations on multi-dimensional data. The shape of a NumPy array is a tuple representing its dimensions (e.g., (6,) for 1D, (2, 3) for 2D), with total elements given by the product of shape dimensions.

Reshaping reorganizes elements into a new shape without copying data or altering values, provided the total number of elements remains constant: $$\prod$($\text{original_shape}$) =$\prod$($\text{new_shape}$)$

This is critical in ML for:

• Converting feature vectors to matrices for models
• Preparing batch data: $($\text{batch_size}$,$\text{features}$)$
• Image reshaping: $($\text{height}$,$\text{width}$,$\text{channels}$)$

2. Algorithm Approach

The core algorithm uses NumPy's reshape() method, which:

1. Validates shape compatibility: $\text{arr.size} ==$\prod$($\text{new_shape}$)$
2. Creates a view (not copy) with new dimensions
3. Returns row-major (C-order) contiguous memory layout by default

Key NumPy methods:

arr.reshape(new_shape) # Reshape to specified dimensions
arr.shape # Get current shape as tuple
arr.tolist() # Convert to nested Python lists
arr.size # Total number of elements

3. Step-by-Step Strategy

def reshape_array(arr, new_shape):
 # Step 1: Capture original shape as list
 original_shape = list(arr.shape)

 # Step 2: Reshape array (guaranteed compatible per constraints)
 reshaped = arr.reshape(new_shape)

 # Step 3: Convert to nested list for output
 array_nested = reshaped.tolist()

 # Step 4: Return required dictionary
 return {
 "original_shape": original_shape,
 "new_shape": list(new_shape),
 "array": array_nested
 }

Execution flow:

1. list(arr.shape) →
2. arr.reshape((2, 3)) → 2×3 view
3. reshaped.tolist() → [[0, 1, 2], [3, 4, 5]]
4. Package in dictionary

4. Common Pitfalls

Memory note: reshape() creates a zero-copy view—efficient but mutations affect original.

5. Time & Space Complexity

Time Complexity: $O(1)$

• reshape(): Metadata update only (no data movement)
• tolist(): $O(n)$ where $n =$ total elements, but minimal for output

Space Complexity: $O(1)$ additional (excluding output)

Input: 1D array of size n
- reshape(): O(1) view
- tolist(): O(n) temporary nested list
- Dictionary: O(1) + O(n) for output array
Total extra: O(n) dominated by output

Why efficient? NumPy uses strided arrays—reshaping adjusts strides (memory step sizes) without copying data.

This solution is optimal for ML data preparation pipelines requiring frequent reshaping.