# 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:
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:
Explanation:
The longest sub-array is {2, 3, 4} as it contains at-most ‘1’ occurrence of the element ‘2’.

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[0]);``    ``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`

## Javascript

 ``

Output:
`5`

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

Previous
Next