Find the Longest Equal Subarray

Find the Longest Equal Subarray - Problem

You are given a 0-indexed integer array nums and an integer k.

A subarray is called equal if all of its elements are equal. Note that the empty subarray is an equal subarray.

Return the length of the longest possible equal subarray after deleting at most k elements from nums.

A subarray is a contiguous, possibly empty sequence of elements within an array.

Input & Output

Example 1 — Basic Case

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

› Output: 3

💡 Note: We can focus on element 1 which appears at positions [0,1,4]. To make subarray from index 0 to 4 all equal to 1, we need to delete the 2 elements at positions 2 and 3. Since 2 ≤ k, we can achieve a length of 3.

Example 2 — No Deletions Needed

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

› Output: 4

💡 Note: All elements are already equal, so no deletions needed. The longest equal subarray has length 4.

Example 3 — Limited Deletions

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

› Output: 1

💡 Note: With k=0, we cannot delete any elements. The longest equal subarray is any single element, with length 1.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is to focus on one element type at a time and use sliding window to find the longest subarray where we can make all elements equal by deleting at most k elements. Best approach uses sliding window for optimal O(n) time complexity by processing element positions efficiently. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force

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

For each possible subarray, determine what the target value should be (most frequent element) and count how many elements need to be deleted to make it equal.

Sliding Window (Optimal)

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

For each unique element, use a sliding window to find the longest subarray where we can make all elements equal to that element by deleting at most k elements.

Brute Force — Algorithm Steps

Step 1: Try all possible subarrays
Step 2: For each subarray, find the most frequent element
Step 3: Count elements that need deletion
Step 4: Track maximum length where deletions ≤ k

Visualization

Tap to expand

Step-by-Step Walkthrough

Try All Subarrays

Generate all possible contiguous subarrays

Count Frequencies

Find most frequent element in each subarray

Calculate Deletions

Check if deletions needed ≤ k

Code -

solution.c — C

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

int solution(int* nums, int numsSize, int k) {
    int maxLength = 0;
    
    // Try all possible subarrays
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Count frequency using simple array scan
            int maxFreq = 0;
            
            // For each unique element in subarray, count its frequency
            for (int target = i; target <= j; target++) {
                int freq = 0;
                for (int idx = i; idx <= j; idx++) {
                    if (nums[idx] == nums[target]) {
                        freq++;
                    }
                }
                if (freq > maxFreq) {
                    maxFreq = freq;
                }
            }
            
            // Elements to delete = total - most frequent
            int toDelete = (j - i + 1) - maxFreq;
            
            // If we can delete enough elements
            if (toDelete <= k) {
                if (maxFreq > maxLength) {
                    maxLength = maxFreq;
                }
            }
        }
    }
    
    return maxLength;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Triple nested loops: O(n²) subarrays × O(n) to process each subarray

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables for counting

✓ Linear Space

23.4K Views

Medium Frequency

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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler