Partial sorting with np.partition() in NumPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of np.partition() on a 1D array

What is the output of the following code using np.partition() on a 1D array?

NumPy

import numpy as np
arr = np.array([7, 2, 5, 3, 9, 1])
result = np.partition(arr, 3)
print(result)

A [1 2 3 5 7 9]

B [2 1 3 5 7 9]

C [1 2 3 7 5 9]

D [2 1 3 5 9 7]

💡 Hint

Remember, np.partition rearranges so that the element at the kth position is in sorted order, and all smaller elements are before it, but the rest are unordered.

The np.partition(arr, 3) places the element that would be at index 3 in a sorted array at index 3. Elements before index 3 are smaller or equal, but not necessarily sorted. Elements after index 3 are larger or equal, unordered.

Sorted array is [1, 2, 3, 5, 7, 9]. The element at index 3 is 5. So after partition, 5 is at index 3, smaller elements (1,2,3) are before it in any order, and larger elements (7,9) after it in any order. Option D matches this.

❓ data_output

intermediate

Number of elements less than pivot after np.partition()

After running np.partition(arr, 2) on arr = np.array([10, 4, 5, 8, 6, 11, 3]), how many elements are guaranteed to be less than or equal to the element at index 2 in the result?

NumPy

import numpy as np
arr = np.array([10, 4, 5, 8, 6, 11, 3])
result = np.partition(arr, 2)
print(result)

A At least 2 elements

B Exactly 3 elements

C At least 3 elements

D Exactly 2 elements

💡 Hint

The kth element after partition is in its sorted position, so all elements before it are smaller or equal.

Using np.partition(arr, 2) places the element that would be at index 2 in sorted order at index 2. All elements before index 2 are smaller or equal to it. So there are at least 3 elements (indices 0,1,2) less than or equal to that element.

🔧 Debug

advanced

Identify the error in np.partition usage

What error does the following code raise?

NumPy

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
result = np.partition(arr, 10)
print(result)

A ValueError: kth out of bounds

B TypeError: invalid type for kth

C IndexError: index 10 is out of bounds for axis 0 with size 5

D No error, returns the sorted array

💡 Hint

Check if the kth index is valid for the array size.

The kth argument must be within the array bounds. Here, 10 is larger than the array length 5, so np.partition raises a ValueError.

🚀 Application

advanced

Using np.partition() to find the 3 smallest values

Which option correctly extracts the 3 smallest values from arr = np.array([12, 3, 5, 7, 19, 1]) using np.partition()?

NumPy

import numpy as np
arr = np.array([12, 3, 5, 7, 19, 1])

A np.partition(arr, 2)[:3]

B np.partition(arr, 3)[:3]

C np.partition(arr, 3)[3:]

D np.partition(arr, 2)[3:]

💡 Hint

Remember, kth index is zero-based, so to get 3 smallest elements, use k=2.

To get the 3 smallest elements, partition at index 2 (third element). The first 3 elements after partition contain the 3 smallest values, unordered.

🧠 Conceptual

expert

Behavior of np.partition() on 2D arrays

Given a 2D array arr = np.array([[9, 4, 7], [1, 3, 5]]), what does np.partition(arr, 1, axis=1) do?

NumPy

import numpy as np
arr = np.array([[9, 4, 7], [1, 3, 5]])
result = np.partition(arr, 1, axis=1)
print(result)

A Partitions each column so the element at index 1 is in sorted position within that column

B Partitions each row so the element at index 1 is in sorted position within that row

C Sorts the entire array along axis 1

D Raises an error because axis=1 is invalid for partition

💡 Hint

Check the meaning of axis=1 for a 2D array in numpy.

Axis=1 means partition is done along rows. Each row is partitioned so that the element at index 1 is in its sorted position within that row, with smaller elements before it and larger after it.

Practice

1. What does np.partition do to an array?

easy

A. It rearranges the array so the kth element is in its sorted position, with partial order around it.

B. It fully sorts the entire array in ascending order.

C. It reverses the array elements.

D. It removes duplicate elements from the array.

Solution

1. Step 1: Understand np.partition behavior

   np.partition places the kth smallest element in its correct sorted position.

2. Step 2: Recognize partial ordering

   Elements before the kth are smaller or equal, and elements after are larger or equal, but not fully sorted.

3. Final Answer:

   It rearranges the array so the kth element is in its sorted position, with partial order around it. -> Option A

4. Quick Check:

   Partial sorting = kth element fixed [OK]

Hint: Remember: np.partition fixes kth element only [OK]

Common Mistakes:

• Thinking np.partition fully sorts the array
• Assuming it reverses or removes duplicates
• Confusing np.partition with np.sort

2. Which of the following is the correct syntax to partition array arr at index 3 using np.partition?

easy

A. np.partition(arr, 3)

B. np.partition(3, arr)

C. arr.partition(3)

D. np.partition(arr, k=3)

Solution

1. Step 1: Check np.partition function signature

   The function is called as np.partition(array, kth), where kth is the index.

2. Step 2: Match syntax with options

   np.partition(arr, 3) matches the correct order: array first, then kth index.

3. Final Answer:

   np.partition(arr, 3) -> Option A

4. Quick Check:

   np.partition(array, kth) syntax [OK]

Hint: Remember: array first, kth second in np.partition() [OK]

Common Mistakes:

• Swapping arguments order
• Using method call on array (arr.partition)
• Using incorrect keyword argument like k=3

3. What is the output of the following code?

import numpy as np
arr = np.array([7, 2, 5, 3, 9])
result = np.partition(arr, 2)
print(arr)

medium

A. [2 3 5 7 9]

B. [7 2 5 3 9]

C. [2 3 5 7 9] sorted

D. [5 2 3 7 9]

Solution

1. Step 1: Identify kth element and partial sorting

   kth=2 means the element at index 2 in sorted order is placed correctly. The 3rd smallest element is 5.

2. Step 2: Rearrange array with partial order

   Elements before index 2 are smaller or equal to 5, after are larger or equal. The output is [7 2 5 3 9] because np.partition returns a new array and does not modify arr in place.

3. Final Answer:

   [7 2 5 3 9] -> Option B

4. Quick Check:

   np.partition returns a new array, original unchanged [OK]

Hint: Check kth element position, others partially ordered [OK]

Common Mistakes:

• Expecting fully sorted output
• Confusing kth index with value
• Ignoring partial order after kth

4. The code below throws an error. What is the mistake?

import numpy as np
arr = np.array([4, 1, 6, 8])
result = np.partition(arr, '2')
print(result)

medium

A. The array must be sorted before partitioning.

B. np.partition does not accept arrays as input.

C. np.partition requires a keyword argument kth=2.

D. The kth argument should be an integer, not a string.

Solution

1. Step 1: Check argument types for np.partition

   The kth argument must be an integer index, not a string.

2. Step 2: Identify error cause

   Passing '2' (string) causes a TypeError; correct is integer 2.

3. Final Answer:

   The kth argument should be an integer, not a string. -> Option D

4. Quick Check:

   kth must be int, not str [OK]

Hint: kth index must be int, not string [OK]

Common Mistakes:

• Passing kth as string instead of int
• Thinking array must be sorted first
• Using keyword argument kth which is invalid

5. You have a large dataset array data with 1 million numbers. You want to quickly find the 1000 smallest values without fully sorting. Which code snippet using np.partition is best?

hard

A. np.partition(data, 1000)[:1000]

B. np.sort(data)[:1000]

C. np.partition(data, 999)[:1000]

D. np.partition(data, -1000)[-1000:]

Solution

1. Step 1: Understand kth index for 1000 smallest

   Indices start at 0, so the 1000th smallest is at index 999.

2. Step 2: Use np.partition to get partial sorted array

   Partition at 999 puts 1000 smallest elements before index 999, so slicing [:1000] gets them.

3. Step 3: Check other options

   np.partition(data, 1000)[:1000] partitions at 1000 (off by one), C fully sorts (slow), D uses negative index (wrong for smallest).

4. Final Answer:

   np.partition(data, 999)[:1000] -> Option C

5. Quick Check:

   kth=999 for 1000 smallest [OK]

Hint: Use kth = count-1 for smallest elements [OK]

Common Mistakes:

• Using kth = 1000 instead of 999
• Using full sort instead of partition
• Using negative kth for smallest values