Primer dígito en el producto de una array de números

Posted on by Rudeus Greyrat

Dada una array de ‘n’ números. Necesitamos encontrar el primer dígito del producto de estos números ‘n’ 
Ejemplos: 
 

Input  : arr[] = {5, 8, 3, 7}
Output : 8
        Product of 5, 8, 3, 7 is 840
        and its first  digit is 8

Input  : arr[] = {6, 7, 9}
Output : 3

Antecedentes: 
Primero comenzamos con una pregunta muy básica sobre cómo encontrar el primer dígito de cualquier número x. Para hacer esto, sigue dividiendo el número hasta que sea mayor que 10. Después de hacer esto, el número que obtendremos será el primer dígito. de x 
 

C++

// C++ implementation to find first digit of a
// single number
#include <bits/stdc++.h>
using namespace std;
 
int firstDigit(int x)
{
    // Keep dividing by 10 until it is
    // greater than equal to 10
    while (x >= 10)
        x = x / 10;
    return x;
}
 
// driver function
int main()
{
    cout << firstDigit(12345) << endl;
    cout << firstDigit(5432) << endl;
}

Java

// Java implementation to find first digit of a
// single number
 
class Test {
    static int firstDigit(int x)
    {
        // Keep dividing by 10 until it is
        // greater than equal to 10
        while (x >= 10)
            x = x / 10;
        return x;
    }
 
    // Driver method
    public static void main(String args[])
    {
        System.out.println(firstDigit(12345));
        System.out.println(firstDigit(5432));
    }
}

Python3

# Python implementation to
# find first digit of a
# single number
 
def firstDigit(x):
 
    # Keep dividing by 10 until it is
    # greater than equal to 10
    while(x >= 10):
        x = x//10
    return x
 
  
# driver function
 
print(firstDigit(12345))
print(firstDigit(5432))
 
# This code is contributed
# by Anant Agarwal.

C#

// C# implementation to find first
// digit of a single number
using System;
 
public class GFG {
     
    static int firstDigit(int x)
    {
         
        // Keep dividing by 10 until
        // it is greater than equal
        // to 10
        while (x >= 10)
            x = x / 10;
             
        return x;
    }
 
    // Driver method
    public static void Main()
    {
        Console.WriteLine(
                  firstDigit(12345));
                   
        Console.WriteLine(
                   firstDigit(5432));
    }
}
 
// This code is contributed by Sam007.

PHP

<?php
// PHP implementation to
// find first digit of a
// single number
 
function firstDigit($x)
{
     
    // Keep dividing by 10
    // until it is greater
    // than equal to 10
    while ($x >= 10)
        $x = $x / 10;
    return floor($x);
}
 
    // Driver Code
    echo firstDigit(12345),"\n" ;
    echo firstDigit(5432) ;
 
// This code is contributed by vishal tripathi.
?>

Javascript

<script>
 
// Javascript implementation to
// find first digit of a
// single number
 
function firstDigit(x)
{
     
    // Keep dividing by 10
    // until it is greater
    // than equal to 10
    while (x >= 10)
        x = x / 10;
    return Math.floor(x);
}
 
    // Driver Code
    document.write( firstDigit(12345)+"<br>" );
    document.write( firstDigit(5432)) ;
 
// This code is contributed by Bobby
 
</script>

Producción: 

1
5

Solución: 
para una array de números, el producto puede ser muy grande y su multiplicación puede no encajar en ningún tipo de datos típico. Incluso si usa Big int, el número será muy grande y encontrar el primero mediante el método de división directa por 10 será muy lento. Así que necesitamos usar algo diferente 
, dejemos que los números sean  a_1 ,  a_2 ,  a_3 …… a_n y su producto es P .P =  a_1 * a_2 …..* a_n . 
sea ​​S =  log_{10} (P) =  log_{10} ( a_1 ) +  log_{10} ( a_2 )…..+ log_{10} ( a_n ). 
Entonces podemos decir P =  10^S . 
Sabemos que cualquier número se puede escribir como la suma de su valor mínimo y su valor fraccionario. 
por lo tanto P =  10^{floor(S) + fractional (S)} lo que implica P =  10^{floor(S)} * 10^{fractional(S)} . 
Ahora podemos aplicar nuestro método discutido anteriormente para encontrar el primer dígito de un número porque después de dividir P por 10 hasta que sea mayor que igual a 10, solo nos quedará  10^{fractional(S)} cuál será nuestra respuesta. Y fraccional(S) se puede calcular fácilmente fraccional(S) = S – piso(S). 
 

C++

// C++ implementation of finding first digit
// of product of n numbers
#include <bits/stdc++.h>
using namespace std;
 
// returns the first digit of product of elements of arr[]
int FirstDigit(int arr[], int n)
{
    // stores the logarithm of product of elements of arr[]
    double S = 0;
    for (int i = 0; i < n; i++)
        S = S + log10(arr[i] * 1.0);
 
    // fractional(s) = s - floor(s)
    double fract_S = S - floor(S);
 
    // ans = 10^fract_s
    int ans = pow(10, fract_S);
    return ans;
}
 
// Driver function
int main()
{
    int arr[] = { 5, 8, 3, 7 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << FirstDigit(arr, n) << endl;
    return 0;
}

Java

// Java implementation of finding first digit
// of product of n numbers
 
class Test {
    // returns the first digit of product of elements of arr[]
    static int FirstDigit(int arr[], int n)
    {
        // stores the logarithm of product of elements of arr[]
        double S = 0;
        for (int i = 0; i < n; i++)
            S = S + Math.log10(arr[i] * 1.0);
 
        // fractional(s) = s - floor(s)
        double fract_S = S - Math.floor(S);
 
        // ans = 10^fract_s
        int ans = (int)Math.pow(10, fract_S);
        return ans;
    }
 
    // Driver method
    public static void main(String args[])
    {
        int arr[] = { 5, 8, 3, 7 };
 
        System.out.println(FirstDigit(arr, arr.length));
    }
}

Python3

# Python implementation of
# finding first digit
# of product of n numbers
 
import math
 
# Returns the first digit of
# product of elements of arr[]
def FirstDigit (arr, n):
 
    # stores the logarithm of
    # product of elements of arr[]
    S = 0
    for i in range(n):
        S = S + math.log10(arr[i]*1.0)
  
    # fractional(s) = s - floor(s)
    fract_S = S - math.floor(S)
  
    # ans = 10 ^ fract_s
    ans = math.pow(10, fract_S)
    return ans
  
# Driver function
 
arr = [5, 8, 3, 7]
n = len(arr)
print((int)(FirstDigit(arr, n)))
     
# This code is contributed
# by Anant Agarwal.

C#

// C# implementation of finding first
// digit of product of n numbers
using System;
 
public class GFG {
     
    // returns the first digit of product
    // of elements of arr[]
    static int FirstDigit(int[] arr, int n)
    {
         
        // stores the logarithm of product
        // of elements of arr[]
        double S = 0;
         
        for (int i = 0; i < n; i++)
            S = S + Math.Log10(arr[i] * 1.0);
 
        // fractional(s) = s - floor(s)
        double fract_S = S - Math.Floor(S);
 
        // ans = 10^fract_s
        int ans = (int)Math.Pow(10, fract_S);
         
        return ans;
    }
 
    // Driver method
    public static void Main()
    {
        int[] arr = { 5, 8, 3, 7 };
        int n = arr.Length;
         
        Console.WriteLine(FirstDigit(arr, n));
    }
}
 
// This code is contributed by Sam007.

PHP

<?php
// PHP implementation of
// finding first digit of
// product of n numbers
 
// Returns the first digit of
// product of elements of arr[]
function FirstDigit($arr, $n)
{
    // stores the logarithm of
    // product of elements of arr[]
    $S = 0;
    for ($i = 0; $i < $n; $i++)
        $S = $S + log10($arr[$i] * 1.0);
 
    // fractional(s) = s - floor(s)
    $fract_S = $S - floor($S);
 
    // ans = 10^fract_s
    $ans = pow(10, $fract_S);
    return floor($ans);
}
 
// Driver Code
$arr = array ( 5, 8, 3, 7 );
$n = sizeof($arr);
echo FirstDigit($arr, $n);
 
// This code is contributed by aj_36
?>

Javascript

<script>
    // Javascript implementation of finding first
    // digit of product of n numbers
     
    // returns the first digit of product
    // of elements of arr[]
    function FirstDigit(arr, n)
    {
          
        // stores the logarithm of product
        // of elements of arr[]
        let S = 0;
          
        for (let i = 0; i < n; i++)
            S = S + Math.log10(arr[i] * 1.0);
  
        // fractional(s) = s - floor(s)
        let fract_S = S - Math.floor(S);
  
        // ans = 10^fract_s
        let ans = parseInt(Math.pow(10, fract_S), 10);
          
        return ans;
    }
     
    let arr = [ 5, 8, 3, 7 ];
    let n = arr.length;
 
    document.write(FirstDigit(arr, n));
     
</script>

Producción : 
 

8

Este artículo es una contribución de Ayush Jha . 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.
 

Publicación traducida automáticamente

Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *