Copy vs View

mediumPROMiscNumPy ConceptsNumpy

Problem Statement

Understand the difference between array copies and views in NumPy.

Background

arr.copy(): Creates a deep copy (independent array)
arr.view() or slicing: Creates a view (shares data with original)
Modifying a view affects the original array!

Your Task

Write a function test_copy_view(arr) that:

Creates a copy and a view of the array
Modifies the first element of each to 999
Returns a dictionary with:
- "original": Original array as list (after modifications)
- "copy_modified": Whether modifying copy affected original (boolean)
- "view_modified": Whether modifying view affected original (boolean)

Output Format

Return a dictionary with exactly these three keys.

Example

Input

[1, 2, 3, 4, 5]

Output

{'original': [999, 2, 3, 4, 5], 'copy_modified': False, 'view_modified': True}

Reasoning

Input: arr is a 1-D integer array of 5 elements, $a = (1, 2, 3, 4, 5)$ . Picture it as one block of memory.
The copy: a copy is a second, independent block with the same values, $c = (1, 2, 3, 4, 5)$ . Setting $c_0 = 999$ changes only that new block, so $a_0$ is still $1$ and the answer for copy_modified is False.
The view: a view is a new array object that reads and writes the same block as $a$ . Setting $v_0 = 999$ writes into that shared memory, so afterwards $a_0 = 999$ and view_modified is True.
Output: original reports the array after both experiments as a plain list, [999, 2, 3, 4, 5]. Only position 0 changed, and only because of the view; the other four values were never touched.
Notice that the copy experiment must be judged before the view writes 999, otherwise $a_0 = 999$ would wrongly make the copy look like it leaked. A one-element array such as $(100)$ ends as $(999)$ the same way.

Constraints

Use .copy() for deep copy
Use .view() for shallow view
Array will have at least 1 element

Learn this in

NumPy & Data WranglingFoundations

Concept primerPREVIEW

1. Background Knowledge

NumPy arrays enable efficient numerical computation through memory sharing concepts: copies (independent data) vs views (shared data pointers).

Deep copy (arr.copy()): Creates new array with independent memory block. Modifications don't propagate. Allocates $O(n)$ space where $n$ is array size.
View (arr.view() or slicing): Creates new array pointing to same data buffer. Same underlying memory, so changes affect original. Space: $O(1)$ (just metadata).
Key theory: NumPy uses strided arrays - views track data via shape, strides (memory steps per dimension), base pointer. Modifying view alters base array's buffer.

Memory model:

Original: [1,2,3] ──┐
 │ (shares buffer)
Copy: [1,2,3] ──┼── independent buffer
View: [1,2,3] ──┘

Prerequisites: NumPy array attributes (base, flags.owndata), boolean testing for modification effects.

2. Algorithm Approach

Direct manipulation with verification:

Create copy (copy_arr = arr.copy()) and view (view_arr = arr.view())
Modify first element: copy_arr = 999, view_arr = 999
Test effects: copy_modified = arr != 999, view_modified = arr == 999
Convert original to list: list(arr)

No complex algorithms needed - leverages NumPy's zero-copy semantics for views.

3. Step-by-Step Strategy

def test_copy_view(arr):
 # Step 1: Create copy and view
 copy_arr = arr.copy() # Deep copy: new memory
 view_arr = arr.view() # Shallow view: shared memory

 # Step 2: Store original first element for comparison
 orig_first = arr

 # Step 3: Modify first elements
 copy_arr = 999
 view_arr = 999

 # Step 4: Test effects on original
 copy_affected = arr == orig_first # Should be True (unchanged)
 view_affected = arr == 999 # Should be True (changed)

PRO

Continue the full explanation

You're reading the free preview. Unlock the complete walkthrough, the code editor, test runner and reference solution with Premium.

PRO

Editor locked

The code editor is locked for Pro problems. It is only available for free problems. Please upgrade to gain access to the code editor for all problems.

solution.py

Python 3.13

Test results