Paradoja del cumpleaños

El problema del cumpleaños, también llamado paradoja del cumpleaños, establece que de un conjunto de 23 personas, hay una probabilidad del 50,7% de que al menos dos personas de ellas cumplan años el mismo día. Para 57 o más personas la probabilidad es mayor del 99,666%. En sentido estricto esto no es una paradoja ya que no es una contradicción lógica; sin embargo, es una verdad matemática que contradice la común intuición. Mucha gente piensa que la probabilidad es mucho más baja, y que hacen falta muchas más personas para que se alcance la probabilidad del 50,666%. Si una habitación tuviera 367 personas, por el Principio del palomar sabemos que habría al menos dos personas cumpliendo años en la misma fecha, ya que un año normal tiene 365 días, y uno bisiesto tiene 366.

Estimación de la probabilidad

Calcular esta probabilidad es el problema del cumpleaños. La teoría fue descrita en American Mathematical Monthly en 1938 en la teoría de Estimación del total de población de peces en un lago de Zoe Emily Schnabel, bajo el nombre de captura-recaptura estadística.

La clave para entender la paradoja del cumpleaños es pensar que hay muchas probabilidades de encontrar parejas que cumplan años el mismo día. Específicamente, entre 23 personas, hay 23×22/2 = 253 pares, cada uno de ellos un candidato potencial para cumplir la paradoja. Hay que entender que si una persona entrase en una habitación con 22 personas, la probabilidad de que cualquiera cumpla años el mismo día que quien entra, no es del 50%, es mucho más baja. Esto es debido a que ahora sólo hay 22 pares posibles. El problema real de la paradoja del cumpleaños consiste en preguntar si el cumpleaños de cualquiera de las 23 personas coincide con el cumpleaños de alguna de las otras personas.

Calculemos la probabilidad de que, en una habitación con n personas, al menos dos cumplan años el mismo día, desechando los años bisiestos y las personas gemelas, y asumiendo que existen 365 cumpleaños que tienen la misma probabilidad. El truco es calcular primero la probabilidad de que n cumpleaños sean diferentes. La probabilidad de que ninguna persona cumpla años el mismo día viene dada por

$p={\frac {365}{365}}\cdot {\frac {364}{365}}\cdot {\frac {363}{365}}\cdots {\frac {365-n+1}{365}}$

porque la segunda persona no puede tener el mismo cumpleaños que el primero (364/365), la tercera persona no puede tener el mismo cumpleaños que las dos primeras (363/365), etc. Usando notación factorial, puede ser escrita como

$p=\left\{{\begin{array}{ll}{\frac {365!}{365^{n}(365-n)!}},&1\leq n\leq 365\\0,&365<n\end{array}}\right.$

Ahora, 1 - p es la probabilidad de que al menos dos personas tengan el mismo día de cumpleaños. Para n = 23 se obtiene una probabilidad de alrededor de 0,507.

$1-p=\left\{{\begin{array}{ll}1-{\frac {365!}{365^{n}(365-n)!}},&1\leq n\leq 365\\1,&365<n\end{array}}\right.$

En contraste, la probabilidad que cualquiera en una habitación de n personas (excluido Ud.) tengan el mismo día de cumpleaños que usted está dada por

$1-\left({\frac {364}{365}}\right)^{n}$

que para n = 22 sólo da alrededor de 0,059, y se necesitaría al menos una n de 253 para dar un valor superior a 0,5.

La solución se puede generalizar para incluir a los nacidos un 29 de febrero, naturalmente de un año bisiesto. Es una solución, puede haber otras, la ventaja de ésta es que es exacta y sencilla. Se usa el algoritmo que figura más arriba (con 365, haya personas nacidas en años bisiestos o no) con los siguientes cambios:

Sean nb las personas presentes que cumplen años el 29 de febrero.

Si nb=0; Aplicar Algoritmo. FIN

Si nb=1; n=n-1; Aplicar Algoritmo. FIN

Si nb>1; hay al menos 2 personas con la misma fecha de cumpleaños. FIN

Programas informáticos

Los siguientes programas calculan las probabilidades desde 1 hasta 100:

Ruby

pr = 1.0
1.upto(100) do |i|
  pr = pr * (366 - i) / 365
  puts "#{i}: #{1 - pr}"
end

Go

package main

import "fmt"

func main() {
  p := 1.0
  for i := 1; i <= 100; i++ {
    p = p * (366 - float64(i)) / 365
    fmt.Println(i, ":", 1 - p)
  }
}

Julia

println("Número de personas : Probabilidad")
p = 1
for i in 1:100
    p = p * (366 - i) / 365
    @printf("%d : %10.6f\n",i,1-p)
end

Pascal

Program Cumples ;
Var
   i : Integer ;
   p : Real ;
Begin
   writeln(' Num  -  Probabilidad') ;
   p := 1.0 ;
   For i := 1 to 100 Do
   Begin
      p := p * (366 - i) / 365 ;
      write(i:3,100*(1-p):17:6) ;
      readln ;
   End ;
End.

Python

print ('Num. probabilidad')
p = 1.0
for i in range(1, 100):
    p = p * (366 - i) / 365
    print ('%3d : %10.6f' % (i, 1-p))

Perl

print ('Num. probabilidad');
my $p = 1.0;
foreach( 1..100 ) {
        $p = $p * (366 - $_) / 365;
        print $_, ' : ', 1-$p, "\n";
}

C++

#include <iostream>
 
using namespace std;
 
long double calcular(int personas)
{
   long double p=1;
   for(int i=0;i<personas;i++)
   {
      p=p*(365-i)/365;
   }
   p=100*(1-p);
   return p;
}
 
int main() 
{
  int grupo;
  long double probabilidad;
  cout << "Introduce cuántas personas tiene el grupo : ";
  cin >> grupo;
  probabilidad = calcular(grupo);
  cout << "La probabilidad de que en un grupo de " << grupo << " personas, dos cumplan años el mismo día es de un " << probabilidad
  << "%" << endl;
  return 0;
}

C#

El siguiente programa calcula las probabilidades dependiendo del número de personas (grupo):

        static void Main(string[] args)
        {
            Console.WriteLine("Introduce el número de personas: ");
            int num = Convert.ToInt32(Console.ReadLine());
            Cumple(num);
            Console.Read();
        }
        static void Cumple(int num)
        {
            double p = 1.0;
            for (int i = 1; i <= num; i++)
            {
                p = p * (366 - i) / 365; //Formula de cumpleaños
            }
            Console.WriteLine(100*(1 - p));
        }

Java

El siguiente programa calcula las probabilidades dependiendo del número de personas (grupo):

import java.util.Scanner;

public class ProblemaDelCumpleanos {
    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        System.out.println("Introduce el número de personas: ");
        int tamanoDePoblacion = (entrada.nextInt());
        System.out.println(cumple(tamanoDePoblacion));
        entrada.next();
    }

    /**
     * @param num Tamaño de la poblacion usada para calcular la probabilidad.
     * @return Propabilidad entre la poblacion haya 2 personas que tengan el
     * mismo cumpleaños.
     */

    public static double cumple(int num) {
        double probabilidad = 1.0;

        for (int i = 1; i <= num; i++) {
            probabilidad = probabilidad * (366 - i) / 365;
        }

        return (100 * ((1 - probabilidad)));
    }
}

PHP

function paradoja($grupo){
  $p = 1.0;			
  for ($i = 1; $i <= $grupo-1; $i++){
    $p = $p * (366-$i) / 365;		
  }	
  $p = 1.0 - (1.0 * $p * (366-$i) / 365);
  return $p;
}  
echo paradoja(NUMERO);

PL/SQL

El siguiente programa tiene en cuenta los años bisiestos (es decir, se requieren 367 personas para garantizar una probabilidad del 100%).

Calcula todas las probabilidades desde n=1 hasta n=367 personas.

Nótese que debido al límite de decimales que PL/SQL puede manejar, si el número de personas es superior a n=227 (probabilidad 99,99999999999999999999999999999999999999%), entonces PL/SQL redondea la probabilidad al 100%.

SET SERVEROUTPUT ON

DECLARE
  P REAL := 1;
  I INTEGER;

BEGIN
  FOR I IN 1..367
  LOOP
        P := P * (367-I) / 366;    
        DBMS_OUTPUT.PUT_LINE ('Para n=' || I || ': Probabilidad ' || 100*(1-P) || '%');    
  END LOOP;
END;

MATLAB

%Script Cumples
disp('Num  :  Probabilidad')
prob=1;
for loop=1:100
    prob=prob*(366-loop)/365;
    fprintf('%.0f : %.4f \n', loop, 1-prob)
end

Microsoft SQL Server

La siguiente consulta calcula las probabilidades dependiendo del número de @Personas

DECLARE @Personas INT

SET @Personas = 23;

WITH TBL AS (
    SELECT 1 i, cast(1 as real) p
    UNION ALL
    SELECT i+1, cast((365-i)/365.0 as real)
    FROM TBL
    WHERE i < @Personas
)
SELECT (1-exp(sum(log(p))))*100 Probabilidad
FROM TBL
OPTION (MAXRECURSION 0)

R

total=1; 
for(i in 1:100) { 
  total=total*((366-i)/365)
  cat("La probabilidad de que en un grupo de ", i, " personas, dos cumplan años el mismo día es de: ", 1-total,"\n")
}

Swift

func cumple(grupo: Int) -> Double{
    var p:Double = 1;
    if grupo > 1 {
        for i in 1...grupo{
            p = p * Double(366-i)/365.0;
        }
    }
    return 1-p;
}

let personas:Int = 25;

print("La probabilidad de que en un grupo de \(personas) personas, existan dos personas que cumplan el mismo dia es de \(cumple(personas)*100)%");

Enlaces externos

• Simulación de la Paradoja del Cumpleaños. Inspección de 50 habitaciones, con diferente cantidad de personas, desde 1 hasta 101.
• Eurocumpleaños 2012. La paradoja del cumpleaños. Un ejemplo práctico de la paradoja del cumpleaños.