Votre question

Aide pour une fonction en VB

Tags :
  • Programme
  • Programmation
Dernière réponse : dans Programmation
1 Juin 2010 16:06:21

Bonjour,
Je suis présentement en train d'écrire un programme en visual basic, version 2007 pour le cadre d'un cours de base en informatique. Puisque ce n'est pas ma tasse de thé, un petit coup de pouce serait vraiment apprécié.

Voilà, il me reste qu'une partie de mon code a créé, et peut importe ce que j'essais je ne trouve pas la solution.

Je doit écrire une fonction qui fait cela pour mon programme :

-attendre tant que ça ne fait pas X fois que mon nombre n'est pas tiré (gagnant)

Par exemple :
-Une roulette de casino, il y a 36 encoches ou l'on peu miser, appelons cette variable : nombre_n
-Une autre variable nommée nombre_k est le nombre de coups consécutif que le nombre_n n'a pas été tiré.

La fonction doit faire une boucle qui est terminer seulement lorsque le nombre_n n'a pas été tiré pour plus de nombre_k fois consécutive.

donc ci je choisie 200 pour nombre_k, il devra ce passer 200 tirages consécutifs non gagnant et ensuite, je peut poursuivre avec un section de mon programme.

J'espère avoir été précis, merci de vôtre aide.

Autres pages sur : aide fonction

2 Juin 2010 17:49:59

Citation :
Bonjour,
Je suis présentement en train d'écrire un programme en visual basic, version 2007 pour le cadre d'un cours de base en informatique. Puisque ce n'est pas ma tasse de thé, un petit coup de pouce serait vraiment apprécié.

Voilà, il me reste qu'une partie de mon code a créé, et peut importe ce que j'essais je ne trouve pas la solution.

Je doit écrire une fonction qui fait cela pour mon programme :

-attendre tant que ça ne fait pas X fois que mon nombre n'est pas tiré (gagnant)

Par exemple :
-Une roulette de casino, il y a 36 encoches ou l'on peu miser, appelons cette variable : nombre_n
-Une autre variable nommée nombre_k est le nombre de coups consécutif que le nombre_n n'a pas été tiré.

La fonction doit faire une boucle qui est terminer seulement lorsque le nombre_n n'a pas été tiré pour plus de nombre_k fois consécutive.

donc ci je choisie 200 pour nombre_k, il devra ce passer 200 tirages consécutifs non gagnant et ensuite, je peut poursuivre avec un section de mon programme.

J'espère avoir été précis, merci de vôtre aide.


J'ai finalement réussie mon programme, enfin je crois... j'ai trouver en faisant des essais :

'****************************************************************************
'* Module : Module1 | travail pratique numero 1
'* Par : Xavier Paquette
'* Date : 02/05/10
'*
'* Ce module regroupe une procédure et quatre fonctions pour
'* le travail pratique un petit tour au casino.
'*
'* FONCTION:
'* Elle saisit et valide le numéro N de l’encoche sur lequel le
'* joueur souhaite miser. L’utilisateur ne peu pas annuler la saisie,
'* ni entrer une valeur entière qui ne soit pas dans l’intervalle
'* [0, 36] pour le choix de l'encoche.
'*
'* Elle saisit et valide le nombre de tirages consécutifs K à laisser
'* passer durant lesquels le numéro N ne doit pas être tiré. L’utilisateur
'* ne peu pas annuler la saisie, ni entrer une valeur entière qui ne soit
'* pas dans l’intervalle [0, 200].
'*
'* Finalment, la procédure calcule le nombre de tirages moyen nécessaires
'* afin que le numéro N soit tiré, sachant que ce numéro n’a pas été tiré
'* lors des K derniers tirages. Sur une moyenne de 100 000 essaies.
'*
'* VALEUR DE RETOUR : Le nombre moyen de tirages qu'il est néccésaire afin
'* que l'encoche choisie par l'utilisateur sois gagnant suite à K fois que
'* l'encoche N n'a pas été gagnant.
'****************************************************************************


'Obliger la déclaration des variables.
Option Explicit

'****************************************************************************
'* LES CONSTANTES
'****************************************************************************



Const nb_répétition = 100000
Const borne_min = 0
Const borne_max1 = 36
Const borne_max2 = 200


'****************************************************************************
'* LA PROCÉDURE :
'****************************************************************************


Public Sub travail_pratique1()

'Variable dans laquelle la valeurs de "N" est enregistrée.
Dim nombre_n As Integer
'Variable dans laquelle la valeurs de "K" est enregistrée.
Dim nombre_k As Integer
'Variable dans laquelle est enregistrée le nombre de tirages total.
'nécéssaire suite à "K" fois que le nombre "N" n'a pas été gagnant.
'Cette variable change ensuite de valeurs, pour la moyenne.

Dim total_tirage As Double
'Cette variable enregistre temporairement les valeurs entrée au
'clavier par l'utilisateur, pour l'envoyer dans la fonction vérifier_intervalle.

Dim valeurs_utilisateur As Integer
'Cette variable est le premier compteurs, pour faire une répétition de 100000 fois.
'de type double car c'est un grand nombre 100 000.
Dim indice As Double

'Placé ici, puisque demandé dans les consiges du travail pratique.
'Permet au programme de faire des nombres aléatoires grâce à cette
'fonction intégré dans VB. Permet d'utiliser Rnd.

Call Randomize

'La valeurs de la variable nombre_n est déterminée par la fonction vérifier_intervalle.
'L'utilisateur entre la donnée manquante avec une inputbox. "N"

nombre_n = vérifier_intervalle(borne_min, borne_max1, Val(InputBox("Veuillez choisir sur " _
& "quelle encoche vous souhaiter miser. " & "Vous devez entrer un nombre compris inclusivement" _
& " dans l'intervalle : " & " [" & borne_min & "," & borne_max1 & "]" & ".")))


'La valeurs de la variable nombre_k est déterminée par la fonction vérifier_intervalle.
'L'utilisateur entre la donnée manquante avec une inputbox. "K".

nombre_k = vérifier_intervalle(borne_min, borne_max2, Val(InputBox("Veuillez choisir le nombre de" _
& " fois consécutif que l'encoche numéro " & nombre_n & " n'a pas été gagnant." & vbCrLf & _
"Ce nombre doit être situé inclusivement entre l'intervalle : [" & borne_min & "," _
& borne_max2 & "]" & ".")))

'Lance la fonction attendre_k en lui envoyant l'information de la variable (nombre_n) et (nombre_k).
Call attendre_k(nombre_n, nombre_k)

'La boucle est répété 100 000 fois, utilise l'indice pour compter le nombre de boucle.
'Le code est découpé en fonctions; attendre_k, compteur_aléatoire.
For indice = 1 To nb_répétition

'Total_tirage est égale à ca propre valeurs, plus la valeurs obtenue avec la fonction
'tirage_aléatoire

total_tirage = total_tirage + tirage_aléatoire(nombre_n, nombre_k)

'Lance de nouveau la boucle indice.
Next indice

'Modifie la valeurs de total_tirage par une moyenne de mises nécéssaire pour que "N" sois gagnant
'suite à "K" fois consécutifs que "N" n'ai pas été tiré.

total_tirage = total_tirage / nb_répétition


'Informe l'utilisateur du résultat final, arrondie !
MsgBox ("Résultat du calcul :" & vbCrLf & "Il vous faudra en moyenne " _
& Round(total_tirage, 2) & " tirages consécutifs. " & vbCrLf & vbCrLf & _
"Cela avant que l'encoche numéro : " & nombre_n & " sois tiré suite à : " _
& nombre_k & " fois consécutives que l'encoche" & " n'ai pas été gagné au préalable. " _
& vbCrLf & vbCrLf & "La moyenne est calculé sur une base de " & _
nb_répétition & " éssais aléatoires." & vbCrLf & vbCrLf & "Fait par Xavier Paquette")

End Sub




'****************************************************************************
'* LES FONCTIONS
'****************************************************************************

'****************************************************************************
'* 01 : VÉRIFIER_INTERVALLE
'*
'* FONCTION :
'* Cette fonction reçois des informations pour vérifier si une valeurs
'* choisie au clavier par l'utilisateur est dans l'intervalle demandé.
'* De plus, lorsque la valeurs n'est pas dans l'intervalle demandé, la
'* fonction demande de choisir un nombre à nouveau, et vérifie chaque fois.
'*
'* PARAMETRES:
'* - borne_min : Valeurs minimale de l'intervalle (Type : Integer)
'*
'* - borne_max : Valeurs maximale de l'intervalle (Type : Integer)
'*
'* - valeurs_utilisateur : Valeurs de du dernier choix entré au clavier
'* par l'utilisateur. (Type : Integer)
'*
'* VALEUR DE RETOUR : Aucune valeurs de retour, une attente.
'*
'****************************************************************************


Public Function vérifier_intervalle(ByVal borne_min As Integer, _
ByVal borne_max As Integer, ByVal valeurs_utilisateur As Integer) As Integer

'La boucle ce répète tant et aussi longtemps que la valeurs entrée par l'utilisateur n'est
'pas entre la borne minimum et la borne maximum.

While (borne_min > valeurs_utilisateur Or borne_max < valeurs_utilisateur)

'Cette fenêtre est affichée si l'utilisateur a fait un mauvais choix, pour qu'il entre
'un nouveau choix, un rappel des bornes y est inscrit.

valeurs_utilisateur = Val(InputBox("Le nombre choisie n'est pas dans l'intervalle [" _
& borne_min & "," & borne_max & "]" & "Veuillez choisir de nouveau."))

Wend

'Enregistre le résultat temporairement dans vérifier_intervalle, cette donnée est ensuite
'transférée dans une variable du programme travail_pratique1.

vérifier_intervalle = valeurs_utilisateur

End Function


'****************************************************************************
'* 02 : ATTENDRE_K
'*
'* FONCTION :
'* Cette fonction permet à la procédure travail_pratique1 d'attendre
'* que le nombre "N" n'ai pas été gagnant pendant "K" tours consécutifs
'* Cette fonction gégère donc, un nombre aléatoire. Le compteur augmente
'* tant que le nombre généré est différent de "N". Une fois que le
'* compteur ai atteint la valeurs recherchée "K", la fonction est terminé.
'*
'* PARAMETRES:
'* - nombre_n : Cette valeurs est choisie préalablement par l'utilisateur
'* et équivaut à "N" le numéro de l'encoche. (type : Integer)
'* - nombre_k : Cette valeurs est choisie préalablement par l'utilisateur
'* et équivaut à "K" le "temps d'attente". (type : Integer)
'* VALEUR DE RETOUR : Aucune valeurs de retour, une attente.
'*
'****************************************************************************


Public Function attendre_k(ByVal nombre_n As Integer, ByVal nombre_k As Integer)

'Ce compteur enregistre le nombre de fois que le nombre "N" n'a pas été tiré.
Dim indice2 As Integer
'Cette variable enregistre un nombre généré aléatoirement.
Dim aléatoire_k As Integer

'Valeurs initiale des variables sont de 0.
indice2 = 0
aléatoire_k = 0

'Tant que indice2 est plus petit que le nombre "K", on génère un nombre aléatoire entre
'[0, 36]. Ci le nombre généré aléatoirement est éguale au nombre "N" alors, indice prend
'une valeurs de 0, puisque l'on veut attendre que la mise n'ai pas été tiré "K" fois.

While (indice2 < nombre_k)

'Génère un nombre aléatoire, [0, 36].
aléatoire_k = generer_un_nombre(borne_min, borne_max1)

'Lorsque aléatoire2 est égale a "N", indice2 se réinitialise à 0.
If (aléatoire_k = nombre_n) Then
indice2 = 0

'Autrement, indice2 augmente de 1 en valeurs.
Else
indice2 = indice2 + 1

End If

Wend

End Function


'****************************************************************************
'* 03 : TIRAGE_ALÉATOIRE
'*
'* FONCTION :
'* Cette fonction genere des tirages en utilisant la fonction
'* generer_un_nombre. Son compteur nous indique combien de tirages ont été
'* fait avant que "N" sois tiré. Une fois "N" tiré la fonction est terminer
'* et doit être appeller de nouveau pour recommencer.
'*
'* PARAMETRES:
'* - nombre_n : Cette valeurs est choisie préalablement par l'utilisateur
'* et équivaut à "N" le numéro de l'encoche. (type : Integer)
'* - nombre_k : Cette valeurs est choisie préalablement par l'utilisateur
'* et équivaut à "K" le "temps d'attente". (type: Integer)
'* VALEUR DE RETOUR : Valeurs du compteur (type : Integer)
'*
'****************************************************************************


Public Function tirage_aléatoire(ByVal nombre_n As Integer, _
ByVal nombre_k As Integer) As Double

'Cette variable est le compteur qui enregistre le nombre de coups
'nécéssaire pour que "N" sois tiré.

Dim compteur As Integer
'Variable qui enregistre un nombre généré aléatoirement pour cette fonction.
Dim aléatoire_n As Integer

'Réinitialise la valeurs du compteur, puisque la valeurs précédente
'est enregistrée dans tirage_aléatoire.

compteur = 0

'Réinitialise la valeurs de tirage_aléatoire à 0, puique la valeurs
'précédente est enregistrée dans la variable total_tirage.
tirage_aléatoire = 0

'Tant que le nombre généré aléatoirement n'est pas celui de l'encoche
'choisie par l'utilisateur le compteur augmente et aléatoire_n prend
'une nouvelle valeurs généré aléatoirement par la fonction generer_un_nombre.

While (aléatoire_n <> nombre_n)

aléatoire_n = generer_un_nombre(borne_min, borne_max1)
compteur = compteur + 1

Wend

'Enregistre la somme du compteur chaque fois que la fonction est appeller.
tirage_aléatoire = compteur

End Function


'****************************************************************************
'* 04 : GENERER_UN_NOMBRE
'*
'* FONCTION :
'* Cette fonction genere un nombre aleatoire dans l'intervalle
'* [min, max]. Chaque valeur dans l'intervalle possède la même
'* probabilité d'être générée.
'*
'* PARAMETRES:
'* - min : La plus petite valeur pouvant etre générée (type :Integer).
'*
'* - max : La plus grande valeur pouvant etre générée (type :Integer).
'*
'* VALEUR DE RETOUR : Une valeur dans l'intervalle [min, max]
'* de type Integer.
'****************************************************************************


Public Function generer_un_nombre(ByVal min As Integer, _
ByVal max As Integer) As Integer

'Le calcul utilisé pour générer un nombre complètement aléatoire.
'La fonction reçois une borne minimum et maximum pour générer le nombre.

generer_un_nombre = Int((max - min + 1) * Rnd + min)

End Function


Ma première version était environt 4 fois plus longue pour faire la même chose, mdr.
Oui, il y a beaucoup de commentaires, les : '
Mais c'est une exigence du cours, donc pas trop le choix d'en mettre plein malgré que c'est chiant.

m
0
l
Tom's guide dans le monde
  • Allemagne
  • Italie
  • Irlande
  • Royaume Uni
  • Etats Unis
Suivre Tom's Guide
Inscrivez-vous à la Newsletter
  • ajouter à twitter
  • ajouter à facebook
  • ajouter un flux RSS