Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Medium
  • Last Updated : 17 Aug, 2021

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 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 which 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 equal sum.

Below is the implementation of the above approach.
 

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");
    }
}
Python 3 
# 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)

    # array to store prefix sum
    Presum = [None]*n

    # first index
    Presum[0] = ord(s[0]) - ord('0')

    # calculate the prefix
    for i in range(1, n):
        Presum[i] = Presum[i - 1] + (ord(s[i]) - ord('0'))

    # iterate for all number from second number
    for i in range(1, n):

        # sum from 0th index to i-1th index
        sum = Presum[i - 1]
        presum = 0
        it = i

        # counter turns true when sum
        # is obtained from a segment
        flag = 0

        # iterate till the last number
        while (it < n):
          
            # sum of segments
            presum = presum + ord(s[it]) - ord('0')

            # if segment sum is equal
            # to first segment
            if (presum == sum):
                presum = 0
                flag = 1
                
            # when greater than not possible
            elif (presum > sum):
                break

            it = it + 1

        # if at the end 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
    return False

# Driver Code
if __name__ == '__main__':
    s = "73452"
    if (check(s)):
        print("Yes")
    else:
        print("No")

# This code is contributed by rakeshsahni


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
 
Time Complexity: O(N2) 
Auxiliary Space: O(N)
 

My Personal Notes
arrow_drop_up
Next

Partition a number into two divisible parts
Recommended Articles
Page :
Find the sums for which an array can be divided into sub-arrays of equal sum
31, Dec 18
First N natural can be divided into two sets with given difference and co-prime sums
18, Apr 18
Program to find remainder when large number is divided by 11
09, Nov 17
Program to find remainder when large number is divided by r
18, Oct 18
Partition the array into three equal sum segments
21, Mar 19
How to store a very large number of more than 100 digits in C++
13, Jul 20
Multiply large integers under large modulo
01, May 17
Check if a string can be split into two substrings with equal number of vowels
16, Feb 21
Split the array into odd number of segments of odd lengths
14, Feb 19
Minimum splits required to convert a number into prime segments
26, Mar 20
Number of times an array can be partitioned repetitively into two subarrays with equal sum
26, Jun 20
Check if a line at 45 degree can divide the plane into two equal weight parts
01, Oct 18
Partition an array such into maximum increasing segments
18, Nov 18
Check whether two strings can be made equal by reversing substring of equal length from both strings
15, Jul 20
GCD of two numbers when one of them can be very large
16, Aug 16
Check if two non-duplicate strings can be made equal after at most two swaps in one string
14, Dec 21
Check if a string can be split into two strings with same number of K-frequent characters
08, Jul 20
Check if a Binary String can be split into disjoint subsequences which are equal to "010"
11, Jun 21
Check if a numeric string can be split into substrings having difference between consecutive numbers equal to K
18, Jun 21
Check if a large number is divisible by a number which is a power of 2
10, Jul 20
Sum of two large numbers
18, Mar 17
Check if a string can be split into 3 substrings such that one of them is a substring of the other two
05, Apr 21
Check if a string can be split into two substrings such that one substring is a substring of the other
23, Dec 20
Check if a large number is divisible by 3 or not
19, Mar 17
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Striver
@Striver
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!