Given an **arr[]** consisting of **N** elements, the task is to count all subarrays of size **K** having atleast one pair whose absolute difference is divisible by **K – 1**.**Examples:**

Input:arr[] = {1, 5, 3, 2, 17, 18}, K = 4Output:3Explanation:

The three subarrays of size 4 are:

{1, 5, 3, 2}: Pair {5, 2} have difference divisible by 3

{5, 3, 2, 17}: Pairs {5, 2}, {5, 17}, {2, 17} have difference divisible by 3

{3, 2, 17, 18}: Pairs {3, 18}, {2, 17} have difference divisible by 3Input:arr[] = {1, 2, 3, 4, 5}, K = 5Output:1Explanation:

{1, 2, 3, 4, 5}: Pair {1, 5} is divisble by 4

**Naive Approach:**

The simplest approach to solve the problem is to iterate over all **subarrays** of size **K** and check if there exists any pair whose difference is divisible by **K – 1**. **Time Complexity:** O(N * K * K)**Efficient Approach:** The above approach can be optimized using Pigeonhole Principle. Follow the steps below to solve the problem:

- Consider
**K-1**boxes labeled**0, 1, 2, …, K-2**respectively. They represent the**remainders**when any number x from the array is divided by**K-1**, which means the boxes store the**modulo K-1**of array elements.

- Now, in a
**subarray**of size**K**, according to the**Pigeonhole Principle**, there must be atleast one pair of boxes with same remainders. It means that there is**atleast**one pair whose difference or even the summation will be divisible by**K**.

- From this theorem we can conclude that
**every**subarray of size**K**, will always have atleast one pair whose difference is divisible by**K-1**.

- So, the answer will be equal to the number of subarrays of size
**K**possible from the given array, which is equal to**N – K + 1**.

Below is the implementation of the above approach:

## C++

`// C++ implementation of the` `// above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to return the required` `// number of subarrays` `int` `findSubarrays(` `int` `arr[],` ` ` `int` `N,` ` ` `int` `K)` `{` ` ` `// Return number of possible` ` ` `// subarrays of length K` ` ` `return` `N - K + 1;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 1, 5, 3, 2, 17, 18 };` ` ` `int` `K = 4;` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `cout << findSubarrays(arr, N, K);` ` ` `return` `0;` `}` |

## Java

`// Java implementation of the` `// above approach` `class` `GFG{` `// Function to return the required` `// number of subarrays` `static` `int` `findSubarrays(` `int` `arr[], ` `int` `N,` ` ` `int` `K)` `{` ` ` ` ` `// Return number of possible` ` ` `// subarrays of length K` ` ` `return` `N - K + ` `1` `;` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `arr[] = { ` `1` `, ` `5` `, ` `3` `, ` `2` `, ` `17` `, ` `18` `};` ` ` `int` `K = ` `4` `;` ` ` `int` `N = arr.length;` ` ` `System.out.print(findSubarrays(arr, N, K));` `}` `}` `// This code is contributed by shivanisinghss2110` |

## Python3

`# Python3 implementation of the` `# above approach` `# Function to return the required` `# number of subarrays` `def` `findSubarrays(arr, N, K):` ` ` ` ` `# Return number of possible` ` ` `# subarrays of length K` ` ` `return` `N ` `-` `K ` `+` `1` `;` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `arr ` `=` `[ ` `1` `, ` `5` `, ` `3` `, ` `2` `, ` `17` `, ` `18` `];` ` ` `K ` `=` `4` `;` ` ` `N ` `=` `len` `(arr);` ` ` `print` `(findSubarrays(arr, N, K));` `# This code is contributed by Rohit_ranjan` |

## C#

`// C# implementation of the` `// above approach` `using` `System;` `class` `GFG{` `// Function to return the required` `// number of subarrays` `static` `int` `findSubarrays(` `int` `[]arr, ` `int` `N,` ` ` `int` `K)` `{` ` ` ` ` `// Return number of possible` ` ` `// subarrays of length K` ` ` `return` `N - K + 1;` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `int` `[]arr = { 1, 5, 3, 2, 17, 18 };` ` ` `int` `K = 4;` ` ` `int` `N = arr.Length;` ` ` `Console.Write(findSubarrays(arr, N, K));` `}` `}` `// This code is contributed by Amit Katiyar` |

## Javascript

`<script>` `// Javascript implementation for the above approach` `// Function to return the required` `// number of subarrays` `function` `findSubarrays(arr, N, K)` `{` ` ` ` ` `// Return number of possible` ` ` `// subarrays of length K` ` ` `return` `N - K + 1;` `}` ` ` `// Driver Code` ` ` ` ` `let arr = [ 1, 5, 3, 2, 17, 18 ];` ` ` `let K = 4;` ` ` `let N = arr.length;` ` ` `document.write(findSubarrays(arr, N, K));` `</script>` |

**Output:**

3

**Time complexity:** O(1) **Auxiliary Space:** O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **DSA Live Classes**