Check if a large number can be divided into two or more segments of equal sum
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:
- Since the number can be large, the number is initialized in a string.
- Use prefixSum array to store the prefix sum of the array.
- 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].
- Use another pointer that traverses from i to n, and keep adding the sum.
- If the sum at any stage is equal to Prefixsum[i-1], then the segment has a sum equal to first.
- Reinitialize the segment sum value to 0 and keep moving the pointer.
- 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.
- 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" ); } } |
Python 3
def check(s):
# length of string
n = len(s)
# array to store prefix sum
Presum = [0] * n
# first index
Presum[0] = int(s[0])
# calculate the prefix
for i in range(1, n):
Presum[i] = Presum[i - 1] + int(s[i])
# iterate for all number from second number
for i in range(1, n - 1):
# 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 += int(s[it])
# 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 += 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
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)
Please Login to comment...