Unique and Count

easyFREEMiscNumPy UtilitiesNumpy

Problem Statement

Find unique elements and their counts in a NumPy array.

Background

np.unique(arr): Returns sorted unique elements
np.unique(arr, return_counts=True): Also returns count of each element

Your Task

Write a function unique_count(arr) that returns a dictionary with:

"unique": Unique elements (sorted) as list
"counts": Count of each unique element as list
"num_unique": Number of unique elements

Output Format

Return a dictionary with exactly these three keys.

Example

Input

[1, 2, 2, 3, 3, 3, 4, 4, 4, 4]

Output

{'unique': [1, 2, 3, 4], 'counts': [1, 2, 3, 4], 'num_unique': 4}

Reasoning

Input: arr is a 1D array of 10 integers, $[1, 2, 2, 3, 3, 3, 4, 4, 4, 4]$ . Values may repeat and need not arrive in order.
Distinct values: collapsing repeats leaves the set $\{1, 2, 3, 4\}$ ; written in ascending order this is the unique list [1, 2, 3, 4].
Frequencies: for each distinct value $v$ , count how many positions hold it: $c_1 = 1$ , $c_2 = 2$ , $c_3 = 3$ , $c_4 = 4$ . Listed in the same order as the values, that gives counts = [1, 2, 3, 4].
Size: num_unique is the number of distinct values, $|\{1,2,3,4\}| = 4$ , a plain integer rather than a list.
Check: the counts must add back to the input length: $1 + 2 + 3 + 4 = 10$ .
Notice that the $k$ -th count belongs to the $k$ -th unique value; here they happen to coincide, but for $[5, 5, 5, 5, 5]$ you'd get unique [5] with counts [5] and num_unique 1. All three entries are plain Python lists/integers, not arrays.

Constraints

Use np.unique() with return_counts=True
Array will have at least 1 element

Concept primer

1. Background Knowledge

NumPy arrays provide efficient multidimensional array objects for numerical computing in Python, enabling vectorized operations that avoid Python loops for better performance. The np.unique() function identifies distinct elements in an array and optionally returns their frequencies, making it ideal for this problem.

Key prerequisites:

Basic NumPy array creation and manipulation
Understanding return_counts=True parameter behavior
Python dictionary construction with specific key-value pairs

Mathematical foundation: For an array $A$ of size $n$ with $k$ unique elements, np.unique(A, return_counts=True) returns sorted unique values $U = [u_1, u_2, \ldots, u_k]$ and counts $C = [c_1, c_2, \ldots, c_k]$ where \sum $c_i = n$ and each $u_i$ appears exactly $c_i$ times.

2. Algorithm Approach

Direct use of np.unique() with return_counts=True is the optimal approach per constraints. This leverages NumPy's internal sorting + counting algorithm:

Input: arr = [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
Step 1: Sort → [1, 2, 2, 3, 3, 3, 4, 4, 4, 4]
Step 2: Scan for runs → unique=[1,2,3,4], counts=[1,2,3,4]

Alternative approaches (not recommended here):

Manual sorting + counting: $O(n \log n)$ time, redundant
Hash tables: $O(n)$ expected time, loses sorted order
np.bincount(): Requires integer indices, doesn't sort

3. Step-by-Step Strategy

def unique_count(arr):
 # Step 1: Get unique elements and counts in one call
 unique_elements, counts = np.unique(arr, return_counts=True)

 # Step 2: Compute number of unique elements
 num_unique = len(unique_elements)

 # Step 3: Package into required dictionary format
 return {
 "unique": unique_elements.tolist(), # Convert to Python list
 "counts": counts.tolist(), # Convert to Python list
 "num_unique": num_unique
 }

Why this works:

np.unique() automatically sorts output
.tolist() converts NumPy arrays to native Python lists for dictionary
Dictionary keys match exact specification

4. Common Pitfalls

Pitfall	Problem	Fix
Forgetting .tolist()	NumPy arrays in dict → serialization issues	Always use .tolist() for dictionary values
Returning NumPy arrays directly	Fails output format requirement	Convert with .tolist()
Using return_index=True	Wrong parameter for counts	Use return_counts=True
Manual loop implementation	Violates constraints, slower	Use np.unique() directly
Missing import numpy as np	NameError	Always import NumPy

Edge cases to test:

# Single element
np.array() → {'unique':, 'counts':, 'num_unique': 1}

# All duplicates
np.array([2, 2, 2]) → {'unique':, 'counts':, 'num_unique': 1}

# Already sorted/unsorted
np.array([3, 1, 3, 2]) → {'unique': [1, 2, 3], 'counts': [1, 1, 2], 'num_unique': 3}

5. Time & Space Complexity

Time Complexity: $O(n \log n)$

np.unique() internally sorts array: $O(n \log n)$
Single linear pass for counting: $O(n)$
Dominant term: $O(n \log n)$ due to sorting

Space Complexity: $O(n)$

Output arrays store $k \leq n$ unique elements + counts
Temporary sorting buffer: $O(n)$
Total: $O(n)$ worst case (all unique elements)

Why efficient: NumPy's C implementation + vectorization provides significant speedup over pure Python (often 100x+).

Complete Solution

import numpy as np

def unique_count(arr):
 """Return dictionary with sorted unique elements, their counts, and count of uniques."""
 unique_elements, counts = np.unique(arr, return_counts=True)
 return {
 "unique": unique_elements.tolist(),
 "counts": counts.tolist(),
 "num_unique": len(unique_elements)
 }

# Test
arr = np.array([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
print(unique_count(arr))
# {'unique': [1, 2, 3, 4], 'counts': [1, 2, 3, 4], 'num_unique': 4}

This solution is constraint-compliant, efficient, and robust across all valid inputs.

solution.py

Python 3.13

Test results