Dado un número n, encuentre los primeros k dígitos de n^n

Dado un número n, encuentra los primeros k dígitos de n ⁿ , donde k es un valor menor que el número de dígitos en n ⁿ  
Ejemplos :
 

 Input :  n = 10
          k = 2
 Output : 10
The first 2 digits in 1010 are 10.

 Input :  n = 144
          k = 6
 Output : 637087 

 Input:  n = 1250
         k = 5
 Output:  13725 

El problema se puede resolver de varias maneras, de las cuales dos son:
Método 1 (Simple): Un método ingenuo que consiste en calcular el valor real y luego dividirlo por 10 hasta obtener la respuesta requerida. Sin embargo, este método no puede aceptar una entrada superior a n = 15, ya que provocaría un desbordamiento. 
 

// C++ program to find the first k digits of n^n
#include <bits/stdc++.h>
using namespace std;
 
// function that manually calculates n^n and then
// removes digits until k digits remain
unsigned long long firstkdigits(int n, int k)
{
   unsigned long long product = 1;
 
   for (int i = 0 ; i < n ; i++)
      product *= n;
 
   // loop will terminate when there are only
   // k digits left
   while ((int)(product / pow(10, k)) != 0)
      product = product / 10;
 
   return product;
}
 
//driver function
int main()
{
   int n = 15;
   int k = 4;
   cout << firstkdigits(n, k);
   return 0;
}

// Java program to find the first k digits of n^n
public class Digits
{
    // function that manually calculates n^n and then
    // removes digits until k digits remain
    static long firstkdigits(int n, int k)
    {
        long product = 1;
        for (int i = 0 ; i < n ; i++)
           product *= n;
     
       // loop will terminate when there are only
        // k digits left
       while ((int)(product / Math.pow(10, k)) != 0)
            product = product / 10;
        return product;
    }
     
    public static void main(String[] args)
    {
      int n = 15;
      int k = 4;
      System.out.println(firstkdigits(n, k));
    }
}
 
//This code is contributed by Saket Kumar

# Python 3 program to find the
# first k digits of n^n
 
# function that manually calculates
# n^n and then removes digits until
# k digits remain
def firstkdigits(n, k):
 
    product = 1
     
    for i in range(n ):
        product *= n
     
    # loop will terminate when there
    # are only k digits left
    while ((product // pow(10, k)) != 0):
        product = product // 10
     
    return product
 
# Driver Code
n = 15
k = 4
print(firstkdigits(n, k))
 
# This code is contributed
# by ChitraNayal

// C# program to find the
// first k digits of n^n
using System;
 
class Digits
{
    // function that manually calculates
    // n^n and then removes digits until
    // k digits remain
    static long firstkdigits(int n, int k)
    {
        long product = 1;
        for (int i = 0 ; i < n ; i++)
        product *= n;
     
    // loop will terminate when there
    // are only k digits left
    while ((int)(product / Math.Pow(10, k)) != 0)
            product = product / 10;
             
        return product;
    }
     
    // Driver code
    public static void Main()
    {
      int n = 15;
      int k = 4;
      Console.Write(firstkdigits(n, k));
    }
}
 
// This code is contributed by nitin mittal.

<?php
// PHP program to find the
// first k digits of n^n
 
// function that manually
// calculates n^n and then
// removes digits until k
// digits remain
 
function firstkdigits($n, $k)
{
    $product = 1;
 
    for ($i = 0 ; $i < $n ; $i++)
    $product *= $n;
 
// loop will terminate when
// there are only k digits left
while ((int)($product / pow(10, $k)) != 0)
    $product = (int) $product / 10;
 
return floor($product);
}
 
// Driver Code
$n = 15;
$k = 4;
echo firstkdigits($n, $k);
 
// This code is contributed by aj_36
?>

<script>
// Javascript program to find the first k digits of n^n
     
    // function that manually calculates n^n and then
    // removes digits until k digits remain
    function firstkdigits(n,k)
    {
        let product = 1;
        for (let i = 0 ; i < n ; i++)
           product *= n;
       
       // loop will terminate when there are only
        // k digits left
       while (Math.floor(product / Math.pow(10, k)) != 0)
            product = Math.floor(product / 10);
        return product;
    }
     
    let n = 15;
    let k = 4;
    document.write(firstkdigits(n, k));
     
    // This code is contributed by avanitrachhadiya2155
</script>

Producción : 
 

4378

Método 2: El siguiente método involucra el uso de logaritmos para calcular los primeros k dígitos. El método y los pasos se explican a continuación:
 

1. Sea producto = n ⁿ . Toma el logaritmo en base 10 en ambos lados de la ecuación. Obtenemos log ₁₀ (producto) = log ₁₀ (n ⁿ ), que también podemos escribir como n*log ₁₀ (n)
2. En este ejemplo, obtenemos log ₁₀ (producto) = 3871,137516. Podemos dividir la RHS como 3871 + 0,137516, por lo que nuestra ecuación ahora se puede escribir como log ₁₀ (producto) = 3871 + 0,137516
3. Eleva ambos lados con base 10, y usando el ejemplo anterior, obtenemos product = 10 ³⁸⁷¹ x 10 ^0.137516 . 10 ³⁸⁷¹ no hará una diferencia en nuestros primeros k dígitos ya que solo cambia los puntos decimales. Estamos interesados ​​en la siguiente parte, 10 ^0.137516 , ya que esto determinará los primeros dígitos. 
   En este caso, el valor de 10 ^0.137516 es 1.37251.
4. Por lo tanto, nuestros primeros 5 dígitos requeridos serían 13725.

//C++ program to generate first k digits of
// n ^ n
#include <bits/stdc++.h>
using namespace std;
 
// function to calculate first k digits
// of n^n
long long firstkdigits(int n,int k)
{
 
   //take log10 of n^n. log10(n^n) = n*log10(n)
   long double product = n * log10(n);
 
   // We now try to separate the decimal and
   // integral part of the /product. The floor
   // function returns the smallest integer
   // less than or equal to the argument. So in
   // this case, product - floor(product) will
   // give us the decimal part of product
   long double decimal_part = product - floor(product);
 
   // we now exponentiate this back by raising 10
   // to the power of decimal part
   decimal_part = pow(10, decimal_part);
 
   // We now try to find the power of 10 by which
   // we will have to multiply the decimal part to
   // obtain our final answer
   long long digits = pow(10, k - 1), i = 0;
 
   return decimal_part * digits;
}
 
// driver function
int main()
{
   int n = 1450;
   int k = 6;
   cout << firstkdigits(n, k);
   return 0;
}

// Java  program to find the first k digits of n^n
 
import java.util.*;
import java.lang.*;
import java.io.*;
 
class KDigitSquare
{
      /* function that manually calculates
         n^n and then removes digits until
         k digits remain */
    public static long  firstkdigits(int n, int k)
    {
        //take log10 of n^n.
        // log10(n^n) = n*log10(n)
        double product = n * Math.log10(n);
      
       /* We will now try to separate the decimal
          and integral part of the /product. The
          floor function returns the smallest integer
          less than or equal to the argument. So in
          this case, product - floor(product) will
          give us the decimal part of product */
        double decimal_part = product - Math.floor(product);
      
        // we will now exponentiate this back by
        // raising 10 to the power of decimal part
        decimal_part = Math.pow(10, decimal_part);
      
        /* We now try to find the power of 10 by
           which we will have to multiply the decimal
           part to obtain our final answer*/
        double digits = Math.pow(10, k - 1), i = 0;
         
        return ((long)(decimal_part * digits));
    }
 
    // driver function
    public static void main (String[] args)
    {
        int n = 1450;
        int k = 6;
        System.out.println(firstkdigits(n,k));
    }
}
 
/* This code is contributed by Mr. Somesh Awasthi */

# Python3 program to generate k digits of n ^ n
import math
 
# function to calculate first k digits of n^n
def firstkdigits(n, k):
     
    # take log10 of n^n.
    # log10(n^n) = n*log10(n)
    product = n * math.log(n, 10);
     
    # We now try to separate the decimal
    # and integral part of the /product.
    # The floor function returns the smallest
    # integer less than or equal to the argument.
    # So in this case, product - floor(product)
    # will give us the decimal part of product
    decimal_part = product - math.floor(product);
     
    # we now exponentiate this back
    # by raising 10 to the power of
    # decimal part
    decimal_part = pow(10, decimal_part);
     
    # We now try to find the power of 10 by
    # which we will have to multiply the
    # decimal part to obtain our final answer
    digits = pow(10, k - 1);
     
    return math.floor(decimal_part * digits);
 
# Driver Code
n = 1450;
k = 6;
print(firstkdigits(n, k));
 
# This code is contributed by mits

// C# program to find the first k digits of n^n
using System;
 
class GFG {
     
    /* function that manually calculates
        n^n and then removes digits until
        k digits remain */
    public static long firstkdigits(int n, int k)
    {
         
        // take log10 of n^n.
        // log10(n^n) = n*log10(n)
        double product = n * Math.Log10(n);
     
    /* We will now try to separate the decimal
        and integral part of the /product. The
        floor function returns the smallest integer
        less than or equal to the argument. So in
        this case, product - floor(product) will
        give us the decimal part of product */
        double decimal_part = product -
                              Math.Floor(product);
     
        // we will now exponentiate this back by
        // raising 10 to the power of decimal part
        decimal_part = Math.Pow(10, decimal_part);
     
        /* We now try to find the power of 10 by
        which we will have to multiply the decimal
        part to obtain our final answer*/
        double digits = Math.Pow(10, k - 1);
         
        return ((long)(decimal_part * digits));
    }
 
    // driver function
    public static void Main ()
    {
        int n = 1450;
        int k = 6;
        Console.Write(firstkdigits(n,k));
    }
}
 
// This code is contributed by nitin mittal

<?php
// PHP program to generate
// k digits of n ^ n
 
// function to calculate
// first k digits of n^n
function firstkdigits($n, $k)
{
 
// take log10 of n^n.
// log10(n^n) = n*log10(n)
    $product = $n * log10($n);
 
// We now try to separate the
// decimal and integral part
// of the /product. The floor
// function returns the smallest
// integer less than or equal to
// the argument. So in this case,
// product - floor(product) will
// give us the decimal part of product
 
    $decimal_part = $product -
                    floor($product);
 
// we now exponentiate this back
// by raising 10 to the power of
// decimal part
 
    $decimal_part = pow(10, $decimal_part);
 
// We now try to find the power
// of 10 by which we will have
// to multiply the decimal part
// to obtain our final answer
     
    $digits = pow(10, $k - 1);
    $i = 0;
 
return floor($decimal_part * $digits);
}
 
// Driver Code
$n = 1450;
$k = 6;
echo firstkdigits($n, $k);
 
// This code is contributed by m_kit
?>

<script>
// Javascript  program to find the first k digits of n^n
     
    /* function that manually calculates
         n^n and then removes digits until
         k digits remain */
    function  firstkdigits(n,k)
    {
        //take log10 of n^n.
        // log10(n^n) = n*log10(n)
        let product = n * Math.log10(n);
        
       /* We will now try to separate the decimal
          and integral part of the /product. The
          floor function returns the smallest integer
          less than or equal to the argument. So in
          this case, product - floor(product) will
          give us the decimal part of product */
        let decimal_part = product - Math.floor(product);
        
        // we will now exponentiate this back by
        // raising 10 to the power of decimal part
        decimal_part = Math.pow(10, decimal_part);
        
        /* We now try to find the power of 10 by
           which we will have to multiply the decimal
           part to obtain our final answer*/
        let digits = Math.pow(10, k - 1), i = 0;
           
        return (Math.floor(decimal_part * digits));
    }
     
     // Driver code
    let n = 1450;
    let k = 6;
    document.write(firstkdigits(n, k));
     
    // This code is contributed by rag2127
</script>

Producción : 
 

962948

Este código se ejecuta en tiempo constante y puede manejar grandes valores de entrada de n
Este artículo es una contribución de Deepak Srivatsav . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.