Count number of ways to divide an array into two halves with same sum
Last Updated :
20 Dec, 2022
Given an integer array of N elements. The task is to find the number of ways to split the array into two equal sum sub-arrays of non-zero lengths.
Examples:
Input: arr[] = {0, 0, 0, 0}
Output: 3
Explanation:
All the possible ways are: { {{0}, {0, 0, 0}}, {{0, 0}, {0, 0}}, {{0, 0, 0}, {0}}
Therefore, the required output is 3.
Input: {1, -1, 1, -1}
Output: 1
Simple Solution: A simple solution is to generate all the possible contiguous sub-arrays pairs and find there sum. If their sum is the same, we will increase the count by one.
Time Complexity: O(N2)
Auxiliary Space: O(1)
Efficient Approach: The idea is to take an auxiliary array say, aux[] to calculate the presum of the array such that for an index i aux[i] will store the sum of all elements from index 0 to index i.
By doing this we can calculate the left sum and right sum for every index of the array in constant time.
So, the idea is to:
- Find the sum of all the numbers of the array and store it in a variable say, S. If the sum is odd, then the answer will be 0.
- Traverse the array and keep calculating the sum of elements. At ith step, we will use the variable S to maintain sum of all the elements from index 0 to i.
- Calculate sum upto the ith index.
- If this sum equals S/2, increase the count of the number of ways by 1.
- Do this from i=0 to i=N-2.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int cntWays( int arr[], int n)
{
if (n == 1)
return 0;
int tot_sum = 0, sum = 0, ans = 0;
for ( int i = 0; i < n; i++)
tot_sum += arr[i];
for ( int i = 0; i < n - 1; i++) {
sum += arr[i];
if (sum == tot_sum / 2)
ans++;
}
return ans;
}
int main()
{
int arr[] = { 1, -1, 1, -1, 1, -1 };
int n = sizeof (arr) / sizeof ( int );
cout << cntWays(arr, n);
return 0;
}
|
Java
import java.util.*;
import java.io.*;
class GFG
{
static int cntWays( int arr[], int n)
{
if (n == 1 )
{
return 0 ;
}
int tot_sum = 0 , sum = 0 , ans = 0 ;
for ( int i = 0 ; i < n; i++)
{
tot_sum += arr[i];
}
for ( int i = 0 ; i < n - 1 ; i++)
{
sum += arr[i];
if (sum == tot_sum / 2 )
{
ans++;
}
}
return ans;
}
public static void main(String[] args)
{
int arr[] = { 1 , - 1 , 1 , - 1 , 1 , - 1 };
int n = arr.length;
System.out.println(cntWays(arr, n));
}
}
|
Python3
def cntWays(arr, n):
if (n = = 1 ):
return 0 ;
tot_sum = 0 ; sum = 0 ; ans = 0 ;
for i in range ( 0 ,n):
tot_sum + = arr[i];
for i in range ( 0 ,n - 1 ):
sum + = arr[i];
if ( sum = = tot_sum / 2 ):
ans + = 1 ;
return ans;
arr = [ 1 , - 1 , 1 , - 1 , 1 , - 1 ];
n = len (arr);
print (cntWays(arr, n));
|
C#
using System;
class GFG
{
static int cntWays( int []arr, int n)
{
if (n == 1)
{
return 0;
}
int tot_sum = 0, sum = 0, ans = 0;
for ( int i = 0; i < n; i++)
{
tot_sum += arr[i];
}
for ( int i = 0; i < n - 1; i++)
{
sum += arr[i];
if (sum == tot_sum / 2)
{
ans++;
}
}
return ans;
}
public static void Main()
{
int []arr = {1, -1, 1, -1, 1, -1};
int n = arr.Length;
Console.WriteLine(cntWays(arr, n));
}
}
|
Javascript
<script>
function cntWays(arr, n)
{
if (n == 1) return 0;
var tot_sum = 0,
sum = 0,
ans = 0;
for ( var i = 0; i < n; i++) tot_sum += arr[i];
for ( var i = 0; i < n - 1; i++) {
sum += arr[i];
if (sum == tot_sum / 2)
ans++;
}
return ans;
}
var arr = [1, -1, 1, -1, 1, -1];
var n = arr.length;
document.write(cntWays(arr, n));
</script>
|
Time Complexity: O(N), since there runs a loop from 0 to (n – 1)
Auxiliary Space: O(1), since no extra space has been taken.
Share your thoughts in the comments
Please Login to comment...