Open In App
Related Articles

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

Improve
Improve
Improve
Like Article
Like
Save Article
Save
Report issue
Report

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 similar 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 the implementation.

C++

// C++ code to find last k digits of a^b
#include <iostream>
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 than 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 than 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);
    }
}

                    

Python3

# 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 than 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 than 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

<?php
// PHP code to find last k digits of a^b
 
/* Iterative Function to calculate
   (x^y)%p in O(log y) */
 
function 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
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
?>

                    

Javascript

<script>
// javascript code to find last k digits of a^b
 
    /* Iterative Function to calculate (x^y)%p in O(log y) */
    function power(x , y , p) {
        var 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 parseInt( res);
    }
 
    // Method to print last k digits of a^b
    function printLastKDigits(a , b , k) {
        document.write("Last " + k + " digits of " + a + "^" + b + " = ");
 
        // Generating 10^k
        var 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 than k. In that
        // case we need to print zeros
        for (i = 0; i < k - temp.toString().length; i++)
            document.write(0);
 
        // If temp is not zero then print temp
        // If temp is zero then already printed
        if (temp != 0)
            document.write(temp);
    }
 
    // Driver Method
     
        var a = 11;
        var b = 3;
        var k = 2;
        printLastKDigits(a, b, k);
 
// This code contributed by gauravrajput1
</script>

                    

Output: 
 

Last 2 digits of 11^3 = 31


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


 



Last Updated : 13 Jul, 2022
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads