# Split an array into two equal Sum subarrays

Given an array of integers greater than zero, find if it is possible to split it in two subarrays (without reordering the elements), such that the sum of the two subarrays is the same. Print the two subarrays.

Examples :

```Input : Arr[] = { 1 , 2 , 3 , 4 , 5 , 5  }
Output :  { 1 2 3 4 }
{ 5 , 5 }

Input : Arr[] = { 4, 1, 2, 3 }
Output : {4 1}
{2 3}

Input : Arr[] = { 4, 3, 2, 1}
Output : Not Possible
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

A Simple solution is to run two loop to split array and check it is possible to split array into two parts such that sum of first_part equal to sum of second_part.
Below is the implementation of above idea.

 `// C++ program to split an array into Two ` `// equal sum subarrays ` `#include ` `using` `namespace` `std; ` ` `  `// Returns split point. If not possible, then ` `// return -1. ` `int` `findSplitPoint(``int` `arr[], ``int` `n) ` `{ ` `    ``int` `leftSum = 0 ; ` ` `  `    ``// traverse array element ` `    ``for` `(``int` `i = 0; i < n; i++) ` `    ``{ ` `        ``// add current element to left Sum ` `        ``leftSum += arr[i] ; ` ` `  `        ``// find sum of rest array elements (rightSum) ` `        ``int` `rightSum = 0 ; ` `        ``for` `(``int` `j = i+1 ; j < n ; j++ ) ` `            ``rightSum += arr[j] ; ` ` `  `        ``// split point index ` `        ``if` `(leftSum == rightSum) ` `            ``return` `i+1 ; ` `    ``} ` ` `  `    ``// if it is not possible to split array into ` `    ``// two parts ` `    ``return` `-1; ` `} ` ` `  `// Prints two parts after finding split point using ` `// findSplitPoint() ` `void` `printTwoParts(``int` `arr[], ``int` `n) ` `{ ` `    ``int` `splitPoint = findSplitPoint(arr, n); ` ` `  `    ``if` `(splitPoint == -1 || splitPoint == n ) ` `    ``{ ` `        ``cout << ``"Not Possible"` `<

 `// Java program to split an array  ` `// into two equal sum subarrays ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Returns split point. If  ` `    ``// not possible, then return -1. ` `    ``static` `int` `findSplitPoint(``int` `arr[], ``int` `n) ` `    ``{ ` `     `  `    ``int` `leftSum = ``0` `; ` ` `  `    ``// traverse array element ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{ ` `        ``// add current element to left Sum ` `        ``leftSum += arr[i] ; ` ` `  `        ``// find sum of rest array ` `        ``// elements (rightSum) ` `        ``int` `rightSum = ``0` `; ` `         `  `        ``for` `(``int` `j = i+``1` `; j < n ; j++ ) ` `            ``rightSum += arr[j] ; ` ` `  `        ``// split point index ` `        ``if` `(leftSum == rightSum) ` `            ``return` `i+``1` `; ` `    ``} ` ` `  `    ``// if it is not possible to  ` `    ``// split array into two parts ` `    ``return` `-``1``; ` `    ``}    ` ` `  `    ``// Prints two parts after finding  ` `    ``// split point using findSplitPoint() ` `    ``static` `void` `printTwoParts(``int` `arr[], ``int` `n) ` `    ``{ ` `     `  `        ``int` `splitPoint = findSplitPoint(arr, n); ` `     `  `        ``if` `(splitPoint == -``1` `|| splitPoint == n ) ` `        ``{ ` `            ``System.out.println(``"Not Possible"``); ` `            ``return``; ` `        ``} ` `         `  `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{ ` `            ``if``(splitPoint == i) ` `               ``System.out.println(); ` `                `  `            ``System.out.print(arr[i] + ``" "``); ` `             `  `        ``} ` `    ``} ` ` `  `// Driver program ` `     `  `    ``public` `static` `void` `main (String[] args) { ` `     `  `    ``int` `arr[] = {``1` `, ``2` `, ``3` `, ``4` `, ``5` `, ``5` `}; ` `    ``int` `n = arr.length; ` `    ``printTwoParts(arr, n); ` `     `  `    ``} ` `} ` ` `  `// This code is contributed by vt_m `

 `# Python3 program to split an array into Two ` `# equal sum subarrays ` `  `  `# Returns split point. If not possible, then ` `# return -1. ` `def` `findSplitPoint(arr, n) : ` `  `  `    ``leftSum ``=` `0`  `   `  `    ``# traverse array element ` `    ``for` `i ``in` `range``(``0``, n) : ` `      `  `        ``# add current element to left Sum ` `        ``leftSum ``+``=` `arr[i]  ` `   `  `        ``# find sum of rest array elements (rightSum) ` `        ``rightSum ``=` `0`  `        ``for` `j ``in` `range``(i``+``1``, n) : ` `            ``rightSum ``+``=` `arr[j]  ` `   `  `        ``# split poindex ` `        ``if` `(leftSum ``=``=` `rightSum) : ` `            ``return` `i``+``1`  `      `  `   `  `    ``# if it is not possible to split array into ` `    ``# two parts ` `    ``return` `-``1` `  `  `   `  `# Prints two parts after finding split pousing ` `# findSplitPoint() ` `def` `printTwoParts(arr, n) : ` `  `  `    ``splitPo ``=` `findSplitPoint(arr, n) ` `   `  `    ``if` `(splitPo ``=``=` `-``1` `or` `splitPo ``=``=` `n ) : ` `        ``print` `(``"Not Possible"``) ` `        ``return` `      `  `    ``for` `i ``in` `range``(``0``, n) : ` `        ``if``(splitPo ``=``=` `i) : ` `            ``print` `("") ` `        ``print` `(``str``(arr[i]) ``+` `' '``,end``=``'') ` `  `  `# driver program ` `arr ``=` `[``1` `, ``2` `, ``3` `, ``4` `, ``5` `, ``5``] ` `n ``=` `len``(arr) ` `printTwoParts(arr, n) ` ` `  `# This code is contributed by Manish Shaw ` `# (manishshaw1) `

 `// C# program to split an array  ` `// into two equal sum subarrays ` `using` `System; ` ` `  `class` `GFG { ` ` `  `    ``// Returns split point. If  ` `    ``// not possible, then return -1. ` `    ``static` `int` `findSplitPoint(``int` `[]arr, ``int` `n) ` `    ``{ ` `     `  `        ``int` `leftSum = 0 ; ` `     `  `        ``// traverse array element ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `             `  `            ``// add current element to left Sum ` `            ``leftSum += arr[i] ; ` `     `  `            ``// find sum of rest array ` `            ``// elements (rightSum) ` `            ``int` `rightSum = 0 ; ` `             `  `            ``for` `(``int` `j = i+1 ; j < n ; j++ ) ` `                ``rightSum += arr[j] ; ` `     `  `            ``// split point index ` `            ``if` `(leftSum == rightSum) ` `                ``return` `i+1 ; ` `        ``} ` ` `  `        ``// if it is not possible to  ` `        ``// split array into two parts ` `        ``return` `-1; ` `    ``}  ` ` `  `    ``// Prints two parts after finding  ` `    ``// split point using findSplitPoint() ` `    ``static` `void` `printTwoParts(``int` `[]arr, ``int` `n) ` `    ``{ ` `     `  `        ``int` `splitPoint = findSplitPoint(arr, n); ` `     `  `        ``if` `(splitPoint == -1 || splitPoint == n ) ` `        ``{ ` `            ``Console.Write(``"Not Possible"``); ` `            ``return``; ` `        ``} ` `         `  `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``if``(splitPoint == i) ` `            ``Console.WriteLine(); ` `                 `  `            ``Console.Write(arr[i] + ``" "``); ` `        ``} ` `    ``} ` ` `  `    ``// Driver program ` `    ``public` `static` `void` `Main () ` `    ``{ ` `        ``int` `[]arr = {1 , 2 , 3 , 4 , 5 , 5 }; ` `        ``int` `n = arr.Length; ` `        ``printTwoParts(arr, n); ` `    ``} ` `} ` ` `  `// This code is contributed by nitin mittal `

 ` `

Output:
```1 2 3 4
5 5
```

Time Complexity : O(n2)
Auxiliary Space : O(1)

An Efficient solution is to first compute the sum of the whole array from left to right. Now we traverse array from right and keep track of right sum, left sum can be computed by subtracting current element from whole sum.

Below is the implementation of above idea.

 `// C++ program to split an array into Two ` `// equal sum subarrays ` `#include ` `using` `namespace` `std; ` ` `  `// Returns split point. If not possible, then ` `// return -1. ` `int` `findSplitPoint(``int` `arr[], ``int` `n) ` `{ ` `    ``// traverse array element and compute sum ` `    ``// of whole array ` `    ``int` `leftSum = 0; ` `    ``for` `(``int` `i = 0 ; i < n ; i++) ` `        ``leftSum += arr[i]; ` ` `  `    ``// again traverse array and compute right sum ` `    ``// and also check left_sum equal to right ` `    ``// sum or not ` `    ``int` `rightSum = 0; ` `    ``for` `(``int` `i=n-1; i >= 0; i--) ` `    ``{ ` `        ``// add current element to right_sum ` `        ``rightSum += arr[i]; ` ` `  `        ``// exclude current element to the left_sum ` `        ``leftSum -=  arr[i] ; ` ` `  `        ``if` `(rightSum == leftSum) ` `            ``return` `i ; ` `    ``} ` ` `  `    ``// if it is not possible to split array ` `    ``// into two parts. ` `    ``return` `-1; ` `} ` ` `  `// Prints two parts after finding split point using ` `// findSplitPoint() ` `void` `printTwoParts(``int` `arr[], ``int` `n) ` `{ ` `    ``int` `splitPoint = findSplitPoint(arr, n); ` ` `  `    ``if` `(splitPoint == -1 || splitPoint == n ) ` `    ``{ ` `        ``cout << ``"Not Possible"` `<

 `// java program to split an array  ` `// into Two equal sum subarrays ` `import` `java.io.*; ` ` `  `class` `GFG { ` ` `  `    ``// Returns split point. If not possible, then ` `    ``// return -1. ` `    ``static` `int` `findSplitPoint(``int` `arr[], ``int` `n) ` `    ``{ ` `     `  `    ``// traverse array element and compute sum ` `    ``// of whole array ` `    ``int` `leftSum = ``0``; ` `     `  `    ``for` `(``int` `i = ``0` `; i < n ; i++) ` `        ``leftSum += arr[i]; ` ` `  `    ``// again traverse array and compute right  ` `    ``// sum and also check left_sum equal to  ` `    ``// right sum or not ` `    ``int` `rightSum = ``0``; ` `     `  `    ``for` `(``int` `i = n-``1``; i >= ``0``; i--) ` `    ``{ ` `        ``// add current element to right_sum ` `        ``rightSum += arr[i]; ` ` `  `        ``// exclude current element to the left_sum ` `        ``leftSum -= arr[i] ; ` ` `  `        ``if` `(rightSum == leftSum) ` `            ``return` `i ; ` `    ``} ` ` `  `    ``// if it is not possible to split array ` `    ``// into two parts. ` `    ``return` `-``1``; ` `    ``} ` ` `  `    ``// Prints two parts after finding split  ` `    ``// point using findSplitPoint() ` `    ``static` `void` `printTwoParts(``int` `arr[], ``int` `n) ` `    ``{ ` `        ``int` `splitPoint = findSplitPoint(arr, n); ` `     `  `        ``if` `(splitPoint == -``1` `|| splitPoint == n ) ` `        ``{ ` `            ``System.out.println(``"Not Possible"` `); ` `            ``return``; ` `        ``} ` `        ``for` `(``int` `i = ``0``; i < n; i++) ` `        ``{ ` `            ``if``(splitPoint == i) ` `                ``System.out.println(); ` `                 `  `            ``System.out.print(arr[i] + ``" "``); ` `        ``} ` `    ``} ` ` `  `    ``// Driver program ` `    ``public` `static` `void` `main (String[] args) { ` `     `  `    ``int` `arr[] = {``1` `, ``2` `, ``3` `, ``4` `, ``5` `, ``5` `}; ` `    ``int` `n = arr.length; ` `     `  `    ``printTwoParts(arr, n); ` `         `  `    ``} ` `} ` ` `  `// This code is contributed by vt_m `

 `# Python3 program to split  ` `# an array into Two ` `# equal sum subarrays ` `  `  `# Returns split point.  ` `# If not possible,  ` `# then return -1. ` `def` `findSplitPoint(arr, n) : ` `    ``# traverse array element and  ` `    ``# compute sum of whole array ` `    ``leftSum ``=` `0` `    ``for` `i ``in` `range``(``0``, n) : ` `        ``leftSum ``+``=` `arr[i] ` `  `  `    ``# again traverse array and ` `    ``# compute right sum and also  ` `    ``# check left_sum equal to  ` `    ``# right sum or not ` `    ``rightSum ``=` `0` `    ``for` `i ``in` `range``(n``-``1``, ``-``1``, ``-``1``) : ` `        ``# add current element ` `        ``# to right_sum ` `        ``rightSum ``+``=` `arr[i] ` `  `  `        ``# exclude current element  ` `        ``# to the left_sum ` `        ``leftSum ``-``=` `arr[i]  ` `  `  `        ``if` `(rightSum ``=``=` `leftSum) : ` `            ``return` `i  ` `  `  `    ``# if it is not possible  ` `    ``# to split array into  ` `    ``# two parts. ` `    ``return` `-``1` `  `  `# Prints two parts after  ` `# finding split point  ` `# using findSplitPoint() ` `def` `printTwoParts(arr, n) : ` `    ``splitPoint ``=` `findSplitPoint(arr, n) ` `  `  `    ``if` `(splitPoint ``=``=` `-``1` `or` `splitPoint ``=``=` `n ) : ` `        ``print` `(``"Not Possible"``)  ` `        ``return` ` `  `    ``for` `i ``in` `range` `(``0``, n) : ` `        ``if``(splitPoint ``=``=` `i) : ` `            ``print` `("") ` `        ``print` `(arr[i], end ``=` `" "``)          ` `  `  `# Driver Code ` `arr ``=` `[``1``, ``2``, ``3``, ``4``, ``5``, ``5``] ` `n ``=` `len``(arr) ` `printTwoParts(arr, n) ` `  `  `# This code is contributed by Manish Shaw ` `# (manishshaw1) `

 `// C# program to split an array  ` `// into Two equal sum subarrays ` `using` `System; ` `  `  `class` `GFG { ` `  `  `    ``// Returns split point. If not possible, then ` `    ``// return -1. ` `    ``static` `int` `findSplitPoint(``int` `[]arr, ``int` `n) ` `    ``{ ` `      `  `    ``// traverse array element and compute sum ` `    ``// of whole array ` `    ``int` `leftSum = 0; ` `      `  `    ``for` `(``int` `i = 0 ; i < n ; i++) ` `        ``leftSum += arr[i]; ` `  `  `    ``// again traverse array and compute right  ` `    ``// sum and also check left_sum equal to  ` `    ``// right sum or not ` `    ``int` `rightSum = 0; ` `      `  `    ``for` `(``int` `i = n-1; i >= 0; i--) ` `    ``{ ` `        ``// add current element to right_sum ` `        ``rightSum += arr[i]; ` `  `  `        ``// exclude current element to the left_sum ` `        ``leftSum -= arr[i] ; ` `  `  `        ``if` `(rightSum == leftSum) ` `            ``return` `i ; ` `    ``} ` `  `  `    ``// if it is not possible to split array ` `    ``// into two parts. ` `    ``return` `-1; ` `    ``} ` `  `  `    ``// Prints two parts after finding split  ` `    ``// point using findSplitPoint() ` `    ``static` `void` `printTwoParts(``int` `[]arr, ``int` `n) ` `    ``{ ` `        ``int` `splitPoint = findSplitPoint(arr, n); ` `      `  `        ``if` `(splitPoint == -1 || splitPoint == n ) ` `        ``{ ` `            ``Console.Write(``"Not Possible"` `); ` `            ``return``; ` `        ``} ` `        ``for` `(``int` `i = 0; i < n; i++) ` `        ``{ ` `            ``if``(splitPoint == i) ` `                 ``Console.WriteLine(); ` `                  `  `             ``Console.Write(arr[i] + ``" "``); ` `        ``} ` `    ``} ` `  `  `    ``// Driver program ` `    ``public` `static` `void` `Main (String[] args) { ` `      `  `    ``int` `[]arr = {1 , 2 , 3 , 4 , 5 , 5 }; ` `    ``int` `n = arr.Length; ` `      `  `    ``printTwoParts(arr, n); ` `          `  `    ``} ` `} ` `  `  `// This code is contributed by parashar `

 `= 0; ``\$i``--) ` `    ``{ ` `        ``// add current element ` `        ``// to right_sum ` `        ``\$rightSum` `+= ``\$arr``[``\$i``]; ` ` `  `        ``// exclude current element  ` `        ``// to the left_sum ` `        ``\$leftSum` `-= ``\$arr``[``\$i``] ; ` ` `  `        ``if` `(``\$rightSum` `== ``\$leftSum``) ` `            ``return` `\$i` `; ` `    ``} ` ` `  `    ``// if it is not possible  ` `    ``// to split array into  ` `    ``// two parts. ` `    ``return` `-1; ` `} ` ` `  `// Prints two parts after  ` `// finding split point  ` `// using findSplitPoint() ` `function` `printTwoParts( ``\$arr``, ``\$n``) ` `{ ` `    ``\$splitPoint` `= findSplitPoint(``\$arr``, ``\$n``); ` ` `  `    ``if` `(``\$splitPoint` `== -1 ``or`  `        ``\$splitPoint` `== ``\$n` `) ` `    ``{ ` `        ``echo` `"Not Possible"` `; ` `        ``return``; ` `    ``} ` `    ``for` `( ``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `    ``{ ` `        ``if``(``\$splitPoint` `== ``\$i``) ` `            ``echo` `"\n"``; ` `        ``echo` `\$arr``[``\$i``] , ``" "` `; ` `    ``} ` `} ` ` `  `// Driver Code ` `\$arr` `= ``array``(1, 2, 3, 4, 5, 5); ` `\$n` `= ``count``(``\$arr``); ` `printTwoParts(``\$arr``, ``\$n``); ` ` `  `// This code is contributed by anuj_67. ` `?> `

Output :
```1 2 3 4
5 5
```

Time Complexity : O(n)
Auxiliary Space : O(1)

This article is contributed by Nishant Singh . If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.