programme de tirage pour l'euromillion. A optimiser...

[C.Ret]

Je suis du même avis que Charo, utiliser l'écran ce n'est pas de la Gruge.
Et en gruge, je m'y connais...

@CRet: balaise, j'ai rien compris!

C'est vrai que je n'est donné aucune explication.

L'idée de base de la méthode se base sur trois constats.

Le premier est que si l'on demande au Pocket de donner 9 nombres entre 1 et 9, il devra répondre 1;2;3;4;5;6;8;7;8;9.
Il n'a pas le choix.

Le code effectuant cela sera quelque chose du style :

Code : Tout sélectionner

X%=0 : FOR I=9 TO 1 STEP -1 : X%=X%+1 : PRINT X%; : NEXT I : PRINT 

Je suis d'accord, on peut faire plus simple, mais ce code donne le résultat souhaité.

Maintenant, si je veux paramétrer cela, j'introduis mes paramètres : A% et B% les bornes de l'intervalle et N% le nombre de tirage.

Mon code devient alors :

Code : Tout sélectionner

10  PRINT "TIRAGE DE 9 NOMBRES ENTRE 1 ET 9 : " ; : A%=1 : B%=9 : N%=9:GOSUB 1000 : END

1000 X%=A%-1 : IF B%<A%+N% THEN STOP
1010 FOR I=N% TO 1 STEP -1 : X%=X%+1 : PRINT X%; : NEXT I : PRINT : RETURN

Bon, c'est pas mal, mais il n'y a rien d'aléatoire. Ce code donnera toujours les N% entiers successifs à partir de A% quelque soit B% suffisamment éloigné (ou un BREAK in 1000 si l'intervalle des entiers entre A% et B% est trop court.)

Si l'intervalle [A%,B%] est suffisamment grand, au lieu de tirer les entiers successifs, on peut prendre un sur deux, ou un sur trois, ou un sur quatre, etc. On aura donc une suite d'entiers croissant successifs mais uniformément répartis entre A% et B%.

L'idée est donc d'utiliser le générateur de nombre pseudo aléatoire RND pour choisir à chaque tirage, combien de positions entières on "saute". Cela revient donc à chaque tirage de considérer non plus l'intervalle [A%,B%], mais l'intervalle ]X%,B%].

Pour être clair, un petit schéma peut être plus éloquent que ma prose:
Supposons que l'on veille tirer 4 nombres entre 1 et 10.
On a donc A%=1:B%=10 et N%=4

Code : Tout sélectionner

A%=1:B%=10:N%=1
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|       |       |       |       |       |       |       |       |       |       |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
Amplitude:   o      o       o       o       o       o       o       o       o       o   = 10

           Pour  I=1           X% = 1 + X% + INT(10 * RND(1))

On initialise X% à 0, tout ce passe avant le premier tirage comme si l'on avait tiré A%-1.


Pour le premier tirage tous les nombres de 1 à 10 ne sont possibles.

Dans le cas d'un seul tirage, il y a 10 positions possibles car il 'y aura pas d'autres tirage et il n'est pas besoin de réserver une position.


Par contre, si l'on veut tirer plusieurs nombres, il ne faut leur réserver au moins une place, sinon on ne pourra plus continuer.
Dans l'exemple ci-dessous, on demande 4 nombre, il faut donc lors du premier tirage réserver au moins les trois dernières positions pour les tirages suivant. Qui ne seront qu'éventuellement à ces positons. Leur position finale dépendra du hasard. Mais si on oublie de les réserver, on ne pourra pas mener l'opération à terme.

Code : Tout sélectionner

A%=1:B%=10:N%=4
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|       |       |       |       |       |       |       |//T2///|//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
Amplitude:   o      o       o       o       o       o       o   = 7

           Pour  I=1           X% = 1 + X% + INT( 6 * RND(1))

Dans l'exemple ci-dessus, seule 7 positions sont possibles. Le tirage pseudo-aléatoire devra donc se faire entre 1 et 7 (exclus).

Iniitalement X%=0, il faut donc tirer un nombre aléatoire strictement inférieur à 7 que l'on ajoutera à X% pour obtenir la valeur du premier tirage.
En fait, à chaque itération, au lieu de tirer les nombres, on tire au hasard l'avancement (ou l'incrément) de façon à tomber dans l'interval possible. Il faut faire attention à laisser des valeurs pour les tirages suivants, mais aussi à 'faire avancer l'interval' de façon à ce qu'éventuellement la dernière valeur de X% tirée soit (éventuellement - par hasard) la dernière (B%) .
De plus on souhaite que les nombres soient distincts, il faut donc avancer à chaque fois au minimum de 1.

Donc pour le premier tirage, le nombre aléatoire qui sera tiré sera compris entre 0 et 5 (tous deux inclus) et on ajoutera automatiquement 1 à X% comme dans précédemment.

8 est en fait l'amplitude de l'intervalle restant (au-delà de X% et réservant encore (I-1) positions pour les tirages suivants.

Supposons que le premier nombre tiré soit 3. Pour le second tirage, nous sommes donc dans la situation suivante:

Code : Tout sélectionner

A%=1:B%=10:N%=4
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|       |       |   T1  |       |       |       |       |//T2///|//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|       |       |       |       |       |//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
Amplitude:                          o       o       o       o       o   = 5

           Pour  T=1  I=4      X% = 3
                 T=2  I=3      X% = 1 + 3 + INT( 5 * RND(1))     -----> X(2)% = 6

Au second tirage, l'intervalle possible est maintenant compris entre X%+1 et 8 car il ne faut réserve plus que deux tirages après.
On constate que la valeur de l'amplitude à chaque itération dépend à la fois du numéro de tirage (une position est libérée à droite) et du X% précèdent; en fonction de la positon qui a été tirée au tour précèdent, l'amplitude de l'intervalle possible est directement affectée.

Supposons que le second nombre tiré soit 6, on se trouve donc à la situation suivante pour le choix du troisième tirage:

Code : Tout sélectionner

A%=1:B%=10:N%=4
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|       |       |   T1  |       |       |       |       |//T2///|//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|       |       |   T2  |       |       |//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|       |       |       |///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
Amplitude:                                                  o       o       o   = 3

           Pour  T=1  I=4      X% = 3
                 T=2  I=3      X% = 6
                 T=3  I=2      X% = 1 + 6 + INT( 3 * RND(1))     -----> X(3)% = 8

Et ainsi de suite, nus voyons déjà le schéma global.
Attention INT (7*RND(1)) retourne 0 1 2 3 4 5 ou 6 (et donc jamais 7).
Supposons que le troisième tirage tombe sur 8, nous obtenons la dernière étape du tirage :

Code : Tout sélectionner

A%=1:B%=10:N%=4
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|       |       |   T1  |       |       |       |       |//T2///|//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|       |       |   T2  |       |       |//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|       |   T3  |       |///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|///////|#######|       |       |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
Amplitude:                                                                  o       o   = 2

           Pour  T=1  I=4      X% = 3
                 T=2  I=3      X% = 6
                 T=3  I=2      X% = 1 + 6 + INT( 3 * RND(1))     -----> X(3)% = 8
                 T=4  I=1      X% = 1 + 8 + INT( 2 * RND(1))     -----> X(4)% = 10

Si l'on suppose le dernier tirage égal à 10, l'état final est le suivant:

Code : Tout sélectionner

A%=1:B%=10:N%=4
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|       |       |   T1  |       |       |       |       |//T2///|//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|       |       |   T2  |       |       |//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|       |   T3  |       |///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|///////|#######|       |   T4  |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|///////|#######|///////|#######|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+

On obtient donc le code suivant :

Code : Tout sélectionner

10  PRINT "TIRAGE DE 9 NOMBRES ENTRE 1 ET 9 : " ; : A%=1 : B%=9 : N%=9:GOSUB 1000 : END

1000 X%=A%-1 : IF B%<A%+N% THEN STOP
1010 FOR I=N% TO 1 STEP -1 
1020 :    X%=X%+1+(1+B%-I-X%)*RND(1)
1030 :     PRINT X%;
1040 NEXT I
1050 PRINT : RETURN

Mais, cette méthode présente un biais important. En effet, le tirage ne se fait plus "au hasard", c'est à dire qu'il n'y a plus équi-répartition des tirages sur l'intervalle 1 à 10. Il y a un fort déséquilibre.

Supposons que la fonction RND() est très proche d'un tirage parfaitement aléatoire et uniforme. Il devrait donc y avoir équi-répartition des tirages, et si l'on réalise un nombre suffisamment grand, nous admettrons, pour simplifier ma démonstration que la 'probabilité' de tomber sur l'un des dix nombre entier est bien 1/10. Et s'il n'y a que n position, nous obtenons 1/n pour chaque (la somme faisant donc bine n/n soit 1 - je peux donc parler de probabilité).

S'il y a qu'un seul tirage, pas de soucis, les tirages sont bien équiprobables:

Code : Tout sélectionner

A%=1:B%=10:N%=1
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|  1/10 |  1/10 |  1/10 |  1/10 |  1/10 | 1/10  | 1/10  | 1/10  | 1/10  | 1/10  |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+

Si nous reprenons le cas ci-dessus, nous pouvons dresser le tableau donnant les équi-répartitions (ou l’équiprobabilité) à chaque tirage:

Code : Tout sélectionner

A%=1:B%=10:N%=4
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|  1/7  |  1/7  |  1/7  |  1/7  |  1/7  |  1/7  |  1/7  |///////|///////|///////|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|  1/5  |  1/5  |  1/5  |  1/5  |  1/5  |///////|///////|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|  1/3  |  1/3  |  1/3  |///////|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|///////|#######|  1/2  |  1/2  |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|Total:/|  1/7  |  1/7  |  1/7  | 12/35 | 12/35 | 12/35 | 71/105|  8/15 |  5/6  |  1/2  |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
           .1428   .1428   .1428   .3429   .3429   .3429   .6762   .5333   .8333   .5000

Comme on s’en rend compte facilement, on est loin de l’equi-répartition. En fait, les nombre vers la fin de la liste sont très fortement privilégier par rapport à ceux du début (car ils ne peuvent être tiré qu’au premier tirage).
La méthode est donc, comme vous l’aviez signalé dès mon premier post, fortement biaisé. A un tel point que si on utilise le code tel qu’il est donné ci-dessus, on obtiendra pratiquement que des tirages qui finisse par …7, 8, 9 ou … 8, 9, 10.

Il faut donc pondérer l’amplitude des tirages dès le premier de façon à tendre vers une meilleure équi-répartition. L’idée est de limiter l’amplitude des premiers tirages afin de laisser plus de place aux derniers tirages et tendre ainsi vers quelque chose de plus régulier.
En quelque sorte c’est comme si l’on cherchait à diviser l’intervalle restant à chaque tirage en autant de sous-intervalles qui contiendront chacun un des tirages. Mais si l’on fait cela, tous les premiers tirage d’un groupe de 4 nombres se trouveront obligatoirement dans le premier quart. C’est un peu comme si l’on cherchait à rendre en plus les tirages aussi répartis que possible.
D’où le terme diviseur en I^(N/(N+1)) qui vient fractionner à chaque tirage l’intervalle restant (l’amplitude) en autant de sous –intervalles réguliers (mais non equivalents).

D’où le code final :

Code : Tout sélectionner

10  PRINT "TIRAGE DE 9 NOMBRES ENTRE 1 ET 9 : " ; : A%=1 : B%=9 : N%=9:GOSUB 1000 : END

1000 X%=A%-1 : IF B%<A%+N% THEN STOP
1010 FOR I=N% TO 1 STEP -1 
1020 :    X%=X%+1+(1+B%-I-X%)*RND(1)/I^(N/(N+1))
1030 :     PRINT X%;
1040 NEXT I
1050 PRINT : RETURN

Et le tableau correspondant à notre exemple : la pondération retire un certain nombre des cases possible afin detenter d'homogénéiser l'amplitude des tirages. Cela se voit par les case huchurées dans le tableau :

Code : Tout sélectionner

A%=1:B%=10:N%=4
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|       |       |   T1  |///////|///////|///////|///////|//T2///|//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|       |       |   T2  |///////|///////|//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|       |   T3  |///////|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|///////|#######|       |   T4  |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|Total: |  1/3  |  1/3  |  1/3  |  1/3  |   1/3 |  1/3  |  1/2  |  1/2  |  1/2  |  1/2  |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+

En réalité, l'étude est plus complexe, car il faut considérer les cas extrêmes favorable (X% tombe en début de l'interval), défavorable (x% tombe à la fin) et en quelque sorte le cas moyen (x% au milieu). On se rend compte alors que l'équiprobabilité n'est pas possible à tous les coups, mais qu'on fonction de la pondération, nous obtiendront une distribution qui statistiquemetn convergera vers l'équi-probabilité.

Donc, l’équiprobabilité ne sera jamais parfaite, mais bien meilleure que sans pondération.

[charognard]

Donc de la gruge
normalement tu as autant de chance d'avoir un tirage avec des nombres en dessous de 10 ou >30 q'uniformément distribués.
et pourtant avec ton programme les deux premiers cas tu ne les aura de dans des cas extrèmement rare (trop rare)

[badaze]

Voici ma modeste contribution (sans gruge)

Code : Tout sélectionner

 100 CLEAR:DIM A(10):RANDOM:T=1 
130 "PRINCIPAL"
140 IF T>5 THEN GOTO "AFFICHE"
150 N = (RND 50) * -1:GOSUB "TRI":GOTO "PRINCIPAL"
180 "AFFICHE":CLS:PRINT A(4);A(3);A(2);A(1);A(0):END
210 "TRI":I=0
220 "BOUCLE"
230 IF I>4 THEN RETURN
240 IF N<A(I) GOSUB "***":RETURN
250 IF N>A(I) LET I=I+1
255 IF N=A(I) THEN RETURN
260 GOTO "BOUCLE"
270 "***"
280 A(I+4)=A(I+3)
290 A(I+3)=A(I+2)
300 A(I+2)=A(I+1)
310 A(I+1)=A(I)
320 A(I)=N
330 T=T+1
340 RETURN

[Gilles59]

... Mais y'a certainement moyen de l'optimiser. Je l'ai écrit pour un sharp PC E500.
Je vais donc jouer 3 grilles qu'il m'a sorti, et je vous dis Lundi combien j'ai gagné!

Pour le tableau de variable j'ai volontairement dimensionné pour 6 numéros (0,1,2,3,4,5), parce qu'avec mon cerveau je comprend mieux quand le 2ème numéro s'appelle N(2) plutôt que N(1)

Code : Tout sélectionner

10 CLS: WAIT 50: PRINT "TIRAGE EUROMILLION"
15 BEEP 1,222,50:  BEEP 1,141,120:  BEEP 1,222,50:  BEEP 1,141,320
20 N=0 : DIM N(5):DIM E(2)

30 FOR I = 1TO 5
40 RANDOMIZE
50 N=RND50
60 IF I=1 THEN N(1)=N: NEXT I
70 IF I=2 AND N<>N(1) THEN N(2)=N : NEXT I
80 IF I=3 AND N<>N(1) AND N<>N(2)THEN N(3)=N : NEXT I
90 IF I=4 AND N<>N(1) AND N<>N(2)AND N<>N(3)THEN N(4)=N : NEXT I
100 IF I=5 AND N<>N(1) AND N<>N(2)AND N<>N(3)AND N<>N(4)THEN N(5)=N:GOTO 200
110 I=I-1: NEXT I

200 FOR X =1TO 2
210 RANDOMIZE
220 E=RND9
230 IF X=1 THEN E(1)=E : NEXT X
240 IFX=2 AND E<>E(1) THEN E(2)=E: GOTO 300
250 X=X-1: NEXT X


300 PRINT "Joue ces numéros: ", N(1), N(2), N(3), N(4) N(5)
310 PRINT "Et joue ces étoiles: ", E(1), E(2)

Je ne connais pas le PCE500 ni l'Euromillion mais ferai comme suit si on s'autorise (ce que permet en général le Basic) une sortie brutale de boucle FOR :

Code : Tout sélectionner

10 CLS: WAIT 50: PRINT "TIRAGE EUROMILLION"
15 BEEP 1,222,50:  BEEP 1,141,120:  BEEP 1,222,50:  BEEP 1,141,320
20 DIM N(5):DIM E(2)

25 RANDOMIZE

30 FOR I = 1 TO 5
50  N=RND50
55  FOR J=1 TO I : IF N=N(J) THEN GOTO 50 :  NEXT J
67  N(I)=N
75 NEXT I

80 E(1)=RND9 :
90 E(2)=RND9 : IF E(2)=E(1) GOTO 90

95 PRINT "Joue ces numéros: ", N(1), N(2), N(3), N(4) N(5)
97 PRINT "Et joue ces étoiles: ", E(1), E(2)

[/size]
Sous réserve que DIM N(5):DIM E(2) initialise par défaut à zéro les éléments ce qui est en général le cas en basic
RND50 ne sort jamais de zéro ?

[charognard]

[quote="AlexandreSous réserve que DIM N(5):DIM E(2) initialise par défaut à zéro les éléments ce qui est en général le cas en basic
RND50 ne sort jamais de zéro ?

non

[Gilles59]

Je suis du même avis que Charo, utiliser l'écran ce n'est pas de la Gruge.
Et en gruge, je m'y connais...

@CRet: balaise, j'ai rien compris!

C'est vrai que je n'est donné aucune explication.

L'idée de base de la méthode se base sur trois constats.

Le premier est que si l'on demande au Pocket de donner 9 nombres entre 1 et 9, il devra répondre 1;2;3;4;5;6;8;7;8;9.
Il n'a pas le choix.

Le code effectuant cela sera quelque chose du style :

Code : Tout sélectionner

X%=0 : FOR I=9 TO 1 STEP -1 : X%=X%+1 : PRINT X%; : NEXT I : PRINT 

Je suis d'accord, on peut faire plus simple, mais ce code donne le résultat souhaité.

Maintenant, si je veux paramétrer cela, j'introduis mes paramètres : A% et B% les bornes de l'intervalle et N% le nombre de tirage.

Mon code devient alors :

Code : Tout sélectionner

10  PRINT "TIRAGE DE 9 NOMBRES ENTRE 1 ET 9 : " ; : A%=1 : B%=9 : N%=9:GOSUB 1000 : END

1000 X%=A%-1 : IF B%<A%+N% THEN STOP
1010 FOR I=N% TO 1 STEP -1 : X%=X%+1 : PRINT X%; : NEXT I : PRINT : RETURN

Bon, c'est pas mal, mais il n'y a rien d'aléatoire. Ce code donnera toujours les N% entiers successifs à partir de A% quelque soit B% suffisamment éloigné (ou un BREAK in 1000 si l'intervalle des entiers entre A% et B% est trop court.)

Si l'intervalle [A%,B%] est suffisamment grand, au lieu de tirer les entiers successifs, on peut prendre un sur deux, ou un sur trois, ou un sur quatre, etc. On aura donc une suite d'entiers croissant successifs mais uniformément répartis entre A% et B%.

L'idée est donc d'utiliser le générateur de nombre pseudo aléatoire RND pour choisir à chaque tirage, combien de positions entières on "saute". Cela revient donc à chaque tirage de considérer non plus l'intervalle [A%,B%], mais l'intervalle ]X%,B%].

Pour être clair, un petit schéma peut être plus éloquent que ma prose:
Supposons que l'on veille tirer 4 nombres entre 1 et 10.
On a donc A%=1:B%=10 et N%=4

Code : Tout sélectionner

A%=1:B%=10:N%=1
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|       |       |       |       |       |       |       |       |       |       |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
Amplitude:   o      o       o       o       o       o       o       o       o       o   = 10

           Pour  I=1           X% = 1 + X% + INT(10 * RND(1))

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

Si nous reprenons le cas ci-dessus, nous pouvons dresser le tableau donnant les équi-répartitions (ou l’équiprobabilité) à chaque tirage:

Code : Tout sélectionner

A%=1:B%=10:N%=4
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|  1/7  |  1/7  |  1/7  |  1/7  |  1/7  |  1/7  |  1/7  |///////|///////|///////|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|  1/5  |  1/5  |  1/5  |  1/5  |  1/5  |///////|///////|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|  1/3  |  1/3  |  1/3  |///////|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|///////|#######|  1/2  |  1/2  |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|Total:/|  1/7  |  1/7  |  1/7  | 12/35 | 12/35 | 12/35 | 71/105|  8/15 |  5/6  |  1/2  |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
           .1428   .1428   .1428   .3429   .3429   .3429   .6762   .5333   .8333   .5000

Comme on s’en rend compte facilement, on est loin de l’equi-répartition. En fait, les nombre vers la fin de la liste sont très fortement privilégier par rapport à ceux du début (car ils ne peuvent être tiré qu’au premier tirage).
La méthode est donc, comme vous l’aviez signalé dès mon premier post, fortement biaisé. A un tel point que si on utilise le code tel qu’il est donné ci-dessus, on obtiendra pratiquement que des tirages qui finisse par …7, 8, 9 ou … 8, 9, 10.

Il faut donc pondérer l’amplitude des tirages dès le premier de façon à tendre vers une meilleure équi-répartition. L’idée est de limiter l’amplitude des premiers tirages afin de laisser plus de place aux derniers tirages et tendre ainsi vers quelque chose de plus régulier.
En quelque sorte c’est comme si l’on cherchait à diviser l’intervalle restant à chaque tirage en autant de sous-intervalles qui contiendront chacun un des tirages. Mais si l’on fait cela, tous les premiers tirage d’un groupe de 4 nombres se trouveront obligatoirement dans le premier quart. C’est un peu comme si l’on cherchait à rendre en plus les tirages aussi répartis que possible.
D’où le terme diviseur en I^(N/(N+1)) qui vient fractionner à chaque tirage l’intervalle restant (l’amplitude) en autant de sous –intervalles réguliers (mais non equivalents).

D’où le code final :

Code : Tout sélectionner

10  PRINT "TIRAGE DE 9 NOMBRES ENTRE 1 ET 9 : " ; : A%=1 : B%=9 : N%=9:GOSUB 1000 : END

1000 X%=A%-1 : IF B%<A%+N% THEN STOP
1010 FOR I=N% TO 1 STEP -1 
1020 :    X%=X%+1+(1+B%-I-X%)*RND(1)/I^(N/(N+1))
1030 :     PRINT X%;
1040 NEXT I
1050 PRINT : RETURN

Et le tableau correspondant à notre exemple : la pondération retire un certain nombre des cases possible afin detenter d'homogénéiser l'amplitude des tirages. Cela se voit par les case huchurées dans le tableau :

Code : Tout sélectionner

A%=1:B%=10:N%=4
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|   0   |   1   |   2   |   3   |   4   |   5   |   6   |   7   |   8   |   9   |  10   |   11  |
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|       |       |   T1  |///////|///////|///////|///////|//T2///|//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|       |       |   T2  |///////|///////|//T3///|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|       |   T3  |///////|///T4//|///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|///////|///////|///////|#######|///////|///////|#######|///////|#######|       |   T4  |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+
|Total: |  1/3  |  1/3  |  1/3  |  1/3  |   1/3 |  1/3  |  1/2  |  1/2  |  1/2  |  1/2  |///////|
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------+

En réalité, l'étude est plus complexe, car il faut considérer les cas extrêmes favorable (X% tombe en début de l'interval), défavorable (x% tombe à la fin) et en quelque sorte le cas moyen (x% au milieu). On se rend compte alors que l'équiprobabilité n'est pas possible à tous les coups, mais qu'on fonction de la pondération, nous obtiendront une distribution qui statistiquemetn convergera vers l'équi-probabilité.
.[/size]
Donc, l’équiprobabilité ne sera jamais parfaite, mais bien meilleure que sans pondération

P.... Si avec çà tu ne gagnes pas à l'EuroMillion y'a de quoi être dégouté

[Alexandre]

Code : Tout sélectionner

10 CLS: WAIT 50: PRINT "TIRAGE EUROMILLION"
15 BEEP 1,222,50:  BEEP 1,141,120:  BEEP 1,222,50:  BEEP 1,141,320
20 DIM N(5):DIM E(2)

25 RANDOMIZE

30 FOR I = 1 TO 5
50  N=RND50
55  FOR J=1 TO I : IF N=N(J) THEN GOTO 50 :  NEXT J
67  N(I)=N
75 NEXT I

80 E(1)=RND9 :
90 E(2)=RND9 : IF E(2)=E(1) GOTO 90

95 PRINT "Joue ces numéros: ", N(1), N(2), N(3), N(4) N(5)
97 PRINT "Et joue ces étoiles: ", E(1), E(2)

Classe les gars! Mais le seul truc que j'ai à peu près compris, c'est l'optimisation de Gilles59.
J'essaierai la version de Charo sur un PC-1500. Parce qu'elle a l'air quand même bien optimisée comme solution...

[C.Ret]

P.... Si avec çà tu ne gagnes pas à l'EuroMillion y'a de quoi être dégouté

Je suis déjà fiché et interdit de jeux de hasards et loteries, à la FDJ comme aussi que dans les établissement L. Barrière et Partouche.

[badaze]

Code : Tout sélectionner

10 CLS: WAIT 50: PRINT "TIRAGE EUROMILLION"
15 BEEP 1,222,50:  BEEP 1,141,120:  BEEP 1,222,50:  BEEP 1,141,320
20 DIM N(5):DIM E(2)

25 RANDOMIZE

30 FOR I = 1 TO 5
50  N=RND50
55  FOR J=1 TO I : IF N=N(J) THEN GOTO 50 :  NEXT J
67  N(I)=N
75 NEXT I

80 E(1)=RND9 :
90 E(2)=RND9 : IF E(2)=E(1) GOTO 90

95 PRINT "Joue ces numéros: ", N(1), N(2), N(3), N(4) N(5)
97 PRINT "Et joue ces étoiles: ", E(1), E(2)

Classe les gars! Mais le seul truc que j'ai à peu près compris, c'est l'optimisation de Gilles59.
J'essaierai la version de Charo sur un PC-1500. Parce qu'elle a l'air quand même bien optimisée comme solution...

Mais n'oublie pas qu'il y a 11 étoiles.

[C.Ret]

Je ne connais pas le PCE500 ni l'Euromillion mais ferai comme suit si on s'autorise (ce que permet en général le Basic) une sortie brutale de boucle FOR :

Une sortie comme celle-là en 1984 c'était directement "Retournez à la prison sans passer par la case départ ni recevoir 20.000 FF".


Surtout que mettre le test dans une boucle FOR c'est un peu oser pour au moins trois raisons :
- la boucle FOR TO STEP / NEXT a été conçue pour boucler sur un jeu définit et prédéterminé de valeurs. Les boucles non prédéterminée (ou interactives) n'ont été conçue que plus tard avec les DO /LOOP et autre WHILE / WEND.
- il est interdit de sortir d'une boucle, certains systèmes BASIC tombent en panne car cela décale leurs pointeurs internes.
- pour tester cinq valeurs, utiliser une boucle FOR TO STEP/NEXT c'est un peu lourd et certainement bien plus long que de faire le test directement.

Sans compter que c'est oublier que l'instruction DIM permet de déclarer les tableaux. Mais contrairement au Pascal et autre langage de programmations élaboré, objet ou implémentant des classes, ce n'est pas la fonction principale. D'ailleurs sur bien des systèmes BASIC, on peut se passer de déclaration par DIM tant que l'on utilise un nombre limité (en général moins de 10) d'éléments.

Non le rôle principal de DIM est de mettre chaque élément du tableau à zéro.
Or zéro ne peut pas être un nombre de la grille de l'EuroMillion. Donc, à chaque tirage, on peut tester tous les éléments, même ceux non encore définit car ils seront à zéro et ne risquent donc pas d'interféré.

 

Donc voici ma lecture du programme d’Alexandre.

Code : Tout sélectionner

10 CLS: WAIT 50: PRINT "TIRAGE EUROMILLION"
15 BEEP 1,222,50: BEEP 1,141,120: BEEP 1,222,50: BEEP 1,141,320

20 CLEAR:DIM N(5),E(2)
25 RANDOMIZE

30 FOR I = 1 TO 5
35 :  N=RND 50
40 :  IF N=N(1) OR N=N(2) OR N=N(3) OR N=N(4) OR N=N(5) THEN 35
45 :  N(I)=N
50 NEXT I
55 PRINT "Joue ces numéros: ";N(1);N(2);N(3);N(4);N(5)

60 E(1)=RND 11
65 E(2)=RND 11 : IF E(2)=E(1) GOTO 65
70 PRINT "Et joue ces étoiles: ";E(1);E(2)
75 END

Bon, mais cette version ne trie pas la liste des nombre. Alors, je vais utiliser la même stratégie que Badaze. A chaque tirage, je mémorise le nombre ans le tableau N() en fonction de son rang. Ou alors je tire un autre nombre s’il existe déjà dans le tableau.
Pour trier le tableau, je laisse monter les bulles les plus grosses vers le haut du tableau, et cela par échanges successifs.

Code : Tout sélectionner

10 CLS: WAIT 50: PRINT "TIRAGE EUROMILLION"
15 BEEP 1,222,50: BEEP 1,141,120: BEEP 1,222,50: BEEP 1,141,320

20 DIM N(5),E(2)
25 RANDOMIZE

30 FOR I = 1 TO 5
35 :  N(I)=RND 50 :IF I=1 THEN ¬60
40 :  FOR J=1 TO I-1
45 :  :  IF N(I)<N(J) THEN SWAP N(I),N(J)
50 :  :  IF N(I)=N(J) THEN N(I)=999
55 :  NEXT J
60 :  IF N(I)=999 THEN 35
65 NEXT I
70 PRINT "Joue ces numéros: ";N(1);N(2);N(3);N(4);N(5)

75 E(1)=RND 11
80 E(2)=RND 11 : IF E(2)=E(1) GOTO 65
85 IF E(1)>E(2) THEN SWAP E(1),E(2)
90 PRINT "Et joue ces étoiles: ";E(1);E(2)
95 END

Où SWAP A,B échange le contenu de A et B. Si votre système BASIC n’a pas cette instruction (ce qui est très fréquent), il faudra adapter.
Par exemple en remplaçant par S=A,A=B,B=S. Mais il y a d’autre façons de faire, Charognard donne une technique sans utiliser de variable S dans le misez p’tit n°7.
viewtopic.php?f=46&t=30216

Quand au tri par bulle, ce n’est la seule façon de faire, on peut aussi faire un comptage ou utiliser des listes chainées :
viewtopic.php?f=46&t=29688

[Gilles59]

Je ne connais pas le PCE500 ni l'Euromillion mais ferai comme suit si on s'autorise (ce que permet en général le Basic) une sortie brutale de boucle FOR :

Une sortie comme celle-là en 1984 c'était directement "Retournez à la prison sans passer par la case départ ni recevoir 20.000 FF".


Surtout que mettre le test dans une boucle FOR c'est un peu oser pour au moins trois raisons :
- la boucle FOR TO STEP / NEXT a été conçue pour boucler sur un jeu définit et prédéterminé de valeurs. Les boucles non prédéterminée (ou interactives) n'ont été conçue que plus tard avec les DO /LOOP et autre WHILE / WEND.
- il est interdit de sortir d'une boucle, certains systèmes BASIC tombent en panne car cela décale leurs pointeurs internes.
- pour tester cinq valeurs, utiliser une boucle FOR TO STEP/NEXT c'est un peu lourd et certainement bien plus long que de faire le test directement.

Bon, perso même pas peur Sur ce genre de machine je suis assez persuadé que çà ne pose pas de pb. Le basic a suffisamment de défauts pour ne pas profiter de ses petits avantages en le brutalisant un peu Je vous accorde que c'est n'est pas conseillé sur tous les basics. Concernant la vitesse et dans le cas présent, pas de problème, c'est suffisamment rapide pour ne pas s'embêter

Pour éviter le violent GOTO

Code : Tout sélectionner

30 FOR I = 1 TO 5
50  N=RND50
55  FOR J=1 TO I :IF N=N(J) THEN N=0 : NEXT J
67  IF N=0 THEN GOTO 50 ELSE N(I)=N
75 NEXT I

[fiend41]

et... personne n'aurait bossé sur un programme de "martingale" ?

çad pouvoir déterminer une suite à base de qq chiffres réfléchis ?! . en observant les tirages passés, on se dit parfois. mais bon sang de bonsoir, y'a comme une suite plus ou moins logique. par ex. bien plus d'"une fois il n'y a que 4-5 chiffres sur 10 qui sont présents dans tous les numéros présents

exemple récent . 1 4 15 29 40 / 1.5 ne sont présents que des chiffres 0 1 2 4 5 9 !!

un générateur de ces chiffres aurait permis de trouver la combinaison gagnante..mais en combien de grilles ?!

[badaze]

et... personne n'aurait bossé sur un programme de "martingale" ?

çad pouvoir déterminer une suite à base de qq chiffres réfléchis ?! . en observant les tirages passés, on se dit parfois. mais bon sang de bonsoir, y'a comme une suite plus ou moins logique. par ex. bien plus d'"une fois il n'y a que 4-5 chiffres sur 10 qui sont présents dans tous les numéros présents

exemple récent . 1 4 15 29 40 / 1.5 ne sont présents que des chiffres 0 1 2 4 5 9 !!

un générateur de ces chiffres aurait permis de trouver la combinaison gagnante..mais en combien de grilles ?!

Sur 116 millions de combinaisons j'ai plus confiance en la chance qu'en un quelconque programme de martingale. Tu peux observer tous les tirages que tu veux, d'une part il n'y a pas eu jusqu'à présent assez de tirages pour pouvoir faire une évaluation statistique fiable (seulement sur un très grand nombre de tirages le nombre de sorties d'un numéro tendra vers 1//50) et d'autre part ce n'est pas parce qu'un numéro est moins sorti qu'un autre qu'il a plus de chances de sortir dans le futur.

Tu as 1 chance sur 23 d'avoir 2 numéros et même en jouant 23 grilles (46 euros) tu n'es pas certain de gagner .... les 4 à 5 euros correspondant à ce niveau de gain. Quand tu joues une grille, tu as 7,8 chances sur 100 de gagner un lot... donc 92,2 chances sur 100 de ne rien gagner.

[OulanB]

Une solution pour HP97+

• A pour les numéros ... imprimés d'abord dans l'ordre du tirage puis ensuite après tri
  E permet d'imprimer à nouveau
  B pour les étoiles

il faut mettre une semence non nulle dans la mémoire A

Code : Tout sélectionner

001  *LBLA     21 11            Tirage 5 numéros de 1 à 50
002      5        05
003      0        00
004   STOB     35 12            MAX
005      5        05
006   STOC     35 13            N
007   GTOa  22 16 11
008  *LBLB     21 12            Tirage 2 numéros de 1 à 11
009      1        01
010      1        01
011   STOB     35 12            MAX
012      2        02
013   STOC     35 13            N
014  *LBLa  21 16 11            On y va
015   DSP0    -63 00
016   RCLB     36 12
017   STOI     35 46            I = MAX
018   STO0     35 00            R0 = MAX
019   RCLI     36 46            <------------------------\
020   STOi     35 45                R(I) = I             |
021      4        04                                     |
022   DSZI  16 25 46                pour R(1) à R(MAX)   |
023    Bcͯ     21 33            -------------------------/
024    SPC     16-11            Rq : I = 0 ici
025  *LBL0     21 00            Pour les N numéros à tirer <--\   
026   ISZI  16 26 46                I = I + 1 (de 1 à N)      |
027   GSBe  23 16 15                alea de I à MAX           |
028   STOE     35 15                -> E                      |
029   RCLi     36 45                on mémorise les numéros   |
030   RCLe     36 33                tirés à partir de R1, on  |
031   PRTX       -14                fait un échange de R(E)   |
032   STOi     35 45                avec R(I) pour conserver  |
033    X↔Y       -41                le numéro en R(I)         |
034   STOe     35 33                R(I) <-> R(E)             |
035      1        01                                          |
036   ST-0  35-45 00                R0 = R0 - 1 (pour 'e')    |
037   RCLC     36 13                N                         |
038   RCLI     36 46                I                         |
039   X≠Y?     16-32                I # N ?                   |
040   GTO0     22 00            ------------------------------/ 
041   RCLC     36 13            
042   STOE     35 15            E = N
043  *LBL1     21 01            Tri à bulle 
044   RCLE     36 15            <-------------------------------\
045   STOI     35 46                                            |
046   DSZI  16 25 46                I = E - 1                   |
047   RCLe     36 33                <-------------------------\ |
048   RCLi     36 45                                          | |
049   X>Y?     16-34                    R(I)>R(E) ?           | |
050   GTO2     22 02                        pas d'échange --\ | |
051   STOe     35 33                                        | | |
052    X↔Y       -41                                        | | |
053   STOi     35 45                        R(E) <-> R(I)   | | |
054  *LBL2     21 02                    <-------------------/ | |
055      1        01                                          | |
056      1        01                                          | |
057   DSZI  16 25 46                    I = I - 1             | |
058    Bcͯ     21 33                I # 0 ? ------------------/ |
059      1        01                                            |
060   RCLE     36 15                                            |
061      1        01                                            |
062     -        -45                                            |
063   X=Y?     16-33                E - 1 = 1 ?                 |
064   GTOE     22 15                terminé---------\           |
065   STOE     35 15                E = E - 1       |           |
066   GTO1     22 01            --------------------+-----------/
067  *LBLE     21 15            On affiche <--------/
068    SPC     16-11            de R(N) à R(1)
069   RCLC     36 13            N
070   STOI     35 46            I = N
071   RCLi     36 45            <--------------\
072   PRTX       -14                print R(I) |
073      4        04                           |
074   DSZI  16 25 46                I = I - 1  |
075    Bcͯ     21 33            I # 0 ? -------/
076    RTN        24            Fini
077  *LBLe  21 16 15            Aléa ...
078   RCLA     36 11
079      9        09
080      9        09
081      7        07
082     ×        -35
083    FRC     16 44
084   STOA     35 11
085   RCL0     36 00
086     ×        -35
087   RCLI     36 46            
088     +        -55
089    INT     16 34            IP(RND * R0 + I)
090    RTN        24

Pour une meilleure distribution, vous pouvez changer le ss-programme 'e' par un meilleur générateur ...
J'ai fait 'rapide'

Bon un peu de commentaires ne fait pas mal semble-t-il ...

Une propriété intéressante est de ne tirer que N nombres au hasard pour faire un tirage de N numéros ...

[C.Ret]

Voici ma modeste contribution (sans gruge)

Code : Tout sélectionner

 100 CLEAR:DIM A(10):RANDOM:T=1 
130 "PRINCIPAL"
140 IF T>5 THEN GOTO "AFFICHE"
150 N = (RND 50) * -1:GOSUB "TRI":GOTO "PRINCIPAL"
180 "AFFICHE":CLS:PRINT A(4);A(3);A(2);A(1);A(0):END
210 "TRI":I=0
220 "BOUCLE"
230 IF I>4 THEN RETURN
240 IF N<A(I) GOSUB "***":RETURN
250 IF N>A(I) LET I=I+1
255 IF N=A(I) THEN RETURN
260 GOTO "BOUCLE"
270 "***"
280 A(I+4)=A(I+3)
290 A(I+3)=A(I+2)
300 A(I+2)=A(I+1)
310 A(I+1)=A(I)
320 A(I)=N
330 T=T+1
340 RETURN

J'aime bien ce code.
Surtout depuis l'ajout de la ligne 255 qui résout maintenant les cas où la version précèdente (et achevée tard dans la nuit) blocquée de temps en temps. En effet, le programme restait "coincé" dans cette boucle.

Non, ce que j'aime c'est l'utilisation des labels;

Bien que l'utilisation ds Label alphanumérique soit présente sur les POcket depuis lanuit des temps, nus sommes très rares à les utiliser 'sauf à réserver quelque raccourci claviers par la touche(ou le mode) DEF.
Et pourtant c'est fort utile, cela permet de composer son code sans ce soucier des n° de ligne. Mais surtout, cela donne une indication précieuse au lecteru, qui par le nom du Label comprend de quoi il s'agit.

En effet, rien n'est plus abscon qu'une ligne comme celle-ci
25 IF R>0 THEN 60 : ELSE 130

Alors que
25 IF Resultat>0 THEN "GAIN":ELSE "PERTES"

donne tout de suite plus de sens au code et donne explicitement ce à quoi sert chaque partie et où (et pourquoi) le programme bifurquera !

C'est un aspect de nos programmes sur Pocket qui est, à mon avis, trop souvent négligé. Ces labels alphanumérique permettent de composer un code plus lisible (Et ZUT aux les grincheux qui y voit une perte de bits et d'octets !)