Contiguous arrays and stride tricks in NumPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of array flags after slicing

What is the output of the following code snippet regarding the contiguity flags of the sliced array?

NumPy

import numpy as np
arr = np.arange(10)
sliced = arr[2:8]
print(sliced.flags['C_CONTIGUOUS'], sliced.flags['F_CONTIGUOUS'])

A True True

B False True

C True False

D False False

💡 Hint

Slicing a 1D numpy array usually returns a view that is still contiguous in memory.

The sliced array is a view of the original 1D array. For 1D arrays, both C_CONTIGUOUS and F_CONTIGUOUS flags are True since there is no distinction between row- and column-major order.

❓ data_output

intermediate

Shape and strides of a reshaped array

Given the code below, what are the shape and strides of the reshaped array?

NumPy

import numpy as np
arr = np.arange(12)
reshaped = arr.reshape((3,4))
print(reshaped.shape, reshaped.strides)

A (3, 4) (32, 8)

B (3, 4) (8, 32)

C (4, 3) (32, 8)

D (4, 3) (8, 32)

💡 Hint

Each element is 8 bytes (int64), and strides indicate bytes to step in each dimension.

The array has shape (3,4). The stride for the first dimension is 4 elements * 8 bytes = 32 bytes, and for the second dimension is 8 bytes (one element).

🔧 Debug

advanced

Why does this stride trick code raise an error?

Consider this code using numpy stride tricks. Why does it raise an error?

NumPy

import numpy as np
from numpy.lib.stride_tricks import as_strided
arr = np.arange(5)
window = as_strided(arr, shape=(3,3), strides=(8,8))
print(window)

A It raises a TypeError because strides must be integers, but 8 is a float.

B It raises a ValueError because the requested shape and strides exceed the original array's memory.

C It raises an IndexError because the shape is larger than the array length.

D It raises no error and prints a 3x3 window.

💡 Hint

Check if the strides and shape fit inside the original array's memory buffer.

The as_strided function creates a view with given shape and strides without bounds checking. Here, the maximum memory offset is 32 bytes (within the 40-byte buffer), so no error occurs. It prints [[0 1 2] [1 2 3] [2 3 4]].

❓ visualization

advanced

Visualizing memory layout with strides

Which option correctly describes the memory layout visualization of a 2D numpy array with shape (2,3) and strides (24,8)?

NumPy

import numpy as np
arr = np.array([[1,2,3],[4,5,6]], dtype=np.int64)
print(arr.strides)

A Each element is 24 bytes apart; array is 1D in memory.

B Each row is 8 bytes apart, each column 24 bytes apart; elements are stored column-wise.

C Each row is 24 bytes apart, each column 8 bytes apart; elements are stored row-wise.

D Strides indicate the number of elements, not bytes, between rows and columns.

💡 Hint

Stride values are in bytes, and int64 elements are 8 bytes each.

Strides (24,8) mean to move 24 bytes to go to next row (3 elements * 8 bytes) and 8 bytes to go to next column. This matches row-major order.

🚀 Application

expert

Using stride tricks to create sliding windows

Which option correctly creates a sliding window view of size 3 over a 1D numpy array using stride tricks?

NumPy

import numpy as np
from numpy.lib.stride_tricks import as_strided
arr = np.arange(5)

A as_strided(arr, shape=(3,), strides=(8,))

B as_strided(arr, shape=(3, 3), strides=(8, 8))

C as_strided(arr, shape=(3, 3), strides=(8, 24))

D as_strided(arr, shape=(3, 3), strides=(8, 8))[:,:]

💡 Hint

Sliding window of size 3 over 1D array should have shape (3, window_size) with correct strides.

To create sliding windows of size 3 over a 1D array of length 5, the shape should be (3,3) and strides (8,8) to move one element at a time for both dimensions. This produces [[0,1,2], [1,2,3], [2,3,4]]. Option B does this.