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++ program to count the number of ways to // divide an array into two halves // with the same sum #include <bits/stdc++.h> using namespace std;
// Function to count the number of ways to // divide an array into two halves // with same sum int cntWays( int arr[], int n)
{ // if length of array is 1
// answer will be 0 as we have
// to split it into two
// non-empty halves
if (n == 1)
return 0;
// variables to store total sum,
// current sum and count
int tot_sum = 0, sum = 0, ans = 0;
// finding total sum
for ( int i = 0; i < n; i++)
tot_sum += arr[i];
// checking if sum equals total_sum/2
for ( int i = 0; i < n - 1; i++) {
sum += arr[i];
if (sum == tot_sum / 2)
ans++;
}
return ans;
} // Driver Code int main()
{ int arr[] = { 1, -1, 1, -1, 1, -1 };
int n = sizeof (arr) / sizeof ( int );
cout << cntWays(arr, n);
return 0;
} |
// Java program to count the number of ways to // divide an array into two halves // with the same sum import java.util.*;
import java.io.*;
class GFG
{ // Function to count the number of ways to
// divide an array into two halves
// with same sum
static int cntWays( int arr[], int n)
{
// if length of array is 1
// answer will be 0 as we have
// to split it into two
// non-empty halves
if (n == 1 )
{
return 0 ;
}
// variables to store total sum,
// current sum and count
int tot_sum = 0 , sum = 0 , ans = 0 ;
// finding total sum
for ( int i = 0 ; i < n; i++)
{
tot_sum += arr[i];
}
// checking if sum equals total_sum/2
for ( int i = 0 ; i < n - 1 ; i++)
{
sum += arr[i];
if (sum == tot_sum / 2 )
{
ans++;
}
}
return ans;
}
// Driver Code
public static void main(String[] args)
{
int arr[] = { 1 , - 1 , 1 , - 1 , 1 , - 1 };
int n = arr.length;
System.out.println(cntWays(arr, n));
}
} // This code contributed by Rajput-Ji |
# Python program to count the number of ways to # divide an array into two halves # with the same sum # Function to count the number of ways to # divide an array into two halves # with same sum def cntWays(arr, n):
# if length of array is 1
# answer will be 0 as we have
# to split it into two
# non-empty halves
if (n = = 1 ):
return 0 ;
# variables to store total sum,
# current sum and count
tot_sum = 0 ; sum = 0 ; ans = 0 ;
# finding total sum
for i in range ( 0 ,n):
tot_sum + = arr[i];
# checking if sum equals total_sum/2
for i in range ( 0 ,n - 1 ):
sum + = arr[i];
if ( sum = = tot_sum / 2 ):
ans + = 1 ;
return ans;
# Driver Code arr = [ 1 , - 1 , 1 , - 1 , 1 , - 1 ];
n = len (arr);
print (cntWays(arr, n));
# This code contributed by PrinciRaj1992 |
// C# program to count the number of ways to // divide an array into two halves with // the same sum using System;
class GFG
{ // Function to count the number of ways to
// divide an array into two halves
// with same sum
static int cntWays( int []arr, int n)
{
// if length of array is 1
// answer will be 0 as we have
// to split it into two
// non-empty halves
if (n == 1)
{
return 0;
}
// variables to store total sum,
// current sum and count
int tot_sum = 0, sum = 0, ans = 0;
// finding total sum
for ( int i = 0; i < n; i++)
{
tot_sum += arr[i];
}
// checking if sum equals total_sum/2
for ( int i = 0; i < n - 1; i++)
{
sum += arr[i];
if (sum == tot_sum / 2)
{
ans++;
}
}
return ans;
}
// Driver Code
public static void Main()
{
int []arr = {1, -1, 1, -1, 1, -1};
int n = arr.Length;
Console.WriteLine(cntWays(arr, n));
}
} // This code contributed by anuj_67.. |
<script> // JavaScript program to count the number of ways to
// divide an array into two halves
// with the same sum
// Function to count the number of ways to
// divide an array into two halves
// with same sum
function cntWays(arr, n)
{
// if length of array is 1
// answer will be 0 as we have
// to split it into two
// non-empty halves
if (n == 1) return 0;
// variables to store total sum,
// current sum and count
var tot_sum = 0,
sum = 0,
ans = 0;
// finding total sum
for ( var i = 0; i < n; i++) tot_sum += arr[i];
// checking if sum equals total_sum/2
for ( var i = 0; i < n - 1; i++) {
sum += arr[i];
if (sum == tot_sum / 2)
ans++;
}
return ans;
}
// Driver Code
var arr = [1, -1, 1, -1, 1, -1];
var n = arr.length;
document.write(cntWays(arr, n));
</script> |
2
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.