# Find the length of the longest subarray with atmost K occurrences of the integer X

Given two numbers K, X and an array arr[] containing N integers, the task is to find the length of the longest subarray such that it contains atmost ‘K’ occurrences of integer’X’.

Examples:

Input: K = 2, X = 2, arr[] = {1, 2, 2, 3, 4}
Output: 5
Explanation:
The longest sub-array is {1, 2, 2, 3, 4} which is the complete array as it contains at-most ‘2’ occurrences of the element ‘2’.

Input: K = 1, X = 2, arr[] = {1, 2, 2, 3, 4},
Output: 3
Explanation:
The longest sub-array is {2, 3, 4} as it contains at-most ‘1’ occurrence of the element ‘2’.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Naive Approach: The naive approach for this problem is to generate all possible subarrays for the given subarray. Then, for every subarray, find the largest subarray that contains at-most K occurrence of the element X. The time complexity for this approach is O(N2) where N is the number of elements in the array.

Efficient Approach: The idea is to solve this problem is to use the two pointer technique.

• Initialize two pointers ‘i’ and ‘j’ to -1 and 0 respectively.
• Keep incrementing ‘i’. If an element X is found, increase the count of that element by keeping a counter.
• If the count of X becomes greater than K, then decrease the count and also decrement the value of ‘j’.
• If the count of X becomes less than or equal to K, increment ‘i’ and make no changes to ‘j’.
• The indices ‘i’ and ‘j’ here represents the starting point and ending point of the subarray which is being considered.
• Therefore, at every step, find the value of |i – j + 1|. The maximum possible value for this is the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program to find the length of the ` `// longest subarray which contains at-most ` `// K occurrences of the integer X ` ` `  `#include ` `using` `namespace` `std; ` ` `  `// Function to find the length of the ` `// longest subarray  which contains at-most ` `// K occurrences of the integer X ` `int` `longest(``int` `a[], ``int` `n, ``int` `k, ``int` `x) ` `{ ` `    ``// Maximum initialized to zero ` `    ``int` `max = 0; ` ` `  `    ``// Both the pointers initialized to -1 ` `    ``int` `i = -1; ` `    ``int` `j = 0; ` ` `  `    ``// Variable to store the count of the ` `    ``// occurrence of the element 'x' ` `    ``int` `m1 = 0; ` ` `  `    ``// Iterate through the array once ` `    ``while` `(i < n) { ` ` `  `        ``// If the count is less than equal to K ` `        ``if` `(m1 <= k) { ` ` `  `            ``// Then increase 'i' ` `            ``i++; ` `            ``if` `(a[i] == x) { ` ` `  `                ``// If the integer 'x' is found, ` `                ``// increase the count. ` `                ``m1++; ` `            ``} ` `        ``} ` ` `  `        ``// If the count is greater than K ` `        ``else` `{ ` ` `  `            ``// If the element 'x' is found, ` `            ``// then decrease the count ` `            ``if` `(a[j] == x) { ` `                ``m1--; ` `            ``} ` ` `  `            ``// Increment the value of j. ` `            ``// This signifies that we are looking ` `            ``// at another subarray ` `            ``j++; ` `        ``} ` ` `  `// Find the maximum possible value ` `// among the obtained values ` `        ``if` `(m1 <= k && i < n) { ` ` `  `            ``if` `(``abs``(i - j + 1) > max) { ` `                ``max = ``abs``(i - j + 1); ` `            ``} ` `        ``} ` ` `  `         `  `    ``} ` ` `  `    ``return` `max; ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 1, 2, 2, 3, 4 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `k = 2; ` `    ``int` `x = 2; ` ` `  `    ``cout << longest(arr, n, k, x); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java program to find the length of the ` `// longest subarray which contains at-most ` `// K occurrences of the integer X ` `import` `java.util.*; ` ` `  `class` `GFG{ ` ` `  `// Function to find the length of the ` `// longest subarray which contains at-most ` `// K occurrences of the integer X ` `static` `int` `longest(``int` `a[], ``int` `n, ` `                   ``int` `k, ``int` `x) ` `{ ` ` `  `    ``// Maximum initialized to zero ` `    ``int` `max = ``0``; ` ` `  `    ``// Both the pointers initialized to -1 ` `    ``int` `i = -``1``; ` `    ``int` `j = ``0``; ` ` `  `    ``// Variable to store the count of the ` `    ``// occurrence of the element 'x' ` `    ``int` `m1 = ``0``; ` ` `  `    ``// Iterate through the array once ` `    ``while` `(i < n) ` `    ``{ ` ` `  `        ``// If the count is less  ` `        ``// than equal to K ` `        ``if` `(m1 <= k) ` `        ``{ ` ` `  `            ``// Then increase 'i' ` `            ``i++; ` ` `  `            ``if` `(i < a.length && a[i] == x) ` `            ``{ ` ` `  `                ``// If the integer 'x' is  ` `                ``// found, increase the count. ` `                ``m1++; ` `            ``} ` `        ``} ` ` `  `        ``// If the count is greater than K ` `        ``else` `        ``{ ` ` `  `            ``// If the element 'x' is found, ` `            ``// then decrease the count ` `            ``if` `(j < a.length && a[j] == x) ` `            ``{ ` `                ``m1--; ` `            ``} ` ` `  `            ``// Increment the value of j. ` `            ``// This signifies that we are  ` `            ``// looking at another subarray ` `            ``j++; ` `        ``} ` `         `  `        ``// Find the maximum possible value ` `        ``// among the obtained values ` `        ``if` `(m1 <= k && i < n) ` `        ``{ ` `            ``if` `(Math.abs(i - j + ``1``) > max)  ` `            ``{ ` `                ``max = Math.abs(i - j + ``1``); ` `            ``} ` `        ``} ` `    ``} ` ` `  `    ``return` `max; ` `} ` ` `  `// Driver code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``int` `arr[] = { ``1``, ``2``, ``2``, ``3``, ``4` `}; ` `    ``int` `n = arr.length; ` `    ``int` `k = ``2``; ` `    ``int` `x = ``2``; ` ` `  `    ``System.out.print(longest(arr, n, k, x)); ` `} ` `} ` ` `  `// This code is contributed by Amit Katiyar `

## Python3

 `# Python3 program to find the length of the  ` `# longest subarray which contains at-most  ` `# K occurrences of the integer X  ` ` `  `# Function to find the length of the  ` `# longest subarray which contains at-most  ` `# K occurrences of the integer X  ` `def` `longest(a, n, k, x): ` `     `  `    ``# Maximum initialized to zero  ` `    ``max` `=` `0``;  ` ` `  `    ``# Both the pointers initialized to -1  ` `    ``i ``=` `-``1``;  ` `    ``j ``=` `0``;  ` ` `  `    ``# Variable to store the count of the  ` `    ``# occurrence of the element 'x'  ` `    ``m1 ``=` `0``;  ` ` `  `    ``# Iterate through the array once  ` `    ``while` `(i < n): ` ` `  `        ``# If the count is less than equal to K  ` `        ``if` `(m1 <``=` `k): ` `            ``if` `(a[i] ``=``=` `x): ` ` `  `                ``# If the integer 'x' is found,  ` `                ``# increase the count.  ` `                ``m1 ``+``=` `1``;  ` `                 `  `            ``# Then increase 'i'      ` `            ``i ``+``=` `1``; ` ` `  `        ``# If the count is greater than K  ` `        ``else` `: ` ` `  `            ``# If the element 'x' is found,  ` `            ``# then decrease the count  ` `            ``if` `(a[j] ``=``=` `x): ` `                ``m1 ``-``=` `1``;  ` ` `  `            ``# Increment the value of j.  ` `            ``# This signifies that we are looking  ` `            ``# at another subarray  ` `            ``j ``+``=` `1``;  ` `         `  `        ``# Find the maximum possible value  ` `        ``# among the obtained values  ` `        ``if` `(m1 <``=` `k ``and` `i < n): ` `            ``if` `(``abs``(i ``-` `j ``+` `1``) > ``max``): ` `                ``max` `=` `abs``(i ``-` `j ``+` `1``);  ` `             `  `    ``return` `max``;  ` ` `  `# Driver code  ` `if` `__name__ ``=``=` `"__main__"` `:  ` ` `  `    ``arr ``=` `[ ``1``, ``2``, ``2``, ``3``, ``4` `];  ` `    ``n ``=` `len``(arr);  ` `    ``k ``=` `2``;  ` `    ``x ``=` `2``; ` `     `  `    ``print``(longest(arr, n, k, x));  ` ` `  `# This code is contributed by AnkitRai01 `

## C#

 `// C# program to find the length of the ` `// longest subarray which contains at-most ` `// K occurrences of the integer X ` `using` `System; ` ` `  `class` `GFG{ ` ` `  `// Function to find the length of the ` `// longest subarray which contains at-most ` `// K occurrences of the integer X ` `static` `int` `longest(``int` `[]a, ``int` `n, ` `                   ``int` `k, ``int` `x) ` `{ ` `     `  `    ``// Maximum initialized to zero ` `    ``int` `max = 0; ` `     `  `    ``// Both the pointers initialized to -1 ` `    ``int` `i = -1; ` `    ``int` `j = 0; ` `     `  `    ``// Variable to store the count of the ` `    ``// occurrence of the element 'x' ` `    ``int` `m1 = 0; ` `     `  `    ``// Iterate through the array once ` `    ``while` `(i < n) ` `    ``{ ` `     `  `        ``// If the count is less  ` `        ``// than equal to K ` `        ``if` `(m1 <= k) ` `        ``{ ` `     `  `            ``// Then increase 'i' ` `            ``i++; ` `             `  `            ``if` `(i < a.Length && a[i] == x) ` `            ``{ ` `     `  `                ``// If the integer 'x' is  ` `                ``// found, increase the count. ` `                ``m1++; ` `            ``} ` `        ``} ` `     `  `        ``// If the count is greater than K ` `        ``else` `        ``{ ` `     `  `            ``// If the element 'x' is found, ` `            ``// then decrease the count ` `            ``if` `(j < a.Length && a[j] == x) ` `            ``{ ` `                ``m1--; ` `            ``} ` `     `  `            ``// Increment the value of j. ` `            ``// This signifies that we are  ` `            ``// looking at another subarray ` `            ``j++; ` `        ``} ` `             `  `        ``// Find the maximum possible value ` `        ``// among the obtained values ` `        ``if` `(m1 <= k && i < n) ` `        ``{ ` `            ``if` `(Math.Abs(i - j + 1) > max)  ` `            ``{ ` `                ``max = Math.Abs(i - j + 1); ` `            ``} ` `        ``} ` `    ``} ` `     `  `    ``return` `max; ` `} ` `     `  `// Driver code ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `    ``int` `[]arr = { 1, 2, 2, 3, 4 }; ` `    ``int` `n = arr.Length; ` `    ``int` `k = 2; ` `    ``int` `x = 2; ` `     `  `    ``Console.WriteLine(longest(arr, n, k, x)); ` `} ` `} ` ` `  `// This code is contributed by AnkitRai01 `

Output:

```5
```

Time Complexity: O(N), where N is the length of the array.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : amit143katiyar, AnkitRai01

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.