Length of Longest Subarray With at Most K Frequency

Length of Longest Subarray With at Most K Frequency - Problem

Imagine you're organizing a playlist where no song should play more than k times in any continuous segment. Given an integer array nums and an integer k, you need to find the longest contiguous subarray where each element appears at most k times.

The frequency of an element is how many times it occurs in the subarray. A subarray is considered "good" if every element in it has a frequency ≤ k.

Goal: Return the length of the longest good subarray.

Example: For nums = [1,2,3,1,2,3,1,2] and k = 2, the longest good subarray could be [1,2,3,1,2,3] with length 6, since each element (1, 2, 3) appears exactly 2 times.

Input & Output

example_1.py — Basic Case

$ Input: nums = [1,2,3,1,2,3,1,2], k = 2

› Output: 6

💡 Note: The longest good subarray is [1,2,3,1,2,3] with length 6. Each element (1, 2, 3) appears exactly 2 times, which equals k=2.

example_2.py — All Same Elements

$ Input: nums = [1,1,1,1,1], k = 3

› Output: 3

💡 Note: Since all elements are 1, the longest subarray where 1 appears at most 3 times has length 3: [1,1,1].

example_3.py — Single Element Array

$ Input: nums = [5], k = 1

› Output: 1

💡 Note: The array has only one element, and its frequency (1) is ≤ k (1), so the answer is 1.

Visualization

Tap to expand

Understanding the Visualization

Start the Playlist

Begin with an empty playlist segment and start adding songs

Track Song Plays

Keep a counter for how many times each song has played in current segment

Expand Safely

Add songs to your playlist as long as no song exceeds k plays

Shrink When Needed

When a song would exceed k plays, remove songs from the beginning until it's valid again

Remember the Best

Always remember the longest valid playlist segment you've created

Key Takeaway

🎯 Key Insight: The sliding window technique allows us to find the optimal playlist segment in linear time by intelligently expanding and contracting our search window based on frequency constraints.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is visited at most twice (once by right pointer, once by left)

✓ Linear Growth

Space Complexity

O(k)

Hash map stores at most k different elements in the current valid window

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ nums.length
k represents the maximum allowed frequency for any element

Asked in

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

The optimal approach uses a sliding window technique with frequency tracking. Maintain two pointers and a hash map to count element frequencies. Expand the window by moving the right pointer, and shrink from the left when any frequency exceeds k. This achieves O(n) time complexity with elegant single-pass processing.

Common Approaches

Approach	Time	Space	Notes
✓ Sliding Window with Hash Map (Optimal)	O(n)	O(k)	Use sliding window technique with frequency tracking to find longest valid subarray
Brute Force (Check All Subarrays)	O(n³)	O(1)	Check every possible subarray and count element frequencies

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Initialize left pointer at 0, frequency map, and max length tracker
Expand window by moving right pointer and updating frequencies
When frequency exceeds k, shrink window from left
Update max length whenever we have a valid window
Continue until right pointer reaches end of array

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Window

Start with left=0, right=0, empty frequency map

Expand Window

Move right pointer, add element to frequency map

Check Validity

If any frequency > k, shrink from left

Update Maximum

Track the largest valid window size seen

Code -

solution.c — C

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

int maxSubarrayLength(int* nums, int numsSize, int k) {
    int left = 0;
    int maxLength = 0;
    int freq[100001] = {0};  // Assuming nums[i] in range [0, 100000]
    
    for (int right = 0; right < numsSize; right++) {
        // Expand window: add current element
        freq[nums[right]]++;
        
        // Shrink window while invalid
        while (freq[nums[right]] > k) {
            freq[nums[left]]--;
            left++;
        }
        
        // Update max length with current valid window
        int currentLength = right - left + 1;
        if (currentLength > maxLength) {
            maxLength = currentLength;
        }
    }
    
    return maxLength;
}

int main() {
    int nums[] = {1, 2, 3, 1, 2, 3, 1, 2};
    int k = 2;
    printf("%d\n", maxSubarrayLength(nums, 8, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is visited at most twice (once by right pointer, once by left)

✓ Linear Growth

Space Complexity

O(k)

Hash map stores at most k different elements in the current valid window

✓ Linear Space

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁵
1 ≤ k ≤ nums.length
k represents the maximum allowed frequency for any element

38.3K Views

High Frequency

~18 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Sliding Window with Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler