Count of Ways to obtain given Sum from the given Array elements
Last Updated :
14 Jun, 2021
Given an array arr[], consisting of N non-negative integers and an integer S, the task is to find the number of ways to obtain the sum S by adding or subtracting array elements.
Note: All the array elements need to be involved in generating the sum.
Examples:
Input: arr[] = {1, 1, 1, 1, 1}, S = 3
Output: 5
Explanation:
Following are the possible ways to obtain the sum S:
- -1 + 1 + 1 + 1 + 1 = 3
- 1 -1 + 1 + 1 + 1 = 3
- 1 + 1 - 1 + 1 + 1 = 3
- 1 + 1 + 1 - 1 + 1 = 3
- 1 + 1 + 1 + 1 - 1 = 3
Input: arr[] = {1, 2, 3, 4, 5}, S = 3
Output: 3
Explanation:
Following are the possible ways to obtain the sum S:
- -1 -2 -3 + 4 + 5 = 3
- -1 + 2 + 3 + 4 - 5 = 3
- 1 - 2 + 3 - 4 + 5 = 3
Recursive Approach: It can be observed that each array element can either be added or subtracted to obtain sum. Therefore, for each array element, recursively check for both the possibilities and increase count when sum S is obtained after reaching the end of the array.
Below is the implementation of the above approach:
C++
// C++ program to implement
// the above approach
#include<bits/stdc++.h>
using namespace std;
// Function to count the number of ways
int dfs(int nums[], int S, int curr_sum,
int index, int n)
{
// Base Case: Reached the
// end of the array
if (index == n)
{
// Sum is equal to the
// required sum
if (S == curr_sum)
return 1;
else
return 0;
}
// Recursively check if required sum
// can be obtained by adding current
// element or by subtracting the
// current index element
return dfs(nums, S, curr_sum + nums[index],
index + 1, n) +
dfs(nums, S, curr_sum - nums[index],
index + 1, n);
}
// Function to call dfs() to
// calculate the number of ways
int findWays(int nums[], int S, int n)
{
return dfs(nums, S, 0, 0, n);
}
// Driver Code
int main()
{
int S = 3;
int arr[] = { 1, 2, 3, 4, 5 };
int n = sizeof(arr) / sizeof(arr[0]);
int answer = findWays(arr, S, n);
cout << (answer);
return 0;
}
// This code is contributed by chitranayal
// Java Program to implement
// the above approach
import java.io.*;
class GFG {
// Function to call dfs() to
// calculate the number of ways
static int findWays(int[] nums, int S)
{
return dfs(nums, S, 0, 0);
}
// Function to count the number of ways
static int dfs(int[] nums, int S,
int curr_sum, int index)
{
// Base Case: Reached the
// end of the array
if (index == nums.length) {
// Sum is equal to the
// required sum
if (S == curr_sum)
return 1;
else
return 0;
}
// Recursively check if required sum
// can be obtained by adding current
// element or by subtracting the
// current index element
return dfs(nums, S, curr_sum + nums[index],
index + 1)
+ dfs(nums, S, curr_sum - nums[index],
index + 1);
}
// Driver Code
public static void main(String[] args)
{
int S = 3;
int[] arr = new int[] { 1, 2, 3, 4, 5 };
int answer = findWays(arr, S);
System.out.println(answer);
}
}
# Python3 program to implement
# the above approach
# Function to count the number of ways
def dfs(nums, S, curr_sum, index):
# Base Case: Reached the
# end of the array
if (index == len(nums)):
# Sum is equal to the
# required sum
if (S == curr_sum):
return 1;
else:
return 0;
# Recursively check if required sum
# can be obtained by adding current
# element or by subtracting the
# current index element
return (dfs(nums, S, curr_sum + nums[index],
index + 1) +
dfs(nums, S, curr_sum - nums[index],
index + 1));
# Function to call dfs() to
# calculate the number of ways
def findWays(nums, S):
return dfs(nums, S, 0, 0);
# Driver Code
if __name__ == '__main__':
S = 3;
arr = [1, 2, 3, 4, 5];
answer = findWays(arr, S);
print(answer);
# This code is contributed by amal kumar choubey
// C# Program to implement
// the above approach
using System;
class GFG{
// Function to call dfs() to
// calculate the number of ways
static int findWays(int[] nums, int S)
{
return dfs(nums, S, 0, 0);
}
// Function to count the number of ways
static int dfs(int[] nums, int S,
int curr_sum, int index)
{
// Base Case: Reached the
// end of the array
if (index == nums.Length)
{
// Sum is equal to the
// required sum
if (S == curr_sum)
return 1;
else
return 0;
}
// Recursively check if required sum
// can be obtained by adding current
// element or by subtracting the
// current index element
return dfs(nums, S, curr_sum +
nums[index], index + 1) +
dfs(nums, S, curr_sum -
nums[index], index + 1);
}
// Driver Code
public static void Main(String[] args)
{
int S = 3;
int[] arr = new int[] { 1, 2, 3, 4, 5 };
int answer = findWays(arr, S);
Console.WriteLine(answer);
}
}
// This code is contributed by Rajput-Ji
<script>
// Javascript Program to implement
// the above approach
// Function to call dfs() to
// calculate the number of ways
function findWays(nums, S)
{
return dfs(nums, S, 0, 0);
}
// Function to count the number of ways
function dfs(nums, S, curr_sum, index)
{
// Base Case: Reached the
// end of the array
if (index == nums.length)
{
// Sum is equal to the
// required sum
if (S == curr_sum)
return 1;
else
return 0;
}
// Recursively check if required sum
// can be obtained by adding current
// element or by subtracting the
// current index element
return dfs(nums, S, curr_sum +
nums[index], index + 1) +
dfs(nums, S, curr_sum -
nums[index], index + 1);
}
let S = 3;
let arr = [ 1, 2, 3, 4, 5 ];
let answer = findWays(arr, S);
document.write(answer);
</script>
Time Complexity: O(2N)
Auxiliary Space: O(1)
Dynamic Programming Approach: The above recursive approach can be optimized by using Memoization.
Below is the implementation of the above approach:
C++
// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to perform the DFS to calculate the
// number of ways
int dfs(vector<vector<int>> memo, int nums[], int S,
int curr_sum, int index, int sum, int N)
{
// Base case: Reached the end of array
if (index == N) {
// If current sum is obtained
if (S == curr_sum)
return 1;
// Otherwise
else
return 0;
}
// If previously calculated
// subproblem occurred
if (memo[index][curr_sum + sum]
!= INT_MIN) {
return memo[index][curr_sum + sum];
}
// Check if the required sum can
// be obtained by adding current
// element or by subtracting the
// current index element
int ans = dfs(memo, nums, index + 1,
curr_sum + nums[index], S, sum, N)
+ dfs(memo, nums, index + 1,
curr_sum - nums[index], S, sum, N);
// Store the count of ways
memo[index][curr_sum + sum] = ans;
return ans;
}
// Function to call dfs
// to calculate the number of ways
int findWays(int nums[], int S, int N)
{
int sum = 0;
// Iterate till the length of array
for (int i = 0; i < N; i++)
sum += nums[i];
// Initialize the memorization table
vector<vector<int>> memo(N + 1, vector<int> (2 * sum + 1, INT_MIN));
return dfs(memo, nums, S, 0, 0, sum, N);
}
// Driver code
int main()
{
int S = 3;
int arr[] ={ 1, 2, 3, 4, 5 };
int N = sizeof(arr) / sizeof(arr[0]);
int answer = findWays(arr, S, N);
cout << answer << endl;
return 0;
}
// This code is contributed by divyesh072019
// Java Program to implement
// the above approach
import java.io.*;
import java.util.*;
class GFG {
// Function to call dfs
// to calculate the number of ways
static int findWays(int[] nums, int S)
{
int sum = 0;
// Iterate till the length of array
for (int i = 0; i < nums.length; i++)
sum += nums[i];
// Initialize the memorization table
int[][] memo
= new int[nums.length + 1][2 * sum + 1];
for (int[] m : memo) {
Arrays.fill(m, Integer.MIN_VALUE);
}
return dfs(memo, nums, S, 0, 0, sum);
}
// Function to perform the DFS to calculate the
// number of ways
static int dfs(int[][] memo, int[] nums, int S,
int curr_sum, int index, int sum)
{
// Base case: Reached the end of array
if (index == nums.length) {
// If current sum is obtained
if (S == curr_sum)
return 1;
// Otherwise
else
return 0;
}
// If previously calculated
// subproblem occurred
if (memo[index][curr_sum + sum]
!= Integer.MIN_VALUE) {
return memo[index][curr_sum + sum];
}
// Check if the required sum can
// be obtained by adding current
// element or by subtracting the
// current index element
int ans = dfs(memo, nums, index + 1,
curr_sum + nums[index], S, sum)
+ dfs(memo, nums, index + 1,
curr_sum - nums[index], S, sum);
// Store the count of ways
memo[index][curr_sum + sum] = ans;
return ans;
}
// Driver Code
public static void main(String[] args)
{
int S = 3;
int[] arr = new int[] { 1, 2, 3, 4, 5 };
int answer = findWays(arr, S);
System.out.println(answer);
}
}
# Python3 program to implement
# the above approach
import sys
# Function to call dfs to
# calculate the number of ways
def findWays(nums, S):
sum = 0
# Iterate till the length of array
for i in range(len(nums)):
sum += nums[i]
# Initialize the memorization table
memo = [[-sys.maxsize - 1 for i in range(2 * sum + 1)]
for j in range(len(nums) + 1)]
return dfs(memo, nums, S, 0, 0, sum)
# Function to perform the DFS to calculate the
# number of ways
def dfs(memo, nums, S, curr_sum, index, sum):
# Base case: Reached the end of array
if (index == len(nums)):
# If current sum is obtained
if (S == curr_sum):
return 1
# Otherwise
else:
return 0
# If previously calculated
# subproblem occurred
if (memo[index][curr_sum + sum] != -sys.maxsize - 1):
return memo[index][curr_sum + sum]
# Check if the required sum can
# be obtained by adding current
# element or by subtracting the
# current index element
ans = (dfs(memo, nums, index + 1,
curr_sum + nums[index], S, sum) +
dfs(memo, nums, index + 1,
curr_sum - nums[index], S, sum))
# Store the count of ways
memo[index][curr_sum + sum] = ans
return ans
# Driver Code
if __name__ == '__main__':
S = 3
arr = [ 1, 2, 3, 4, 5 ]
answer = findWays(arr, S)
print(answer)
# This code is contributed by bgangwar59
// C# program to implement
// the above approach
using System;
class GFG{
// Function to call dfs
// to calculate the number of ways
static int findWays(int[] nums, int S)
{
int sum = 0;
// Iterate till the length of array
for(int i = 0; i < nums.Length; i++)
sum += nums[i];
// Initialize the memorization table
int[,] memo = new int[nums.Length + 1,
2 * sum + 1];
for(int i = 0; i < memo.GetLength(0); i++)
{
for(int j = 0; j < memo.GetLength(1); j++)
{
memo[i, j] = int.MinValue;
}
}
return dfs(memo, nums, S, 0, 0, sum);
}
// Function to perform the DFS to calculate the
// number of ways
static int dfs(int[,] memo, int[] nums, int S,
int curr_sum, int index, int sum)
{
// Base case: Reached the end of array
if (index == nums.Length)
{
// If current sum is obtained
if (S == curr_sum)
return 1;
// Otherwise
else
return 0;
}
// If previously calculated
// subproblem occurred
if (memo[index, curr_sum + sum] != int.MinValue)
{
return memo[index, curr_sum + sum];
}
// Check if the required sum can
// be obtained by adding current
// element or by subtracting the
// current index element
int ans = dfs(memo, nums, index + 1,
curr_sum + nums[index], S, sum) +
dfs(memo, nums, index + 1,
curr_sum - nums[index], S, sum);
// Store the count of ways
memo[index, curr_sum + sum] = ans;
return ans;
}
// Driver Code
public static void Main(String[] args)
{
int S = 3;
int[] arr = new int[] { 1, 2, 3, 4, 5 };
int answer = findWays(arr, S);
Console.WriteLine(answer);
}
}
// This code is contributed by Amit Katiyar
<script>
// Javascript program to implement
// the above approach
// Function to call dfs
// to calculate the number of ways
function findWays(nums, S)
{
let sum = 0;
// Iterate till the length of array
for(let i = 0; i < nums.length; i++)
sum += nums[i];
// Initialize the memorization table
let memo = new Array([nums.length + 1][2 * sum + 1]);
for(let i = 0; i < nums.length + 1; i++)
{
memo[i] = new Array(2 * sum + 1);
for(let j = 0; j < 2 * sum + 1; j++)
{
memo[i][j] = Number.MIN_VALUE;
}
}
return dfs(memo, nums, S, 0, 0, sum);
}
// Function to perform the DFS to calculate
// the number of ways
function dfs(memo, nums, S, curr_sum, index, sum)
{
// Base case: Reached the end of array
if (index == nums.length)
{
// If current sum is obtained
if (S == curr_sum)
return 1;
// Otherwise
else
return 0;
}
// If previously calculated
// subproblem occurred
if (memo[index][curr_sum + sum] !=
Number.MIN_VALUE)
{
return memo[index][curr_sum + sum];
}
// Check if the required sum can
// be obtained by adding current
// element or by subtracting the
// current index element
let ans = dfs(memo, nums, index + 1,
curr_sum + nums[index], S, sum) +
dfs(memo, nums, index + 1,
curr_sum - nums[index], S, sum);
// Store the count of ways
memo[index][curr_sum + sum] = ans;
return ans;
}
// Driver Code
let S = 3;
let arr = [ 1, 2, 3, 4, 5 ];
let answer = findWays(arr, S);
document.write(answer);
// This code is contributed by avanitrachhadiya2155
</script>
Time Complexity: O(N * S)
Auxiliary Space: O(N * S)
Knapsack Approach: The idea is to implement the 0/1 Knapsack problem. Follow the steps below:
- The original problem reduces to finding the number of ways to find a subset of arr[] that are all positive and the remaining elements as negative, such that their sum is equal to S.
- Therefore, the problem is to finding no of subsets from the given array having sum (S + totalSum)/2.
Below is the implementation of the above approach:
C++
// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
// Function to call dfs
// to calculate the number of ways
int knapSack(int nums[], int S, int n)
{
int sum = 0;
for(int i = 0; i < n; i++)
sum += nums[i];
// If target + sum is odd or
// S exceeds sum
if (sum < S || -sum > -S ||
(S + sum) % 2 == 1)
// No sultion exists
return 0;
int dp[(S + sum) / 2 + 1];
for(int i = 0; i <= (S + sum) / 2; i++)
dp[i] = 0;
dp[0] = 1;
for(int j = 0; j < n; j++)
{
for(int i = (S + sum) / 2;
i >= nums[j]; i--)
{
dp[i] += dp[i - nums[j]];
}
}
// Return the answer
return dp[(S + sum) / 2];
}
// Driver Code
int main()
{
int S = 3;
int arr[] = { 1, 2, 3, 4, 5 };
int answer = knapSack(arr, S, 5);
cout << answer << endl;
}
// This code is contributed by amal kumar choubey
// Java Program to implement
// the above approach
import java.io.*;
class GFG {
// Function to call dfs
// to calculate the number of ways
static int knapSack(int[] nums, int S)
{
int sum = 0;
for (int i : nums)
sum += i;
// If target + sum is odd or S exceeds sum
if (sum < S || -sum > -S || (S + sum) % 2 == 1)
// No sultion exists
return 0;
int[] dp = new int[(S + sum) / 2 + 1];
dp[0] = 1;
for (int num : nums) {
for (int i = dp.length - 1; i >= num; i--) {
dp[i] += dp[i - num];
}
}
// Return the answer
return dp[dp.length - 1];
}
// Driver Code
public static void main(String[] args)
{
int S = 3;
int[] arr = new int[] { 1, 2, 3, 4, 5 };
int answer = knapSack(arr, S);
System.out.println(answer);
}
}
# Python3 Program to implement
# the above approach
# Function to call dfs
# to calculate the number of ways
def knapSack(nums, S):
sum = 0;
for i in range(len(nums)):
sum += nums[i];
# If target + sum is odd or S exceeds sum
if (sum < S or -sum > -S or
(S + sum) % 2 == 1):
# No sultion exists
return 0;
dp = [0]*(((S + sum) // 2) + 1);
dp[0] = 1;
for j in range(len(nums)):
for i in range(len(dp) - 1, nums[j] - 1, -1):
dp[i] += dp[i - nums[j]];
# Return the answer
return dp[len(dp) - 1];
# Driver Code
if __name__ == '__main__':
S = 3;
arr = [1, 2, 3, 4, 5 ];
answer = knapSack(arr, S);
print(answer);
# This code is contributed by Princi Singh
// C# Program to implement
// the above approach
using System;
class GFG{
// Function to call dfs
// to calculate the number of ways
static int knapSack(int[] nums, int S)
{
int sum = 0;
foreach (int i in nums)
sum += i;
// If target + sum is odd or S exceeds sum
if (sum < S || -sum > -S ||
(S + sum) % 2 == 1)
// No sultion exists
return 0;
int[] dp = new int[(S + sum) / 2 + 1];
dp[0] = 1;
foreach (int num in nums)
{
for (int i = dp.Length - 1; i >= num; i--)
{
dp[i] += dp[i - num];
}
}
// Return the answer
return dp[dp.Length - 1];
}
// Driver Code
public static void Main(String[] args)
{
int S = 3;
int[] arr = new int[] { 1, 2, 3, 4, 5 };
int answer = knapSack(arr, S);
Console.WriteLine(answer);
}
}
// This code is contributed by Rajput-Ji
<script>
// Javascript Program to implement
// the above approach
// Function to call dfs
// to calculate the number of ways
function knapSack(nums, S)
{
let sum = 0;
for (let i = 0; i < nums.length; i++)
sum += nums[i];
// If target + sum is odd or S exceeds sum
if (sum < S || -sum > -S || (S + sum) % 2 == 1)
// No sultion exists
return 0;
let dp = new Array(parseInt((S + sum) / 2, 10) + 1);
dp.fill(0);
dp[0] = 1;
for (let num = 0; num < nums.length; num++) {
for (let i = dp.length - 1; i >= nums[num]; i--) {
dp[i] += dp[i - nums[num]];
}
}
// Return the answer
return dp[dp.length - 1];
}
let S = 3;
let arr = [ 1, 2, 3, 4, 5 ];
let answer = knapSack(arr, S);
document.write(answer);
// This code is contributed by divyeshrabadiya07.
</script>
Time Complexity: O(n*(sum + S)), where sum denotes the sum of the array
Auxiliary Space: O(S + sum)
Similar Reads
Count of ways to choose K elements from given Array with maximum sum
Given an array, arr[] of size N and an integer K, the task is to find the number of ways of selecting K array elements, such that the sum of these K elements is the maximum possible sum. Examples: Input: arr[] = {3, 1, 1, 2}, K = 3 Output: 2Explanation: The possible ways of selecting 3 elements are:
8 min read
Count ways to select K array elements lying in a given range
Given three positive integers, L, R, K and an array arr[] consisting of N positive integers, the task is to count the number of ways to select at least K array elements from the given array having values in the range [L, R]. Examples: Input: arr[] = {12, 4, 6, 13, 5, 10}, K = 3, L = 4, R = 10 Output
9 min read
Count of elements which is the sum of a subarray of the given Array
Given an array arr[], the task is to count elements in an array such that there exists a subarray whose sum is equal to this element.Note: Length of subarray must be greater than 1. Examples: Input: arr[] = {1, 2, 3, 4, 5, 6, 7} Output: 4 Explanation: There are 4 such elements in array - arr[2] = 3
7 min read
Count of pairs of elements with Sum X and multiplication Y in given Array
Given array A[] (-109 <= A[i] <= 109) of size N (2 <= N <= 107) along with integers X (-2*109 <= X <= 2*109) and Y (-1018 <= Y <= 1018), the task for this problem is to find the count of pairs (A[i], A[j]) such that X = A[i] + A[j] and Y = A[i] * A[j] also i < j. Also A[i]
11 min read
Construct sum-array with sum of elements in given range
You are given an array of n-elements and an odd-integer m. You have to construct a new sum_array from given array such that sum_array[i] = ?arr[j] for (i-(m/2)) < j (i+(m/2)). note : for 0 > j or j >= n take arr[j] = 0. Examples: Input : arr[] = {1, 2, 3, 4, 5}, m = 3 Output : sum_array = {
7 min read
Count of ways to make Array sum even by removing only one element
Given an array arr[] positive integers, the task is to find the number of ways to convert the array sum even if we are allowed to remove only one element.Examples: Input: arr[] = { 1, 3, 3, 2 } Output: 3 Explanation: 1. Remove 1, then sum is 3 + 3 + 2 = 8. 2. Remove 3, then sum is 1 + 3 + 2 = 6. 3.
5 min read
Print elements that can be added to form a given sum
Given an array arr[] of positive integers and a sum, the task is to print the elements that will be included to get the given sum. Note: Consider the elements in the form of queue i.e. Elements to be added from starting and up to the sum of elements is lesser or becomes equal to the given sum.Also,
5 min read
Queries to count array elements from a given range having a single set bit
Given an array arr[] consisting of N integers and a 2D array Q[][] consisting of queries of the following two types: 1 L R: Print the count of numbers from the range [L, R] having only a single set bit.2 X V: Update the array element at Xth index with V.Examples: Input: arr[] = { 12, 11, 16, 2, 32 }
15+ min read
Count pairs from two sorted arrays whose sum is equal to a given value x
Given two sorted arrays of size m and n of distinct elements. Given a value x. The problem is to count all pairs from both arrays whose sum is equal to x. Note: The pair has an element from each array.Examples : Input : arr1[] = {1, 3, 5, 7} arr2[] = {2, 3, 5, 8} x = 10 Output : 2 The pairs are: (5,
15+ min read
Count of subarrays which forms a permutation from given Array elements
Given an array A[] consisting of integers [1, N], the task is to count the total number of subarrays of all possible lengths x (1 ? x ? N), consisting of a permutation of integers [1, x] from the given array. Examples: Input: A[] = {3, 1, 2, 5, 4} Output: 4 Explanation: Subarrays forming a permutati
6 min read