Le paradoxe de l’anniversaire

Original: http://www.efgh.com/math/birthday.htm

 

LOGO

Philip J. Erdelsky

4 juillet 2001
S’il vous plaîte-mail des commentaires, des correctionset des ajout sau webmestre à [email protected].

Un problème de favori en cours élémentaires de probabilités et statistiques est le problème de l’anniversaire : quelle est la probabilité qu’au moins deux des personnes choisies au hasard N ont le même anniversaire ? (Même mois et jour, mais pas nécessairement la même année.)

Une deuxième partie du problème : Comment grand N faut afin que la probabilité est supérieure à 50 % ? La réponse est de 23, qui frappe la plupart des gens comme excessivement petites. Pour cette raison, le problème est souvent appelé le paradoxe de l’anniversaire. Certains sharpies recommandent de Paris, à même de l’argent, qu’il y a des anniversaires en double parmi un groupe de 23 personnes. Vraisemblablement, il y a quelques drageons mal informés qui accepteront le pari.
Le problème est généralement simplifié en supposant que deux choses :
Personne n’est né le 29 février.
Anniversaires du peuple sont également répartis sur les autres 365 jours de l’année.
Une des premières choses à remarquer ce problème est qu’il est beaucoup plus facile de résoudre le problème complémentaire : quelle est la probabilité que les personnes choisies au hasard N ont tous différents anniversaires ? On peut écrire ceci comme une fonction récursive :

 

double different_birthdays (int n)
{
retour n == 1 ? 1.0 : different_birthdays(n-1) * (365.0-(n-1))/365.0 ;
}

 

Évidemment, pour N = 1 la probabilité est de 1. Pour N > 1, la probabilité est le produit des deux probabilités :
Que les gens de N-1 premiers ont tous différents anniversaires.
Que la personne de la N-ème a un anniversaire du premier N-1.
Un programme pour afficher les probabilités va quelque chose comme ceci :

 

void main (void)
{
int n ;
pour (n = 1; n < = 365; n ++)
printf (“% 3d : %e\n «, n, 1.0-different_birthdays(n)) ;
}

 

Le résultat est quelque chose comme ceci :

 

0.000000e + 1: 00
2: 2.739726e-03
3: 8.204166e-03
4: 1.635591e-02
5: 2.713557e-02
***

 

20 : 4.114384e-01
21 : 4.436883e-01
22 : 4.756953e-01
23 : 5.072972e-01
24 : 5.383443e-01
25 : 5.686997e-01
***

 

 

La probabilité qu’au moins deux des personnes N ont le même anniversaire dépasse 0.5 quand N = 23.

 

MAIS QU’EN EST-IL DES ANNÉES BISSEXTILES ?

 

Le problème initial peut être résolu avec une règle à calcul, qui est exactement ce que je faisais quand j’ai entendu beaucoup, il y a de nombreuses années.
Si l’on y ajoute le 29 février le mélange, il devient beaucoup plus complexe. Dans ce cas, nous faisons quelques hypothèses supplémentaires :
Un nombre égal de personnes naissent les jours autres que le 29 février.
Le nombre de personnes nées le 29 février est un quart du nombre de personnes nées sur n’importe quel autre jour.
Par conséquent, la probabilité qu’une personne sélectionnée au hasard est né le 29 février est 0.25/365.25, et la probabilité qu’une personne sélectionnée au hasard est né à une autre date est 1/365,25.
La probabilité que les personnes N, celui qui est né le 29 février, incluant éventuellement ont des anniversaires distincts est la somme des deux probabilités :
Que les personnes N sont nés à des dates différentes N autre que le 29 février.
Que les personnes N sont nés à des dates différentes de N et incluent une personne née le 29 février.
Les probabilités ajoutent parce que les deux affaires sont mutuellement exclusives.
Maintenant chaque probabilité peut être exprimée de manière récursive :

 

double different_birthdays_excluding_Feb_29(int n)
{
retour n == 1 ? 365.0/365.25 :
different_birthdays_excluding_Feb_29(n-1) * (365.0-(n-1)) / 365.25 ;
}

 

double different_birthdays_including_Feb_29(int n)
{
retour n == 1 ? 0.25 / 365.25 :
different_birthdays_including_Feb_29(n-1) * (365.0-(n-2)) / 365.25 +
different_birthdays_excluding_Feb_29(n-1) * 0,25 / 365.25 ;
}

 

Un programme pour afficher les probabilités va quelque chose comme ceci :

 

void main (void)
{
int n ;
pour (n = 1; n < = 366; n ++)
printf (“% 3d : %e\n «, n, 1.0-different_birthdays_excluding_Feb_29(n) –
different_birthdays_including_Feb_29(n)) ;
}

 

Le résultat est quelque chose comme ceci :
1:-8.348357e-18
2: 2.736445e-03
3: 8.194354e-03
4: 1.633640e-02
5: 2.710333e-02
***
20 : 4.110536e-01
21 : 4.432853e-01
22 : 4.752764e-01
23 : 5.068650e-01
24 : 5.379013e-01
25 : 5.682487e-01
***

 

 

Comme prévu, les probabilités sont légèrement plus bas, parce qu’il y a une probabilité plus faible de faire correspondre les anniversaires quand il y a des anniversaires plus possibles. Mais le plus petit nombre avec une probabilité supérieure à 0,5 est encore 23.

 

Bien sûr, un puriste mathématique peut argumenter que les années bissextiles ne viennent pas toujours tous les quatre ans, donc les calculs de besoin de modification ultérieure. Toutefois, l’an dernier quadriennal qui n’était pas une année bissextile était de 1900, et celle qui suit sera 2100. Le nombre de personnes vivant aujourd’hui qui sont nés en 1900 est si petit que je pense que notre rapprochement est valable à toutes fins utiles. Mais vous êtes invités à apporter les modifications requises si vous le souhaitez.

 

Le paradoxe de l’anniversaire a des répercussions au-delà du monde du salon de Paris. Une technique standard de stockage de données consiste à affecter à chaque élément un numéro appelé un code de hachage. L’élément est alors stocké dans un emplacement correspondant à son code de hachage. Cela accélère la récupération car seulement un bac unique doit être recherché. Le paradoxe de l’anniversaire montre que la probabilité que deux ou plusieurs éléments seront retrouveront dans le même bac est élevée, même si le nombre d’éléments est considérablement inférieur au nombre de bacs. D’où une gestion efficace des bacs contenant deux ou plusieurs éléments est requis dans tous les cas.

 

Comments are closed.