# Modulo power for large numbers represented as strings

Given two numbers sa and sb represented as strings, find ab % MOD where MOD is 1e9 + 7. The numbers a and b can contain upto 106 digits.

Examples:

Input : sa = 2, sb = 3
Output : 8

Input : sa = 10000000000000000000000000000000000000000000
sb = 10000000000000000000000000000000000000000000
Output : 494234546

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

As a and b very large (may contain upto 10^6 digits each). So what we can do, we apply Fermat’s little theorem and property of modulo to reduce a and b.
Reduce a:
As we know,

`(ab) % MOD = ((a % MOD)b) % MOD`

Reduce b:
How to reduce b, We have already discuss in Find (a^b)%m where ‘b’ is very large

Now finally we have both a and b are in range of 1<=a, b<=10^9+7. Hence we can now use our modular exponentiation to calculate required answer.

## C++

 `// CPP program to find (a^b) % MOD where a and ` `// b may be very large and represented as strings. ` `#include ` `using` `namespace` `std; ` ` `  `#define ll long long int ` `const` `ll MOD = 1e9 + 7; ` ` `  `// Returns modulo exponentiation for two numbers ` `// represented as long long int. It is used by ` `// powerStrings(). Its complexity is log(n) ` `ll powerLL(ll x, ll n) ` `{ ` `    ``ll result = 1; ` `    ``while` `(n) { ` `        ``if` `(n & 1) ` `            ``result = result * x % MOD; ` `        ``n = n / 2; ` `        ``x = x * x % MOD; ` `    ``} ` `    ``return` `result; ` `} ` ` `  `// Returns modulo exponentiation for two numbers ` `// represented as strings. It is used by ` `// powerStrings() ` `ll powerStrings(string sa, string sb) ` `{ ` `    ``// We convert strings to number  ` ` `  `    ``ll a = 0, b = 0; ` ` `  `    ``// calculating  a % MOD ` `    ``for` `(``int` `i = 0; i < sa.length(); i++) ` `        ``a = (a * 10 + (sa[i] - ``'0'``)) % MOD; ` ` `  `    ``// calculating  b % (MOD - 1) ` `    ``for` `(``int` `i = 0; i < sb.length(); i++) ` `        ``b = (b * 10 + (sb[i] - ``'0'``)) % (MOD - 1); ` ` `  `    ``// Now a and b are long long int. We ` `    ``// calculate a^b using modulo exponentiation ` `    ``return` `powerLL(a, b); ` `} ` ` `  `int` `main() ` `{ ` `    ``// As numbers are very large ` `    ``// that is it may contains upto ` `    ``// 10^6 digits. So, we use string. ` `    ``string sa = ``"2"``, sb = ``"3"``; ` ` `  `    ``cout << powerStrings(sa, sb) << endl; ` `    ``return` `0; ` `} `

## Java

 `// Java program to find (a^b) % MOD  ` `// where a and b may be very large  ` `// and represented as strings.  ` `import` `java.util.*; ` ` `  `class` `GFG  ` `{ ` ` `  `    ``static` `long` `MOD = (``long``) (1e9 + ``7``); ` ` `  `    ``// Returns modulo exponentiation for two numbers  ` `    ``// represented as long long int. It is used by  ` `    ``// powerStrings(). Its complexity is log(n)  ` `    ``static` `long` `powerLL(``long` `x, ``long` `n)  ` `    ``{ ` `        ``long` `result = ``1``; ` `        ``while` `(n > ``0``)  ` `        ``{ ` `            ``if` `(n % ``2` `== ``1``)  ` `            ``{ ` `                ``result = result * x % MOD; ` `            ``} ` `            ``n = n / ``2``; ` `            ``x = x * x % MOD; ` `        ``} ` `        ``return` `result; ` `    ``} ` ` `  `    ``// Returns modulo exponentiation for ` `    ``// two numbers  represented as strings.   ` `    ``// It is used by powerStrings()  ` `    ``static` `long` `powerStrings(String sa, String sb)  ` `    ``{ ` `        ``// We convert strings to number  ` `        ``long` `a = ``0``, b = ``0``; ` ` `  `        ``// calculating a % MOD  ` `        ``for` `(``int` `i = ``0``; i < sa.length(); i++)  ` `        ``{ ` `            ``a = (a * ``10` `+ (sa.charAt(i) - ``'0'``)) %  ` `                                               ``MOD; ` `        ``} ` ` `  `        ``// calculating b % (MOD - 1)  ` `        ``for` `(``int` `i = ``0``; i < sb.length(); i++)  ` `        ``{ ` `            ``b = (b * ``10` `+ (sb.charAt(i) - ``'0'``)) % ` `                                        ``(MOD - ``1``); ` `        ``} ` ` `  `        ``// Now a and b are long long int. We  ` `        ``// calculate a^b using modulo exponentiation  ` `        ``return` `powerLL(a, b); ` `    ``} ` ` `  `    ``// Driver code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `         `  `        ``// As numbers are very large  ` `        ``// that is it may contains upto  ` `        ``// 10^6 digits. So, we use string.  ` `        ``String sa = ``"2"``, sb = ``"3"``; ` `        ``System.out.println(powerStrings(sa, sb)); ` `    ``} ` `}  ` ` `  `// This code is contributed by Rajput-JI `

## Python3

 `# Python3 program to find (a^b) % MOD  ` `# where a and b may be very large  ` `# and represented as strings. ` `MOD ``=` `1000000007``; ` ` `  `# Returns modulo exponentiation  ` `# for two numbers represented as ` `# long long int. It is used by ` `# powerStrings(). Its complexity  ` `# is log(n) ` `def` `powerLL(x, n): ` ` `  `    ``result ``=` `1``; ` `    ``while` `(n):  ` `        ``if` `(n & ``1``): ` `            ``result ``=` `result ``*` `x ``%` `MOD; ` `        ``n ``=` `int``(n ``/` `2``); ` `        ``x ``=` `x ``*` `x ``%` `MOD; ` `    ``return` `result; ` ` `  `# Returns modulo exponentiation  ` `# for two numbers represented as  ` `# strings. It is used by powerStrings() ` `def` `powerStrings(sa, sb): ` `     `  `    ``# We convert strings to number  ` `    ``a ``=` `0``; ` `    ``b ``=` `0``; ` ` `  `    ``# calculating a % MOD ` `    ``for` `i ``in` `range``(``len``(sa)): ` `        ``a ``=` `(a ``*` `10` `+` `(``ord``(sa[i]) ``-`  `                       ``ord``(``'0'``))) ``%` `MOD; ` ` `  `    ``# calculating b % (MOD - 1) ` `    ``for` `i ``in` `range``(``len``(sb)): ` `        ``b ``=` `(b ``*` `10` `+` `(``ord``(sb[i]) ``-`  `                       ``ord``(``'0'``))) ``%` `(MOD ``-` `1``); ` ` `  `    ``# Now a and b are long long int.  ` `    ``# We calculate a^b using modulo  ` `    ``# exponentiation ` `    ``return` `powerLL(a, b); ` ` `  `# Driver code ` ` `  `# As numbers are very large ` `# that is it may contains upto ` `# 10^6 digits. So, we use string. ` `sa ``=` `"2"``; ` `sb ``=` `"3"``; ` ` `  `print``(powerStrings(sa, sb)); ` `     `  `# This code is contributed by mits `

## C#

 `// C# program to find (a^b) % MOD where a and b   ` `// may be very large and represented as strings.  ` `using` `System; ` ` `  `class` `GFG  ` `{  ` `    ``static` `long` `MOD = (``long``) (1e9 + 7);  ` `     `  `    ``// Returns modulo exponentiation for two numbers  ` `    ``// represented as long long int. It is used by  ` `    ``// powerStrings(). Its complexity is log(n)  ` `    ``static` `long` `powerLL(``long` `x, ``long` `n)  ` `    ``{  ` `        ``long` `result = 1;  ` `        ``while` `(n > 0)  ` `        ``{  ` `            ``if` `(n % 2 == 1)  ` `            ``{  ` `                ``result = result * x % MOD;  ` `            ``}  ` `            ``n = n / 2;  ` `            ``x = x * x % MOD;  ` `        ``}  ` `        ``return` `result;  ` `    ``}  ` `     `  `    ``// Returns modulo exponentiation for  ` `    ``// two numbers represented as strings.  ` `    ``// It is used by powerStrings()  ` `    ``static` `long` `powerStrings(String sa, String sb)  ` `    ``{  ` `        ``// We convert strings to number  ` `        ``long` `a = 0, b = 0;  ` `     `  `        ``// calculating a % MOD  ` `        ``for` `(``int` `i = 0; i < sa.Length; i++)  ` `        ``{  ` `            ``a = (a * 10 + (sa[i] - ``'0'``)) % MOD;  ` `        ``}  ` `     `  `        ``// calculating b % (MOD - 1)  ` `        ``for` `(``int` `i = 0; i < sb.Length; i++)  ` `        ``{  ` `            ``b = (b * 10 + (sb[i] - ``'0'``)) % (MOD - 1);  ` `        ``}  ` `     `  `        ``// Now a and b are long long int. We  ` `        ``// calculate a^b using modulo exponentiation  ` `        ``return` `powerLL(a, b);  ` `    ``}  ` `     `  `    ``// Driver code  ` `    ``public` `static` `void` `Main(String[] args)  ` `    ``{  ` `         `  `        ``// As numbers are very large  ` `        ``// that is it may contains upto  ` `        ``// 10^6 digits. So, we use string.  ` `        ``String sa = ``"2"``, sb = ``"3"``;  ` `        ``Console.WriteLine(powerStrings(sa, sb));  ` `    ``}  ` `}  ` `     `  `// This code is contributed by 29AjayKumar `

## PHP

 ` `

Output:

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