Aquileo | Split an Array into Two Equal Sum Subarrays

Given an array of integers arr[], determine whether it is possible to split it into two contiguous subarrays (without reordering the elements) such that the sum of the two subarrays is equal.

Input : arr[] = [1 , 2 , 3 , 4 , 5 , 5]
Output : true
Explanation :The array can be divided after index 3 into two subarrays: [1, 2, 3, 4] and [5, 5].

Input : arr[] = [4, 3, 2, 1]
Output : false
Explanation: No possible split gives equal sum.

Try It Yourself

Table of Content

[Naive Approach] Using Nested Loops - O(n^2) Time and O(1) Space
[Expected Approach] Running Prefix Sum and Suffix Sum - O(n) Time and O(1) Space

[Naive Approach] Using Nested Loops - O(n^2) Time and O(1) Space

Use two loops where the outer loop determines the split position, and the inner loops compute the sum of the left part (including the current index) and the right part (excluding the current index). If the two sums are equal, a valid partition is found.

C++

#include <vector>
#include <iostream>
using namespace std;

bool canSplit(vector<int> &arr)
{
    // Try every possible split position
    for (int i = 0; i < arr.size(); i++)
    {
        int leftSum = 0;
        int rightSum = 0;

        // Compute left sum (0 to i)
        for (int j = 0; j <= i; j++)
            leftSum += arr[j];

        // Compute right sum (i+1 to n-1)
        for (int j = i + 1; j < arr.size(); j++)
            rightSum += arr[j];

        // Check condition
        if (leftSum == rightSum)
            return true;
    }

    return false;
}

int main()
{
    vector<int> arr = {1, 2, 3, 4, 5, 5};

    cout << boolalpha << canSplit(arr) << endl;
    return 0;
}

Java

import java.util.Arrays;

class GfG {

    static boolean canSplit(int[] arr)
    {
        // Try every possible split position
        for (int i = 0; i < arr.length; i++)
        {
            int leftSum = 0;
            int rightSum = 0;

            // Compute left sum (0 to i)
            for (int j = 0; j <= i; j++)
                leftSum += arr[j];

            // Compute right sum (i+1 to n-1)
            for (int j = i + 1; j < arr.length; j++)
                rightSum += arr[j];

            // Check condition
            if (leftSum == rightSum)
                return true;
        }
        
        return false;
    }

    public static void main(String[] args)
    {
        int[] arr = {1, 2, 3, 4, 5, 5};

        System.out.println(canSplit(arr));
    }
}

Python

def canSplit(arr):
    
    # Try every possible split position
    for i in range(len(arr)):
        leftSum = 0
        rightSum = 0

        # Compute left sum (0 to i)
        for j in range(i + 1):
            leftSum += arr[j]

        # Compute right sum (i+1 to n-1)
        for j in range(i + 1, len(arr)):
            rightSum += arr[j]

        # Check the condition
        if leftSum == rightSum:
            return True

    return False


if __name__ == "__main__":
    arr = [1, 2, 3, 4, 5, 5]

    print("true" if canSplit(arr) else "false")

using System;

class GfG {
    static bool canSplit(int[] arr)
    {
        // Try every possible split position
        for (int i = 0; i < arr.Length; i++)
        {
            int leftSum = 0;
            int rightSum = 0;

            // Compute left sum (0 to i)
            for (int j = 0; j <= i; j++)
                leftSum += arr[j];

            // Compute right sum (i+1 to n-1)
            for (int j = i + 1; j < arr.Length; j++)
                rightSum += arr[j];

            // Check the condition
            if (leftSum == rightSum)
                return true;
        }

        return false;
    }

    static void Main()
    {
        int[] arr = { 1, 2, 3, 4, 5, 5 };

        Console.WriteLine(canSplit(arr) ? "true" : "false");
    }
}

JavaScript

function canSplit(arr)
{
    // Try every possible split position
    for (let i = 0; i < arr.length; i++)
    {
        let leftSum = 0;
        let rightSum = 0;

        // Compute left sum (0 to i)
        for (let j = 0; j <= i; j++)
            leftSum += arr[j];

        // Compute right sum (i+1 to n-1)
        for (let j = i + 1; j < arr.length; j++)
            rightSum += arr[j];

        // Check the condition
        if (leftSum === rightSum)
            return true;
    }

    return false;
}

// Driver code
const arr = [1, 2, 3, 4, 5, 5];

console.log(canSplit(arr));

Output

true

[Expected Approach] Running Prefix Sum and Suffix Sum - O(n) Time and O(1) Space

First, compute the total sum of the array. Then traverse from left to right, maintaining a running left sum. At each step, subtract the left sum from the total sum to obtain the right sum.

Dry run for arr[] = [1, 2, 3, 4, 5, 5]:

First compute total sum of array = 20.
Start traversing and keep adding elements to leftSum.
At each index, rightSum is obtained by subtracting leftSum from total.
At i = 0, leftSum becomes 1 and remaining rightSum is 19, not equal.
At i = 1, leftSum becomes 3 and rightSum is 17, not equal.
At i = 2, leftSum becomes 6 and rightSum is 14, not equal.
At i = 3, leftSum becomes 10 and rightSum is 10 then both equal, so valid split found.
Once equal sums are found, return true as array can be partitioned into two equal parts.

C++

#include <vector>
using namespace std;

bool canSplit(vector<int> &arr)
{
    // total sum
    int total = 0;
    for (int i = 0; i < arr.size(); i++)
        total += arr[i];

    int leftSum = 0;
    for (int i = 0; i < arr.size(); i++)
    {
        leftSum += arr[i];

        // right sum
        int rightSum = total - leftSum;

        // Check the condition
        if (leftSum == rightSum)
            return true;
    }

    return false;
}

int main()
{
    vector<int> arr = {1, 2, 3, 4, 5, 5};

    cout << boolalpha << canSplit(arr) << endl;
    return 0;
}