Length of Longest Subarray With at Most K Frequency - Problem

You are given an integer array nums and an integer k.

The frequency of an element x is the number of times it occurs in an array.

An array is called good if the frequency of each element in this array is less than or equal to k.

Return the length of the longest good subarray of nums.

A subarray is a contiguous non-empty sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

› Output: 6

💡 Note: The whole array is good since each element appears at most 2 times: 1 appears 2 times, 2 appears 2 times, 3 appears 2 times.

Example 2 — Frequency Constraint

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

› Output: 4

💡 Note: Longest good subarray could be [1,2,1,2] with length 4. Element 1 appears 2 times and element 2 appears 2 times.

Example 3 — Single Element

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

› Output: 4

💡 Note: Element 5 can appear at most 4 times, so longest good subarray has length 4.

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ 10⁹
1 ≤ k ≤ nums.length

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to use a sliding window that expands greedily and contracts only when frequency constraints are violated. The optimal approach uses two pointers with a hash map to track frequencies. Time: O(n), Space: O(min(n,k))

Common Approaches

✓ Brute Force - Check All Subarrays

⏱️ Time: O(n³) Space: O(n)

Generate all possible subarrays and for each one, count the frequency of each element. Keep track of the longest subarray where no element appears more than k times.

Sliding Window (Optimal)

⏱️ Time: O(n) Space: O(min(n,k))

Maintain a sliding window that expands to include new elements and contracts when any element's frequency exceeds k. Use a hash map to track frequencies and adjust window boundaries dynamically.

Brute Force - Check All Subarrays — Algorithm Steps

Step 1: Generate all possible subarrays using nested loops
Step 2: For each subarray, count frequency of each element
Step 3: Check if all frequencies are ≤ k, update max length

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Subarrays

Check each possible contiguous subarray

Count Frequencies

For each subarray, count element occurrences

Find Maximum

Track longest valid subarray

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    int maxLength = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            int freq[2001] = {0}; // Assuming values in range [-1000, 1000]
            int valid = 1;
            
            for (int idx = i; idx <= j; idx++) {
                freq[nums[idx] + 1000]++;
                if (freq[nums[idx] + 1000] > k) {
                    valid = 0;
                    break;
                }
            }
            
            if (valid) {
                int len = j - i + 1;
                if (len > maxLength) {
                    maxLength = len;
                }
            }
        }
    }
    
    return maxLength;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int k;
    scanf("%d", &k);
    
    printf("%d\n", solution(nums, numsSize, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: O(n²) subarrays × O(n) to count frequencies

⚠ Quadratic Growth

Space Complexity

O(n)

Hash map to store frequency counts for each subarray

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~15 min Avg. Time

890 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

Length of Longest Subarray With at Most K Frequency - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Check All Subarrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler