Open in App
Not now

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

• Difficulty Level : Medium
• Last Updated : 16 Feb, 2023

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 ` `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

 ``

Output

`Yes`

Complexity Analysis:

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

My Personal Notes arrow_drop_up
Related Articles