GeeksforGeeks App
Open App
Browser
Continue

# Find unit digit of x raised to power y

Given two numbers x and y, find unit digit of xy.

Examples :

```Input  : x = 2, y = 1
Output : 2
Explanation
2^1 = 2 so units digit is 2.

Input : x = 4, y = 2
Output : 6
Explanation
4^2 = 16 so units digit is 6.```

Method 1 (Simple) Compute value of xy and find its last digit. This method causes overflow for slightly larger values of x and y.
Method 2 (Efficient)
1) Find last digit of x.
2) Compute x^y under modulo 10 and return its value.

## C++

 `// Efficient C++ program to``// find unit digit of x^y.``#include ``using` `namespace` `std;` `// Returns unit digit of x``// raised to power y``int` `unitDigitXRaisedY(``int` `x, ``int` `y)``{``    ``// Initialize result as 1 to``    ``// handle case when y is 0.``    ``int` `res = 1;` `    ``// One by one multiply with x``    ``// mod 10 to avoid overflow.``    ``for` `(``int` `i = 0; i < y; i++)``        ``res = (res * x) % 10;` `    ``return` `res;``}` `// Driver program``int` `main()``{ ``   ``cout << unitDigitXRaisedY(4, 2);``   ``return` `0;``}`

## Java

 `// Efficient Java program to find``// unit digit of x^y.``import` `java.io.*;` `class` `GFG {``    ``// Returns unit digit of x raised to power y``    ``static` `int` `unitDigitXRaisedY(``int` `x, ``int` `y)``    ``{``        ``// Initialize result as 1 to``        ``// handle case when y is 0.``        ``int` `res = ``1``;``    ` `        ``// One by one multiply with x``        ``// mod 10 to avoid overflow.``        ``for` `(``int` `i = ``0``; i < y; i++)``            ``res = (res * x) % ``10``;``    ` `        ``return` `res;``    ``}``    ` `    ``// Driver program``    ``public` `static` `void` `main(String args[])``throws` `IOException``    ``{``    ``System.out.println(unitDigitXRaisedY(``4``, ``2``));``    ``}``}` `// This code is contributed by Nikita Tiwari.`

## Python3

 `# Python3 code to find``# unit digit of x^y.` `# Returns unit digit of``# x raised to power y``def` `unitDigitXRaisedY( x , y ):` `    ``# Initialize result as 1 to``    ``# handle case when y is 0.``    ``res ``=` `1``    ` `    ``# One by one multiply with x``    ``# mod 10 to avoid overflow.``    ``for` `i ``in` `range``(y):``        ``res ``=` `(res ``*` `x) ``%` `10``    ` `    ``return` `res``    ` `# Driver program``print``( unitDigitXRaisedY(``4``, ``2``))`  `# This code is contributed by Abhishek Sharma44.`

## C#

 `// Efficient Java program to find``// unit digit of x^y.``using` `System;` `class` `GFG``{``    ``// Returns unit digit of x raised to power y``    ``static` `int` `unitDigitXRaisedY(``int` `x, ``int` `y)``    ``{``        ``// Initialize result as 1 to``        ``// handle case when y is 0.``        ``int` `res = 1;``    ` `        ``// One by one multiply with x``        ``// mod 10 to avoid overflow.``        ``for` `(``int` `i = 0; i < y; i++)``            ``res = (res * x) % 10;``    ` `        ``return` `res;``    ``}``    ` `    ``// Driver program``    ``public` `static` `void` `Main()``    ``{``    ``Console.WriteLine(unitDigitXRaisedY(4, 2));``    ``}``}` `// This code is contributed by vt_m.`

## PHP

 ``

## Javascript

 ``

Output

`6`

Output :

`6`

Time Complexity: O(y), where y is the power
Auxiliary Space: O(1), as no extra space is required
Further Optimizations: We can compute modular power in Log y.

Method 3 (Direct based on cyclic nature of last digit)
This method depends on the cyclicity with the last digit of x that is

```x   |  power 2  |  power 3  |   power 4  | Cyclicity
0   | .................................. |  .... repeat with 0
1   | .................................. |  .... repeat with 1
2   |     4     |     8     |      6     | .... repeat with 2
3   |     9     |     7     |      1     | .... repeat with 3
4   |     6     |....................... |  .... repeat with 4
5   | .................................. |  .... repeat with 5
6   | .................................. |  .... repeat with 6
7   |     9     |     3     |      1     | .... repeat with 7
8   |     4     |     2     |      6     | .... repeat with 8
9   |     1     | ...................... |  .... repeat with 9 ```

So here we directly mod the power y with 4 because this is the last power after this all number’s repetition start
after this we simply power with number x last digit then we get the unit digit of produced number.

## C++

 `// C++ code to find the unit digit of x``// raised to power y.``#include``#include``using` `namespace` `std;` `// find unit digit``int` `unitnumber(``int` `x, ``int` `y)``{``    ``// Get last digit of x``    ``x = x % 10;``      ` `    ``// Last cyclic modular value``    ``if``(y!=0)``        ``y = y % 4 + 4;` `    ``// here we simply return the``    ``// unit digit or the power``    ``// of a number``    ``return` `(((``int``)(``pow``(x, y))) % 10);``}` `int` `main()``{``    ``int` `x = 133, y = 5;``    ` `    ``// get unit digit number here we pass``    ``// the unit  digit of x and the last``    ``// cyclicity number that is y%4``    ``cout << unitnumber(x, y);`` ` `    ``return` `0;``}`

## Java

 `// Java code to find the unit``// digit of x  raised to power y.``import` `java.io.*;``import` `java.util.*;` `class` `GFG {``    ` `    ``// find unit digit``    ``static` `int` `unitnumber(``int` `x, ``int` `y)``    ``{``        ``// Get last digit of x``        ``x = x % ``10``;``            ` `        ``// Last cyclic modular value``        ``if``(y!=``0``)``             ``y = y % ``4` `+ ``4``;``    ` `        ``// here we simply return the``        ``// unit digit or the power``        ``// of a number``        ``return` `(((``int``)(Math.pow(x, y))) % ``10``);``    ``}``    ` `    ` `    ``public` `static` `void` `main (String[] args)``    ``{``        ``int` `x = ``133``, y = ``5``;``    ` `        ``// get unit digit number here we pass``        ``// the unit digit of x and the last``        ``// cyclicity number that is y%4``        ``System.out.println(unitnumber(x, y));``    ` `    ``}``}` `// This code is contributed by Gitanjali.`

## Python3

 `# Python3 code to find the unit  ``# digit of x raised to power y.``import` `math` `# Find unit digit``def` `unitnumber(x, y):` `    ``# Get last digit of x``    ``x ``=` `x ``%` `10``        ` `    ``# Last cyclic modular value``    ``if` `y!``=``0``:``         ``y ``=` `y ``%` `4` `+` `4` `    ``# Here we simply return ``    ``# the unit digit or the ``    ``# power of a number``    ``return` `(((``int``)(math.``pow``(x, y))) ``%` `10``)`  `# Driver code``x ``=` `133``; y ``=` `5``    ` `# Get unit digit number here we pass``# the unit digit of x and the last``# cyclicity number that is y%4``print``(unitnumber(x, y))`  `# This code is contributed by Gitanjali.`

## C#

 `// C# code to find the unit``// digit of x raised to power y.``using` `System;` `class` `GFG {``    ` `    ``// find unit digit``    ``static` `int` `unitnumber(``int` `x, ``int` `y)``    ``{``        ``// Get last digit of x``        ``x = x % 10;``            ` `        ``// Last cyclic modular value``        ``if``(y!=0)``             ``y = y % 4 + 4;``    ` `        ``// here we simply return the``        ``// unit digit or the power``        ``// of a number``        ``return` `(((``int``)(Math.Pow(x, y))) % 10);``    ``}``    ` `    ``// Driver code``    ``public` `static` `void` `Main ()``    ``{``        ``int` `x = 133, y = 5;``    ` `        ``// get unit digit number here we pass``        ``// the unit digit of x and the last``        ``// cyclicity number that is y%4``        ``Console.WriteLine(unitnumber(x, y));``    ` `    ``}``}` `// This code is contributed by vt_m.`

## PHP

 ``

## Javascript

 ``

Output

`3`

Time Complexity: O(log n)
Auxiliary Space: O(1)

## Approach: Binomial Expansion method

Here are the steps to find the unit digit of x raised to power y using the Binomial Expansion method:

1. Handle special cases:

If y is 0, return 1 as any number raised to power 0 is 1.
If x is 0, return 0 as any number raised to power 0 is 1 and the unit digit of 0 is 0.

2. Calculate the y-th term in the expansion of (x+10)^y using the binomial theorem:

The y-th term in the expansion is given by: C(y, 0)x^y10^0 + C(y, 1)*x^(y-1)*10^1 + … + C(y, y)x^010^y
Here, C(y, k) represents the binomial coefficient, which is equal to y! / (k! * (y-k)!).
We only need to calculate the last term in this expansion, which is C(y, y)x^010^y.

3. Find the unit digit of the y-th term:

The unit digit of the y-th term is the same as the last digit of the y-th term.
We can find the last digit of the y-th term by taking the remainder of the term when divided by 10.

4. Return the unit digit found in step 3 as the result.

## C++

 `#include ``#include ``using` `namespace` `std;` `int` `unit_digit(``int` `x, ``int` `y) {``    ``if` `(y == 0) {``        ``return` `1;``    ``}``    ``if` `(x == 0) {``        ``return` `0;``    ``}``    ``int` `term = ``pow``(x + 10, y);``    ``int` `last_digit = term % 10;``    ``return` `last_digit;``}` `int` `main() {``    ``cout << unit_digit(2, 1) << endl;  ``// Output: 2``    ``cout << unit_digit(4, 2) << endl;  ``// Output: 6``    ``return` `0;``}``// This is contributed by uppalasridevi`

## Java

 `import` `java.lang.Math;` `public` `class` `Main {``    ``public` `static` `int` `unitDigit(``int` `x, ``int` `y) {``        ``if` `(y == ``0``) {``            ``return` `1``;``        ``}``        ``if` `(x == ``0``) {``            ``return` `0``;``        ``}``        ``int` `term = (``int``) Math.pow(x + ``10``, y);``        ``int` `lastDigit = term % ``10``;``        ``return` `lastDigit;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``System.out.println(unitDigit(``2``, ``1``)); ``// Output: 2``        ``System.out.println(unitDigit(``4``, ``2``)); ``// Output: 6``    ``}``}`

## Python3

 `def` `unit_digit(x, y):``    ``if` `y ``=``=` `0``:``        ``return` `1``    ``if` `x ``=``=` `0``:``        ``return` `0``    ``term ``=` `(x``+``10``)``*``*``y``    ``last_digit ``=` `term ``%` `10``    ``return` `last_digit` `# Using the binomial theorem method``print``(unit_digit(``2``, ``1``))  ``# Output: 2``# Using the binomial theorem method``print``(unit_digit(``4``, ``2``))  ``# Output: 6` `# This is contributed by uppalasridevi`

## C#

 `// C# Code for the above approach``using` `System;` `public` `class` `MainClass {` `    ``// Function to find the unit digit``    ``public` `static` `int` `UnitDigit(``int` `x, ``int` `y)``    ``{``        ``if` `(y == 0) {``            ``return` `1;``        ``}``        ``if` `(x == 0) {``            ``return` `0;``        ``}``        ``int` `term = (``int``)Math.Pow(x + 10, y);``        ``int` `lastDigit = term % 10;``        ``return` `lastDigit;``    ``}` `    ``// Driver Code` `    ``public` `static` `void` `Main(``string``[] args)``    ``{``        ``Console.WriteLine(UnitDigit(2, 1)); ``// Output: 2``        ``Console.WriteLine(UnitDigit(4, 2)); ``// Output: 6``    ``}``}`

## Javascript

 `function` `unitDigit(x, y) {``    ``if` `(y == 0) {``        ``return` `1;``    ``}``    ``if` `(x == 0) {``        ``return` `0;``    ``}``    ``let term = Math.pow(x + 10, y);``    ``let lastDigit = term % 10;``    ``return` `lastDigit;``}` `console.log(unitDigit(2, 1)); ``// Output: 2``console.log(unitDigit(4, 2)); ``// Output: 6`

Output

```2
6```

The time complexity  is O(log y), where y is the input variable

The auxiliary space also O(1)

Thanks to DevanshuAgarwal for suggesting above solution.
How to handle large numbers?
Efficient method for Last Digit Of a^b for Large Numbers

My Personal Notes arrow_drop_up