Find the Longest Equal Subarray - Practice Coding Problems

Find the Longest Equal Subarray - Problem

Find the Longest Equal Subarray

You are given a 0-indexed integer array nums and an integer k representing the maximum number of elements you can delete.

Your goal is to find the longest possible equal subarray after deleting at most k elements from the original array. An equal subarray is one where all elements have the same value.

Key Points:
• A subarray must be contiguous in the final array (after deletions)
• You can delete at most k elements from anywhere in the array
• The empty subarray is considered an equal subarray with length 0
• Elements don't need to be originally adjacent before deletions

Example: Given nums = [1,3,2,3,1,3] and k = 3, you can delete the elements at indices 0, 2, and 4 to get [3,3,3], resulting in an equal subarray of length 3.

Return: The length of the longest possible equal subarray after performing at most k deletions.

Input & Output

example_1.py — Basic case

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

› Output: 3

💡 Note: We can delete elements at indices 0, 2, and 4 to get [3,3,3]. This creates an equal subarray of length 3, which is the maximum possible.

example_2.py — No deletions needed

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

› Output: 2

💡 Note: The longest equal subarrays are [1,1], [2,2], or [5,5], each with length 2. No deletions are needed since these are already contiguous equal subarrays.

example_3.py — Single element array

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

› Output: 1

💡 Note: With only one element, the longest equal subarray has length 1. No deletions are needed or allowed (k=0).

Constraints

1 ≤ nums.length ≤ 10⁵
1 ≤ nums[i] ≤ nums.length
0 ≤ k ≤ nums.length
Follow-up: Can you solve this in O(n) time?

Visualization

Tap to expand

Understanding the Visualization

Sort pearls by color

Group all pearl positions by their color (value)

For each color, use sliding window

Find the longest span where deletions ≤ k

Track the best result

Return the maximum length found across all colors

Key Takeaway

🎯 Key Insight: Group elements by value and use sliding window on each group's indices. For any window spanning positions [i,j] with c target elements, we need exactly (j-i+1-c) deletions. Find the maximum c where deletions ≤ k.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The optimal solution uses a sliding window approach with hash maps. First, group element indices by their values. Then, for each unique value, apply sliding window technique to find the longest subsequence where deletions needed ≤ k. The key insight is that for a window spanning positions [i,j] with c elements of target value, we need (j-i+1) - c deletions. This achieves O(n) time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check All Subarrays)	O(n³)	O(n)	Check every possible subarray and count deletions needed
Sliding Window with Hash Map (Optimal)	O(n)	O(n)	Use sliding window technique for each unique element value

Brute Force (Check All Subarrays) — Algorithm Steps

Iterate through all possible starting positions (i)
For each starting position, iterate through all possible ending positions (j)
For each subarray [i,j], count frequency of each element
Calculate minimum deletions needed: subarray_length - max_frequency
If deletions needed ≤ k, update the maximum length
Return the maximum length found

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first subarray

Begin with subarray [0,0], count frequencies

Expand subarray

Extend to [0,1], [0,2], etc., recalculating frequencies

Move to next starting position

Start new subarrays from position 1, then 2, etc.

Track maximum

Keep track of the longest valid equal subarray found

Code -

solution.c — C

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

int longestEqualSubarray(int* nums, int numsSize, int k) {
    int maxLength = 0;
    
    // Check all possible subarrays
    for (int i = 0; i < numsSize; i++) {
        for (int j = i; j < numsSize; j++) {
            // Count frequency using array (assuming values are reasonable)
            int freq[100001] = {0}; // Adjust size based on constraints
            int maxFreq = 0;
            
            for (int idx = i; idx <= j; idx++) {
                freq[nums[idx]]++;
                if (freq[nums[idx]] > maxFreq) {
                    maxFreq = freq[nums[idx]];
                }
            }
            
            int subarrayLength = j - i + 1;
            int deletionsNeeded = subarrayLength - maxFreq;
            
            // Check if we can make this subarray equal with at most k deletions
            if (deletionsNeeded <= k) {
                if (maxFreq > maxLength) {
                    maxLength = maxFreq;
                }
            }
        }
    }
    
    return maxLength;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops: O(n²) for all subarrays and O(n) for frequency counting in each subarray

⚠ Quadratic Growth

Space Complexity

O(n)

HashMap to store frequency counts for each subarray (at most n different elements)

⚡ Linearithmic Space

28.2K Views

Medium-High Frequency

~25 min Avg. Time

847 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 (Check All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler