Discussion :

[JEF95]

j'ai récupéré un prg visual basic sur le web et j'ai essayé de le transformer en purebasic, mais je rencontre des soucis. Mais grâce à vous, peut-être vais je trouver la solution et je vous en remercie d'avance.

pour les besoins d'un jeu, je tire aléatoirement 2000 séries de 5 nombres différents ( de 1 à 22 ). je voulais faire un programme pour réduire le nombre de ces séries au maximum tout en étant sur de retrouver dans une des nouvelles séries au moins 3 ou 4 nombres ( ou + ) d'une des 2000 séries. Et ce n'est pas le cas, le prg me sort des séries avec parfois des numéros en double ou + et aucunes séries qu'il m'affiche ne correspond à ce que je veux.

Je suis plutôt débutant ( et il y à certaines fonction du prg que je ne connais pas encore ), mais j'arrive à me débrouiller, mais là, je cherche depuis longtemps la solution, je croyais l'avoir trouvé, mais non.

Est-ce que vous pourriez m'aider à résoudre ce problème qui me prends bien la tête depuis un bon moment ?

Merci beaucoup pour votre aide et excellente jounée.

Jef95

[CosmoKnacki]

Poste ton code (entre balises [code] bien entendu). Montre aussi ce que tu veux obtenir (ou pas), parce que ta description n'est pas super clair.

[JEF95]

Poste ton code (entre balises [code] bien entendu). Montre aussi ce que tu veux obtenir (ou pas), parce que ta description n'est pas super clair.

J'ai 2000 séries de nombre de 1 à 30, ex :


série 1 : 01,17,24,26,29
série 2 : 02,05,18,22,25
série 3 : 10,12,18,23,29 ------------------------------- pour l'exemple, je retiens cette série
série 4 : 05,09,13,20,21
série 5 : 22,24,30,17,15
etc...
etc... jusqu'à 2000 séries

je veux réduire au maximum le nombre des séries ( 2000 ), tout en étant sur que dans le nombre des nouvelles séries, j'en ai au moins une ( ou plus ) qui comporte les 4 ( ou plus ) nombres d'une même série précédentes. En suivant l'exemple que j'ai donné ci-dessus, dans les nouvelles séries, il faut qu'il y en ait une ( ou plus ) qui comporte 4 ( ou plus ) des nombres de la série 3 :10,12,18,23,29.

;-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

pour l'instant, j'ai ce prg qui est une conversion d'un prg Visual Basic, mais qui ne donne pas le résultat attendu :

OpenConsole()
EnableGraphicalConsole(1)
ClearConsole()




; Par défaut les variables sont des integer

Procedure IIf(hasMatch, V, F)
If hasMatch
ProcedureReturn V
Else
ProcedureReturn F
EndIf
EndProcedure


Dim chosenNumbers(5)
chosenNumbers(1) = 1
chosenNumbers(2) = 20
chosenNumbers(3) = 33
chosenNumbers(4) = 14
chosenNumbers(5) = 45



numSequences = 200
sequenceLength = 5
minMatches = 4
reducedNumSequences = 100

; CInt arrondit (arrondi du banquier) à l’entier le plus proche au lieu de tronquer la partie fractionnelle des nombres
Dim sequences( sequenceLength,numSequences)
For i = 1 To numSequences
For j = 1 To sequenceLength
rd.f=Random(1000000,0)/1000000
While rd=1.0
rd=Random(1000000,0)/1000000
Wend
sequences(j, i) = Round((Round((50 - 1 + 1) * Rd,#PB_Round_Down)),#PB_Round_Nearest) + 1
Next j
Next i


hasMatch.b = #False
For i = 1 To numSequences
matchCount = 0
For j = 1 To sequenceLength
For k = 1 To 5
If sequences(j, i) = chosenNumbers(k)
matchCount + 1
EndIf
Next k
Next j
If matchCount >= minMatches
hasMatch = True
EndIf
Next i

If Not hasMatch
ReDim sequences(sequenceLength,numSequences + 1)
For i = 1 To minMatches
sequences( i,numSequences + 1) = chosenNumbers(i)
Next i
For i = minMatches + 1 To sequenceLength
rd.f=Random(50,1)
While rd=1.0
rd=Random(50,1)
Wend
sequences(i,numSequences + 1) = Round(Round(((10 - minMatches) - (minMatches + 1) + 1) * Rd,#PB_Round_Down),#PB_Round_Nearest) + (minMatches + 1)
Next i
EndIf

Dim reducedSequences(reducedNumSequences, sequenceLength)
For i = 1 To reducedNumSequences
rd.f=Random(50,1)/50
While rd=1.0
rd=Random(50,1)/50
Wend
sequenceIndex = Round(Round(((numSequences + IIf(hasMatch, 0, 1)) - 1 + 1) * Rd,#PB_Round_Down),#PB_Round_Nearest) + 1
For j = 1 To sequenceLength
reducedSequences(i, j) = sequences(j,sequenceIndex)
Next j
Next i

;OpenConsole()
For i = 1 To reducedNumSequences
For j = 1 To sequenceLength
Print(Str(reducedSequences(i, j))+"-")
Next j
PrintN("")
Next i
R$ = Input()


Input()

;********************************************************************************************************************************************************************************************
PrintN("FIN du PROGRAMME ... SUITE = EXIT.")
PrintN("")rintN("")
Input()

;********************************************************************************************************************************************************************************************
FINPRG:
PrintN("FIN du PROGRAMME......")

CloseConsole()
End

;------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

Bon après-midi

Jef95

[umfred]

Tu peux peut-être reprendre le problème à la base: générer x séquences de 5 chiffres entre 1 et 22 sans répétition
Ta problématique est qu'il y a des répétitions d'un même nombre dans un tirage, si j'ai bien compris ?
Il faut donc au moment du tirage, vérifier que le nombre n'est pas déjà présent; et continuer de sortir un nombre au hasard tant que celui-ci est présent dans la séquence.

Je ferais donc une petite méthode IsInArray(maTable, Valeur) me renvoyant un booleen Vrai/Faux selon la présence de Valeur dans le tableau maTable); ça pourrait donner quelque chose comme ça (il y a probablement des corrections de syntaxe à faire)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
Procedure IsInArray (Array maTable(1), Valeur)
    dim i
    dim resultat
    resultat=False
    for i = 1 to ArraySize(maTable)
        if maTable(i) = Valeur then
             resultat=True
             break
    Next i
    ProcedureReturn resultat
Endprocedure

[JEF95]

Tu peux peut-être reprendre le problème à la base: générer x séquences de 5 chiffres entre 1 et 22 sans répétition
Ta problématique est qu'il y a des répétitions d'un même nombre dans un tirage, si j'ai bien compris ?
Il faut donc au moment du tirage, vérifier que le nombre n'est pas déjà présent; et continuer de sortir un nombre au hasard tant que celui-ci est présent dans la séquence.

Je ferais donc une petite méthode IsInArray(maTable, Valeur) me renvoyant un booleen Vrai/Faux selon la présence de Valeur dans le tableau maTable); ça pourrait donner quelque chose comme ça (il y a probablement des corrections de syntaxe à faire)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
Procedure IsInArray (Array maTable(1), Valeur)
    dim i
    dim resultat
    resultat=False
    for i = 1 to ArraySize(maTable)
        if maTable(i) = Valeur then
             resultat=True
             break
    Next i
    ProcedureReturn resultat
Endprocedure

Le problème n'est pas la répétition des numéros ( ça j'arrive à le résoudre ), c'est juste la réduction ( la plus importante possible ) du nombre des séries , tout en étant sur que dans cette nouvelle série ( réduite ), qu'il y ai au moins une série ( ou plus ) qui comporte 4 ( ou plus de nombres ) d'une des séries précédentes ( celles d'origine ). Je veux juste réduire le nombre de ces séries avec cette garantie. J'ai malheureusement poser le même questions sur beaucoup de forums, et personne n'a pu trouver la solution !!!!!

[umfred]

Le programme d'origine répondait à ta demande ? si oui poste le (dans les balises CODE cette fois-ci, bouton # de l'interface)
Pour ta réduction, l'ordre (la position) des nombres importe ?
et je n'ai trop compris comment tu veux réduire (la logique de réduction) la liste des 2000 premières séquences.
Tu dis retenir une séquence, tu la choisis au hasard ?
Tu peux partir de la séquence retenue pour faire varier un seul des nombres de celle-ci (tirage au sort d'un nombre, tirage au sort d'une position dans la séquence, modification du nombre de la position tirée par le nombre tirée)

[JEF95]

Le programme d'origine répondait à ta demande ? si oui poste le (dans les balises CODE cette fois-ci, bouton # de l'interface)
Pour ta réduction, l'ordre (la position) des nombres importe ?
et je n'ai trop compris comment tu veux réduire (la logique de réduction) la liste des 2000 premières séquences.
Tu dis retenir une séquence, tu la choisis au hasard ?
Tu peux partir de la séquence retenue pour faire varier un seul des nombres de celle-ci (tirage au sort d'un nombre, tirage au sort d'une position dans la séquence, modification du nombre de la position tirée par le nombre tirée)

-------------------------------------------------------------------------------------------------------------------------------------------------------

Le programme d'origine ne répondait pas a ce que je voulais.

la position des nombres n'est pas importante.

Je calcule toutes les séries de 5 nombres parmi 30 ( ce qui me donne 142506 séries ), et ce nombre de séries est trop important pour moi.

Je veux donc créer moins de séries à partir des premières.

Ensuite, je tire une séquence de 5 nombres aléatoirement ( parmi 30 ), et je veux retrouver au moins 4 nombres ( ou plus ) d'une des séries d'origine, dans une des nouvelles
séries ( celles crées après la réduction du nombre des séries d'origine ).

Ci-dessous, petit programme fait rapidement, si cela peut vous aider à comprendre ce que je veux.

Et merci infiniment de votre aide et de votre patience.

Jef

--------------------------------------------------------------------------------------------------------------------------------------------------------

OpenConsole()
EnableGraphicalConsole(1)
ClearConsole()


NombreDeSeries=0

; (A) = calcul de toutes les séries de 5 nombres parmi 30

For a=1 To 26
For b=A+1 To 27
For c=b+1 To 28
For d=c+1 To 29
For e=d+1 To 30

; AFFICHAGE DE (A)

PrintN("a = "+a+" - b = "+b+ " - c = "+c+" - d = "+d+" - e = "+e)
NombreDeSeries=NombreDeSeries+1
Next;e
Next;d
Next;c
Next;b
Next;a

; résultat

PrintN("")rintN("")
PrintN("Total Nombre de Séries = "+NombreDeSeries); RESULTAT (NombreDeSeries (A) = 142506


; ENSUITE :

; (B) = je tire aléatoirement 5 nombres différents ( de 1 à 30 ).

; je vais automatiquement retrouver ces 5 nombres (B) ( et plusieurs fois 1,2,3 ou 4 nombres ) dans les 142506 séries (A) générées précédement.

;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
; CE QUE JE VEUX, C'EST REDUIRE LE PLUS POSSIBLE LE NOMBRE DES SERIES D'ORIGINE (NombreDeSeries (A) = 142506).
; PASSER PAR EXEMPLE DE 142506 SERIES (A) à 65000 NOUVELLES SERIES ( que je nommerais (C) ),
; MAIS CECI, EN ETANT SUR DE RETROUVER 4 NOMBRES ( ou plus ) DU TIRAGE ALEATOIRE (B) DANS LES NOUVELLES SERIES (C).
;-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------


PrintN("FIN du PROGRAMME......")
Input()
CloseConsole()
End

[umfred]

réduire le plus possible le nombre de séquence par rapport à un tirage, bah c'est de prendre la séquence du tirage voulu, on ne peut pas réduire plus que ça

Sinon je réitère ce que j'ai dit dans mon message précédent: tu pars de la B et tu tires un nombre aléatoire (x), et une position aléatoire (y) et tu fais la substitution pour avoir une autre séquence
B=[(1,2,3,4,5)]
C=[(1,2,3,4,12),(1,2,6,4,5),(21,2,3,4,5), etc) en ayant tiré (x,y)=(12,4) puis (6,2) puis (21,0) ...

Je ne vois pas l'intérêt de passer par l'étape A (surtout que A ne contient que les possibilités ordonnées tel que a<b<c<d<e) (ici ce sont tes variables de boucles)
donc le tirage B ne sera dans A que si il est ordonné lui aussi (non précisé)
et ma solution reste valable, il suffit d'ordonner le résultat.
si ça répond à ta demande qui, pour moi, reste flou