Broadcasting for distance matrices in NumPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of broadcasting distance calculation

What is the output of this code that calculates Euclidean distances between points using broadcasting?

NumPy

import numpy as np
points = np.array([[1, 2], [4, 6], [7, 8]])
diffs = points[:, np.newaxis, :] - points[np.newaxis, :, :]
distances = np.sqrt(np.sum(diffs ** 2, axis=2))
print(np.round(distances, 2))

A

[[0.   5.   8.49]
 [5.   0.   3.61]
 [8.49 3.61 0.  ]]

B

[[0.   3.61 5.  ]
 [3.61 0.   8.49]
 [5.   8.49 0.  ]]

C

[[0.   4.24 7.07]
 [4.24 0.   5.  ]
 [7.07 5.   0.  ]]

D

[[0.   6.4  9.2 ]
 [6.4  0.   4.5 ]
 [9.2  4.5  0.  ]]

💡 Hint

Remember Euclidean distance is sqrt((x2-x1)^2 + (y2-y1)^2). Broadcasting helps subtract all pairs at once.

The code uses broadcasting to subtract each point from every other point, then sums squared differences and takes square roots. The resulting matrix shows distances between points. Option A matches the correct calculated distances.

❓ data_output

intermediate

Shape of broadcasted arrays for distance matrix

Given points array shape (4, 3), what is the shape of the array after broadcasting for pairwise distance calculation using diffs = points[:, np.newaxis, :] - points[np.newaxis, :, :]?

NumPy

import numpy as np
points = np.random.rand(4, 3)
diffs = points[:, np.newaxis, :] - points[np.newaxis, :, :]
print(diffs.shape)

A (4, 4, 3)

B (3, 3, 4)

C (3, 4, 4)

D (4, 3, 4)

💡 Hint

Broadcasting adds a new axis to compare each point with every other point.

points[:, np.newaxis, :] adds a new axis at position 1, making shape (4,1,3). points[np.newaxis, :, :] adds a new axis at position 0, shape (1,4,3). Subtracting broadcasts to (4,4,3).

🔧 Debug

advanced

Identify the error in broadcasting distance code

What error will this code raise when calculating pairwise distances using broadcasting?

NumPy

import numpy as np
points = np.array([[1, 2], [3, 4]])
diffs = points[:, :, np.newaxis] - points[np.newaxis, :, :]
distances = np.sqrt(np.sum(diffs ** 2, axis=2))
print(distances)

A IndexError: too many indices for array

B No error, prints distance matrix

C ValueError: operands could not be broadcast together

D TypeError: unsupported operand type(s) for -: 'int' and 'int'

💡 Hint

Check the shapes of arrays before subtraction.

points[:, :, np.newaxis] changes shape to (2, 2, 1) but points[np.newaxis, :, :] is (1, 2, 2). These shapes cannot broadcast together for subtraction, causing ValueError.

🚀 Application

advanced

Calculate Manhattan distance matrix using broadcasting

Which code snippet correctly calculates the Manhattan (L1) distance matrix between points using broadcasting?

A

diffs = points[:, np.newaxis, :] - points[np.newaxis, :, :]
distances = np.sqrt(np.sum(diffs ** 2, axis=1))

B

diffs = points[:, :, np.newaxis] - points[np.newaxis, :, :]
distances = np.sum(np.abs(diffs), axis=1)

C

diffs = points[:, np.newaxis, :] + points[np.newaxis, :, :]
distances = np.sum(np.abs(diffs), axis=2)

D

diffs = points[:, np.newaxis, :] - points[np.newaxis, :, :]
distances = np.sum(np.abs(diffs), axis=2)

💡 Hint

Manhattan distance sums absolute differences along each dimension.

Option D correctly broadcasts to get pairwise differences, takes absolute values, and sums along the last axis to get Manhattan distances. Other options have wrong axes or operations.

🧠 Conceptual

expert

Why broadcasting is efficient for distance matrices

Why is broadcasting preferred over explicit loops when computing distance matrices for large datasets?

A Broadcasting automatically parallelizes computations across multiple CPUs without extra code.

B Broadcasting uses vectorized operations that run faster and use less memory than explicit Python loops.

C Broadcasting reduces the dimensionality of data, making calculations simpler.

D Broadcasting avoids the need to import external libraries like numpy.

💡 Hint

Think about how numpy handles operations internally compared to Python loops.

Broadcasting leverages numpy's optimized C code to perform operations on whole arrays at once, which is much faster and more memory efficient than looping in Python. It does not automatically parallelize or reduce dimensionality.