Skip to content
Related Articles
Open in App
Not now

Related Articles

Count non-overlapping Subarrays of size K with equal alternate elements

Improve Article
Save Article
  • Last Updated : 28 Dec, 2022
Improve Article
Save Article

Given an array arr[] of length N, the task is to find the count of non-overlapping subarrays of size K such that the alternate elements are equal.

Examples:

Input: arr[] = {2, 4, 2, 7}, K = 3
Output: 1
Explanation:  Given subarray {2, 4, 2} is a valid array because the elements in even position(index no.0 and 2) are equal. Hence the count of the subarrays with size K = 3 is 1.

Input: arr[] =  {5, 2, 5, 2, 3, 9, 7, 9, 7}, K = 4
Output: 2
Explanation:  Subarray {5, 2, 5, 2} and {9, 7, 9, 7} are valid subarrays because the elements in even position(index no.0 and 2) and odd positions(index no.1 and 3) are equal.  Hence the count of the subarrays with size K = 4 is 2.

Approach: Implement the idea below to solve the problem

Initially find all the non-overlapping subarrays where  alternate elements are equal. Comparing the lengths of each such subarray with K, we can find out how many valid subarrays of size K can be extracted from each of those.

Follow the below steps to implement the idea:

  • Initialize t = 2  in starting and c = 0, to maintain the count of subarrays.
  • Iterate over the array from index 2.
  • Whenever we found arr[i] = arr[i-2], increment t by 1.
  • When t gets equal to K, increase c by 1 and reset t = 0.
  • If the length of the given array arr[] is less than 2, see the value of K and return the output accordingly.
  • After iterating over the array, return c as the count subarrays.

Below is the implementation of the above approach.

C++




// C++ code to implement the approach
#include <iostream>
using namespace std;
 
// Function to find the count of subarrays
int fun(int arr[], int k, int n)
{
 
  // For checking the length of array
  if (n <= 2) {
    if (k == 1) {
      return n;
    }
    else if (k == 2) {
      return 1;
    }
    else {
      return 0;
    }
  }
  int t = 2;
  int c = 0;
 
  // Loop through the array from 2 to arr.length
  for (int i = 2; i < n; i++)
  {
    // For checking the array elements at odd and
    // even index
    if (arr[i] == arr[i - 2]) {
      t = t + 1;
    }
    else {
      t = 2;
    }
 
    // check whether current size equals k
    if (t == k)
    {
      // Increment the count by 1
      c = c + 1;
      t = 0;
    }
  }
  return c;
}
 
int main() {
 
  int arr[] = { 5, 2, 5, 2, 5, 2, 5, 2, 3, 9, 7, 9, 7 };
  int K = 4;
  int n = sizeof(arr) / sizeof(arr[0]);
 
  // Function call
  cout << fun(arr, K, n) << endl;
 
  return 0;
}
 
// This code is contributed by lokesh.


Java




// Java code to implement the approach
import java.io.*;
 
class GFG {
 
  // Function to find the cound of subarrays
  static int fun(int[] arr, int k)
  {
 
    // For checking the length of array
    if (arr.length <= 2) {
      if (k == 1) {
        return arr.length;
      }
      else if (k == 2) {
        return 1;
      }
      else {
        return 0;
      }
    }
    int t = 2;
    int c = 0;
 
    // Loop through the array from 2 to arr.length
    for (int i = 2; i < arr.length; i++)
    {
 
      // For checking the array elements at odd and
      // even index
      if (arr[i] == arr[i - 2]) {
        t = t + 1;
      }
      else {
        t = 2;
      }
 
      // check whether current size equals k
      if (t == k)
      {
 
        // Increment the count by 1
        c = c + 1;
        t = 0;
      }
    }
    return c;
  }
 
  public static void main(String[] args)
  {
    int[] arr
      = { 5, 2, 5, 2, 5, 2, 5, 2, 3, 9, 7, 9, 7 };
    int K = 4;
 
    // Function call
    System.out.print(fun(arr, K));
  }
}
 
// This code is contributed by lokeshmvs21.


Python3




# Python code to implement the approach
 
 
# Function to find the count of subarrays
def fun(arr, k):
 
    # For checking the length of array
    if len(arr) <= 2:
        if k == 1:
            return len(arr)
        elif k == 2:
            return 1
        else:
            return 0
 
    else:
        # For storing current subarray
        t = 2
        c = 0
 
        # Loop through the array from 2 to len(arr)
        for i in range(2, len(arr)):
 
            # For checking the array elements at
            # odd and even index
            if arr[i] == arr[i-2]:
 
                t = t + 1
            else:
                t = 2
 
            # check whether current size
            # equals k
            if t == k:
 
                # Increment the count by 1
                c += 1
                t = 0
        return c
 
 
# Driver code
if __name__ == '__main__':
 
    arr = [5, 2, 5, 2, 5, 2, 5, 2, 3, 9, 7, 9, 7]
    K = 4
 
    # Function call
    print(fun(arr, K))


C#




// C# code to implement the approach
using System;
 
class GFG {
 
// Function to find the cound of subarrays
static int fun(int[] arr, int k)
{
 
    // For checking the length of array
    if (arr.Length <= 2) {
    if (k == 1) {
        return arr.Length;
    }
    else if (k == 2) {
        return 1;
    }
    else {
        return 0;
    }
    }
    int t = 2;
    int c = 0;
 
    // Loop through the array from 2 to arr.length
    for (int i = 2; i < arr.Length; i++)
    {
 
    // For checking the array elements at odd and
    // even index
    if (arr[i] == arr[i - 2]) {
        t = t + 1;
    }
    else {
        t = 2;
    }
 
    // check whether current size equals k
    if (t == k)
    {
 
        // Increment the count by 1
        c = c + 1;
        t = 0;
    }
    }
    return c;
}
 
static public void Main ()
{
    int[] arr= { 5, 2, 5, 2, 5, 2, 5, 2, 3, 9, 7, 9, 7 };
    int K = 4;
 
    // Function call
    Console.Write(fun(arr, K));
}
}
 
// This code is contributed by Pushpesh Raj.


Javascript




// javascript code to implement the approach
 
// Function to find the count of subarrays
function fun(arr, k, n)
{
 
  // For checking the length of array
  if (n <= 2) {
    if (k == 1) {
      return n;
    }
    else if (k == 2) {
      return 1;
    }
    else {
      return 0;
    }
  }
  let t = 2;
  let c = 0;
 
  // Loop through the array from 2 to arr.length
  for (let i = 2; i < n; i++)
  {
    // For checking the array elements at odd and
    // even index
    if (arr[i] == arr[i - 2]) {
      t = t + 1;
    }
    else {
      t = 2;
    }
 
    // check whether current size equals k
    if (t == k)
    {
      // Increment the count by 1
      c = c + 1;
      t = 0;
    }
  }
  return c;
}
 
let arr = [ 5, 2, 5, 2, 5, 2, 5, 2, 3, 9, 7, 9, 7 ];
  let K = 4;
  let n = arr.length;
 
  // Function call
  console.log(fun(arr, K, n));
   
  // This code is contributed by garg28harsh.


Output

3

Time Complexity: O(N)
Auxiliary Space: O(1)

Related Articles:


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!