Open In App

We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy

Find if array can be divided into two subarrays of equal sum

Given an array of integers, find if it’s possible to remove exactly one integer from the array that divides the array into two subarrays with the same sum.

Examples: 

Input:  arr = [6, 2, 3, 2, 1]
Output:  true
Explanation:  On removing element 2 at index 1,
the array gets divided into two subarrays [6]
 and [3, 2, 1] having equal sum

Input:  arr = [6, 1, 3, 2, 5]
Output:  true
Explanation:  On removing element 3 at index 2,
the array gets divided into two subarrays [6, 1]
and [2, 5] having equal sum.

Input:  arr = [6, -2, -3, 2, 3]
Output: true
Explanation:  On removing element 6 at index 0, 
the array gets divided into two sets [] 
and [-2, -3, 2, 3] having equal sum

Input:  arr = [6, -2, 3, 2, 3]
Output: false

A naive solution would be to consider all elements of the array and calculate their left and right sum and return true if left and right sum are found to be equal. The time complexity of this solution would be O(n2).

The efficient solution involves calculating sum of all elements of the array in advance. Then for each element of the array, we can calculate its right sum in O(1) time by using total sum of the array elements minus sum of elements found so far. The time complexity of this solution would be O(n) and auxiliary space used by it will be O(1).

Below is the implementation of above approach:




// C++ program to divide the array into two
// subarrays with the same sum on removing
// exactly one integer from the array
#include <iostream>
using namespace std;
 
// Utility function to print the sub-array
void printSubArray(int arr[], int start, int end)
{
    cout << "[ ";
    for (int i = start; i <= end; i++)
        cout << arr[i] << " ";
    cout << "] ";
}
 
// Function that divides the array into two subarrays
// with the same sum
bool divideArray(int arr[], int n)
{
    // sum stores sum of all elements of the array
    int sum = 0;
    for (int i = 0; i < n; i++)
        sum += arr[i];
 
    // sum stores sum till previous index of the array
    int sum_so_far = 0;
 
    for (int i = 0; i < n; i++)
    {
        // If on removing arr[i], we get equals left
        // and right half
        if (2 * sum_so_far + arr[i] == sum)
        {
            cout << "The array can be divided into"
                    "two subarrays with equal sum\nThe"
                    " two subarrays are - ";
            printSubArray(arr, 0, i - 1);
            printSubArray(arr, i + 1, n - 1);
 
            return true;
        }
        // add current element to sum_so_far
        sum_so_far += arr[i];
    }
 
    // The array cannot be divided
    cout << "The array cannot be divided into two "
         "subarrays with equal sum";
 
    return false;
}
 
// Driver code
int main()
{
    int arr[] = {6, 2, 3, 2, 1};
    int n = sizeof(arr)/sizeof(arr[0]);
 
    divideArray(arr, n);
 
    return 0;
}
 





                        























                                    



                                    




                                    




                                    


                                



















// Java program to divide the array into two


// subarrays with the same sum on removing


// exactly one integer from the array



import java.io.*;



 



class GFG 



{



    // Utility function to print the sub-array




    static void printSubArray(int arr[], int start, int end)




    {




        System.out.print("[ ");




        for (int i = start; i <= end; i++)




            System.out.print(arr[i] +" ");




        System.out.print("] ");




    }




     



    // Function that divides the array into two subarrays




    // with the same sum




    static boolean divideArray(int arr[], int n)




    {




        // sum stores sum of all elements of the array




        int sum = 0;




        for (int i = 0; i < n; i++)




            sum += arr[i];




  



        // sum stores sum till previous index of the array




        int sum_so_far = 0;




  



        for (int i = 0; i < n; i++)




        {




            // If on removing arr[i], we get equals left




            // and right half




            if (2 * sum_so_far + arr[i] == sum)




            {




                System.out.print("The array can be divided into "




                    +"two subarrays with equal sum\nThe"




                    +" two subarrays are - ");




                printSubArray(arr, 0, i - 1);




                printSubArray(arr, i + 1, n - 1);




  



                return true;




            }




            // add current element to sum_so_far




            sum_so_far += arr[i];




        }




  



        // The array cannot be divided




        System.out.println("The array cannot be divided into two "




                +"subarrays with equal sum");




                 



        return false;




    }




     



    // Driver program




    public static void main (String[] args) 




    {




        int arr[] = {6, 2, 3, 2, 1};




        int n = arr.length;




  



        divideArray(arr, n);




    }



}


 


// This code is contributed by Pramod Kumar


















                        






                        























                                    



                                    




                                    




                                    


                                



















''' Python3 program to divide the array 


into two subarrays with the same sum on 


removing exactly one integer from the array'''


 


# Utility function to print the sub-array



def printSubArray(arr, start, end):




    print ("[ ", end = "")




    for i in range(start, end+1):




        print (arr[i], end =" ")




    print ("]", end ="")



 


# Function that divides the array into


# two subarrays with the same sum



def divideArray(arr, n):



 



    # sum stores sum of all 




    # elements of the array




    sum = 0




    for i in range(0, n):




        sum += arr[i]



 



    # sum stores sum till previous 




    # index of the array




    sum_so_far = 0




    for i in range(0, n):



 



        # If on removing arr[i], we get




        # equals left and right half




        if 2 * sum_so_far + arr[i] == sum:




            print ("The array can be divided into",




                    "two subarrays with equal sum")




            print ("two subarrays are -", end = "")




            printSubArray(arr, 0, i - 1)




            printSubArray(arr, i + 1, n - 1)




            return True



 



        # add current element to sum_so_far




        sum_so_far += arr[i]



 



    # The array cannot be divided




    print ("The array cannot be divided into"




           "two subarrays with equal sum", end = "")



 



    return False



 


# Driver code



arr = [6, 2, 3, 2, 1]




n = len(arr)



divideArray(arr, n)


 


# This code is contributed by Shreyanshi Arun


















                        






                        























                                    



                                    




                                    




                                    


                                



















// C# program to divide the array into two


// subarrays with the same sum on removing


// exactly one integer from the array



using System;



 



class GFG {




     



    // Utility function to print the sub-array




    static void printSubArray(int []arr, 




                           int start, int end)




    {




        Console.Write("[ ");




        for (int i = start; i <= end; i++)




            Console.Write(arr[i] +" ");




        Console.Write("] ");




    }




     



    // Function that divides the array into 




    // two subarrays with the same sum




    static bool divideArray(int []arr, int n)




    {




         



        // sum stores sum of all elements of 




        // the array




        int sum = 0;




        for (int i = 0; i < n; i++)




            sum += arr[i];



 



        // sum stores sum till previous index




        // of the array




        int sum_so_far = 0;



 



        for (int i = 0; i < n; i++)




        {




             



            // If on removing arr[i], we get




            // equals left and right half




            if (2 * sum_so_far + arr[i] == sum)




            {




                Console.Write("The array can be"




                 + " divided into two subarrays"




                 + " with equal sum\nThe two"




                 + " subarrays are - ");




                printSubArray(arr, 0, i - 1);




                printSubArray(arr, i + 1, n - 1);



 



                return true;




            }




            // add current element to sum_so_far




            sum_so_far += arr[i];




        }



 



        // The array cannot be divided




        Console.WriteLine("The array cannot be"




          + " divided into two subarrays with "




                                + "equal sum");




                 



        return false;




    }




     



    // Driver program




    public static void Main () 




    {




        int []arr = {6, 2, 3, 2, 1};




        int n = arr.Length;



 



        divideArray(arr, n);




    }



}


 


// This code is contributed by anuj_67.


















                        






                        























                                    



                                    




                                    




                                    


                                



















<?php


// PHP program to divide the array into two


// subarrays with the same sum on removing


// exactly one integer from the array


 


// Utility function to print the sub-array



function printSubArray($arr, $start, $end)



{



    echo "[ ";




    for ($i = $start; $i <= $end; $i++)




        echo $arr[$i] . " ";




    echo "] ";



}


 


// Function that divides the


// array into two subarrays


// with the same sum



function divideArray($arr, $n)



{



     



    // sum stores sum of all 




    // elements of the array




    $sum = 0;




    for ($i = 0; $i < $n; $i++)




        $sum += $arr[$i];



 



    // sum stores sum till previous




    // index of the array




    $sum_so_far = 0;



 



    for ($i = 0; $i < $n; $i++)




    {




         



        // If on removing arr[i],




        // we get equals left




        // and right half




        if (2 * $sum_so_far + $arr[$i] == $sum)




        {




            echo "The array can be divided into" .




                 "two subarrays with equal sum\nThe".




                 " two subarrays are - ";




            printSubArray($arr, 0, $i - 1);




            printSubArray($arr, $i + 1, $n - 1);



 



            return true;




        }




         



        // add current element 




        // to sum_so_far




        $sum_so_far += $arr[$i];




    }



 



    // The array cannot be divided




    echo "The array cannot be divided into two ".




         "subarrays with equal sum";



 



    return false;



}


 



    // Driver code




    $arr = array(6, 2, 3, 2, 1);




    $n = sizeof($arr);



 



    divideArray($arr, $n);




     


// This code is contributed by Anuj_67


?>


















                        






                        























                                    



                                    




                                    




                                    


                                



















<script>


 



    // JavaScript program to divide the array into two




    // subarrays with the same sum on removing




    // exactly one integer from the array




     



    // Utility function to print the sub-array




    function printSubArray(arr, start, end)




    {




        document.write("[ ");




        for (let i = start; i <= end; i++)




            document.write(arr[i] +" ");




        document.write("] ");




    }




       



    // Function that divides the array into 




    // two subarrays with the same sum




    function divideArray(arr, n)




    {




           



        // sum stores sum of all elements of 




        // the array




        let sum = 0;




        for (let i = 0; i < n; i++)




            sum += arr[i];




   



        // sum stores sum till previous index




        // of the array




        let sum_so_far = 0;




   



        for (let i = 0; i < n; i++)




        {




               



            // If on removing arr[i], we get




            // equals left and right half




            if (2 * sum_so_far + arr[i] == sum)




            {




                document.write("The array can be"




                 + " divided into two subarrays"




                 + " with equal sum " + "</br>" + "The two"




                 + " sets are - ");




                printSubArray(arr, 0, i - 1);




                printSubArray(arr, i + 1, n - 1);




   



                return true;




            }




            // add current element to sum_so_far




            sum_so_far += arr[i];




        }




   



        // The array cannot be divided




        document.write("The array cannot be"




          + " divided into two subarrays with "




                                + "equal sum" + "</br>");




                   



        return false;




    }




     



    let arr = [6, 2, 3, 2, 1];




    let n = arr.length;



 



    divideArray(arr, n);




     


</script>


















                        






                        








Output

The array can be divided intotwo subarrays with equal sum
The two subarrays are - [ 6 ] [ 3 2 1 ] 



	

        Article Tags : 
        

            Arrays
DSA        


	


      

      

          
Recommended Articles

      

      

          
          
1. Difference between ceil of array sum divided by K and sum of ceil of array elements divided by K

          
2. Absolute difference between floor of Array sum divided by X and floor sum of every Array element when divided by X

          
3. Find the sums for which an array can be divided into sub-arrays of equal sum

          
4. Check if a large number can be divided into two or more segments of equal sum

          
5. Check if an array of 1s and 2s can be divided into 2 parts with equal sum

          
6. Check if any square (with one colored cell) can be divided into two equal parts

          
7. Number of times an array can be partitioned repetitively into two subarrays with equal sum

          
8. Check if N can be divided into K consecutive elements with a sum equal to N

          
9. Check if array can be divided into two subsequences merging whom makes Array sorted

          
10. Minimum length of a rod that can be split into N equal parts that can further be split into given number of equal parts

          
11. Check if String can be divided into two Subsequences so that product of sum is odd

          
12. Check if array can be divided into two sub-arrays such that their absolute difference is K

          
13. Number of K's such that the given array can be divided into two sets satisfying the given conditions

          
14. Count ways to split array into two equal sum subarrays by replacing each array element to 0 once

          
15. Count ways to split array into two equal sum subarrays by changing sign of any one array element

          
16. Check if Array can be split into subarrays such that XOR of length of Longest Decreasing Subsequences of those subarrays is 0

          
17. Check if a given array can be divided into pairs with even sum

          
18. Check if an array can be divided into pairs whose sum is divisible  by k

          
19. First N natural can be divided into two sets with given difference and co-prime sums

          
20. Split an array into two equal Sum subarrays

          
21. Split array into K subarrays such that sum of maximum of all subarrays is maximized

          
22. Minimize the sum of the squares of the sum of elements of each group the array is divided into

          
23. Generate Array whose sum of all K-size subarrays divided by N leaves remainder X

          
24. Check if given Array can be divided into subsequences of K increasing consecutive integers

          
25. Check if Array can be divided into K groups of size C and all elements of group are distinct