Probabilidad de obtener Números Primos como producto de los valores obtenidos al lanzar N dados

Dado un número entero N que denota el número de dados, la tarea es encontrar la probabilidad de que el producto de los números que aparecen en las caras superiores de N dados lanzados sea un número primo . Todos los N dados deben lanzarse simultáneamente.

Ejemplos:

Entrada : N = 2
Salida: 6 / 36
Explicación:
Al lanzar N(=2) dados simultáneamente, los resultados posibles en las caras superiores de N(=2) dados cuyo producto es igual a un número primo son: {(1, 2 ), (1, 3), (1, 5), (2, 1), (3, 1), (5, 1)}.
Por lo tanto, el conteo de resultados favorables = 6 y el conteo del espacio muestral es = 36
Por lo tanto, la salida requerida es (6 / 36)

Entrada: N = 3
Salida: 9 / 216

Enfoque ingenuo: el enfoque más simple para resolver este problema es generar todos los resultados posibles en las caras superiores de N dados lanzando N dados simultáneamente y para cada resultado posible verificar si el producto de los números en las caras superiores es un número primo o no. Si se encuentra que es cierto, entonces incremente el contador. Finalmente, imprima la probabilidad de obtener el producto de los números en las caras superiores como un número primo.

Complejidad temporal: O(6 ^N * N)
Espacio auxiliar: O(1)

Enfoque eficiente: para optimizar el enfoque anterior, la idea es utilizar el hecho de que el producto de N números es un número primo solo si (N – 1) los números son 1 y el número restante es un número primo. Las siguientes son las observaciones:

Si el producto de N números es un número primo, entonces el valor de (N – 1) números debe ser 1 y el número restante debe ser un número primo.
El recuento total de números primos en el rango [1, 6] es 3.
Por lo tanto, el número total de resultados en los que el producto de N números en la parte superior es un número primo = 3 * N.
P(E) = N( E) / N(S)
P(E) = probabilidad de obtener como número primo el producto de los números de las caras superiores de N dados.
N(E) = recuento total de resultados favorables = 3 * N
N(S) = número total de eventos en el espacio muestral = 6 ^N

Siga los pasos a continuación para resolver este problema:

Inicialice una variable, diga N_E para almacenar el recuento de resultados favorables.
Inicialice una variable, digamos N_S para almacenar el conteo del espacio muestral.
Actualizar N_E = 3 * N .
Actualizar N_S = 6 ^N .
Finalmente, imprima el valor de (N_E / N_S) .

A continuación se muestra la implementación del enfoque anterior.

C++

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
 
// Function to find the value
// of power(X, N)
long long int power(long long int x,
                    long long int N)
{
    // Stores the value
    // of (X ^ N)
    long long int res = 1;
 
    // Calculate the value of
    // power(x, N)
    while (N > 0) {
         
       // If N is odd
       if(N & 1) {
            
           //Update res
           res = (res * x);
       }
        
       //Update x
       x = (x * x);
        
       //Update N
       N = N >> 1;
        
    }
    return res;
}
 
// Function to find the probability of
// obtaining a prime number as the
// product of N thrown dices
void probablityPrimeprod(long long int N)
{
    // Stores count of favorable outcomes
    long long int N_E = 3 * N;
     
    // Stores count of sample space
    long long int N_S = power(6, N);
     
    // Print the required probability
    cout<<N_E<<" / "<<N_S;
}
 
// Driver code
int main()
{
    long long int N = 2;
    probablityPrimeprod(N);
}

Java

// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
     
// Function to find the value
// of power(X, N)
static int power(int x, int N)
{
     
    // Stores the value
    // of (X ^ N)
    int res = 1;
 
    // Calculate the value of
    // power(x, N)
    while (N > 0)
    {
         
        // If N is odd
        if (N % 2 == 1)
        {
             
            // Update res
            res = (res * x);
        }
         
        // Update x
        x = (x * x);
         
        // Update N
        N = N >> 1;
    }
    return res;
}
 
// Function to find the probability of
// obtaining a prime number as the
// product of N thrown dices
static void probablityPrimeprod(int N)
{
     
    // Stores count of favorable outcomes
    int N_E = 3 * N;
     
    // Stores count of sample space
    int N_S = power(6, N);
     
    // Print the required probability
    System.out.print(N_E + " / " + N_S);
}
 
// Driver code
public static void main(String[] args)
{
    int N = 2;
     
    probablityPrimeprod(N);
}
}
 
// This code is contributed by Amit Katiyar

Python3

# Python3 program to implement
# the above approach
 
# Function to find the value
# of power(X, N)
def power(x, N):
     
    # Stores the value
    # of (X ^ N)
    res = 1
 
    # Calculate the value of
    # power(x, N)
    while (N > 0):
 
        # If N is odd
        if (N % 2 == 1):
             
            # Update res
            res = (res * x)
 
        # Update x
        x = (x * x)
 
        # Update N
        N = N >> 1
 
    return res
 
# Function to find the probability of
# obtaining a prime number as the
# product of N thrown dices
def probablityPrimeprod(N):
     
    # Stores count of favorable outcomes
    N_E = 3 * N
 
    # Stores count of sample space
    N_S = power(6, N)
 
    # Print required probability
    print(N_E, " / ", N_S)
 
# Driver code
if __name__ == '__main__':
     
    N = 2
 
    probablityPrimeprod(N)
 
# This code is contributed by 29AjayKumar

C#

// C# program to implement
// the above approach
using System;
class GFG{
     
// Function to find the
// value of power(X, N)
static int power(int x,
                 int N)
{   
  // Stores the value
  // of (X ^ N)
  int res = 1;
 
  // Calculate the value
  // of power(x, N)
  while (N > 0)
  {
    // If N is odd
    if (N % 2 == 1)
    {
      // Update res
      res = (res * x);
    }
 
    // Update x
    x = (x * x);
 
    // Update N
    N = N >> 1;
  }
  return res;
}
 
// Function to find the probability
// of obtaining a prime number as
// the product of N thrown dices
static void probablityPrimeprod(int N)
{   
  // Stores count of favorable
  // outcomes
  int N_E = 3 * N;
 
  // Stores count of sample
  // space
  int N_S = power(6, N);
 
  // Print the required
  // probability
  Console.Write(N_E + " / " + N_S);
}
 
// Driver code
public static void Main(String[] args)
{
  int N = 2;
  probablityPrimeprod(N);
}
}
 
// This code is contributed by Princi Singh

Javascript

<script>
 
// JavaScript program to implement the above approach
 
// Function to find the value
// of power(X, N)
function power(x, N)
{
     
    // Stores the value
    // of (X ^ N)
    let res = 1;
 
    // Calculate the value of
    // power(x, N)
    while (N > 0)
    {
         
        // If N is odd
        if (N % 2 == 1)
        {
             
            // Update res
            res = (res * x);
        }
         
        // Update x
        x = (x * x);
         
        // Update N
        N = N >> 1;
    }
    return res;
}
 
// Function to find the probability of
// obtaining a prime number as the
// product of N thrown dices
function probablityPrimeprod(N)
{
     
    // Stores count of favorable outcomes
    let N_E = 3 * N;
     
    // Stores count of sample space
    let N_S = power(6, N);
     
    // Print the required probability
    document.write(N_E + " / " + N_S);
}
 
// Driver Code
    let N = 2;
    probablityPrimeprod(N);
     
    // This code is contributed by susmitakunndugoaldanga.
 
</script>

Producción:

6 / 36

Complejidad de Tiempo: O(log ₂ N)
Espacio Auxiliar: O( 1 )

Publicación traducida automáticamente

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

C++

Java

Python3

C#

Javascript

Deja una respuesta Cancelar la respuesta