Open In App

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

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Share
Report issue
Report

Given a very large Number N. The task is to check if the number can be divided into two or more segments of an equal sum. 

Examples:

Input: N = 73452  
Output: Yes
Segments of {7}, {3, 4}, {5, 2} which has equal sum of 7

Input: N = 1248
Output: No

The following steps can be followed to solve the problem:  

  1. Since the number can be large, the number is initialized in a string.
  2. Use prefixSum array to store the prefix sum of the array.
  3. Now traverse from the second element to last, and the first segment thus will be 0 to i-1, whose sum is Prefixsum[i-1].
  4. Use another pointer that traverses from i to n, and keep adding the sum.
  5. If the sum at any stage is equal to Prefixsum[i-1], then the segment has a sum equal to first.
  6. Reinitialize the segment sum value to 0 and keep moving the pointer.
  7. If at any stage the segment sum exceeds the sum of the first segment, then break, as the division with segment sum as prefixsum[i-1] is not possible.
  8. If the pointer reaches the last number, check if the last segment sum is equal to the first segment sum i.e., prefixsum[i-1], then it can be divided into segments of the equal sum.

Implementation:

C++




// C++ program to Check if a large number can be divided
// into two or more segments of equal sum
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if a number
// can be divided into segments
bool check(string s)
{
    // length of string
    int n = s.length();
 
    // array to store prefix sum
    int Presum[n];
 
    // first index
    Presum[0] = s[0] - '0';
 
    // calculate the prefix
    for (int i = 1; i < n; i++) {
        Presum[i] = Presum[i - 1] + (s[i] - '0');
    }
 
    // iterate for all number from second number
    for (int i = 1; i <= n - 1; i++) {
 
        // sum from 0th index to i-1th index
        int sum = Presum[i - 1];
        int presum = 0;
        int it = i;
 
        // counter turns true when sum
        // is obtained from a segment
        int flag = 0;
 
        // iterate till the last number
        while (it < n) {
            // sum of segments
            presum += s[it] - '0';
 
            // if segment sum is equal
            // to first segment
            if (presum == sum) {
                presum = 0;
                flag = 1;
            }
            // when greater than not possible
            else if (presum > sum) {
                break;
            }
            it++;
        }
 
        // if at the end all values are traversed
        // and all segments have sum equal to first segment
        // then it is possible
        if (presum == 0 && it == n && flag == 1) {
            return true;
        }
    }
    return false;
}
 
// Driver Code
int main()
{
    string s = "73452";
    if (check(s))
        cout << "Yes";
    else
        cout << "No";
    return 0;
}


Java




// Java program to Check if a large number can be divided
// into two or more segments of equal sum
 
public class GFG {
 
    // Function to check if a number
    // can be divided into segments
    static boolean check(String s)
    {
        // length of string
        int n = s.length();
      
        // array to store prefix sum
        int[] Presum = new int[n];
      
        // first index
        char[] s1 = s.toCharArray();
        Presum[0] = s1[0] - '0';
      
        // calculate the prefix
        for (int i = 1; i < n; i++) {
            Presum[i] = Presum[i - 1] + (s1[i] - '0');
        }
      
        // iterate for all number from second number
        for (int i = 1; i <= n - 1; i++) {
      
            // sum from 0th index to i-1th index
            int sum = Presum[i - 1];
            int presum = 0;
            int it = i;
      
            // counter turns true when sum
            // is obtained from a segment
            int flag = 0;
      
            // iterate till the last number
            while (it < n) {
                // sum of segments
                presum += s1[it] - '0';
      
                // if segment sum is equal
                // to first segment
                if (presum == sum) {
                    presum = 0;
                    flag = 1;
                }
                // when greater than not possible
                else if (presum > sum) {
                    break;
                }
                it++;
            }
      
            // if at the end all values are traversed
            // and all segments have sum equal to first segment
            // then it is possible
            if (presum == 0 && it == n && flag == 1) {
                return true;
            }
        }
        return false;
    }
      
    // Driver Code
    public static void main(String[] args) {
         
        String s = "73452";
        if (check(s))
            System.out.println("Yes");
        else
            System.out.println("No");
    }
}


Python3




# Python program to Check if a large number can be divided
# into two or more segments of equal sum
 
# Function to check if a number
# can be divided into segments
def check(s):
    # length of string
    n = len(s)
    # list to store prefix sum
    Presum = [0] * n
    # calculate the first prefix sum
    Presum[0] = int(s[0])
    # calculate the prefix sum for rest of the numbers
    for i in range(1, n):
        Presum[i] = Presum[i - 1] + int(s[i])
    # iterate for all numbers from second number
    for i in range(1, n - 1):
        # sum from 0th index to i-1th index
        sum = Presum[i - 1]
        # temporary sum
        presum = 0
        # iterator for checking all segments
        it = i
        # counter to check if sum is obtained from a segment
        flag = 0
        # iterate till the last number
        while it < n:
            # sum of segments
            presum += int(s[it])
            # if segment sum is equal to first segment sum
            if presum == sum:
                # reset the temporary sum
                presum = 0
                # set the flag to indicate segment sum is obtained
                flag = 1
            # when greater than first segment sum not possible
            elif presum > sum:
                break
            # move to next number
            it += 1
        # if all values are traversed and all segments have sum equal to first segment
        # then it is possible
        if presum == 0 and it == n and flag == 1:
            return True
    # if not possible
    return False
 
# Driver Code
s = "73452"
if check(s):
    print("Yes")
else:
    print("No")


C#




// C# program to Check if a large
// number can be divided into two
// or more segments of equal sum
using System;
 
class GFG
{
 
    // Function to check if a number
    // can be divided into segments
    static bool check(String s)
    {
        // length of string
        int n = s.Length;
     
        // array to store prefix sum
        int[] Presum = new int[n];
     
        // first index
        char[] s1 = s.ToCharArray();
        Presum[0] = s1[0] - '0';
     
        // calculate the prefix
        for (int i = 1; i < n; i++)
        {
            Presum[i] = Presum[i - 1] + (s1[i] - '0');
        }
     
        // iterate for all number from second number
        for (int i = 1; i <= n - 1; i++)
        {
     
            // sum from 0th index to i-1th index
            int sum = Presum[i - 1];
            int presum = 0;
            int it = i;
     
            // counter turns true when sum
            // is obtained from a segment
            int flag = 0;
     
            // iterate till the last number
            while (it < n)
            {
                // sum of segments
                presum += s1[it] - '0';
     
                // if segment sum is equal
                // to first segment
                if (presum == sum)
                {
                    presum = 0;
                    flag = 1;
                }
                 
                // when greater than not possible
                else if (presum > sum)
                {
                    break;
                }
                it++;
            }
     
            // if at the end all values are traversed
            // and all segments have sum equal to first segment
            // then it is possible
            if (presum == 0 && it == n && flag == 1)
            {
                return true;
            }
        }
        return false;
    }
     
    // Driver Code
    public static void Main(String[] args)
    {
         
        String s = "73452";
        if (check(s))
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
    }
}
 
// This code has been contributed by 29AjayKumar


Javascript




<script>
    // Javascript program to Check if a large number can be divided
    // into two or more segments of equal sum
 
    // Function to check if a number
    // can be divided into segments
    function check(s)
    {
     
        // length of string
        let n = s.length;
 
        // array to store prefix sum
        var Presum = [];
         
        // first index
        Presum.push(parseInt(s[0]));
 
        // calculate the prefix
        let i;
        for (i = 1; i < n; i++) {
            Presum.push(Presum[i - 1] + parseInt(s[i]));
        }
 
        // iterate for all number from second number
        for (i = 1; i <= n - 1; i++) {
 
            // sum from 0th index to i-1th index
            let sum = Presum[i - 1];
            let presum = 0;
            let it = i;
 
            // counter turns true when sum
            // is obtained from a segment
            let flag = 0;
 
            // iterate till the last number
            while (it < n) {
                // sum of segments
                presum += parseInt(s[it]);
 
                // if segment sum is equal
                // to first segment
                if (presum == sum) {
                    presum = 0;
                    flag = 1;
                }
                // when greater than not possible
                else if (presum > sum) {
                    break;
                }
                it++;
            }
 
            // if at the end all values are traversed
            // and all segments have sum equal to first segment
            // then it is possible
            if (presum == 0 && it == n && flag == 1) {
                return true;
            }
        }
        return false;
    }
     
    // Driver Code
    var s = "73452";
    if (check(s))
        document.write("Yes");
    else
        document.write("No");
         
        // This code is contributed by ajaykrsharma132.
</script>


Output

Yes

Complexity Analysis:

  • Time Complexity: O(N2
  • Auxiliary Space: O(N)


Last Updated : 16 Feb, 2023
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads