# Print last k digits of a^b (a raised to power b)

Given positive integers k, a and b we need to print last k digits of a^b ie.. pow(a, b).

```Input Constraint:
k <= 9, a <= 10^6, b<= 10^6
```

Examples:

```Input : a = 11, b = 3, k = 2
Output : 31
Explanation : a^b = 11^3 = 1331, hence
last two digits are 31

Input : a = 10, b = 10000, k = 5
Output : 00000
Explanation : a^b = 1000..........0 (total
zeros = 10000), hence last 5 digits are 00000
```

## Naive Solution

First Calculate a^b, then take last k digits by taking modulo with 10^k. Above solution fails when a^b is too large, as we can hold at most 2^64 -1 in C/C++.

## Efficient Solution

The efficient way is to keep only k digits after every multiplication. This idea is very simiar to discussed in Modular Exponentiation where we discussed a general way to find (a^b)%c, here in this case c is 10^k.

Here is implementation.

## C++

 `// C++ code to find last k digits of a^b ` `#include ` `using` `namespace` `std; ` ` `  `/* Iterative Function to calculate (x^y)%p in O(log y) */` `int` `power(``long` `long` `int` `x, ``long` `long` `int` `y, ``long` `long` `int` `p) ` `{ ` `    ``long` `long` `int` `res = 1; ``// Initialize result ` ` `  `    ``x = x % p; ``// Update x if it is more than or ` `    ``// equal to p ` ` `  `    ``while` `(y > 0) { ` ` `  `        ``// If y is odd, multiply x with result ` `        ``if` `(y & 1) ` `            ``res = (res * x) % p; ` ` `  `        ``// y must be even now ` `        ``y = y >> 1; ``// y = y/2 ` `        ``x = (x * x) % p; ` `    ``} ` `    ``return` `res; ` `} ` ` `  `// C++ function to calculate ` `// number of digits in x ` `int` `numberOfDigits(``int` `x) ` `{ ` `    ``int` `i = 0; ` `    ``while` `(x) { ` `        ``x /= 10; ` `        ``i++; ` `    ``} ` `    ``return` `i; ` `} ` ` `  `// C++ function to print last k digits of a^b ` `void` `printLastKDigits(``int` `a, ``int` `b, ``int` `k) ` `{ ` `    ``cout << ``"Last "` `<< k; ` `    ``cout << ``" digits of "` `<< a; ` `    ``cout << ``"^"` `<< b << ``" = "``; ` `     `  `    ``// Generating 10^k ` `    ``int` `temp = 1; ` `    ``for` `(``int` `i = 1; i <= k; i++) ` `        ``temp *= 10; ` ` `  `    ``// Calling modular exponentiation ` `    ``temp = power(a, b, temp); ` ` `  `    ``// Printing leftmost zeros. Since (a^b)%k  ` `    ``// can have digits less then k. In that ` `    ``// case we need to print zeros ` `    ``for` `(``int` `i = 0; i < k - numberOfDigits(temp); i++) ` `        ``cout << 0; ` ` `  `    ``// If temp is not zero then print temp ` `    ``// If temp is zero then already printed ` `    ``if` `(temp) ` `        ``cout << temp; ` `} ` ` `  `// Driver program to test above functions ` `int` `main() ` `{ ` `    ``int` `a = 11; ` `    ``int` `b = 3; ` `    ``int` `k = 2; ` `    ``printLastKDigits(a, b, k); ` `    ``return` `0; ` `} `

## Java

 `// Java code to find last k digits of a^b ` ` `  `public` `class` `GFG  ` `{ ` `    ``/* Iterative Function to calculate (x^y)%p in O(log y) */` `    ``static` `int` `power(``long` `x, ``long` `y, ``long` `p) ` `    ``{ ` `        ``long` `res = ``1``; ``// Initialize result ` `      `  `        ``x = x % p; ``// Update x if it is more than or ` `        ``// equal to p ` `      `  `        ``while` `(y > ``0``) { ` `      `  `            ``// If y is odd, multiply x with result ` `            ``if` `((y & ``1``) != ``0``) ` `                ``res = (res * x) % p; ` `      `  `            ``// y must be even now ` `            ``y = y >> ``1``; ``// y = y/2 ` `            ``x = (x * x) % p; ` `        ``} ` `        ``return` `(``int``) res; ` `    ``} ` `      `  `    ``// Method  to print last k digits of a^b ` `    ``static` `void` `printLastKDigits(``int` `a, ``int` `b, ``int` `k) ` `    ``{ ` `        ``System.out.print(``"Last "` `+ k + ``" digits of "` `+ a + ` `                            ``"^"`  `+  b + ``" = "``); ` `          `  `        ``// Generating 10^k ` `        ``int` `temp = ``1``; ` `        ``for` `(``int` `i = ``1``; i <= k; i++) ` `            ``temp *= ``10``; ` `      `  `        ``// Calling modular exponentiation ` `        ``temp = power(a, b, temp); ` `      `  `        ``// Printing leftmost zeros. Since (a^b)%k  ` `        ``// can have digits less then k. In that ` `        ``// case we need to print zeros ` `        ``for` `(``int` `i = ``0``; i < k - Integer.toString(temp).length() ; i++) ` `            ``System.out.print(``0``); ` `      `  `        ``// If temp is not zero then print temp ` `        ``// If temp is zero then already printed ` `        ``if` `(temp != ``0``) ` `            ``System.out.print(temp); ` `    ``} ` `     `  `    ``// Driver Method ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``int` `a = ``11``; ` `        ``int` `b = ``3``; ` `        ``int` `k = ``2``; ` `        ``printLastKDigits(a, b, k); ` `    ``} ` `} `

## Python 3

 `# Python 3 code to find last  ` `# k digits of a^b ` ` `  `# Iterative Function to calculate  ` `# (x^y)%p in O(log y)  ` `def` `power(x, y, p): ` ` `  `    ``res ``=` `1` `# Initialize result ` ` `  `    ``x ``=` `x ``%` `p ``# Update x if it is more  ` `              ``# than or equal to p ` ` `  `    ``while` `(y > ``0``) : ` ` `  `        ``# If y is odd, multiply ` `        ``# x with result ` `        ``if` `(y & ``1``): ` `            ``res ``=` `(res ``*` `x) ``%` `p ` ` `  `        ``# y must be even now ` `        ``y ``=` `y >> ``1` `# y = y/2 ` `        ``x ``=` `(x ``*` `x) ``%` `p ` `     `  `    ``return` `res ` ` `  `# function to calculate ` `# number of digits in x ` `def` `numberOfDigits(x): ` ` `  `    ``i ``=` `0` `    ``while` `(x) : ` `        ``x ``/``/``=` `10` `        ``i ``+``=` `1` ` `  `    ``return` `i ` ` `  `# function to print last k digits of a^b ` `def` `printLastKDigits( a, b, k): ` ` `  `    ``print``(``"Last "` `+` `str``( k)``+``" digits of "` `+`  `                    ``str``(a) ``+` `"^"` `+` `str``(b), end ``=` `" = "``) ` `     `  `    ``# Generating 10^k ` `    ``temp ``=` `1` `    ``for` `i ``in` `range``(``1``, k ``+` `1``): ` `        ``temp ``*``=` `10` ` `  `    ``# Calling modular exponentiation ` `    ``temp ``=` `power(a, b, temp) ` ` `  `    ``# Printing leftmost zeros. Since (a^b)%k  ` `    ``# can have digits less then k. In that ` `    ``# case we need to print zeros ` `    ``for` `i ``in` `range``( k ``-` `numberOfDigits(temp)): ` `        ``print``(``"0"``) ` ` `  `    ``# If temp is not zero then print temp ` `    ``# If temp is zero then already printed ` `    ``if` `(temp): ` `        ``print``(temp) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `"__main__"``: ` `    ``a ``=` `11` `    ``b ``=` `3` `    ``k ``=` `2` `    ``printLastKDigits(a, b, k) ` ` `  `# This code is contributed  ` `# by ChitraNayal `

## C#

 `// C# code to find last k digits of a^b ` `using` `System; ` ` `  `class` `GFG  ` `{ ` ` `  `// Iterative Function to calculate  ` `// (x^y)%p in O(log y)  ` `static` `int` `power(``long` `x, ``long` `y, ``long` `p) ` `{ ` `    ``long` `res = 1; ``// Initialize result ` ` `  `    ``x = x % p; ``// Update x if it is more  ` `               ``// than or equal to p ` ` `  `    ``while` `(y > 0)  ` `    ``{ ` ` `  `        ``// If y is odd, multiply x with result ` `        ``if` `((y & 1) != 0) ` `            ``res = (res * x) % p; ` ` `  `        ``// y must be even now ` `        ``y = y >> 1; ``// y = y/2 ` `        ``x = (x * x) % p; ` `    ``} ` `    ``return` `(``int``) res; ` `} ` ` `  `// Method to print last k digits of a^b ` `static` `void` `printLastKDigits(``int` `a, ``int` `b, ``int` `k) ` `{ ` `    ``Console.Write(``"Last "` `+ k + ``" digits of "` `+  ` `                            ``a + ``"^"` `+ b + ``" = "``); ` `     `  `    ``// Generating 10^k ` `    ``int` `temp = 1; ` `    ``for` `(``int` `i = 1; i <= k; i++) ` `        ``temp *= 10; ` ` `  `    ``// Calling modular exponentiation ` `    ``temp = power(a, b, temp); ` ` `  `    ``// Printing leftmost zeros. Since (a^b)%k  ` `    ``// can have digits less then k. In that ` `    ``// case we need to print zeros ` `    ``for` `(``int` `i = 0;      ` `             ``i < k - temp.ToString().Length; i++) ` `        ``Console.WriteLine(0); ` ` `  `    ``// If temp is not zero then print temp ` `    ``// If temp is zero then already printed ` `    ``if` `(temp != 0) ` `        ``Console.Write(temp); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `    ``int` `a = 11; ` `    ``int` `b = 3; ` `    ``int` `k = 2; ` `    ``printLastKDigits(a, b, k); ` `} ` `} ` ` `  `// This code is contributed ` `// by 29AjayKumar `

## PHP

 ` 0)  ` `    ``{  ` ` `  `        ``// If y is odd, multiply x  ` `        ``// with result  ` `        ``if` `(``\$y` `& 1)  ` `            ``\$res` `= (``\$res` `* ``\$x``) % ``\$p``;  ` ` `  `        ``// y must be even now  ` `        ``\$y` `= ``\$y` `>> 1; ``// y = y/2  ` `        ``\$x` `= (``\$x` `* ``\$x``) % ``\$p``;  ` `    ``}  ` `    ``return` `\$res``;  ` `}  ` ` `  `// function to calculate  ` `// number of digits in x  ` `function` `numberOfDigits(``\$x``)  ` `{  ` `    ``\$i` `= 0;  ` `    ``while` `(``\$x``)  ` `    ``{  ` `        ``\$x` `= (int)``\$x` `/ 10;  ` `        ``\$i``++;  ` `    ``}  ` `    ``return` `\$i``;  ` `}  ` ` `  `// function to print last k digits of a^b  ` `function` `printLastKDigits( ``\$a``, ``\$b``, ``\$k``)  ` `{  ` `    ``echo` `"Last "``,``\$k``;  ` `    ``echo` `" digits of "` `,``\$a``;  ` `    ``echo` `"^"` `, ``\$b` `, ``" = "``;  ` `     `  `    ``// Generating 10^k  ` `    ``\$temp` `= 1;  ` `    ``for` `(``\$i` `= 1; ``\$i` `<= ``\$k``; ``\$i``++)  ` `        ``\$temp` `*= 10;  ` ` `  `    ``// Calling modular exponentiation  ` `    ``\$temp` `= power(``\$a``, ``\$b``, ``\$temp``);  ` ` `  `    ``// Printing leftmost zeros. Since  ` `    ``// (a^b)%k can have digits less  ` `    ``// then k. In that case we need ` `    ``// to print zeros  ` `    ``for` `(``\$i` `= 0;  ` `         ``\$i` `< ``\$k` `- numberOfDigits(``\$temp``); ``\$i``++)  ` `        ``echo` `0;  ` ` `  `    ``// If temp is not zero then print temp  ` `    ``// If temp is zero then already printed  ` `    ``if` `(``\$temp``)  ` `        ``echo` `\$temp``;  ` `}  ` ` `  `// Driver Code ` `\$a` `= 11;  ` `\$b` `= 3;  ` `\$k` `= 2;  ` `printLastKDigits(``\$a``, ``\$b``, ``\$k``);  ` ` `  `// This code is contributed by ajit ` `?> `

Output:

```Last 2 digits of 11^3 = 31
```

Time Complexity : O(log b)
Space Complexity : O(1)

This article is contributed by Pratik Chhajer. 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.