Related Articles
Find Last Digit of a^b for Large Numbers
• Difficulty Level : Medium
• Last Updated : 13 Apr, 2021

You are given two integer numbers, the base a (number of digits d, such that 1 <= d <= 1000) and the index b (0 <= b <= 922*10^15). You have to find the last digit of a^b.
Examples:

```Input  : 3 10
Output : 9

Input  : 6 2
Output : 6

Input  : 150 53
Output : 0```

After taking few examples, we can notice below pattern.

```Number  |  Last digits that repeat in cycle
1     |     1
2     |  4, 8, 6, 2
3     |  9, 7, 1, 3
4     |  6, 4
5     |  5
6     |  6
7     |  9, 3, 1, 7
8     |  4, 2, 6, 8
9     |  1, 9```

In the given table, we can see that maximum length for cycle repetition is 4.
Example: 2*2 = 4*2 = 8*2 = 16*2 = 32 last digit in 32 is 2 that means after multiplying 4 times digit repeat itself. So the algorithm is very simple .
Source : Brilliants.org
Algorithm :

1. Since number are very large we store them as a string.
2. Take last digit in base a.
3. Now calculate b%4. Here b is very large.
• If b%4==0 that means b is completely divisible by 4, so our exponent now will be exp = 4 because by multiplying number 4 times, we get the last digit according to cycle table in above diagram.
• If b%4!=0 that means b is not completely divisible by 4, so our exponent now will be exp=b%4 because by multiplying number exponent times, we get the last digit according to cycle table in above diagram.
• Now calculate ldigit = pow( last_digit_in_base, exp ).
• Last digit of a^b will be ldigit%10.

Below is the implementation of above algorithm.

## C++

 `// C++ code to find last digit of a^b``#include ``using` `namespace` `std;` `// Function to find b % a``int` `Modulo(``int` `a, ``char` `b[])``{``    ``// Initialize result``    ``int` `mod = 0;` `    ``// calculating mod of b with a to make``    ``// b like 0 <= b < a``    ``for` `(``int` `i = 0; i < ``strlen``(b); i++)``        ``mod = (mod * 10 + b[i] - ``'0'``) % a;` `    ``return` `mod; ``// return modulo``}` `// function to find last digit of a^b``int` `LastDigit(``char` `a[], ``char` `b[])``{``    ``int` `len_a = ``strlen``(a), len_b = ``strlen``(b);` `    ``// if a and b both are 0``    ``if` `(len_a == 1 && len_b == 1 && b == ``'0'` `&& a == ``'0'``)``        ``return` `1;` `    ``// if exponent is 0``    ``if` `(len_b == 1 && b == ``'0'``)``        ``return` `1;` `    ``// if base is 0``    ``if` `(len_a == 1 && a == ``'0'``)``        ``return` `0;` `    ``// if exponent is divisible by 4 that means last``    ``// digit will be pow(a, 4) % 10.``    ``// if exponent is not divisible by 4 that means last``    ``// digit will be pow(a, b%4) % 10``    ``int` `exp` `= (Modulo(4, b) == 0) ? 4 : Modulo(4, b);` `    ``// Find last digit in 'a' and compute its exponent``    ``int` `res = ``pow``(a[len_a - 1] - ``'0'``, ``exp``);` `    ``// Return last digit of result``    ``return` `res % 10;``}` `// Driver program to run test case``int` `main()``{``    ``char` `a[] = ``"117"``, b[] = ``"3"``;``    ``cout << LastDigit(a, b);``    ``return` `0;``}`

## Java

 `// Java code to find last digit of a^b``import` `java.io.*;``import` `java.math.*;` `class` `GFG {` `    ``// Function to find b % a``    ``static` `int` `Modulo(``int` `a, ``char` `b[])``    ``{``        ``// Initialize result``        ``int` `mod = ``0``;` `        ``// calculating mod of b with a to make``        ``// b like 0 <= b < a``        ``for` `(``int` `i = ``0``; i < b.length; i++)``            ``mod = (mod * ``10` `+ b[i] - ``'0'``) % a;` `        ``return` `mod; ``// return modulo``    ``}` `    ``// Function to find last digit of a^b``    ``static` `int` `LastDigit(``char` `a[], ``char` `b[])``    ``{``        ``int` `len_a = a.length, len_b = b.length;` `        ``// if a and b both are 0``        ``if` `(len_a == ``1` `&& len_b == ``1` `&& b[``0``] == ``'0'` `&& a[``0``] == ``'0'``)``            ``return` `1``;` `        ``// if exponent is 0``        ``if` `(len_b == ``1` `&& b[``0``] == ``'0'``)``            ``return` `1``;` `        ``// if base is 0``        ``if` `(len_a == ``1` `&& a[``0``] == ``'0'``)``            ``return` `0``;` `        ``// if exponent is divisible by 4 that means last``        ``// digit will be pow(a, 4) % 10.``        ``// if exponent is not divisible by 4 that means last``        ``// digit will be pow(a, b%4) % 10``        ``int` `exp = (Modulo(``4``, b) == ``0``) ? ``4` `: Modulo(``4``, b);` `        ``// Find last digit in 'a' and compute its exponent``        ``int` `res = (``int``)(Math.pow(a[len_a - ``1``] - ``'0'``, exp));` `        ``// Return last digit of result``        ``return` `res % ``10``;``    ``}` `    ``// Driver program to run test case``    ``public` `static` `void` `main(String args[]) ``throws` `IOException``    ``{``        ``char` `a[] = ``"117"``.toCharArray(), b[] = { ``'3'` `};``        ``System.out.println(LastDigit(a, b));``    ``}``}` `// This code is contributed by Nikita Tiwari.`

Python3

``````
# Python 3 code to find last digit of a ^ b

import math

# Function to find b % a
def Modulo(a, b) :
# Initialize result
mod = 0

# calculating mod of b with a to make
# b like 0 <= b < a
for i in range(0, len(b)) :
mod = (mod * 10 + (int)(b[i])) % a

return mod # return modulo

# function to find last digit of a ^ b
def LastDigit(a, b) :
len_a = len(a)
len_b = len(b)

# if a and b both are 0
if (len_a == 1 and len_b == 1 and b == '0' and a == '0') :
return 1

# if exponent is 0
if (len_b == 1 and b=='0') :
return 1

# if base is 0
if (len_a == 1 and a == '0') :
return 0

# if exponent is divisible by 4 that means last
# digit will be pow(a, 4) % 10.
# if exponent is not divisible by 4 that means last
# digit will be pow(a, b % 4) % 10
if((Modulo(4, b) == 0)) :
exp = 4
else :
exp = Modulo(4, b)

# Find last digit in 'a' and compute its exponent
res = math.pow((int)(a[len_a - 1]), exp)

# Return last digit of result
return res % 10

# Driver program to run test case
a = ['1', '1', '7']
b = ['3']
print(LastDigit(a, b))

# This code is contributed to Nikita Tiwari.
``````

## C#

 `// C# code to find last digit of a^b.``using` `System;` `class` `GFG {` `    ``// Function to find b % a``    ``static` `int` `Modulo(``int` `a, ``char``[] b)``    ``{``        ` `        ``// Initialize result``        ``int` `mod = 0;` `        ``// calculating mod of b with a``        ``// to make b like 0 <= b < a``        ``for` `(``int` `i = 0; i < b.Length; i++)``            ``mod = (mod * 10 + b[i] - ``'0'``) % a;` `        ``// return modulo``        ``return` `mod;``    ``}` `    ``// Function to find last digit of a^b``    ``static` `int` `LastDigit(``char``[] a, ``char``[] b)``    ``{``        ``int` `len_a = a.Length, len_b = b.Length;` `        ``// if a and b both are 0``        ``if` `(len_a == 1 && len_b == 1 &&``                   ``b == ``'0'` `&& a == ``'0'``)``            ``return` `1;` `        ``// if exponent is 0``        ``if` `(len_b == 1 && b == ``'0'``)``            ``return` `1;` `        ``// if base is 0``        ``if` `(len_a == 1 && a == ``'0'``)``            ``return` `0;` `        ``// if exponent is divisible by 4``        ``// that means last digit will be``        ``// pow(a, 4) % 10. if exponent is``        ``//not divisible by 4 that means last``        ``// digit will be pow(a, b%4) % 10``        ``int` `exp = (Modulo(4, b) == 0) ? 4``                            ``: Modulo(4, b);` `        ``// Find last digit in 'a' and``        ``// compute its exponent``        ``int` `res = (``int``)(Math.Pow(a[len_a - 1]``                                ``- ``'0'``, exp));` `        ``// Return last digit of result``        ``return` `res % 10;``    ``}` `    ``// Driver program to run test case``    ``public` `static` `void` `Main()``    ``{``        ` `        ``char``[] a = ``"117"``.ToCharArray(),``        ``b = { ``'3'` `};``        ` `        ``Console.Write(LastDigit(a, b));``    ``}``}` `// This code is contributed by nitin mittal.`

## PHP

 ``

## Javascript

 ``

Output :

`3`

This article is contributed by Shashank Mishra ( Gullu ). This article is reviewed by team geeksforgeeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up