Count of longest possible subarrays with sum not divisible by K

Last Updated : 12 May, 2021

Given an array of integers arr[] and a positive integer K, the task is to find the count of the longest possible subarrays with sum of its elements not divisible by K.

Examples:

Input: arr[] = {2, 3, 4, 6}, K = 3
Output: 1
Explanation: There is only one longest possible subarray of size 3 i.e. {3, 4, 6} having a sum 13, which is not divisible by K = 3.

Input: arr[] = {2, 4, 3, 5, 1}, K = 3
Output: 2
Explanation: There are 2 longest possible subarrays of size 4 i.e. {2, 4, 3, 5} and {4, 3, 5, 1} having a sum 14 and 13 respectively, which is not divisible by K = 3.

Approach:

Check if the sum of all the elements of the array is divisible by K
If the sum is not divisible by K, return 1 as the longest subarray would be of size N.
Else
- Find the index of the first number not divisible by K. Let that be L.
- Find the index of the last number not divisible by K. Let that be R.
- Remove the elements all the way up to index L and find the size of the subarray. Remove the elements beyond R and find the size of this subarray as well. Whichever length is greater, that will be the size of the longest subarray not divisible by K.
- Using this length as the window size, apply the sliding window technique on the arr[] to find out the count of sub-arrays of the size obtained above which are not divisible by K.

Below is the implementation of the above approach:

C++

   // C++ program for the above problem
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the count of
// longest subarrays with sum not
// divisible by K
int CountLongestSubarrays(
    int arr[], int n, int k)
{
 
    // Sum of all elements in
    // an array
    int i, s = 0;
    for (i = 0; i < n; ++i) {
        s += arr[i];
    }
 
    // If overall sum is not
    // divisible then return
    // 1, as only one subarray
    // of size n is possible
    if (s % k) {
        return 1;
    }
    else {
        int ini = 0;
 
        // Index of the first number
        // not divisible by K
        while (ini < n
               && arr[ini] % k == 0) {
            ++ini;
        }
 
        int final = n - 1;
 
        // Index of the last number
        // not divisible by K
        while (final >= 0
               && arr[final] % k == 0) {
            --final;
        }
 
        int len, sum = 0, count = 0;
        // Subarray doesn't exist
        if (ini == n) {
            return -1;
        }
        else {
            len = max(n - 1 - ini,
                      final);
        }
 
        // Sum of the window
        for (i = 0; i < len; i++) {
            sum += arr[i];
        }
 
        if (sum % k != 0) {
            count++;
        }
        // Calculate the sum of rest of
        // the windows of size len
        for (i = len; i < n; i++) {
            sum = sum + arr[i];
            sum = sum - arr[i - len];
            if (sum % k != 0) {
                count++;
            }
        }
        return count;
    }
}
 
// Driver Code
int main()
{
    int arr[] = { 3, 2, 2, 2, 3 };
    int n = sizeof(arr)
            / sizeof(arr[0]);
    int k = 3;
    cout << CountLongestSubarrays(arr, n, k);
    return 0;
}
 
  

Java

   // Java program for the above problem 
import java.util.*; 
 
class GFG{ 
 
// Function to find the count of 
// longest subarrays with sum not 
// divisible by K 
static int CountLongestSubarrays(int arr[], 
                                int n, int k) 
{ 
     
    // Sum of all elements in 
    // an array 
    int i, s = 0; 
    for(i = 0; i < n; ++i) 
    { 
    s += arr[i]; 
    } 
 
    // If overall sum is not 
    // divisible then return 
    // 1, as only one subarray 
    // of size n is possible 
    if ((s % k) != 0) 
    { 
        return 1; 
    } 
    else
    { 
        int ini = 0; 
 
        // Index of the first number 
        // not divisible by K 
        while (ini < n && arr[ini] % k == 0) 
        { 
            ++ini; 
        } 
 
        int fin = n - 1; 
 
        // Index of the last number 
        // not divisible by K 
        while (fin >= 0 && arr[fin] % k == 0) 
        { 
            --fin; 
        } 
 
        int len, sum = 0, count = 0; 
         
        // Subarray doesn't exist 
        if (ini == n) 
        { 
            return -1; 
        } 
        else
        { 
            len = Math.max(n - 1 - ini, fin); 
        } 
 
        // Sum of the window 
        for(i = 0; i < len; i++) 
        { 
        sum += arr[i]; 
        } 
 
        if (sum % k != 0) 
        { 
            count++; 
        } 
         
        // Calculate the sum of rest of 
        // the windows of size len 
        for(i = len; i < n; i++) 
        { 
        sum = sum + arr[i]; 
        sum = sum - arr[i - len]; 
        if (sum % k != 0) 
        { 
            count++; 
        } 
        } 
        return count; 
    } 
} 
 
// Driver Code 
public static void main (String []args) 
{ 
    int arr[] = { 3, 2, 2, 2, 3 }; 
    int n = arr.length; 
    int k = 3; 
     
    System.out.print(CountLongestSubarrays( 
                    arr, n, k)); 
} 
} 
 
// This code is contributed by chitranayal 
 
  

Python3

   # Python3 program for the above problem 
 
# Function to find the count of
# longest subarrays with sum not
# divisible by K
def CountLongestSubarrays(arr, n, k):
 
    # Sum of all elements in
    # an array
    s = 0
    for i in range(n):
        s += arr[i]
 
    # If overall sum is not
    # divisible then return
    # 1, as only one subarray
    # of size n is possible
    if(s % k):
        return 1
    else:
        ini = 0
 
        # Index of the first number
        # not divisible by K
        while (ini < n and arr[ini] % k == 0):
            ini += 1
        final = n - 1
 
        # Index of the last number
        # not divisible by K
        while (final >= 0 and arr[final] % k == 0):
            final -= 1
             
        sum, count = 0, 0
         
        # Subarray doesn't exist
        if(ini == n):
            return -1
        else:
            length = max(n - 1 - ini, final)
 
        # Sum of the window
        for i in range(length):
            sum += arr[i]
 
        if(sum % k != 0):
            count += 1
 
        # Calculate the sum of rest of
        # the windows of size len
        for i in range(length, n):
            sum = sum + arr[i]
            sum = sum + arr[i - length]
            if (sum % k != 0):
                count += 1
 
        return count
 
# Driver Code
if __name__ == '__main__':
 
    arr = [ 3, 2, 2, 2, 3 ]
    n = len(arr)
    k = 3
 
    print(CountLongestSubarrays(arr, n, k))
     
# This code is contributed by Shivam Singh
 
  

C#

   // C# program for the above problem
using System;
 
class GFG{
 
// Function to find the count of
// longest subarrays with sum not
// divisible by K
static int CountLongestSubarrays(int[] arr, 
                                 int n, int k)
{
     
    // Sum of all elements in
    // an array
    int i, s = 0;
    for(i = 0; i < n; ++i)
    {
       s += arr[i];
    }
 
    // If overall sum is not
    // divisible then return
    // 1, as only one subarray
    // of size n is possible
    if ((s % k) != 0)
    {
        return 1;
    }
    else
    {
        int ini = 0;
 
        // Index of the first number
        // not divisible by K
        while (ini < n && arr[ini] % k == 0)
        {
            ++ini;
        }
 
        int fin = n - 1;
 
        // Index of the last number
        // not divisible by K
        while (fin >= 0 && arr[fin] % k == 0)
        {
            --fin;
        }
 
        int len, sum = 0, count = 0;
 
        // Subarray doesn't exist
        if (ini == n)
        {
            return -1;
        }
        else
        {
            len = Math.Max(n - 1 - ini, fin);
        }
 
        // Sum of the window
        for(i = 0; i < len; i++)
        {
           sum += arr[i];
        }
 
        if (sum % k != 0)
        {
            count++;
        }
 
        // Calculate the sum of rest of
        // the windows of size len
        for(i = len; i < n; i++) 
        {
           sum = sum + arr[i];
           sum = sum - arr[i - len];
           if (sum % k != 0)
           {
               count++;
           }
        }
        return count;
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    int[] arr = { 3, 2, 2, 2, 3 };
    int n = arr.Length;
    int k = 3;
 
    Console.WriteLine(CountLongestSubarrays(
                      arr, n, k));
}
}
 
// This code is contributed by jrishabh99
 
  

Javascript

   <script>
 
// JavaScript program for the above problem  
 
// Function to find the count of 
// longest subarrays with sum not 
// divisible by K 
function CountLongestSubarrays(arr, n, k) 
{ 
     
    // Sum of all elements in 
    // an array 
    let i, s = 0; 
    for(i = 0; i < n; ++i) 
    { 
        s += arr[i]; 
    } 
 
    // If overall sum is not 
    // divisible then return 
    // 1, as only one subarray 
    // of size n is possible 
    if ((s % k) != 0) 
    { 
        return 1; 
    } 
    else
    { 
        let ini = 0; 
 
        // Index of the first number 
        // not divisible by K 
        while (ini < n && arr[ini] % k == 0) 
        { 
            ++ini; 
        } 
 
        let fin = n - 1; 
 
        // Index of the last number 
        // not divisible by K 
        while (fin >= 0 && arr[fin] % k == 0) 
        { 
            --fin; 
        } 
 
        let len, sum = 0, count = 0; 
         
        // Subarray doesn't exist 
        if (ini == n) 
        { 
            return -1; 
        } 
        else
        { 
            len = Math.max(n - 1 - ini, fin); 
        } 
 
        // Sum of the window 
        for(i = 0; i < len; i++) 
        { 
            sum += arr[i]; 
        } 
 
        if (sum % k != 0) 
        { 
            count++; 
        } 
         
        // Calculate the sum of rest of 
        // the windows of size len 
        for(i = len; i < n; i++) 
        { 
            sum = sum + arr[i]; 
            sum = sum - arr[i - len]; 
             
            if (sum % k != 0) 
            { 
                count++; 
            } 
        } 
        return count; 
    } 
}
     
// Driver Code
let arr = [ 3, 2, 2, 2, 3 ]; 
let n = arr.length; 
let k = 3; 
 
document.write(CountLongestSubarrays( 
                arr, n, k)); 
                 
// This code is contributed by sanjoy_62      
 
</script>
 
  

Output:

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

Longest Subarray With Sum Divisible By K

mayur_patil

Improve

Article Tags :

Practice Tags :

Count of longest possible subarrays with sum not divisible by K

C++

Java

Python3

C#

Javascript

Similar Reads