# Find if there is any subset of size K with 0 sum in an array of -1 and +1

Given an integer K and an array arr containing only 1 and -1, the task is to find if there is any subset of size K sum of whose elements is 0.

Examples:

Input: arr[] = {1, -1, 1}, K = 2
Output: Yes
{1, -1} is a valid subset

Input: arr[] = {1, 1, -1, -1, 1}, K = 5
Output: No

Approach:

• In order for the sum to be 0, there has to be equal number of 1 and -1 in the subset.
• If K is odd then no subset will satisfy the given condition.
• Else if K is even then we need to choose exactly (K / 2) 1’s and (K / 2) -1’s in order to form the subset so that the sum of all of it’s elements is 0
• So, if K is even and number of 1’s â‰¥ K / 2 and number of -1’s â‰¥ K / 2 then print Yes else print No.

Below is the implementation of the above approach:

## C++

 `// C++ program to find if there is a subset of size``// k with sum 0 in an array of -1 and +1``#include ``using` `namespace` `std;` `// Function to return the number of 1's in the array``int` `countOnes(``int` `n, ``int` `a[])``{``    ``int` `i, count = 0;``    ``for` `(i = 0; i < n; i++)``        ``if` `(a[i] == 1)``            ``count++;``    ``return` `count;``}` `bool` `isSubset(``int` `arr[], ``int` `n, ``int` `k)``{``    ``int` `countPos1 = countOnes(n, arr);``    ``int` `countNeg1 = n - countPos1;` `    ``// If K is even and there are``    ``// at least K/2 1's and -1's``    ``return` `(k % 2 == 0 && countPos1 >= k / 2 && ``                          ``countNeg1 >= k / 2);``}` `// Driver Program to test above function``int` `main()``{``    ``int` `a[] = { 1, 1, -1, -1, 1 };``    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]);``    ``int` `k = 5;``    ``if` `(isSubset(a, n, k))``      ``cout << ``"Yes"``;``    ``else``      ``cout << ``"No"``;``    ``return` `0;``}`

## Java

 `// Java program to find if there is a subset of size``// k with sum 0 in an array of -1 and +1` `import` `java.io.*;` `class` `GFG {``   `  `// Function to return the number of 1's in the array``static` `int` `countOnes(``int` `n, ``int` `a[])``{``    ``int` `i, count = ``0``;``    ``for` `(i = ``0``; i < n; i++)``        ``if` `(a[i] == ``1``)``            ``count++;``    ``return` `count;``}` `static` `boolean` `isSubset(``int` `arr[], ``int` `n, ``int` `k)``{``    ``int` `countPos1 = countOnes(n, arr);``    ``int` `countNeg1 = n - countPos1;` `    ``// If K is even and there are``    ``// at least K/2 1's and -1's``    ``return` `(k % ``2` `== ``0` `&& countPos1 >= k / ``2` `&& ``                        ``countNeg1 >= k / ``2``);``}` `// Driver Program to test above function``public` `static` `void` `main (String[] args) {``        ``int` `[]a = { ``1``, ``1``, -``1``, -``1``, ``1` `};``    ``int` `n = a.length;``    ``int` `k = ``5``;``    ``if` `(isSubset(a, n, k))``     ``System.out.println( ``"Yes"``);``    ``else``    ``System.out.println( ``"No"``);``    ``}``}``// This code is contributed by shs`

## Python3

 `# Python3 program to find if there is ``# a subset of size k with sum 0 in an``# array of -1 and +1 ` `# Function to return the number of``# 1's in the array ``def` `countOnes(n, a): ` `    ``count ``=` `0``    ``for` `i ``in` `range``(``0``, n): ``        ``if` `a[i] ``=``=` `1``: ``            ``count ``+``=` `1``    ``return` `count ` `def` `isSubset(arr, n, k): ` `    ``countPos1 ``=` `countOnes(n, arr) ``    ``countNeg1 ``=` `n ``-` `countPos1 ` `    ``# If K is even and there are ``    ``# at least K/2 1's and -1's ``    ``return` `(k ``%` `2` `=``=` `0` `and` `countPos1 >``=` `k ``/``/` `2` `and``                           ``countNeg1 >``=` `k ``/``/` `2``) ` `# Driver Code``if` `__name__ ``=``=` `"__main__"``: ` `    ``a ``=` `[``1``, ``1``, ``-``1``, ``-``1``, ``1``] ``    ``n ``=` `len``(a) ``    ``k ``=` `5``    ` `    ``if` `isSubset(a, n, k) ``=``=` `True``: ``        ``print``(``"Yes"``) ``    ``else``:``        ``print``(``"No"``) ``    ` `# This code is contributed ``# by Rituraj Jain`

## C#

 `// C# program to find if there is ``// a subset of size k with sum 0``// in an array of -1 and +1``using` `System;` `class` `GFG``{` `// Function to return the number``// of 1's in the array``static` `int` `countOnes(``int` `n, ``int` `[]a)``{``    ``int` `i, count = 0;``    ``for` `(i = 0; i < n; i++)``        ``if` `(a[i] == 1)``            ``count++;``    ``return` `count;``}` `static` `bool` `isSubset(``int` `[]arr,``                     ``int` `n, ``int` `k)``{``    ``int` `countPos1 = countOnes(n, arr);``    ``int` `countNeg1 = n - countPos1;` `    ``// If K is even and there are``    ``// at least K/2 1's and -1's``    ``return` `(k % 2 == 0 && countPos1 >= k / 2 && ``                          ``countNeg1 >= k / 2);``}` `// Driver Code``public` `static` `void` `Main ()``{``    ``int` `[]a = { 1, 1, -1, -1, 1 };``    ``int` `n = a.Length;``    ``int` `k = 5;``    ``if` `(isSubset(a, n, k))``        ``Console.WriteLine( ``"Yes"``);``    ``else``        ``Console.WriteLine( ``"No"``);``}``}` `// This code is contributed by shs`

## Javascript

 ``

## PHP

 `= ``\$k` `/ 2 && ``                           ``\$countNeg1` `>= ``\$k` `/ 2);``}` `// Driver Code``\$a` `= ``array``(1, 1, -1, -1, 1);``\$n` `= sizeof(``\$a``);``\$k` `= 5;` `if` `(isSubset(``\$a``, ``\$n``, ``\$k``))``    ``echo` `"Yes"``;``else``    ``echo` `"No"``;` `// This code is contributed``// by Akanksha Rai``?>`

Output
```No

```

Time Complexity: O(n)

Approach:

• Approach to solve this problem could be to use a sliding window technique and keep track of the sum of the elements in the window.
• We can start by initializing two pointers, left and right, and a variable sum to 0.
• Then we can move the right pointer to the right until the window size is K.
• If the sum of the elements in the window is 0, we can return true as we have found a subset of size K with sum 0.
• Otherwise, we can move the left pointer to the right and subtract the element at the left pointer from the sum, and continue this process until we have found a subset of size K with sum 0 or until the window size is less than K.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `bool` `isSubset(``int` `arr[], ``int` `n, ``int` `k) {``    ``int` `left = 0, right = 0, sum = 0;``    ``while` `(right < n) {``        ``sum += arr[right];``        ``if` `(right - left + 1 == k) {``            ``if` `(sum == 0) {``                ``return` `true``;``            ``}``            ``sum -= arr[left];``            ``left++;``        ``}``        ``right++;``    ``}``    ``return` `false``;``}` `int` `main() {``    ``int` `a[] = {1, 1, -1, -1, 1};``    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]);``    ``int` `k = 5;``    ``if` `(isSubset(a, n, k)) {``        ``cout << ``"Yes"``;``    ``} ``else` `{``        ``cout << ``"No"``;``    ``}``    ``return` `0;``}`

## Java

 `public` `class` `Main {``    ``public` `static` `boolean` `isSubset(``int``[] arr, ``int` `n, ``int` `k) {``        ``int` `left = ``0``, right = ``0``, sum = ``0``;``        ``while` `(right < n) {``          ``// Add the current element to the sum``            ``sum += arr[right];  ``            ``if` `(right - left + ``1` `== k) {  ``// If the window size is equal to k``                ``if` `(sum == ``0``) {  ``// If the sum of the window elements is 0``                    ``return` `true``;  ``// The subset with sum 0 is found``                ``}``                ``sum -= arr[left];  ``// Subtract the leftmost element from the sum``                ``left++;  ``// Slide the window to the right by incrementing left``            ``}``            ``right++;  ``// Slide the window to the right by incrementing right``        ``}``        ``return` `false``;  ``// No subset with sum 0 found``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``int``[] a = {``1``, ``1``, -``1``, -``1``, ``1``};``        ``int` `n = a.length;``        ``int` `k = ``5``;``        ``if` `(isSubset(a, n, k)) {``            ``System.out.println(``"Yes"``);  ``// Subset with sum 0 is found``        ``} ``else` `{``            ``System.out.println(``"No"``);  ``// Subset with sum 0 is not found``        ``}``    ``}``}`

## Python3

 `def` `isSubset(arr, n, k):``    ``left, right, total_sum ``=` `0``, ``0``, ``0``    ``while` `right < n:``        ``# Add the current element to the sum``        ``total_sum ``+``=` `arr[right]``        ``if` `right ``-` `left ``+` `1` `=``=` `k:  ``# If the window size is equal to k``            ``if` `total_sum ``=``=` `0``:  ``# If the sum of the window elements is 0``                ``return` `True`  `# The subset with sum 0 is found``            ``# Subtract the leftmost element from the sum``            ``total_sum ``-``=` `arr[left]``            ``left ``+``=` `1`  `# Slide the window to the right by incrementing left``        ``right ``+``=` `1`  `# Slide the window to the right by incrementing right``    ``return` `False`  `# No subset with sum 0 found`  `def` `main():``    ``a ``=` `[``1``, ``1``, ``-``1``, ``-``1``, ``1``]``    ``n ``=` `len``(a)``    ``k ``=` `5``    ``if` `isSubset(a, n, k):``        ``print``(``"Yes"``)  ``# Subset with sum 0 is found``    ``else``:``        ``print``(``"No"``)  ``# Subset with sum 0 is not found`  `if` `__name__ ``=``=` `"__main__"``:``    ``main()``# This code is contributed by akshitaguprzj3`

## C#

 `using` `System;` `public` `class` `GFG {``    ``public` `static` `bool` `IsSubset(``int``[] arr, ``int` `n, ``int` `k)``    ``{``        ``int` `left = 0, right = 0, sum = 0;``        ``while` `(right < n) {``            ``// Add the current element to the sum``            ``sum += arr[right];``            ``if` `(right - left + 1``                ``== k) ``// If the window size is equal to k``            ``{``                ``if` `(sum == 0) ``// If the sum of the window``                              ``// elements is 0``                ``{``                    ``return` `true``; ``// The subset with sum 0 is``                                 ``// found``                ``}``                ``sum -= arr[left]; ``// Subtract the leftmost``                                  ``// element from the sum``                ``left++; ``// Slide the window to the right by``                        ``// incrementing left``            ``}``            ``right++; ``// Slide the window to the right by``                     ``// incrementing right``        ``}``        ``return` `false``; ``// No subset with sum 0 found``    ``}` `    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``int``[] a = { 1, 1, -1, -1, 1 };``        ``int` `n = a.Length;``        ``int` `k = 5;``        ``if` `(IsSubset(a, n, k)) {``            ``Console.WriteLine(``                ``"Yes"``); ``// Subset with sum 0 is found``        ``}``        ``else` `{``            ``Console.WriteLine(``                ``"No"``); ``// Subset with sum 0 is not found``        ``}``    ``}``}` `// This code is contributed by akshitaguprzj3`

## Javascript

 `function` `isSubset(arr, n, k) {``    ``let left = 0;``    ``let right = 0;``    ``let sum = 0;``    ` `    ``while` `(right < n) {``        ``// Add the current element to the sum``        ``sum += arr[right];` `        ``if` `(right - left + 1 === k) {``            ``// If the window size is equal to k``            ``if` `(sum === 0) {``                ``// If the sum of the window elements is 0``                ``return` `true``; ``// The subset with sum 0 is found``            ``}``            ``sum -= arr[left];``            ``// Subtract the leftmost element from the sum``            ``left++;``            ``// Slide the window to the right by incrementing left``        ``}``        ``right++;``        ``// Slide the window to the right by incrementing right``    ``}``    ` `    ``return` `false``; ``// No subset with sum 0 found``}` `// Main function``function` `main() {``    ``const a = [1, 1, -1, -1, 1];``    ``const n = a.length;``    ``const k = 5;``    ` `    ``if` `(isSubset(a, n, k)) {``        ``console.log(``"Yes"``); ``// Subset with sum 0 is found``    ``} ``else` `{``        ``console.log(``"No"``); ``// Subset with sum 0 is not found``    ``}``}` `main();`

Output
```No

```

Time Complexity: O(N), where N is the size of the input array, as we iterate over the array at most twice.
Space Complexity: O(1), as we only use a constant amount of extra space to store the pointers and the sum variable.

Previous
Next