Retard, probabilite et statistiques

par **Doraki** » 21 Oct 2011, 10:44

Dlzlogic a écrit: Boules[j] < Moi.j1

ça devrait pas être Boules[j] < Boules[Moi.j1] plutôt ?

Enfin bon même en jouant à chaque fois les boules 0 1 2, on ne devrait pas avoir un joueur gagnant plus souvent qu'un autre.

on peut le faire tourner sur http://codepad.org/ ?
après quelques fixs pour la fonction random il m'a fait un segfault :/ et je m'y connais pas spécialement en c++

par **Dlzlogic** » 21 Oct 2011, 11:42

Bonjour nuage,
Concernant le terme d'écart-type, je ne l'ai lu dans aucune documentation avant cette époque (début 80) par contre le terme d'écart moyen quadratique était connu et utilisé.

Je ne commente pas tes autres interventions : c'est pas la peine de s'énerver.

Traduction : je ne vais pas répondre aux autres points, pourquoi perdre son temps?

par **Dlzlogic** » 21 Oct 2011, 12:45

Boules[j] < Moi.j1

ça devrait pas être Boules[j] < Boules[Moi.j1] plutôt ?

Si, j'ai honte :marteau: :hum: :mur:
Code en révision.

par **Dlzlogic** » 21 Oct 2011, 15:01

Bon, après une petite révision du code ...
J'ai rajouté les impressions du score de chaque numéro en "pour 1000" au début de chaque jeu, c'est à dire après 1000 tirages et à la fin, c'est à dire après 200 x 3 boules tirées en plus.
Théoriquement, c'est du C de base, donc, ça devrait tourner dans n'importe quel environnement.
(sauf l'instruction system() propre à Windows.
Dans un environnement Unix ou Linux, il vaut mieux utiliser srand() et rand() à la place de randimize() et random() respectivement.
Pardon pour ce contre-temps.

Code: Tout sélectionner: int main() { randomize(); // initialisation de la fonction aléatoire. // joueur moyen : il parie 3 boules au hasard // joueur savant : il parie les 3 boules les plus en retard struct JOUEUR { int gains; int j1,j2,j3; int gainTot; } JoueurX, Moi; JoueurX.gainTot=0; Moi.gainTot=0; FILE *ecr=fopen("Tirage.txt","wt"); for (int fois = 0; fois < 10; fois++) // le traitement jusqu'à la fin de ce bloc { // sera fait 10 fois JoueurX.gains=0; // on initialise le compte de 2 joueurs à 0 Moi.gains=0; int Boules[50]; // le tableau Boules[i] comptabilise le nombre de tirages // de la boule de numéro i cad si Boules[25] = 12, // ça veut dire que la boune N°25 est sortie 12 fois. for (int nb=0; nb<15; nb++) // on joue 15 parties { for (int i=0; i<50; i++) Boules[i]=0; // initialisation for (int i=0; i<1000; i++) // nombres de tirages d'initialisation { int N=random(50); // donc 0 à 49 // tirage au hasard Boules[N]++; // la boule de numéro N est sortie } // l'intérêt de cette initialisation est de démarrer le jeu "en cours" fprintf(ecr,"\nNUMERO "); for (int i=0; i<50; i++) fprintf(ecr,"%3d ",i+1); fprintf(ecr,"\nDEBUT "); for (int i=0; i<50; i++) fprintf(ecr,"%3d ",Boules[i]); int tot=0; for (int n=0; n<50; n++) tot+=Boules[n]; for (int i=0; i<200; i++) // nombres de tirages { // là on joue pour de vrai // JoueurX joue au hasard // les valeurs j1, j2 et j3 sont les 3 boules cochées qur la grille JoueurX.j1=random(50); int N; do { N=random(50); if (N != JoueurX.j1) {JoueurX.j2 = N; break;} } while (true); do { N=random(50); if (N != JoueurX.j1 && N != JoueurX.j2) {JoueurX.j3 = N; break;} } while (true); // JoueurX a donc 3 numéros au hasard // Moi joue intelligemment Moi.j1 = 0; Moi.j2 = 1; Moi.j3 = 2; // je cherche parmi les 50 boules, les 3 les plus en retard // et c'est celle-là que je coche sur la grille // je commence au début et une plus en retard remplace dans mon choix // celle que j'avais prévue. for (int j=3; j<50; j++) { if (Boules[j] < Boules[Moi.j1]) Moi.j1 = j; else if (Boules[j] < Boules[Moi.j2]) Moi.j2 = j; else if (Boules[j] < Boules[Moi.j3]) Moi.j3 = j; } // N=random(50); // donc 0 à 49 // on tire 3 boules int B1=-1; int B2=-1; int B3=-1; B1=random(50); Boules[B1]++; do // il na faut par tirer le même numéro { N=random(50); if (N != B1) {B2 = N; Boules[B2]++; break;} } while (true); do { N=random(50); if (N != B1 && N != B2) {B3 = N; Boules[B3]++; break;} } while (true); // les gains // les 2 séquences pour JoueurX et moi sont identiques if (JoueurX.j1 == B1 || JoueurX.j1 == B2 || JoueurX.j1 == B3 ) JoueurX.gains++; if (JoueurX.j2 == B1 || JoueurX.j2 == B2 || JoueurX.j2 == B3 ) JoueurX.gains++; if (JoueurX.j3 == B1 || JoueurX.j3 == B2 || JoueurX.j3 == B3 ) JoueurX.gains++; if (Moi.j1 == B1 || Moi.j1 == B2 || Moi.j1 == B3 ) Moi.gains++; if (Moi.j2 == B1 || Moi.j2 == B2 || Moi.j2 == B3 ) Moi.gains++; if (Moi.j3 == B1 || Moi.j3 == B2 || Moi.j3 == B3 ) Moi.gains++; } fprintf(ecr,"\n FIN "); for (int i=0; i<50; i++) fprintf(ecr,"%3d ",10*Boules[i]/16); fprintf(ecr,"\n"); tot=0; // fprintf(ecr,"Fin des tirages\n"); printf("Tirage N %d JoueurX = %d Moi = %d \n",nb,JoueurX.gains,Moi.gains); fprintf(ecr,"Tirage N %d JoueurX = %d Moi = %d \n",nb,JoueurX.gains,Moi.gains); JoueurX.gainTot+=JoueurX.gains; Moi.gainTot+=Moi.gains; } printf("Total JoueurX = %d Moi = %d \n",JoueurX.gainTot,Moi.gainTot); printf("\n\n"); } fprintf(ecr,"\nTotaux JoueurX = %d Moi = %d \n",JoueurX.gainTot,Moi.gainTot); system("Pause"); fclose(ecr); return 0; }

Il est vrai que JoueurX est parfois gagnant, mais Moi est globalement largement gagnant.

PS. Je tiens à préciser, et c'est très important dans mon esprit, qu tout ceci n'a qu'un intérêt mathématique et qu'une quelconque application aux jeux de hasard est sans objet puisque les implications d'ordre financier ont un impact beaucoup important.

par **Dlzlogic** » 21 Oct 2011, 17:17

Bonjour beagle,
C'est mon tour de poser une question.
Etant donné une série d'évènements indépendants, peut-on savoir si cette série est satisfaisante et correcte?
Il faut considérer le terme "évènement" au sens le plus large, c'est à dire, une mesure, une observation, un tirage etc.

par **beagle** » 21 Oct 2011, 18:27

Dlzlogic a écrit:Bonjour beagle,
C'est mon tour de poser une question.
Etant donné une série d'évènements indépendants, peut-on savoir si cette série est satisfaisante et correcte?
Il faut considérer le terme "évènement" au sens le plus large, c'est à dire, une mesure, une observation, un tirage etc.

Je sais pas, oui,
avec des trucs comme:
http://fr.wikipedia.org/wiki/Test_d'hypoth%C3%A8se

par **Dlzlogic** » 21 Oct 2011, 19:04

Bonsoir,
Comment faisait-on avant Wiki ? C'est pas une nouvelle question c'est une observation.
La solution, c'est à dire la méthode, je l'ai indiquée quelques messages plus haut.
1- on fait la moyenne arithmétique
2- on calcule l'écart moyen quadratique (écart-type) : c'est à ça qu'il sert
3- on calcule l'écart probable = 2/3 emq
4- on classe les écarts à la moyenne en 8 classes (1ep, 2ep, 3ep 4ep, à gauche et à droite)
5- les écarts supérieurs à 4ep sont douteux, ils doivent être vérifiés. S'ils sont éliminés, on recommence éventuellement au "1-", s'il y a peu de mesures.
6- on compare le nombre d'écart de chaque classe avec les valeurs théoriques (25%, 16%, 7% 2%)

Je suppose que tu as une question à poser. :dodo:

par **beagle** » 21 Oct 2011, 19:14

Je veux bien poser une question si c'est mon tour.
A chaque fois que tu veux "démontrer" que l'on gagne à jouer les retards,
tu nous refaits un bon cours sur la courbe de Gauss.
La question est donc:
grace à la distribution de Gauss, quelle propriété utilises-tu
pour en déduire que les retards sont comblés préférentiellement?

Et pourquoi n'utilises-tu pas Gauss pour dire à tout moment,
à tout moment dès le départ, à n=100,
n=5000, n= 10 053,
les tirages à venir seront issus de Gauss et donc symétriques et donc pas plus pour pile que pour face
à tout moment
...

si c'est compté deux questions, on considére que je suis en avance.

par **Dlzlogic** » 22 Oct 2011, 12:02

Bonjoour,

La question est donc:
grace à la distribution de Gauss, quelle propriété utilises-tu
pour en déduire que les retards sont comblés préférentiellement?

Et pourquoi n'utilises-tu pas Gauss pour dire à tout moment,
à tout moment dès le départ, à n=100,
n=5000, n= 10 053,
les tirages à venir seront issus de Gauss et donc symétriques et donc pas plus pour pile que pour face
à tout moment

Avec pile ou face, on va pas bien loin, sauf si on introduit les suites par exemple. Il me semble plus facile de discuter à partir des 50 boules.
A chaque tirage d'une boule, celle-ci a une chance sur 50 de sortir. Il est bien évident que la probabilité que au bout des 50 premiers tirages, chaque boule soit sorti une fois.

On sait qu'au bout d'un grand nombre de tirages chaque boule a le même nombre de chances d'avoir été tirée. Mais il me parait évident que l'égalité ne sera pas respectée "à tout moment".

Code: Tout sélectionner: NUMERO 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 DEBUT 27 18 18 17 18 19 28 12 19 26 23 22 20 15 17 12 14 30 30 16 21 16 16 20 19 31 19 22 32 15 19 16 26 22 18 20 18 26 20 19 19 21 15 21 15 17 18 22 21 15 FIN 21 18 21 16 16 20 25 14 18 21 20 23 23 15 17 16 13 23 26 18 18 21 18 22 15 28 23 21 30 14 18 21 23 21 20 22 20 23 18 19 18 18 16 19 15 19 18 18 19 18 NUMERO 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 DEBUT 28 18 31 24 21 11 15 19 15 21 25 23 13 23 28 28 23 22 18 25 15 20 11 15 21 16 16 22 19 19 18 21 16 28 19 15 20 18 19 13 18 16 21 26 19 22 24 22 12 28 FIN 24 21 27 20 21 16 15 20 18 19 22 21 21 19 25 26 20 23 18 26 13 16 13 16 20 17 18 21 15 20 16 19 18 25 20 18 17 19 21 15 18 13 18 21 18 20 24 23 18 26 NUMERO 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 DEBUT 20 19 20 30 30 25 24 20 19 20 17 26 17 12 14 25 19 24 24 21 24 16 18 17 10 19 15 19 17 24 21 18 12 13 14 24 21 20 22 26 14 20 19 29 24 26 23 14 19 16 FIN 21 16 19 26 23 25 22 18 19 23 19 26 16 18 13 26 17 25 19 22 21 15 14 20 10 20 14 18 16 21 18 19 12 15 15 21 21 18 19 24 19 24 20 25 23 26 23 16 18 20

J'ai copié les 3 premiers tirages.
La première ligne indique le numéro des boules (de 1 à 50)
La deuxième ligne indique pour chaque boules le score après 1000 tirages pour initialisation.
Le troisième ligne indique pour chaque boule le score après 600 tirage, soit 1600 en tout.
Les scores sont ramenés à un nombre pour 1000, c'est à dire que la valeur théorique, ou moyenne, comme on voudra, est 20.
Naturellement, j'en ai des pages et des pages comme ça, mais ce sont les totaux qui sont importants.
N'importe qui peut exécuter le code que j'ai mis et vérifier les totaux.
Ais-je répondu?

par **Dlzlogic** » 22 Oct 2011, 12:12

grace à la distribution de Gauss, quelle propriété utilises-tu
pour en déduire que les retards sont comblés préférentiellement?

Il me semble que je n'ai pas répondu à cette question.
On a constaté, vérifié que la répartition pour un grand nombre de tirages avait toujours la forme de la courbe de Gauss, à un rapport d'échelle près, naturellement.
Toute valeur tend vers sa position théorique sur la courbe de Gauss.
Si à un instant donné elle est trop forte, elle va attendre de se faire rattraper, si elle est trop faible elle va rattraper son retard. Ca peut se présenter comme des coureurs cyclistes qui partent en même temps et qui auraient décidé, pour manifester, d'arriver en même temps.

par **beagle** » 22 Oct 2011, 12:27

Dlzlogic a écrit:Il me semble que je n'ai pas répondu à cette question.
On a constaté, vérifié que la répartition pour un grand nombre de tirages avait toujours la forme de la courbe de Gauss, à un rapport d'échelle près, naturellement.
Toute valeur tend vers sa position théorique sur la courbe de Gauss.
Si à un instant donné elle est trop forte, elle va attendre de se faire rattraper, si elle est trop faible elle va rattraper son retard. Ca peut se présenter comme des coureurs cyclistes qui partent en même temps et qui auraient décidé, pour manifester, d'arriver en même temps.

mais non, les coureurs ne savent pas où est le départ, chaque tirage est un nouveau départ,
et les coureurs ne savent pas quand se terminent la course, la fin est arbitraire c'est toi qui dit stop,
ou alors en plus ils arrivent à deviner ton stop?
donc à l'intérieur d'une grande série de 10 000 tirages
tu peux prendre un sous-ensemble de 1000 tirages, il respectera la courbe de gauss (attendue pour 1000)
quel que soit ton mode de fabrication des 1000 tirages,
donc les tirages de la fin ne savent, ne connaissent absolument pas les tirages de départ.

par **beagle** » 22 Oct 2011, 12:34

OK pour essayer de voir ton tirage de boules,
mais c'est bien compliqué,
pourquoi les trois séries sont divisées en deux une de 1000 et une de 600,
c'est la 600 qui est ramenée à 1000????

j'ai bien compris si je dis ceci:
boule 1
sortie 27 (sur 1000), donc en avance
ensuite 21, donc encore avance, ça marche pas le comblement

boule 2
18 retard
ensuite 18 retard, ça marche pas

la trois 18 retard devient 21, ça marche

boule 4
retard puis retard, ça marche pas

par **beagle** » 22 Oct 2011, 12:37

ou alors boule 1
en avance sur première série
en avance sur deuxième série
en avance sur troisième série

boule 2
retard première série
retard deuxième série
retard troisième série

bon ça marche pas bien le comblement de retard

par **Dlzlogic** » 22 Oct 2011, 13:21

mais non, les coureurs ne savent pas où est le départ, chaque tirage est un nouveau départ,
et les coureurs ne savent pas quand se terminent la course, la fin est arbitraire c'est toi qui dit stop,
ou alors en plus ils arrivent à deviner ton stop?
donc à l'intérieur d'une grande série de 10 000 tirages
tu peux prendre un sous-ensemble de 1000 tirages, il respectera la courbe de gauss (attendue pour 1000)
quel que soit ton mode de fabrication des 1000 tirages,
donc les tirages de la fin ne savent, ne connaissent absolument pas les tirages de départ.

Comme toute comparaison, celle de coureurs a ses limites.
Il est vrai que c'est assez difficile à imaginer ce qui se passe pour 1000 tirages parmi une grande série.
Quand j'ai calculé ce truc pour la première fois (il y a près de 30 ans) ce point m'a bien tracassé. Pour moi, l'explication est celle ci : a tout moment la répartition des tirages respecte la loi normale (courbe Gauss). L'exact respect de la répartition ne peut arriver que pour un nombre infini de tirages. Pour un petit nombre de tirages, la répartition des écarts en valeurs relatives est respectée, par contre en valeur absolue, c'est beaucoup moins vrai. Plus le nombre de tirages est grand, plus la répartition an valeur absolue sera vraie.

Quant à tes remarques sur les boules 1, 2 et 3, naturellement, prises indépendamment, il est très probable qu'il y ait des boules qui se soient trompées, mais on parle de statistique, de probabilité de loi des grands nombres etc.
Par exemple, la boule 25 au 3è tirage n'a rien compris à ce qu'elle devait faire.

Je vais faire une nouvelle simulation avec le modifications suivantes
1- au lieu de faire 200 tirages de 3 boules, je vais faire 600 tirages de 1 boule. Je garde les mêmes nombres pour être strictement comparable.
2- je vais rajouter un 3è joueur (que je vais appeler Beagle) et qui va jouer le contraire de Moi, c'est à dire celle qui est le plus en avance.

Je prévois
1- l'écart entre JoueurX et Moi va être augmenté.
2- Beagle va être dégouté de jouer. :lol3:

par **beagle** » 22 Oct 2011, 13:29

Quant à tes remarques sur les boules 1, 2 et 3, naturellement, prises indépendamment, il est très probable qu'il y ait des boules qui se soient trompées, mais on parle de statistique, de probabilité de loi des grands nombres etc.
Par exemple, la boule 25 au 3è tirage n'a rien compris à ce qu'elle devait faire.

"Je vais faire une nouvelle simulation avec le modifications suivantes
1- au lieu de faire 200 tirages de 3 boules, je vais faire 600 tirages de 1 boule. Je garde les mêmes nombres pour être strictement comparable.
2- je vais rajouter un 3è joueur (que je vais appeler Beagle) et qui va jouer le contraire de Moi, c'est à dire celle qui est le plus en avance.

Je prévois
1- l'écart entre JoueurX et Moi va être augmenté.
2- Beagle va être dégouté de jouer. "

.............................................

OK, c'était juste poursavoir si j'interprétais bien,
on va regarder les % sur 50 boule

pour le jeu , c'est trop d'honneur,
néanmoins seul fatal-error et doraki semblent en mesure de comprendre ton programme

par **beagle** » 22 Oct 2011, 13:49

tu as des résultats déroutants en effet,
j'ai regardé juste tirage 1 versus tirage 2
on trouve un résultat remarquable
+20 vers +20:9
-20vers -20:9
+20 vers -20:9
-20 vers +20:18

j'adore les maths, quel bol de trouver 9,9,9,2x9
et effectivement sacré biais vers comblement du retard.

J'ai plus le temps de regarder sur autres esemples,
mais je le ferais.

en attendant je demanderais un échantillon certifié hasardeux, parce que là c'est surprenant de prime abord.

par **Dlzlogic** » 22 Oct 2011, 14:08

Résultat :
JoueurX (joue au hasard) 14331
Moi (parie sur le retardataire) 14515
Beagle (Parie sur le meilleur) 14365

J'avoue que je suis un peu déçu, je pensais que l'écart s'augmenterait, et surtout que Beagle perdrait plus.
Je vais rétablir le tirage avec 3 boules.

Pas de problème pour t'envoyer l'exécutable. Il tourne sous Windows, on peut faire toutes les simulations qu'on veut et voir les résultats.

par **fatal_error** » 22 Oct 2011, 14:46

deux boules pour moi :

Code: Tout sélectionner: #include #include #include #define PIL 0 #define FACE 1 void simulation(int N); int main(int argc, char* argv[]){ int nbSimulation = 10; int N=1000; srand ( time(NULL) ); for(int i=0; i<nbSimulation; i++){ std::cout<<std::endl; srand ( rand() ); simulation(N); } return 0; } /** N : nombre de tirages de pil ou face */ void simulation(int N){ /* Algorithm - 2 joueurs p1 et p2 - N tirages de pil ou face Pour chaque tirage, p1 essaie de deviner au pif p2 mise sur le la face qui est la moins sortie */ int nbFaces=0; int nbPils=0; int p1Success = 0; //nombre de good guess pour p1 int p2Success = 0; //nombre de good guess pour p2 for(int i=0; i<N; ++i){ int lancer = rand() % 2; //on memorise le nombre de pils/faces pour p2 if(lancer==PIL){ nbPils++; }else{ nbFaces++; } //p1 devine au pif int essaiP1 = rand()%2; if(essaiP1 == lancer){ p1Success++; } //p2 mise sur la face la plus en retard int essaiP2 = (nbFaces<nbPils)?FACE:PIL; //si jamais ya le meme nombre de faces, il devine au pif if(nbFaces==nbPils){ essaiP2 = essaiP1; } if(essaiP2 == lancer){ p2Success++; } } std::cout<<"good guess average"<<std::endl; std::cout<<"p1 : "<<(float)p1Success/N<<std::endl; std::cout<<"p2 : "<<(float)p2Success/N<<std::endl; }

pour g++
Resultat :

Code: Tout sélectionner: good guess average p1 : 0.515 p2 : 0.474 good guess average p1 : 0.5 p2 : 0.475 good guess average p1 : 0.52 p2 : 0.455 good guess average p1 : 0.519 p2 : 0.498 good guess average p1 : 0.507 p2 : 0.486 good guess average p1 : 0.494 p2 : 0.484 good guess average p1 : 0.508 p2 : 0.491 good guess average p1 : 0.496 p2 : 0.467 good guess average p1 : 0.472 p2 : 0.481 good guess average p1 : 0.502 p2 : 0.479

Bref, il semblerait, qu'étrangement, le joueur misant le retard soit perdant :we:

par **Dlzlogic** » 22 Oct 2011, 15:47

Bonjour,

Bref, il semblerait, qu'étrangement, le joueur misant le retard soit perdant

Oui, et chaque fois, sauf une.
A chaque tirage, il y a 4 possibilités
p1 gagne ET p2 gagne
p1 gagne ET p2 perd
p1 perd ET p2 gagne
p1 perd ET p2 perd
Comment peut-il se faire qu'à deux ensemble la somme des 2 gains soit toujours inférieure à 1 ?
Ca voudrait dire que le chois de P2 est plus souvent mauvais que bon, puisque pour p1, c'est aléatoire?
Je vais le compiler et l'exécuter.

par **Dlzlogic** » 22 Oct 2011, 17:37

J'ai compilé le programme, avec quelques modifications.
Le seule importante est que le comptage des pile ou face doit être fait APRèS que P2 ait fait son choix.
Sinon, c'est juste des problèmes de style auquel je suis plus habitué.
Sur 10 exécution successives, j'obtiens un total de 49888 pour P1 et 50103 pour P2.
Il est vrai que sur une simulation avec 50 boules c'est plus significatif (environ 3%).

Code: Tout sélectionner: void simulation(int N, int &TotP1, int &TotP2); int main(int argc, char* argv[]) { int nbSimulation = 10; int N=1000; srand ( time(NULL) ); int TotP1=0; int TotP2=0; for(int i=0; i 0) //printf("Pile = %3d face=%3d lancer = %d \n",nbPils,nbFaces,lancer); //on memorise le nombre de pils/faces pour p2 AU PROCHAIN COUP if(lancer == 0) nbPils++; else nbFaces++; } printf("Pile = %3d face=%3d p1=%3d p2=%3d \n",nbPils,nbFaces,p1Success,p2Success); TotP1+=p1Success; TotP2+=p2Success; /* std::cout<<"good guess average"<<std::endl; std::cout<<"p1 : "<<(float)p1Success/N<<std::endl; std::cout<<"p2 : "<<(float)p2Success/N<<std::endl; */ }

Retard, probabilite et statistiques

Qui est en ligne