Degree of an Array - Practice Coding Problems

Degree of an Array - Problem

Find the Shortest Subarray with Maximum Frequency

Given a non-empty array of non-negative integers nums, imagine you're analyzing data patterns where certain values appear more frequently than others. The degree of this array is defined as the maximum frequency of any element within it.

Your mission: find the smallest possible length of a contiguous subarray that has the same degree as the original array. In other words, find the shortest subarray that contains all occurrences of the most frequent element(s).

Example: In [1,2,2,3,1], both 1 and 2 appear twice (degree = 2). The shortest subarray containing all 1's is [1,2,2,3,1] (length 5), but the shortest subarray containing all 2's is [2,2] (length 2). So the answer is 2.

Input & Output

example_1.py — Basic Case

$ Input: [1, 2, 2, 3, 1]

› Output: 2

💡 Note: The array has degree 2 (both 1 and 2 appear twice). The shortest subarray containing all 1's is the entire array (length 5), but the shortest subarray containing all 2's is [2, 2] at indices 1-2 (length 2). Return the minimum: 2.

example_2.py — Single Element

$ Input: [1, 2, 2, 3, 1, 4, 2]

› Output: 6

💡 Note: The array has degree 3 (element 2 appears 3 times at indices 1, 2, and 6). The shortest subarray containing all occurrences of 2 spans from index 1 to 6: [2, 2, 3, 1, 4, 2] with length 6.

example_3.py — All Same Elements

$ Input: [1, 1, 1, 1]

› Output: 4

💡 Note: All elements are the same, so the degree is 4. The shortest (and only) subarray with the same degree is the entire array, so the answer is 4.

Constraints

nums.length will be between 1 and 50,000
nums[i] will be an integer between 0 and 49,999
The array is non-empty
All integers are non-negative

Visualization

Tap to expand

Understanding the Visualization

Survey the City

Drive through once, counting store locations and noting first/last positions

Identify Popular Chains

Find which store chain(s) have the most locations (degree)

Calculate Routes

For each popular chain, measure distance from first to last location

Choose Shortest

Select the shortest route among all popular chains

Key Takeaway

🎯 Key Insight: The shortest subarray with maximum degree spans from the first to last occurrence of any element with maximum frequency - we don't need to check every subarray!

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 28

The optimal solution uses a one-pass hash table approach with O(n) time complexity. The key insight is that for any element with maximum frequency, the shortest subarray containing all its occurrences spans from its first occurrence to its last occurrence. We track three hash maps simultaneously: frequency, first position, and last position of each element.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n)	O(n)	Track first/last occurrence and frequency of each element in a single pass
Brute Force (All Subarrays)	O(n³)	O(n)	Check every possible subarray and find the shortest one with maximum degree

One-Pass Hash Table (Optimal) — Algorithm Steps

Initialize hash maps for frequency, first occurrence, and last occurrence
Iterate through array once, updating frequency and positions for each element
Find the maximum frequency (degree) from the frequency map
For all elements with maximum frequency, calculate subarray length using (last - first + 1)
Return the minimum length among all candidates

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Maps

Create hash maps for frequency, first occurrence, and last occurrence

Single Pass

Iterate once, updating all three maps for each element

Find Degree

Identify maximum frequency from the frequency map

Calculate Lengths

For elements with max frequency, compute last - first + 1

Return Minimum

Return the smallest length among all candidates

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int findShortestSubArray(int* nums, int numsSize) {
    if (numsSize == 0) return 0;
    
    // Find max value to determine array size
    int maxVal = 0;
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > maxVal) maxVal = nums[i];
    }
    
    int* frequency = (int*)calloc(maxVal + 1, sizeof(int));
    int* firstOccurrence = (int*)malloc((maxVal + 1) * sizeof(int));
    int* lastOccurrence = (int*)malloc((maxVal + 1) * sizeof(int));
    
    // Initialize first occurrence to -1
    for (int i = 0; i <= maxVal; i++) {
        firstOccurrence[i] = -1;
    }
    
    // Single pass to build all arrays
    for (int i = 0; i < numsSize; i++) {
        int num = nums[i];
        if (firstOccurrence[num] == -1) {
            firstOccurrence[num] = i;
        }
        frequency[num]++;
        lastOccurrence[num] = i;
    }
    
    // Find degree (maximum frequency)
    int degree = 0;
    for (int i = 0; i <= maxVal; i++) {
        if (frequency[i] > degree) {
            degree = frequency[i];
        }
    }
    
    // Find minimum length among all elements with maximum frequency
    int minLength = numsSize;
    for (int i = 0; i <= maxVal; i++) {
        if (frequency[i] == degree) {
            int length = lastOccurrence[i] - firstOccurrence[i] + 1;
            if (length < minLength) {
                minLength = length;
            }
        }
    }
    
    free(frequency);
    free(firstOccurrence);
    free(lastOccurrence);
    
    return minLength;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array to build maps, plus O(k) to find minimum length where k is number of unique elements

✓ Linear Growth

Space Complexity

O(n)

Three hash maps storing frequency, first position, and last position for each unique element

⚡ Linearithmic Space

68.4K Views

Medium Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler