Contiguous memory layout concept in NumPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Check if a NumPy array is contiguous

Given the code below, what will be the output of the print statement?

NumPy

import numpy as np
arr = np.arange(12).reshape(3,4)
print(arr.flags['C_CONTIGUOUS'])

A True

B False

C None

D Raises an error

💡 Hint

Think about how reshape affects memory layout by default.

The reshape method by default returns a view with a contiguous memory layout in C order (row-major). So the C_CONTIGUOUS flag is True.

❓ Predict Output

intermediate

Effect of transpose on memory contiguity

What will be the output of this code snippet?

NumPy

import numpy as np
arr = np.arange(6).reshape(2,3)
arr_t = arr.T
print(arr_t.flags['C_CONTIGUOUS'])

A True

B None

C Raises ValueError

D False

💡 Hint

Transpose changes the order of elements in memory.

Transposing an array returns a view with a different memory layout, which is not contiguous in C order. Hence, C_CONTIGUOUS is False.

❓ data_output

advanced

Memory layout after slicing

Consider the following code. How many elements does the resulting array have, and is it contiguous in memory?

NumPy

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

A 5, False

B 10, False

C 10, True

D 5, True

💡 Hint

Slicing with a step creates a view but may break contiguity.

The slice arr[::2] selects every second element, resulting in 5 elements. This view is not contiguous in memory, so C_CONTIGUOUS is False.

❓ visualization

advanced

Visualizing memory layout flags

Which option correctly shows the output of the following code?

NumPy

import numpy as np
arr = np.arange(6).reshape(2,3)
arr_slice = arr[:, 1:3]
print(arr_slice.flags)

A

  C_CONTIGUOUS : True
  F_CONTIGUOUS : True
  OWNDATA : True
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

B

  C_CONTIGUOUS : True
  F_CONTIGUOUS : False
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

C

  C_CONTIGUOUS : False
  F_CONTIGUOUS : False
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

D

  C_CONTIGUOUS : False
  F_CONTIGUOUS : True
  OWNDATA : False
  WRITEABLE : True
  ALIGNED : True
  WRITEBACKIFCOPY : False
  UPDATEIFCOPY : False

💡 Hint

Slicing columns keeps row-major order but may break contiguity.

The slice arr[:, 1:3] returns a view that is contiguous in C order because columns are contiguous in each row. So C_CONTIGUOUS is True and F_CONTIGUOUS is False. The array does not own its data (OWNDATA is False).

🧠 Conceptual

expert

Understanding memory layout impact on performance

Which statement best explains why contiguous memory layout improves performance in NumPy?

A Contiguous arrays automatically compress data to save memory space.

B Contiguous arrays reduce the number of CPU cores needed to process data.

C Contiguous arrays allow faster access because data is stored sequentially in memory, improving cache usage.

D Contiguous arrays enable parallel processing without any synchronization.

💡 Hint

Think about how computers read memory and the role of CPU cache.

Contiguous memory means data is stored one after another. This helps the CPU cache to load data efficiently, speeding up computations. Other options are incorrect because they describe unrelated or false effects.

Practice

1. What does contiguous memory layout mean in numpy arrays?

easy

A. Data is stored only on disk, not in memory

B. Data is stored randomly across memory

C. Data is stored in one continuous block in memory

D. Data is stored as separate small blocks scattered in memory

Solution

1. Step 1: Understand memory layout concept

   Contiguous memory layout means all data elements are stored next to each other in one block.

2. Step 2: Compare options

   Only Data is stored in one continuous block in memory describes this continuous block storage; others describe scattered or disk storage.

3. Final Answer:

   Data is stored in one continuous block in memory -> Option C

4. Quick Check:

   Contiguous memory layout = continuous block [OK]

Hint: Contiguous means continuous block in memory [OK]

Common Mistakes:

• Confusing contiguous with random or scattered storage
• Thinking contiguous means stored on disk
• Assuming contiguous means data is compressed

2. Which numpy function checks if an array has a contiguous memory layout?

easy

A. array.is_contiguous

B. array.flags['C_CONTIGUOUS']

C. np.iscontiguous()

D. np.contiguous_check()

Solution

1. Step 1: Recall numpy array flags attribute

   Numpy arrays have a flags attribute that shows memory layout info.

2. Step 2: Identify correct flag for contiguous

   The flag 'C_CONTIGUOUS' tells if array is contiguous in C order.

3. Final Answer:

   array.flags['C_CONTIGUOUS'] -> Option B

4. Quick Check:

   Check contiguous with flags['C_CONTIGUOUS'] [OK]

Hint: Use array.flags['C_CONTIGUOUS'] to check contiguity [OK]

Common Mistakes:

• Using non-existent np.iscontiguous() function
• Trying to call array.is_contiguous property (doesn't exist)
• Confusing function names with similar words

3. What will be the output of this code?

import numpy as np
arr = np.arange(6).reshape(2,3)
slice_arr = arr[:, 1:3]
print(slice_arr.flags['C_CONTIGUOUS'])

medium

A. False

B. None

C. Raises AttributeError

D. True

Solution

1. Step 1: Understand slicing effect on contiguity

   Slicing columns creates a view that is not contiguous in memory.

2. Step 2: Check the flag for the slice

   slice_arr.flags['C_CONTIGUOUS'] will be False because data is not stored continuously.

3. Final Answer:

   False -> Option A

4. Quick Check:

   Slices often break contiguity = False [OK]

Hint: Slicing columns usually breaks contiguity [OK]

Common Mistakes:

• Assuming all slices are contiguous
• Confusing True/False for flags
• Expecting a runtime error instead of boolean

4. Find the error in this code that tries to make a numpy array contiguous:

import numpy as np
arr = np.arange(10)[::2]
cont_arr = np.ascontiguousarray(arr)
print(cont_arr.flags['C_CONTIGUOUS'])

medium

A. cont_arr is still not contiguous

B. np.ascontiguousarray() does not exist

C. arr is already contiguous, so no change

D. No error, code runs and prints True

Solution

1. Step 1: Understand slicing with step and contiguity

   arr = np.arange(10)[::2] creates a non-contiguous view with step 2.

2. Step 2: Use np.ascontiguousarray to copy contiguous

   np.ascontiguousarray(arr) returns a contiguous copy of arr.

3. Final Answer:

   No error, code runs and prints True -> Option D

4. Quick Check:

   ascontiguousarray fixes contiguity = True [OK]

Hint: ascontiguousarray copies to contiguous memory [OK]

Common Mistakes:

• Thinking ascontiguousarray does not exist
• Assuming original array is contiguous after slicing with step
• Expecting cont_arr to be a view, not a copy

5. You have a large 2D numpy array data that is a transpose of a contiguous array. You want to speed up computations that require contiguous memory. What is the best way to get a contiguous array without changing the data values?

hard

A. Use np.ascontiguousarray(data) to get a contiguous array

B. Use data.copy(order='K') to get a contiguous copy

C. Use data.T again to reverse transpose

D. Use data.flatten() to get a 1D contiguous array

Solution

1. Step 1: Understand transpose effect on contiguity

   Transposing an array usually breaks contiguity because rows and columns swap.

2. Step 2: Choose method to get contiguous array without changing data

   np.ascontiguousarray returns a contiguous array copy without changing data values.

3. Step 3: Evaluate other options

   data.copy(order='K') preserves the original layout (F-contiguous), so flags['C_CONTIGUOUS'] remains False; data.T reverses transpose but changes shape; flatten() changes shape to 1D, which may not be desired.

4. Final Answer:

   Use np.ascontiguousarray(data) to get a contiguous array -> Option A

5. Quick Check:

   ascontiguousarray fixes contiguity efficiently [OK]

Hint: Use np.ascontiguousarray to ensure contiguous copy [OK]

Common Mistakes:

• Using data.copy(order='K') which preserves F-contiguity
• Thinking transpose reverses contiguity
• Using flatten() changes array shape unexpectedly