# Count number of ways to divide an array into two halves with same sum

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:3Explanation:

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(N^{2})**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++

`// 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

`// Java program to count the number of ways to` `// divide an array into two halves` `// with the same sum` `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` |

## Python3

`# 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#

`// 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..` |

## Javascript

`<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>` |

**Output:**

2

**Time Complexity:** O(N)**Auxiliary Space:** O(1)

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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend **live classes **with experts, please refer **DSA Live Classes for Working Professionals **and **Competitive Programming Live for Students**.