Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Divide array into two parts with equal sum according to the given constraints

  • Difficulty Level : Medium
  • Last Updated : 06 May, 2019

Given an array arr[] of N integers, the task is to select an integer x (which may or may not be present in the array) and remove all of its occurrences from the array and divide the remaining array into two non-empty sub-sets such that:

  1. The elements of the first set are strictly smaller than x.
  2. The elements of the second set are strictly greater than x.
  3. The sum of the elements of both the sets is equal.
      If such an integer exists then print Yes otherwise print No.

      Examples:

      Input: arr[] = {1, 2, 2, 5}
      Output: Yes
      Choose x = 3, after removing all of its occurrences the array becomes arr[] = {1, 2, 2, 5}
      {1, 2, 2} and {5} are the required sub-sets.

      Input: arr[] = {2, 1}
      Output: No

      Approach: The idea is to first sort the array and for all the numbers lying between 1 to maximum number present in the array, apply binary search and check if on removing all its occurrences from the array, sum of elements present on its left side (which are smaller than it) and sum of elements present on the right side (which are greater than it) is equal.

      Below is the implementation of the above approach:

      C++




      // C++ implementation of the approach
      #include <bits/stdc++.h>
      using namespace std;
        
      // Function that checks if the given
      // conditions are satisfied
      void IfExists(int arr[], int n)
      {
          // To store the prefix sum
          // of the array elements
          int sum[n];
        
          // Sort the array
          sort(arr, arr + n);
        
          sum[0] = arr[0];
        
          // Compute the prefix sum array
          for (int i = 1; i < n; i++)
              sum[i] = sum[i - 1] + arr[i];
        
          // Maximum element in the array
          int max = arr[n - 1];
        
          // Variable to check if there exists any number
          bool flag = false;
        
          for (int i = 1; i <= max; i++) {
        
              // Stores the index of the largest
              // number present in the array
              // smaller than i
              int findex = 0;
        
              // Stores the index of the smallest
              // number present in the array
              // greater than i
              int lindex = 0;
        
              int l = 0;
              int r = n - 1;
        
              // Find index of smallest number
              // greater than i
              while (l <= r) {
                  int m = (l + r) / 2;
        
                  if (arr[m] < i) {
                      findex = m;
                      l = m + 1;
                  }
                  else
                      r = m - 1;
              }
        
              l = 1;
              r = n;
              flag = false;
        
              // Find index of smallest number
              // greater than i
              while (l <= r) {
                  int m = (r + l) / 2;
        
                  if (arr[m] > i) {
                      lindex = m;
                      r = m - 1;
                  }
                  else
                      l = m + 1;
              }
        
              // If there exists a number
              if (sum[findex] == sum[n - 1] - sum[lindex - 1]) {
                  flag = true;
                  break;
              }
          }
        
          // If no such number exists
          // print no
          if (flag)
              cout << "Yes";
          else
              cout << "No";
      }
        
      // Driver code
      int main()
      {
          int arr[] = { 1, 2, 2, 5 };
          int n = sizeof(arr) / sizeof(int);
          IfExists(arr, n);
        
          return 0;
      }
      Java



      // Java implementation of the approach 
      import java.util.*;
        
      class GFG
      {
        
      // Function that checks if the given 
      // conditions are satisfied 
      static void IfExists(int arr[], int n) 
      { 
          // To store the prefix sum 
          // of the array elements 
          int sum[] = new int[n]; 
        
          // Sort the array 
          Arrays.sort(arr); 
        
          sum[0] = arr[0]; 
        
          // Compute the prefix sum array 
          for (int i = 1; i < n; i++) 
              sum[i] = sum[i - 1] + arr[i]; 
        
          // Maximum element in the array 
          int max = arr[n - 1]; 
        
          // Variable to check if there exists any number 
          boolean flag = false; 
        
          for (int i = 1; i <= max; i++) 
          { 
        
              // Stores the index of the largest 
              // number present in the array 
              // smaller than i 
              int findex = 0; 
        
              // Stores the index of the smallest 
              // number present in the array 
              // greater than i 
              int lindex = 0; 
        
              int l = 0; 
              int r = n - 1; 
        
              // Find index of smallest number 
              // greater than i 
              while (l <= r) 
              { 
                  int m = (l + r) / 2; 
        
                  if (arr[m] < i) 
                  { 
                      findex = m; 
                      l = m + 1; 
                  } 
                  else
                      r = m - 1; 
              } 
        
              l = 1; 
              r = n; 
              flag = false; 
        
              // Find index of smallest number 
              // greater than i 
              while (l <= r) 
              { 
                  int m = (r + l) / 2; 
        
                  if (arr[m] > i) 
                  { 
                      lindex = m; 
                      r = m - 1; 
                  } 
                  else
                      l = m + 1; 
              } 
        
              // If there exists a number 
              if (sum[findex] == sum[n - 1] - sum[lindex - 1]) 
              { 
                  flag = true; 
                  break; 
              } 
          } 
        
          // If no such number exists 
          // print no 
          if (flag) 
              System.out.println("Yes"); 
          else
              System.out.println("No"); 
      } 
        
      // Driver code 
      public static void main(String args[])
      { 
          int arr[] = { 1, 2, 2, 5 }; 
          int n = arr.length; 
          IfExists(arr, n); 
      }
      } 
        
      // This code is contributed by Arnab Kundu
      Python3



      # Python3 implementation of the approach 
        
      # Function that checks if the given 
      # conditions are satisfied 
      def IfExists(arr, n) :
        
          # To store the prefix sum 
          # of the array elements 
          sum = [0] * n; 
        
          # Sort the array 
          arr.sort(); 
        
          sum[0] = arr[0]; 
        
          # Compute the prefix sum array 
          for i in range(1, n) : 
              sum[i] = sum[i - 1] + arr[i]; 
        
          # Maximum element in the array 
          max = arr[n - 1]; 
        
          # Variable to check if there 
          # exists any number 
          flag = False; 
        
          for i in range(1, max + 1) :
        
              # Stores the index of the largest 
              # number present in the array 
              # smaller than i 
              findex = 0; 
        
              # Stores the index of the smallest 
              # number present in the array 
              # greater than i 
              lindex = 0; 
        
              l = 0; 
              r = n - 1; 
        
              # Find index of smallest number 
              # greater than i 
              while (l <= r) :
                  m = (l + r) // 2; 
        
                  if (arr[m] < i) :
                      findex = m; 
                      l = m + 1; 
                    
                  else :
                      r = m - 1; 
                
              l = 1; 
              r = n; 
              flag = False; 
        
              # Find index of smallest number 
              # greater than i 
              while (l <= r) : 
                  m = (r + l) // 2; 
        
                  if (arr[m] > i) : 
                      lindex = m; 
                      r = m - 1; 
                    
                  else :
                      l = m + 1; 
                
              # If there exists a number 
              if (sum[findex] == sum[n - 1] - 
                                 sum[lindex - 1]) : 
                  flag = True; 
                  break; 
                
          # If no such number exists 
          # print no 
          if (flag) : 
              print("Yes"); 
          else :
              print("No"); 
        
      # Driver code 
      if __name__ == "__main__" : 
        
          arr = [ 1, 2, 2, 5 ]; 
            
          n = len(arr) ;
          IfExists(arr, n); 
            
      # This code is contributed by Ryuga
      C#



      // C# implementation of the approach 
      using System;
        
      class GFG
      {
            
      // Function that checks if the given 
      // conditions are satisfied 
      static void IfExists(int[] arr, int n) 
      { 
          // To store the prefix sum 
          // of the array elements 
          int[] sum = new int[n]; 
        
          // Sort the array 
          Array.Sort(arr); 
        
          sum[0] = arr[0]; 
        
          // Compute the prefix sum array 
          for (int i = 1; i < n; i++) 
              sum[i] = sum[i - 1] + arr[i]; 
        
          // Maximum element in the array 
          int max = arr[n - 1]; 
        
          // Variable to check if there exists any number 
          bool flag = false; 
        
          for (int i = 1; i <= max; i++) 
          { 
        
              // Stores the index of the largest 
              // number present in the array 
              // smaller than i 
              int findex = 0; 
        
              // Stores the index of the smallest 
              // number present in the array 
              // greater than i 
              int lindex = 0; 
        
              int l = 0; 
              int r = n - 1; 
        
              // Find index of smallest number 
              // greater than i 
              while (l <= r) 
              { 
                  int m = (l + r) / 2; 
        
                  if (arr[m] < i) 
                  { 
                      findex = m; 
                      l = m + 1; 
                  } 
                  else
                      r = m - 1; 
              } 
        
              l = 1; 
              r = n; 
              flag = false; 
        
              // Find index of smallest number 
              // greater than i 
              while (l <= r) 
              { 
                  int m = (r + l) / 2; 
        
                  if (arr[m] > i) 
                  { 
                      lindex = m; 
                      r = m - 1; 
                  } 
                  else
                      l = m + 1; 
              } 
        
              // If there exists a number 
              if (sum[findex] == sum[n - 1] - sum[lindex - 1]) 
              { 
                  flag = true; 
                  break; 
              } 
          } 
        
          // If no such number exists 
          // print no 
          if (flag) 
              Console.WriteLine("Yes"); 
          else
              Console.WriteLine("No"); 
      } 
        
      // Driver code 
      public static void Main()
      { 
          int[] arr = { 1, 2, 2, 5 }; 
          int n = arr.Length; 
          IfExists(arr, n); 
      }
      } 
        
      // This code is contributed by Code_Mech.
      PHP



      <?php
      // PHP implementation of the approach
        
      // Function that checks if the given
      // conditions are satisfied
      function IfExists($arr, $n)
      {
          // To store the prefix $sum
          // of the array elements
          $sum = array_fill(0, $n, 0);
        
          // Sort the array
          sort($arr);
        
          $sum[0] = $arr[0];
        
          // Compute the prefix sum array
          for ($i = 1; $i < $n; $i++)
              $sum[$i] = $sum[$i - 1] + $arr[$i];
        
          // Maximum element in the array
          $max = $arr[$n - 1];
        
          // Variable to check if there exists any number
          $flag = false;
        
          for ($i = 1; $i <= $max; $i++) 
          {
        
              // Stores the index of the largest
              // number present in the array
              // smaller than i
              $findex = 0;
        
              // Stores the index of the smallest
              // number present in the array
              // greater than i
              $lindex = 0;
        
              $l = 0;
              $r = $n - 1;
        
              // Find index of smallest number
              // greater than i
              while ($l <= $r) 
              {
                  $m = ($l + $r) / 2; 
                  if ($arr[$m] < $i) 
                  {
                      $findex = $m;
                      $l = $m + 1;
                  }
                  else
                      $r = $m - 1;
              }
        
              $l = 1;
              $r = $n;
              $flag = false;
        
              // Find index of smallest number
              // greater than i
              while ($l <= $r)
              {
                  $m = ($r + $l) / 2;
        
                  if ($arr[$m] > $i) 
                  {
                      $lindex = $m;
                      $r = $m - 1;
                  }
                  else
                      $l = $m + 1;
              }
        
              // If there exists a number
              if ($sum[$findex] == $sum[$n - 1] -
                                   $sum[$lindex - 1])
              {
                  $flag = true;
                  break;
              }
          }
        
          // If no such number exists
          // print no
          if ($flag == true)
              echo "Yes";
          else
              echo "No";
      }
        
      // Driver code
      $arr = array(1, 2, 2, 5 );
      $n = sizeof($arr);
      IfExists($arr, $n);
        
      // This code is contributed by ihritik
      ?>
      Output:
      Yes


      My Personal Notes
arrow_drop_up
Previous
Check if all the 1's in a binary string are equidistant or not
Next

Split the array elements into strictly increasing and decreasing sequence
Recommended Articles
Page :
Count the number of ways to divide an array into three contiguous parts having equal sum
18, May 17
Divide a sorted array in K parts with sum of difference of max and min minimized in each part
12, May 20
Divide a sorted array in K parts with sum of difference of max and min minimized in each part - Set 2
29, Dec 21
Divide array into two arrays which does not contain any pair with sum K
03, Nov 20
Divide N segments into two non-empty groups such that given condition is satisfied
21, Jan 19
Count ways to split array into two equal sum subarrays by changing sign of any one array element
03, Dec 20
Equally divide into two sets such that one set has maximum distinct elements
04, Sep 18
Number of times an array can be partitioned repetitively into two subarrays with equal sum
26, Jun 20
Minimize moves to sort Array in non decreasing order by breaking elements in two parts
04, Apr 22
Divide an array into k segments to maximize maximum of segment minimums
19, Oct 17
Minimize range [L, R] to divide Array into K subarrays with majority elements in [L, R]
28, Feb 22
Check if given Array can be grouped into N/2 pairs with equal sum
10, Mar 22
Check if there exist two elements in an array whose sum is equal to the sum of rest of the array
22, Feb 17
Find minimum time to finish all jobs with given constraints
04, Oct 15
Minimum time required to transport all the boxes from source to the destination under the given constraints
24, Apr 19
Check if it is possible to form string B from A under the given constraints
02, May 19
Given a string and an integer k, find the kth sub-string when all the sub-strings are sorted according to the given condition
17, Apr 19
Change the given string according to the given conditions
28, Jul 20
Perform given queries on Queue according to the given rules
05, Oct 21
Sort an array according to absolute difference with given value
22, Dec 16
Sort an array according to absolute difference with a given value "using constant extra space"
10, Sep 17
Sort an array according to absolute difference with given value using Functors
24, Jun 19
Sort given Array in descending order according to highest power of prime factors
29, Dec 21
Sort an array according to the order defined by another array
13, Aug 14
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Sakshi_Srivastava
@Sakshi_Srivastava
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

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

Lightbox

Start Your Coding Journey Now!