# Breaking a number such that first part is integral division of second by a power of 10

Given a very large number N, we need to count the total ways such that if we divide the number into two parts a and b, the first part a can be obtained by integral division of second b by some power p of 10 and p>=0.
1 <= No of digits in N <= .

Examples:

```Input : 220
Output : 1
220 can be divided as a = 2 and b = 20
such that for p = 1, b/10 = a.

Input : 1111
Output : 2
We get answer 2 because we need to consider
integral division.
Let's consider the first partition a = 1,
b = 111. for p = 2, b/pow(10,p) = a thus
this is a valid partition.
now a = 11, b = 11. for p = 0, b/pow(10,p)
= a thus this too is a valid combination.

Input : 2202200
Output : 2
for a = 2 b = 202200, p = 5 and
a = 220, b = 2200, p = 1
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Since the number can be very large to be contained even in a long long int we will store it as a string. According to the conditions mentioned in the problem, division is the floor function. A simple and inefficient approach will be to divide the string into two substrings then convert those to integer and perform division.
An efficient method to do it will be to use the string compare function to match the most significant digits of the two strings and ignore the rest( floor function). Below is the implementation of this idea :

## C++

 `#include ` `using` `namespace` `std; ` ` `  `// c++ function to count ways to divide a ` `// string in two parts a and b such that ` `// b/pow(10, p) == a ` `int` `calculate(string N) ` `{ ` `    ``int` `len = N.length(); ` `    ``int` `l = (len) / 2; ` `    ``int` `count = 0; ` ` `  `    ``for` `(``int` `i = 1; i <= l; i++) { ` ` `  `        ``// substring representing int a ` `        ``string s = N.substr(0, i); ` ` `  `        ``// no of digits in a ` `        ``int` `l1 = s.length(); ` ` `  `        ``// consider only most significant  ` `        ``// l1 characters of remaining string  ` `        ``// for int b ` `        ``string t = N.substr(i, l1); ` ` `  `        ``// if any of a or b contains leading 0s ` `        ``// discard this combination ` `        ``if` `(s == ``'0'` `|| t == ``'0'``) ` `            ``continue``; ` ` `  `        ``// if both are equal ` `        ``if` `(s.compare(t) == 0)  ` `            ``count++;         ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// driver function to test above function ` `int` `main() ` `{ ` `    ``string N = ``"2202200"``; ` `    ``cout << calculate(N); ` `    ``return` `0; ` `} `

## Java

 `// Java program to count ways to divide a ` `// String in two parts a and b such that ` `// b/pow(10, p) == a ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `static` `int` `calculate(String N) ` `{ ` `    ``int` `len = N.length(); ` `    ``int` `l = (len) / ``2``; ` `    ``int` `count = ``0``; ` ` `  `    ``for` `(``int` `i = ``1``; i <= l; i++)  ` `    ``{ ` ` `  `        ``// subString representing int a ` `        ``String s = N.substring(``0``, i); ` ` `  `        ``// no of digits in a ` `        ``int` `l1 = s.length(); ` ` `  `        ``// consider only most significant  ` `        ``// l1 characters of remaining String  ` `        ``// for int b ` `        ``String t = N.substring(i, l1 + i); ` ` `  `        ``// if any of a or b contains leading 0s ` `        ``// discard this combination ` `        ``if` `(s.charAt(``0``) == ``'0'` `|| t.charAt(``0``) == ``'0'``) ` `            ``continue``; ` ` `  `        ``// if both are equal ` `        ``if` `(s.compareTo(t) == ``0``)  ` `            ``count++;      ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``String N = ``"2202200"``; ` `    ``System.out.print(calculate(N)); ` `} ` `} ` ` `  `// This code is contributed by Rajput-Ji `

## Python3

 `# Python3 program to count ways to divide ` `# a string in two parts a and b such that ` `# b/pow(10, p) == a ` ` `  `def` `calculate( N ): ` `    ``length ``=` `len``(N) ` `    ``l ``=` `int``((length) ``/` `2``) ` `    ``count ``=` `0` `     `  `    ``for` `i ``in` `range``(l ``+` `1``): ` `         `  `        ``# substring representing int a ` `        ``s ``=` `N[``0``: ``0` `+` `i] ` `         `  `        ``# no of digits in a ` `        ``l1 ``=` `len``(s) ` `         `  `        ``# consider only most significant ` `        ``# l1 characters of remaining  ` `        ``# string for int b ` `        ``t ``=` `N[i: l1 ``+` `i] ` `         `  `        ``# if any of a or b contains  ` `        ``# leading 0s discard this  ` `        ``try``: ` `            ``if` `s[``0``] ``=``=` `'0'` `or` `t[``0``] ``=``=` `'0'``: ` `                ``continue` `        ``except``: ` `            ``continue` `         `  `        ``# if both are equal ` `        ``if` `s ``=``=` `t: ` `            ``count``+``=``1` `    ``return` `count ` `     `  `# driver code to test above function ` `N ``=` `str``(``"2202200"``) ` `print``(calculate(N)) ` ` `  `# This code is contributed by "Sharad_Bhardwaj". `

## C#

 `// C# program to count ways to divide a ` `// String in two parts a and b such that ` `// b/pow(10, p) == a ` `using` `System; ` ` `  `class` `GFG ` `{ ` `static` `int` `calculate(String N) ` `{ ` `    ``int` `len = N.Length; ` `    ``int` `l = (len) / 2; ` `    ``int` `count = 0; ` ` `  `    ``for` `(``int` `i = 1; i <= l; i++)  ` `    ``{ ` ` `  `        ``// subString representing int a ` `        ``String s = N.Substring(0, i); ` ` `  `        ``// no of digits in a ` `        ``int` `l1 = s.Length; ` ` `  `        ``// consider only most significant  ` `        ``// l1 characters of remaining String  ` `        ``// for int b ` `        ``String t = N.Substring(i, l1); ` ` `  `        ``// if any of a or b contains leading 0s ` `        ``// discard this combination ` `        ``if` `(s == ``'0'` `|| t == ``'0'``) ` `            ``continue``; ` ` `  `        ``// if both are equal ` `        ``if` `(s.CompareTo(t) == 0)  ` `            ``count++;      ` `    ``} ` `    ``return` `count; ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(String[] args) ` `{ ` `    ``String N = ``"2202200"``; ` `    ``Console.Write(calculate(N)); ` `} ` `} ` ` `  `// This code is contributed by PrinciRaj1992 `

Output:

```2
```

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : Rajput-Ji, princiraj1992

Article Tags :
Practice Tags :

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.