# 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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next