Paradoja del cumpleaños

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda
Birthday Paradox.svg

El problema del cumpleaños, también llamado paradoja del cumpleaños, establece que si hay 23 personas reunidas, 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%. En sentido estricto esto no es una paradoja ya que no es una contradicción lógica; es una paradoja en el sentido de que 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%. Si una habitación tuviera 367 personas, lógicamente habría al menos dos personas cumpliendo años en la misma fecha teniendo en cuenta que un año tiene 365 días y uno bisiesto, 366.

Estimación de la probabilidad[editar]

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[editar]

Pascal[editar]

Los siguientes cuatro programas calculan las probabilidades desde 1 hasta 100:

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[editar]

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

1

Perl[editar]

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

JavaScript[editar]

// Probar en la consola del navegador
function Cumple(){
  var p = 1.0;			
  for (var i = 1; i <= 100; i++){
    p = p*(366-i)/365;				
    console.log(1-p);
  }					
};
Cumple();

C++[editar]

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

//Elaborado por R4nD0m# C++ Estándar, Simplificado
#include <iostream>
 
using namespace std;
 
double calcular(int grupo){
   double p=1;
   int i;
   for(i=1;i<grupo;++i){
      p=p*(366-i)/365;
   }
   p=100-(100*p*(366-i)/365);
   return p;
}
 
int main() {
   int grupo;
   double probabilidad;
   cout << "Introduce cuántas personas tiene el grupo" << endl;
   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: " << probabilidad
   << "%" << endl;
   return 0;
 
}

PHP[editar]

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[editar]

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;

Enlaces externos[editar]