Given an array of N integers, the task is to find a non-empty subset such that the sum of elements of the subset is divisible by N. Output any such subset with its size and the indices(1-based indexing) of elements in the original array if it exists. **Prerequisites:** Pigeonhole Principle**Examples:**

Input: arr[] = { 2, 3, 7, 1, 9 } Output: 2 1 2 The required subset is { 2, 3 } whose indices are 1 and 2. Input: arr[] = {2, 11, 4} Output: 2 2 3

A naive approach will be to generate all possible subsets by using the Power Set of the given array, calculate their respective sums and check if the sum is divisible by N. **Time Complexity:** O(2^{N} * N), O(2^{N}) for generating all subsets, and O(N) for calculating the sum of every subset.**Efficient Approach:** On considering Prefix Sums, we obtain:

prefixSum

_{0}= arr_{0}

prefixSum_{1}= arr_{0}+ arr_{1}

prefixSum_{2}= arr_{0}+ arr_{1}+ arr_{2}

…

prefixSum_{N}= arr_{0}+ arr_{1}+ arr_{2}+ … + arr_{N}

It can be seen easily that arr_{L}+ arr_{L+1}+ … + arr_{R}(L ≤ R) equals to prefixSum_{R}–

prefixSum_{L-1}. If the sum of any contiguous subsegment is divisible by N, then it

means the residue upon taking modulo N of prefixSum_{R}– prefixSum_{L-1}

is zero, i.e.

(prefixSum_{R}– prefixSum_{L-1}) % N = 0;

Splitting the modulo,

prefixSum_{R}% N – prefixSum_{L-1}% N = 0

prefixSum_{R}% N = prefixSum_{L-1}% N.

Since there are (N) values of prefixSums and N possible residues for N (0, 1, 2 … N-2, N-1). Hence, according to the pigeonhole principle there always exists a contiguous subsegment whose prefixSum extremities are equal. If at any instance, prefix_{L}, then the first L indexes will give the subset.

Below is the implementation of the above approach:

## C++

`// CPP Program to find Non empty` `// subset such that its elements' sum` `// is divisible by N` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to print the subset index and size` `void` `findNonEmptySubset(` `int` `arr[], ` `int` `N)` `{` ` ` `// Hash Map to store the indices of residue upon` ` ` `// taking modulo N of prefixSum` ` ` `unordered_map<` `int` `, ` `int` `> mp;` ` ` `int` `sum = 0;` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// Calculating the residue of prefixSum` ` ` `sum = (sum + arr[i]) % N;` ` ` `// If the pre[i]%n==0` ` ` `if` `(sum == 0) {` ` ` `// print size` ` ` `cout << i + 1 << endl;` ` ` `// Print the first i indices` ` ` `for` `(` `int` `j = 0; j <= i; j++)` ` ` `cout << j + 1 << ` `" "` `;` ` ` `return` `;` ` ` `}` ` ` `// If this sum was seen earlier, then` ` ` `// the contiguous subsegment has been found` ` ` `if` `(mp.find(sum) != mp.end()) {` ` ` `// Print the size of subset` ` ` `cout << (i - mp[sum]) << endl;` ` ` `// Print the indices of contiguous subset` ` ` `for` `(` `int` `j = mp[sum] + 1; j <= i; j++)` ` ` `cout << j + 1 << ` `" "` `;` ` ` `return` `;` ` ` `}` ` ` `else` ` ` `mp[sum] = i;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 2, 3, 7, 1, 9 };` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `findNonEmptySubset(arr, N);` ` ` `return` `0;` `}` |

## Java

`// Java Program to find Non ` `// empty subset such that ` `// its elements' sum is ` `// divisible by N` `import` `java.io.*;` `import` `java.util.HashMap;` `import` `java.util.Map.Entry;` `import` `java.util.Map;` `import` `java.lang.*;` `class` `GFG` `{` ` ` `// Function to print the` `// subset index and size` `static` `void` `findNonEmptySubset(` `int` `arr[], ` ` ` `int` `N)` `{` ` ` `// Hash Map to store the` ` ` `// indices of residue upon` ` ` `// taking modulo N of prefixSum` ` ` `HashMap<Integer, Integer> mp = ` ` ` `new` `HashMap<Integer, Integer>();` ` ` `int` `sum = ` `0` `;` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++) ` ` ` `{` ` ` `// Calculating the` ` ` `// residue of prefixSum` ` ` `sum = (sum + arr[i]) % N;` ` ` `// If the pre[i]%n==0` ` ` `if` `(sum == ` `0` `) ` ` ` `{` ` ` `// print size` ` ` `System.out.print(i + ` `1` `+ ` `"\n"` `);` ` ` `// Print the first i indices` ` ` `for` `(` `int` `j = ` `0` `; j <= i; j++)` ` ` `System.out.print(j + ` `1` `+ ` `" "` `);` ` ` `return` `;` ` ` `}` ` ` `// If this sum was seen ` ` ` `// earlier, then the ` ` ` `// contiguous subsegment` ` ` `// has been found` ` ` `if` `(mp.containsKey(sum) == ` `true` `) ` ` ` `{` ` ` `// Print the size of subset` ` ` `System.out.println((i - ` ` ` `mp.get(sum)));` ` ` `// Print the indices of` ` ` `// contiguous subset` ` ` `for` `(` `int` `j = mp.get(sum) + ` `1` `; ` ` ` `j <= i; j++)` ` ` `System.out.print(j + ` `1` `+ ` `" "` `);` ` ` `return` `;` ` ` `}` ` ` `else` ` ` `mp.put(sum,i);` ` ` `}` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `int` `arr[] = { ` `2` `, ` `3` `, ` `7` `, ` `1` `, ` `9` `};` ` ` `int` `N = arr.length;` ` ` `findNonEmptySubset(arr, N);` `}` `}` |

## Python3

`# Python3 Program to find Non ` `# empty subset such that its ` `# elements' sum is divisible ` `# by N ` `# Function to print the subset ` `# index and size ` `def` `findNonEmptySubset(arr, N): ` ` ` `# Hash Map to store the indices ` ` ` `# of residue upon taking modulo ` ` ` `# N of prefixSum ` ` ` `mp ` `=` `{}` ` ` `Sum` `=` `0` ` ` `for` `i ` `in` `range` `(N):` ` ` `# Calculating the residue of ` ` ` `# prefixSum ` ` ` `Sum` `=` `(` `Sum` `+` `arr[i]) ` `%` `N` ` ` `# If the pre[i]%n==0 ` ` ` `if` `(` `Sum` `=` `=` `0` `) : ` ` ` `# print size ` ` ` `print` `(i ` `+` `1` `) ` ` ` `# Print the first i indices ` ` ` `for` `j ` `in` `range` `(i ` `+` `1` `): ` ` ` `print` `(j ` `+` `1` `, end ` `=` `" "` `) ` ` ` `return` ` ` `# If this sum was seen earlier,` ` ` `# then the contiguous subsegment ` ` ` `# has been found ` ` ` `if` `Sum` `in` `mp : ` ` ` ` ` `# Print the size of subset ` ` ` `print` `((i ` `-` `mp[` `Sum` `])) ` ` ` `# Print the indices of contiguous` ` ` `# subset ` ` ` `for` `j ` `in` `range` `(mp[` `Sum` `] ` `+` `1` `, ` ` ` `i ` `+` `1` `):` ` ` `print` `(j ` `+` `1` `, end ` `=` `" "` `)` ` ` `return` ` ` `else` `:` ` ` `mp[` `Sum` `] ` `=` `i` ` ` `# Driver code ` `arr ` `=` `[` `2` `, ` `3` `, ` `7` `, ` `1` `, ` `9` `]` `N ` `=` `len` `(arr) ` `findNonEmptySubset(arr, N)` `# This code is contributed by divyeshrabadiya07` |

## C#

`// C# Program to find Non ` `// empty subset such that ` `// its elements' sum is ` `// divisible by N ` `using` `System;` `using` `System.Collections ;` `class` `GFG ` `{ ` ` ` `// Function to print the ` ` ` `// subset index and size ` ` ` `static` `void` `findNonEmptySubset(` `int` `[]arr, ` `int` `N) ` ` ` `{ ` ` ` ` ` `// Hash Map to store the ` ` ` `// indices of residue upon ` ` ` `// taking modulo N of prefixSum ` ` ` `Hashtable mp = ` `new` `Hashtable(); ` ` ` ` ` `int` `sum = 0; ` ` ` `for` `(` `int` `i = 0; i < N; i++) ` ` ` `{ ` ` ` `// Calculating the ` ` ` `// residue of prefixSum ` ` ` `sum = (sum + arr[i]) % N; ` ` ` ` ` `// If the pre[i]%n==0 ` ` ` `if` `(sum == 0) ` ` ` `{ ` ` ` `// print size ` ` ` `Console.Write(i + 1 + ` `"\n"` `); ` ` ` ` ` `// Print the first i indices ` ` ` `for` `(` `int` `j = 0; j <= i; j++) ` ` ` `Console.Write(j + 1 + ` `" "` `); ` ` ` `return` `; ` ` ` `} ` ` ` ` ` `// If this sum was seen ` ` ` `// earlier, then the ` ` ` `// contiguous subsegment ` ` ` `// has been found ` ` ` `if` `(mp.ContainsKey(sum) == ` `true` `) ` ` ` `{ ` ` ` `// Print the size of subset ` ` ` `Console.WriteLine(i - Convert.ToInt32(mp[sum])); ` ` ` ` ` `// Print the indices of ` ` ` `// contiguous subset ` ` ` `for` `(` `int` `j = Convert.ToInt32(mp[sum]) + 1; ` ` ` `j <= i; j++) ` ` ` `Console.Write(j + 1 + ` `" "` `); ` ` ` ` ` `return` `; ` ` ` `} ` ` ` `else` ` ` `mp.Add(sum,i); ` ` ` `} ` ` ` `} ` ` ` ` ` `// Driver Code ` ` ` `public` `static` `void` `Main() ` ` ` `{ ` ` ` `int` `[]arr = { 2, 3, 7, 1, 9 }; ` ` ` `int` `N = arr.Length; ` ` ` ` ` `findNonEmptySubset(arr, N); ` ` ` `} ` ` ` `// This code is contributed by Ryuga` `} ` |

**Output:**

2 1 2

**Time Complexity: **O(N), where N is the size of array.

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.