Smallest subarray whose sum is multiple of array size
Last Updated :
18 Sep, 2023
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 [2 4]
We can solve this problem considering the below facts,
Let S[i] denotes sum of first i elements i.e.
S[i] = a[1] + a[2] .. + a[i]
Now subarray arr(i, i + x) has sum multiple of N then,
(arr(i] + arr[i+1] + .... + arr[i + x])) % N = 0
(S[i+x] – S[i] ) % N = 0
S[i] % N = S[i + x] % N
We need to find the minimum value of x for which the above condition holds. This can be implemented in a single iteration with O(N) time-complexity using another array modIdx of size N. Array modIdx is initialized with all elements as -1. modIdx[k] is to be updated with i in each iteration, where k = sum % N.
Now in each iteration, we need to update modIdx[k] according to the value of sum % N.
We need to check two things,
If at any instant k = 0 and it is the first time we are updating modIdx[0] (i.e. modIdx[0] was -1)
Then we assign x to i + 1, because (i + 1) will be the length of subarray whose sum is multiple of N
In another case whenever we get a mod value, if this index is not -1, that means it is updated by some other sum value, whose index is stored at that index, we update x with this difference value, i.e. by i - modIdx[k].
After each above operation, we update the minimum value of length and corresponding starting index and end index for the subarray. Finally, this gives the solution to our problem.
Implementation:
C++
// C++ program to find subarray whose sum
// is multiple of size
#include <bits/stdc++.h>
using namespace std;
// Method prints smallest subarray whose sum is
// multiple of size
void printSubarrayMultipleOfN(int arr[], int N)
{
// A direct index table to see if sum % N
// has appeared before or not.
int modIdx[N];
// initialize all mod index with -1
for (int i = 0; i < N; i++)
modIdx[i] = -1;
// initializing minLen and curLen with larger
// values
int minLen = N + 1;
int curLen = N + 1;
// To store sum of array elements
int sum = 0;
// looping for each value of array
int l, r;
for (int i = 0; i < N; i++)
{
sum += arr[i];
sum %= N;
// If this is the first time we have
// got mod value as 0, then S(0, i) % N
// == 0
if (modIdx[sum] == -1 && sum == 0)
curLen = i + 1;
// If we have reached this mod before then
// length of subarray will be i - previous_position
if (modIdx[sum] != -1)
curLen = i - modIdx[sum];
// choose minimum length as subarray till now
if (curLen < minLen)
{
minLen = curLen;
// update left and right indices of subarray
l = modIdx[sum] + 1;
r = i;
}
modIdx[sum] = i;
}
// print subarray
for (int i = l; i <= r; i++)
cout << arr[i] << " ";
cout << endl;
}
// Driver code to test above method
int main()
{
int arr[] = {1, 1, 2, 2, 4, 2};
int N = sizeof(arr) / sizeof(int);
printSubarrayMultipleOfN(arr, N);
return 0;
}
// Java program to find subarray whose sum
// is multiple of size
class GFG {
// Method prints smallest subarray whose sum is
// multiple of size
static void printSubarrayMultipleOfN(int arr[],
int N)
{
// A direct index table to see if sum % N
// has appeared before or not.
int modIdx[] = new int[N];
// initialize all mod index with -1
for (int i = 0; i < N; i++)
modIdx[i] = -1;
// initializing minLen and curLen with
// larger values
int minLen = N + 1;
int curLen = N + 1;
// To store sum of array elements
int sum = 0;
// looping for each value of array
int l = 0, r = 0;
for (int i = 0; i < N; i++) {
sum += arr[i];
sum %= N;
// If this is the first time we
// have got mod value as 0, then
// S(0, i) % N == 0
if (modIdx[sum] == -1 && sum == 0)
curLen = i + 1;
// If we have reached this mod before
// then length of subarray will be i
// - previous_position
if (modIdx[sum] != -1)
curLen = i - modIdx[sum];
// choose minimum length as subarray
// till now
if (curLen < minLen) {
minLen = curLen;
// update left and right indices
// of subarray
l = modIdx[sum] + 1;
r = i;
}
modIdx[sum] = i;
}
// print subarray
for (int i = l; i <= r; i++)
System.out.print(arr[i] + " ");
System.out.println();
}
// Driver program
public static void main(String arg[])
{
int arr[] = { 1, 1, 2, 2, 4, 2 };
int N = arr.length;
printSubarrayMultipleOfN(arr, N);
}
}
// This code is contributed by Anant Agarwal.
# Python3 program to find subarray
# whose sum is multiple of size
# Method prints smallest subarray
# whose sum is multiple of size
def printSubarrayMultipleOfN(arr, N):
# A direct index table to see if sum % N
# has appeared before or not.
modIdx = [0 for i in range(N)]
# initialize all mod index with -1
for i in range(N):
modIdx[i] = -1
# initializing minLen and curLen
# with larger values
minLen = N + 1
curLen = N + 1
# To store sum of array elements
sum = 0
# looping for each value of array
l = 0; r = 0
for i in range(N):
sum += arr[i]
sum %= N
# If this is the first time we have
# got mod value as 0, then S(0, i) % N
# == 0
if (modIdx[sum] == -1 and sum == 0):
curLen = i + 1
# If we have reached this mod before then
# length of subarray will be i - previous_position
if (modIdx[sum] != -1):
curLen = i - modIdx[sum]
# choose minimum length as subarray till now
if (curLen < minLen):
minLen = curLen
# update left and right indices of subarray
l = modIdx[sum] + 1
r = i
modIdx[sum] = i
# print subarray
for i in range(l, r + 1):
print(arr[i] , " ", end = "")
print()
# Driver program
arr = [1, 1, 2, 2, 4, 2]
N = len(arr)
printSubarrayMultipleOfN(arr, N)
# This code is contributed by Anant Agarwal.
// C# program to find subarray whose sum
// is multiple of size
using System;
class GFG {
// Method prints smallest subarray whose sum is
// multiple of size
static void printSubarrayMultipleOfN(int []arr,
int N)
{
// A direct index table to see if sum % N
// has appeared before or not.
int []modIdx = new int[N];
// initialize all mod index with -1
for (int i = 0; i < N; i++)
modIdx[i] = -1;
// initializing minLen and curLen with
// larger values
int minLen = N + 1;
int curLen = N + 1;
// To store sum of array elements
int sum = 0;
// looping for each value of array
int l = 0, r = 0;
for (int i = 0; i < N; i++) {
sum += arr[i];
sum %= N;
// If this is the first time we
// have got mod value as 0, then
// S(0, i) % N == 0
if (modIdx[sum] == -1 && sum == 0)
curLen = i + 1;
// If we have reached this mod before
// then length of subarray will be i
// - previous_position
if (modIdx[sum] != -1)
curLen = i - modIdx[sum];
// choose minimum length as subarray
// till now
if (curLen < minLen) {
minLen = curLen;
// update left and right indices
// of subarray
l = modIdx[sum] + 1;
r = i;
}
modIdx[sum] = i;
}
// print subarray
for (int i = l; i <= r; i++)
Console.Write(arr[i] + " ");
Console.WriteLine();
}
// Driver Code
public static void Main()
{
int []arr = {1, 1, 2, 2, 4, 2};
int N = arr.Length;
printSubarrayMultipleOfN(arr, N);
}
}
// This code is contributed by nitin mittal.
<?php
// PHP program to find subarray
// whose sum is multiple of size
// Method prints smallest subarray
// whose sum is multiple of size
function printSubarrayMultipleOfN($arr,
$N)
{
// A direct index table to see
// if sum % N has appeared
// before or not.
$modIdx = array();
// initialize all mod
// index with -1
for ($i = 0; $i < $N; $i++)
$modIdx[$i] = -1;
// initializing minLen and
// curLen with larger values
$minLen = $N + 1;
$curLen = $N + 1;
// To store sum of
// array elements
$sum = 0;
// looping for each
// value of array
$l; $r;
for ($i = 0; $i < $N; $i++)
{
$sum += $arr[$i];
$sum %= $N;
// If this is the first time
// we have got mod value as 0,
// then S(0, i) % N == 0
if ($modIdx[$sum] == -1 &&
$sum == 0)
$curLen = $i + 1;
// If we have reached this mod
// before then length of subarray
// will be i - previous_position
if ($modIdx[$sum] != -1)
$curLen = $i - $modIdx[$sum];
// choose minimum length
// as subarray till now
if ($curLen < $minLen)
{
$minLen = $curLen;
// update left and right
// indices of subarray
$l = $modIdx[$sum] + 1;
$r = $i;
}
$modIdx[$sum] = $i;
}
// print subarray
for ($i = $l; $i <= $r; $i++)
echo $arr[$i] , " ";
echo "\n" ;
}
// Driver Code
$arr = array(1, 1, 2, 2, 4, 2);
$N = count($arr);
printSubarrayMultipleOfN($arr, $N);
// This code is contributed by anuj_67.
?>
<script>
// Javascript program to find subarray whose sum
// is multiple of size
// Method prints smallest subarray whose sum is
// multiple of size
function printSubarrayMultipleOfN(arr, N)
{
// A direct index table to see if sum % N
// has appeared before or not.
let modIdx = new Array(N);
// initialize all mod index with -1
for (let i = 0; i < N; i++)
modIdx[i] = -1;
// initializing minLen and curLen with
// larger values
let minLen = N + 1;
let curLen = N + 1;
// To store sum of array elements
let sum = 0;
// looping for each value of array
let l = 0, r = 0;
for (let i = 0; i < N; i++) {
sum += arr[i];
sum %= N;
// If this is the first time we
// have got mod value as 0, then
// S(0, i) % N == 0
if (modIdx[sum] == -1 && sum == 0)
curLen = i + 1;
// If we have reached this mod before
// then length of subarray will be i
// - previous_position
if (modIdx[sum] != -1)
curLen = i - modIdx[sum];
// choose minimum length as subarray
// till now
if (curLen < minLen) {
minLen = curLen;
// update left and right indices
// of subarray
l = modIdx[sum] + 1;
r = i;
}
modIdx[sum] = i;
}
// print subarray
for (let i = l; i <= r; i++)
document.write(arr[i] + " ");
document.write("</br>");
}
let arr = [1, 1, 2, 2, 4, 2];
let N = arr.length;
printSubarrayMultipleOfN(arr, N);
</script>
Time Complexity: O(N)
Auxiliary Space: O(N)
Similar Reads
Smallest subarray with positive sum for all indices
Given an array arr[] of size N. The task is to determine the minimum length of a subarray starting from index i, such that the sum of the subarray is strictly greater than 0. Calculate the length for all i's in the range 1 to N. If no such subarray exists, then return 0. Examples: Input: N = 3, arr[
8 min read
Smallest Subarray with Sum K from an Array
Given an array arr[] consisting of N integers, the task is to find the length of the Smallest subarray with a sum equal to K. Examples: Input: arr[] = {2, 4, 6, 10, 2, 1}, K = 12 Output: 2 Explanation: All possible subarrays with sum 12 are {2, 4, 6} and {10, 2}. Input: arr[] = {-8, -8, -3, 8}, K =
10 min read
Find a subarray whose sum is divisible by size of the array
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[] =
13 min read
Length of the smallest subarray with maximum possible sum
Given an array arr[] consisting of N non-negative integers, the task is to find the minimum length of the subarray whose sum is maximum. Example: Input: arr[] = {0, 2, 0, 0, 12, 0, 0, 0}Output: 4Explanation: The sum of the subarray {2, 0, 0, 12} = 2 + 0 + 0 + 12 = 14, which is maximum sum possible a
6 min read
Smallest sum contiguous subarray | Set-2
Given an array containing N integers. The task is to find the sum of the elements of the contiguous subarray having the smallest(minimum) sum.Examples: Input: arr[] = {3, -4, 2, -3, -1, 7, -5} Output:-6 Input: arr = {2, 6, 8, 1, 4} Output: 1 An approach has already been discussed in the previous pos
5 min read
Smallest subarray whose product leaves remainder K when divided by size of the array
Given an array arr[] of N integers and an integer K, the task is to find the length of the smallest subarray whose product when divided by N gives remainder K. If no such subarray exists the print "-1". Examples: Input: N = 3, arr = {2, 2, 6}, K = 1 Output: 2 Explanation: All possible subarrays are:
6 min read
Longest Subarray With Sum Divisible By K
Given an arr[] containing n integers and a positive integer k, he problem is to find the longest subarray's length with the sum of the elements divisible by k.Examples:Input: arr[] = [2, 7, 6, 1, 4, 5], k = 3Output: 4Explanation: The subarray [7, 6, 1, 4] has sum = 18, which is divisible by 3.Input:
10 min read
Subarray whose absolute sum is closest to K
Given an array of n non-negative elements and an integer K, the task is to find the contiguous subarray whose sum of elements shows the minimum deviation from K. In other words, find the subarray whose absolute sum is closest to K. Example Input: arr[] = {1, 3, 7, 10}, K = 15Output: 7 10Explanation:
10 min read
Smallest subarray which upon repetition gives the original array
Given an array arr[] of N integers, the task is to find the smallest subarray brr[] of size at least 2 such that by performing repeating operation on the array brr[] gives the original array arr[]. Print "-1" if it is not possible to find such a subarray. A repeating operation on an array is to appe
8 min read
Smallest subarray from a given Array with sum greater than or equal to K | Set 2
Given an array A[] consisting of N positive integers and an integer K, the task is to find the length of the smallest subarray with a sum greater than or equal to K. If no such subarray exists, print -1. Examples: Input: arr[] = {3, 1, 7, 1, 2}, K = 11Output: 3Explanation:The smallest subarray with
15+ min read