Find a subarray whose sum is divisible by size of the array
Last Updated :
31 May, 2022
Given an array arr[] of length N. The task is to check if there exists any subarray whose sum is a multiple of N. If there exists such subarray, then print the starting and ending index of that subarray else print -1. If there are multiple such subarrays, print any of them.
Examples:
Input: arr[] = {7, 5, 3, 7}
Output: 0 1
Sub-array from index 0 to 1 is [7, 5]
sum of this subarray is 12 which is a multiple of 4
Input: arr[] = {3, 7, 14}
Output: 0 0
Naive Approach: The naive approach is to generate all the sub-arrays and calculate their sum. If the sum for any subarray is a multiple of N, then return the starting as well as ending index.
Time Complexity: O(N3)
Better Approach: A better approach is to maintain a prefix sum array that stores the sum of all previous elements. To calculate the sum of a subarray between index i and j, we can use the formula:
subarray sum[i:j] = presum[j]-presum[i-1]
Now check for every sub-array whether its sum is a multiple of N or not.
Below is the implementation of the above approach:
C++
// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
// Function to find a subarray
// whose sum is a multiple of N
void CheckSubarray(int arr[], int N)
{
// Prefix sum array to store cumulative sum
int presum[N + 1] = { 0 };
// Single state dynamic programming
// relation for prefix sum array
for (int i = 1; i <= N; i += 1) {
presum[i] = presum[i - 1] + arr[i - 1];
}
// Generating all sub-arrays
for (int i = 1; i <= N; i += 1) {
for (int j = i; j <= N; j += 1) {
// If the sum of the sub-array[i:j]
// is a multiple of N
if ((presum[j] - presum[i - 1]) % N == 0) {
cout << i - 1 << " " << j - 1;
return;
}
}
}
// If the function reaches here it means
// there are no subarrays with sum
// as a multiple of N
cout << -1;
}
// Driver code
int main()
{
int arr[] = { 7, 5, 3, 7 };
int N = sizeof(arr) / sizeof(arr[0]);
CheckSubarray(arr, N);
return 0;
}
// Java implementation of above approach
import java.io.*;
class GFG
{
// Function to find a subarray
// whose sum is a multiple of N
static void CheckSubarray(int arr[], int N)
{
// Prefix sum array to store cumulative sum
int presum[] = new int[N + 1];
// Single state dynamic programming
// relation for prefix sum array
for (int i = 1; i <= N; i += 1)
{
presum[i] = presum[i - 1] + arr[i - 1];
}
// Generating all sub-arrays
for (int i = 1; i <= N; i += 1)
{
for (int j = i; j <= N; j += 1)
{
// If the sum of the sub-array[i:j]
// is a multiple of N
if ((presum[j] - presum[i - 1]) % N == 0)
{
System.out.print((i - 1) + " " + (j - 1));
return;
}
}
}
// If the function reaches here it means
// there are no subarrays with sum
// as a multiple of N
System.out.print(-1);
}
// Driver code
public static void main (String[] args)
{
int []arr = { 7, 5, 3, 7 };
int N = arr.length;
CheckSubarray(arr, N);
}
}
// This code is contributed by anuj_67..
# Python3 implementation of above approach
# Function to find a subarray
# whose sum is a multiple of N
def CheckSubarray(arr, N):
# Prefix sum array to store cumulative sum
presum=[0 for i in range(N + 1)]
# Single state dynamic programming
# relation for prefix sum array
for i in range(1, N+1):
presum[i] = presum[i - 1] + arr[i - 1]
# Generating all sub-arrays
for i in range(1, N+1):
for j in range(i, N+1):
# If the sum of the sub-array[i:j]
# is a multiple of N
if ((presum[j] - presum[i - 1]) % N == 0):
print(i - 1,j - 1)
return
# If the function reaches here it means
# there are no subarrays with sum
# as a multiple of N
print("-1")
# Driver code
arr = [ 7, 5, 3, 7]
N = len(arr)
CheckSubarray(arr, N)
# This code is contributed by mohit kumar 29
// C# implementation of above approach
using System;
class GFG
{
// Function to find a subarray
// whose sum is a multiple of N
static void CheckSubarray(int []arr, int N)
{
// Prefix sum array to store cumulative sum
int []presum = new int[N + 1];
// Single state dynamic programming
// relation for prefix sum array
for (int i = 1; i <= N; i += 1)
{
presum[i] = presum[i - 1] + arr[i - 1];
}
// Generating all sub-arrays
for (int i = 1; i <= N; i += 1)
{
for (int j = i; j <= N; j += 1)
{
// If the sum of the sub-array[i:j]
// is a multiple of N
if ((presum[j] - presum[i - 1]) % N == 0)
{
Console.Write((i - 1) + " " + (j - 1));
return;
}
}
}
// If the function reaches here it means
// there are no subarrays with sum
// as a multiple of N
Console.Write(-1);
}
// Driver code
public static void Main ()
{
int []arr = { 7, 5, 3, 7 };
int N = arr.Length;
CheckSubarray(arr, N);
}
}
// This code is contributed by anuj_67..
<script>
// Javascript implementation of above approach
// Function to find a subarray
// whose sum is a multiple of N
function CheckSubarray(arr, N)
{
// Prefix sum array to store cumulative sum
let presum = new Array(N + 1).fill(0);
// Single state dynamic programming
// relation for prefix sum array
for (let i = 1; i <= N; i += 1) {
presum[i] = presum[i - 1] + arr[i - 1];
}
// Generating all sub-arrays
for (let i = 1; i <= N; i += 1) {
for (let j = i; j <= N; j += 1) {
// If the sum of the sub-array[i:j]
// is a multiple of N
if ((presum[j] - presum[i - 1]) % N == 0) {
document.write((i - 1) + " " + (j - 1));
return;
}
}
}
// If the function reaches here it means
// there are no subarrays with sum
// as a multiple of N
document.write(-1);
}
// Driver code
let arr = [ 7, 5, 3, 7 ];
let N = arr.length;
CheckSubarray(arr, N);
</script>
Time Complexity: O(N2)
Auxiliary Space: O(N)
Efficient Approach: The idea is to use the Pigeon-Hole Principle. Let's suppose the array elements are a1, a2...aN.
For a sequence of numbers as follows:
a1, a1 + a2, a1 + a2 + a3, ..., a1 + a2 +a3 + ... +aN
In the above sequence, there are N terms. There are two possible cases:
- If one of the above prefix sums is a multiple of N then print the ith subarray indices.
- If None of the above sequence elements lies in the 0 modulo class of N, then there are (N - 1) modulo classes left. By the pigeon-hole principle, there are N pigeons (elements of the prefix sum sequence) and (N - 1) holes (modulo classes), we can say that at least two elements would lie in the same modulo class. The difference between these two elements would give a sub-array whose sum will be a multiple of N.
It could be seen that it is always possible to get such a sub-array.
Below is the implementation of the above approach:
C++
// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
// Function to check is there exists a
// subarray whose sum is a multiple of N
void CheckSubarray(int arr[], int N)
{
// Prefix sum array to store cumulative sum
int presum[N + 1] = { 0 };
// Single state dynamic programming
// relation for prefix sum array
for (int i = 1; i <= N; i += 1) {
presum[i] = presum[i - 1] + arr[i - 1];
}
// Modulo class vector
vector<int> moduloclass[N];
// Storing the index value in the modulo class vector
for (int i = 1; i <= N; i += 1) {
moduloclass[presum[i] % N].push_back(i - 1);
}
// If there exists a sub-array with
// starting index equal to zero
if (moduloclass[0].size() > 0) {
cout << 0 << " " << moduloclass[0][0];
return;
}
for (int i = 1; i < N; i += 1) {
// In this class, there are more than two presums%N
// Hence difference of any two subarrays would be a
// multiple of N
if (moduloclass[i].size() >= 2) {
// 0 based indexing
cout << moduloclass[i][0] + 1 << " " << moduloclass[i][1];
return;
}
}
}
// Driver code
int main()
{
int arr[] = { 7, 3, 5, 2 };
int N = sizeof(arr) / sizeof(arr[0]);
CheckSubarray(arr, N);
return 0;
}
// Java implementation of above approach
import java.util.*;
class GFG
{
// Function to check is there exists a
// subarray whose sum is a multiple of N
static void CheckSubarray(int arr[], int N)
{
// Prefix sum array to store cumulative sum
int[] presum = new int[N + 1];
// Single state dynamic programming
// relation for prefix sum array
for (int i = 1; i <= N; i += 1)
{
presum[i] = presum[i - 1] + arr[i - 1];
}
// Modulo class vector
Vector<Integer>[] moduloclass = new Vector[N];
for (int i = 0; i < N; i += 1)
{
moduloclass[i] = new Vector<>();
}
// Storing the index value
// in the modulo class vector
for (int i = 1; i <= N; i += 1)
{
moduloclass[presum[i] % N].add(i - 1);
}
// If there exists a sub-array with
// starting index equal to zero
if (moduloclass[0].size() > 0)
{
System.out.print(0 + " " +
moduloclass[0].get(0));
return;
}
for (int i = 1; i < N; i += 1)
{
// In this class, there are more than
// two presums%N. Hence difference of
// any two subarrays would be a multiple of N
if (moduloclass[i].size() >= 2)
{
// 0 based indexing
System.out.print(moduloclass[i].get(0) + 1 +
" " + moduloclass[i].get(1));
return;
}
}
}
// Driver code
public static void main(String args[])
{
int arr[] = {7, 3, 5, 2};
int N = arr.length;
CheckSubarray(arr, N);
}
}
// This code is contributed by 29AjayKumar
# Python 3 implementation of above approach
# Function to check is there exists a
# subarray whose sum is a multiple of N
def CheckSubarray(arr, N):
# Prefix sum array to store cumulative sum
presum = [0 for i in range(N+1)]
# Single state dynamic programming
# relation for prefix sum array
for i in range(1,N+1):
presum[i] = presum[i - 1] + arr[i - 1]
# Modulo class vector
moduloclass = [[]]*N
# Storing the index value in the modulo class vector
for i in range(1,N+1,1):
moduloclass[presum[i] % N].append(i - 1)
# If there exists a sub-array with
# starting index equal to zero
if (len(moduloclass[0]) > 0):
print(0+1,moduloclass[0][0]+2)
return
for i in range(1,N):
# In this class, there are more than two presums%N
# Hence difference of any two subarrays would be a
# multiple of N
if (len(moduloclass[i]) >= 2):
# 0 based indexing
print(moduloclass[i][0] + 1,moduloclass[i][1])
return
# Driver code
if __name__ == '__main__':
arr = [7, 3, 5, 2]
N = len(arr)
CheckSubarray(arr, N)
# This code is contributed by
# Surendra_Gangwar
// C# implementation of the approach
using System;
using System.Collections.Generic;
class GFG
{
// Function to check is there exists a
// subarray whose sum is a multiple of N
static void CheckSubarray(int []arr, int N)
{
// Prefix sum array to store cumulative sum
int[] presum = new int[N + 1];
// Single state dynamic programming
// relation for prefix sum array
for (int i = 1; i <= N; i += 1)
{
presum[i] = presum[i - 1] + arr[i - 1];
}
// Modulo class vector
List<int>[] moduloclass = new List<int>[N];
for (int i = 0; i < N; i += 1)
{
moduloclass[i] = new List<int>();
}
// Storing the index value
// in the modulo class vector
for (int i = 1; i <= N; i += 1)
{
moduloclass[presum[i] % N].Add(i - 1);
}
// If there exists a sub-array with
// starting index equal to zero
if (moduloclass[0].Count > 0)
{
Console.Write(0 + " " +
moduloclass[0][0]);
return;
}
for (int i = 1; i < N; i += 1)
{
// In this class, there are more than
// two presums%N. Hence difference of
// any two subarrays would be a multiple of N
if (moduloclass[i].Count >= 2)
{
// 0 based indexing
Console.Write(moduloclass[i][0] + 1 +
" " + moduloclass[i][1]);
return;
}
}
}
// Driver code
public static void Main(String []args)
{
int []arr = {7, 3, 5, 2};
int N = arr.Length;
CheckSubarray(arr, N);
}
}
// This code is contributed by Rajput-Ji
<script>
// Javascript implementation of above approach
// Function to check is there exists a
// subarray whose sum is a multiple of N
function CheckSubarray(arr, N)
{
// Prefix sum array to store cumulative sum
let presum = new Array(N + 1);
for(let i = 0; i < (N + 1); i++)
presum[i] = 0;
// Single state dynamic programming
// relation for prefix sum array
for(let i = 1; i <= N; i += 1)
{
presum[i] = presum[i - 1] + arr[i - 1];
}
// Modulo class vector
let moduloclass = new Array(N);
for(let i = 0; i < N; i += 1)
{
moduloclass[i] = [];
}
// Storing the index value
// in the modulo class vector
for(let i = 1; i <= N; i += 1)
{
moduloclass[presum[i] % N].push(i - 1);
}
// If there exists a sub-array with
// starting index equal to zero
if (moduloclass[0].length > 0)
{
document.write(0 + " " +
moduloclass[0][0]);
return;
}
for(let i = 1; i < N; i += 1)
{
// In this class, there are more than
// two presums%N. Hence difference of
// any two subarrays would be a multiple of N
if (moduloclass[i].length >= 2)
{
// 0 based indexing
document.write(moduloclass[i][0] + 1 +
" " + moduloclass[i][1]);
return;
}
}
}
// Driver code
let arr = [ 7, 3, 5, 2 ];
let N = arr.length;
CheckSubarray(arr, N);
// This code is contributed by unknown2108
</script>
Time Complexity: O(n)
Auxiliary Space: O(n)
Similar Reads
Subsequences of size three in an array whose sum is divisible by m
Given an array A[] (1<=A_i <=10^9 ) of size N (1<=N<=10^5 ), find the number of subsequences of length 3 whose sum is divisible by M (1<=M<=10^3 ). Examples: Input : A[] = {1, 2, 4, 3} M = 3 Output : 2 Explanation : We can choose two such subsequence of length 3 such that its sum i
15+ min read
Size of the largest divisible subset in an Array
Given an array arr[] of size N. The task is to find the size of the set of numbers from the given array such that each number divides another or is divisible by another.Examples: Input : arr[] = {3, 4, 6, 8, 10, 18, 21, 24} Output : 3 One of the possible sets with a maximum size is {3, 6, 18} Input
5 min read
Find the maximum range [L,R] whose sum is divisible by M
Given an array arr[] consisting of positive numbers, the task is to find the maximum range [L, R] whose sum is divisible by M. If there is no range present return -1. Examples: Input: arr[] = {3, 7, 5, 2, 5, 10}, M = 3 Output: 1 3 Explanation: Sum of numbers from 1 to 3 is 3+7+5 which is 15. Input :
8 min read
Count pairs in array whose sum is divisible by 4
Given a array if 'n' positive integers. Count number of pairs of integers in the array that have the sum divisible by 4. Examples : Input: {2, 2, 1, 7, 5}Output: 3Explanation:Only three pairs are possible whose sumis divisible by '4' i.e., (2, 2), (1, 7) and (7, 5)Input: {2, 2, 3, 5, 6}Output: 4Reco
9 min read
Count pairs in array whose sum is divisible by K
Given an array A[] and positive integer K, the task is to count the total number of pairs in the array whose sum is divisible by K. Note: This question is a generalized version of this Examples: Input : A[] = {2, 2, 1, 7, 5, 3}, K = 4 Output : 5 Explanation : There are five pairs possible whose sum
10 min read
Smallest subarray whose sum is multiple of array size
Given an array of size N, we need to find the smallest subarray whose sum is divisible by array size N. Examples : Input : arr[] = [1, 1, 2, 2, 4, 2] Output : [2 4] Size of array, N = 6 Following subarrays have sum as multiple of N [1, 1, 2, 2], [2, 4], [1, 1, 2, 2, 4, 2] The smallest among all is [
11 min read
Generate Array whose sum of all K-size subarrays divided by N leaves remainder X
Given three integer N, K and X, the task is to create an array of length N such that sum of all its K-length subarrays modulo N is X.Examples: Input: N = 6, K = 3, X = 3 Output: 9 6 6 9 6 6 Explanation: All subarrays of length 3 and their respective sum%N values are as follows: [9, 6, 6] Sum = 21 %
4 min read
Count of pairs in Array whose product is divisible by K
Given an array A[] and positive integer K, the task is to count the total number of pairs in the array whose product is divisible by K. Examples : Input: A[] = [1, 2, 3, 4, 5], K = 2Output: 7Explanation: The 7 pairs of indices whose corresponding products are divisible by 2 are(0, 1), (0, 3), (1, 2)
9 min read
Subarray with no pair sum divisible by K
Given an array of N non-negative integers, task is to find the maximum size of a subarray such that the pairwise sum of the elements of this subarray is not divisible by a given integer, K. Also, print this subarray as well. If there are two or more subarrays that follow the above stated condition,
13 min read
Generate an Array such that the sum of any Subarray is not divisible by its Length
Given an integer N. Then the task is to output an array let's say A[] of length N such that: The sum S, of any subarray, let's say A[L, R] where (L != R) must not leave the remainder as 0 when dividing by the length of A[L, R]. Formally, Sum(A[L, R])%(length of A[L, R]) != 0. A[] must contain all un
5 min read