# Modulo power for large numbers represented as strings

• Difficulty Level : Medium
• Last Updated : 03 May, 2021

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

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

 ``

## Javascript

 ``
Output:
`8`

My Personal Notes arrow_drop_up