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 [tabby title="PHP"]

 ` `

Output:

```8
```

My Personal Notes arrow_drop_up