Vectorization over loops in NumPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of vectorized vs loop sum

What is the output of the following code that sums two arrays using a loop and using vectorization?

NumPy

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])

# Using loop
result_loop = []
for i in range(len(arr1)):
    result_loop.append(arr1[i] + arr2[i])

# Using vectorization
result_vec = arr1 + arr2

print(result_loop)
print(result_vec.tolist())

A [5, 7, 9]\n[4, 6, 8]

B [5, 7, 9]\n[1, 2, 3, 4, 5, 6]

C [5, 7, 9]\n[5, 7, 9]

D [4, 6, 8]\n[5, 7, 9]

💡 Hint

Think about how element-wise addition works in numpy arrays compared to manual loops.

Both the loop and vectorized code add corresponding elements of the two arrays. The loop creates a list with sums, and vectorization returns a numpy array which is converted to list for printing. Both outputs are the same: [5, 7, 9].

❓ data_output

intermediate

Result shape after vectorized operation

Given two numpy arrays a with shape (3, 1) and b with shape (1, 4), what is the shape of the result after a + b?

NumPy

import numpy as np
a = np.array([[1], [2], [3]])
b = np.array([[10, 20, 30, 40]])
c = a + b
print(c.shape)

A (3, 4)

B (3, 1)

C (1, 4)

D (4, 3)

💡 Hint

Remember numpy broadcasting rules for arrays with different shapes.

Array a has shape (3,1) and b has shape (1,4). Broadcasting expands them to (3,4) each before addition, so the result shape is (3,4).

🔧 Debug

advanced

Identify error in vectorized code

What error does the following code raise?

NumPy

import numpy as np
arr = np.array([1, 2, 3])
result = arr + '4'
print(result)

A TypeError: unsupported operand type(s) for +: 'numpy.ndarray' and 'str'

B ValueError: operands could not be broadcast together with shapes (3,) (1,)

C SyntaxError: invalid syntax

D No error, output: [5 6 7]

💡 Hint

Think about adding numbers and strings in numpy arrays.

You cannot add a numpy array of integers and a string directly. This raises a TypeError about unsupported operand types.

🚀 Application

advanced

Vectorized calculation of Euclidean distances

You have two sets of points in 2D space stored as numpy arrays A (shape (m, 2)) and B (shape (n, 2)). Which option correctly computes the matrix of Euclidean distances between each point in A and each point in B using vectorization?

NumPy

import numpy as np
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8], [9, 10]])

A np.sqrt(((A - B) ** 2).sum(axis=1))

B np.sqrt(((A[:, None, :] - B[None, :, :]) ** 2).sum(axis=2))

C np.linalg.norm(A - B, axis=1)

D np.sum(np.abs(A - B), axis=2)

💡 Hint

Use broadcasting to subtract each point in B from each point in A, then sum squared differences.

Option B uses broadcasting to create a (m, n, 2) array of differences, squares them, sums over coordinates, and takes square root to get Euclidean distances matrix of shape (m, n).

🧠 Conceptual

expert

Why vectorization is faster than loops in numpy?

Which of the following best explains why vectorized operations in numpy are faster than explicit Python loops?

A Vectorized operations use GPU by default to speed up calculations.

B Vectorized operations use multiple CPU cores automatically to parallelize loops.

C Vectorized operations convert data to strings for faster processing.

D Vectorized operations use optimized C code and avoid Python-level loops, reducing overhead.

💡 Hint

Think about what happens under the hood when numpy runs vectorized code.

Numpy vectorized operations run compiled C code internally, avoiding slow Python loops and function calls, which makes them faster. They do not automatically use multiple cores or GPUs.

Practice

1. What is the main advantage of using vectorization in numpy instead of loops?

easy

A. It makes the code run faster by doing many operations at once.

B. It uses more memory but slows down the code.

C. It makes the code harder to read and understand.

D. It requires writing more lines of code.

Solution

1. Step 1: Understand vectorization concept

   Vectorization means applying operations on whole arrays at once, not one element at a time.

2. Step 2: Compare speed and simplicity

   This approach uses optimized numpy functions that run faster than explicit loops.

3. Final Answer:

   It makes the code run faster by doing many operations at once. -> Option A

4. Quick Check:

   Vectorization = faster code [OK]

Hint: Vectorization speeds up code by handling arrays at once [OK]

Common Mistakes:

• Thinking vectorization slows code
• Believing vectorization needs more code
• Confusing vectorization with loops

2. Which of the following numpy codes correctly replaces a loop to add 5 to each element in array a?

easy

A. a + 5

B. for i in a: i = i + 5

C. np.add(a, 5, out=a)

D. a.append(5)

Solution

1. Step 1: Identify vectorized addition

   Using np.add(a, 5, out=a) adds 5 to every element in array a efficiently.

2. Step 2: Check other options

   a + 5 works but returns a new array, for i in a: i = i + 5 does not change a, and a.append(5) is invalid for numpy arrays.

3. Final Answer:

   np.add(a, 5, out=a) -> Option C

4. Quick Check:

   np.add = vectorized add [OK]

Hint: Use numpy functions like np.add for vectorized operations [OK]

Common Mistakes:

• Using loops that don't modify array
• Trying list methods on numpy arrays
• Confusing array addition with append

3. What is the output of this code?

import numpy as np
arr = np.array([1, 2, 3])
result = arr * 2
print(result)

medium

A. [2 4 6]

B. [1 2 3 1 2 3]

C. [3 4 5]

D. Error: cannot multiply array by int

Solution

1. Step 1: Understand array multiplication

   Multiplying a numpy array by a number multiplies each element by that number.

2. Step 2: Calculate element-wise multiplication

   Each element in [1, 2, 3] is multiplied by 2, resulting in [2, 4, 6].

3. Final Answer:

   [2 4 6] -> Option A

4. Quick Check:

   Array * number = element-wise multiply [OK]

Hint: Array * number multiplies each element [OK]

Common Mistakes:

• Thinking it concatenates arrays
• Expecting an error on multiplication
• Confusing element-wise with matrix multiply

4. Identify the error in this code that tries to add 10 to each element of arr using a loop:

import numpy as np
arr = np.array([1, 2, 3])
for i in arr:
    i = i + 10
print(arr)

medium

A. Syntax error in for loop.

B. Loop variable i does not modify original array elements.

C. Array arr is not defined.

D. Cannot add integer to numpy array elements.

Solution

1. Step 1: Understand loop variable behavior

   Variable i is a copy of each element, so changing i does not change arr.

2. Step 2: Explain why array remains unchanged

   The original array arr stays the same because the loop does not assign back to array elements.

3. Final Answer:

   Loop variable i does not modify original array elements. -> Option B

4. Quick Check:

   Loop var copy ≠ array change [OK]

Hint: Loop vars are copies; assign to array to change [OK]

Common Mistakes:

• Assuming loop changes array automatically
• Thinking syntax error exists
• Believing numpy disallows int addition

5. You have a numpy array data = np.array([1, 2, 3, 4, 5]). You want to create a new array where each element is squared if it is even, otherwise doubled. Which vectorized code achieves this?

hard

A. data * 2 if data % 2 else data ** 2

B. [x**2 if x%2==0 else x*2 for x in data]

C. for i in range(len(data)): data[i] = data[i]**2 if data[i]%2==0 else data[i]*2

D. np.where(data % 2 == 0, data**2, data*2)

Solution

1. Step 1: Understand vectorized conditional with np.where

   np.where(condition, x, y) returns array choosing x where condition is true, else y.

2. Step 2: Apply condition for even and odd elements

   Condition data % 2 == 0 checks even numbers; squares them, else doubles.

3. Step 3: Check other options

   [x**2 if x%2==0 else x*2 for x in data] uses list comprehension (not vectorized), C uses loop (not vectorized), D is invalid syntax.

4. Final Answer:

   np.where(data % 2 == 0, data**2, data*2) -> Option D

5. Quick Check:

   np.where = vectorized if-else [OK]

Hint: Use np.where for vectorized if-else conditions [OK]

Common Mistakes:

• Using loops or list comprehensions instead of vectorization
• Writing invalid syntax for conditional operations
• Confusing element-wise operations with scalar