Find unit digit of x raised to power y

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

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 x^y 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 <bits/stdc++.h>
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

<?php
// Efficient PHP program to
// find unit digit of x^y.

// Returns unit digit of x
// raised to power y
function 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 = 0; $i < $y; $i++)
        $res = ($res * $x) % 10;

    return $res;
}

// Driver Code
echo(unitDigitXRaisedY(4, 2));

// This code is contributed by Ajit.
?>

Javascript

<script>

// Efficient Javascript program to
// find unit digit of x^y.

// Returns unit digit of x
// raised to power y
function unitDigitXRaisedY(x, y)
{

    // Initialize result as 1 to
    // handle case when y is 0.
    let res = 1;

    // One by one multiply with x
    // mod 10 to avoid overflow.
    for(let i = 0; i < y; i++)
        res = (res * x) % 10;

    return res;
}

// Driver Code
document.write(unitDigitXRaisedY(4, 2));

// This code is contributed by _saurabh_jaiswal.

</script>

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<iostream>
#include<math.h>
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

<?php
// PHP code to find the unit
// digit of x raised to power y.

// find unit digit
function 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)(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
echo(unitnumber($x, $y));

// This code is contributed by Ajit.
?>

Javascript

<script>

// Javascript code to find the unit
// digit of x raised to power y.

// find unit digit
function 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 ((parseInt(Math.pow(x, y))) % 10);
}

// Driver code
let x = 133;
let y = 5;

// get unit digit number here we pass
// the unit digit of x and the last
// cyclicity number that is y%4
document.write(unitnumber(x, y));

// This code is contributed by _saurabh_jaiswal.

</script>

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 <iostream>
#include <cmath>
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