Dm algorithme

par **rambo83** » 01 Oct 2012, 19:05

S'il vous plait C.Ret pouvez-vous nous éclairer ?

par **rambo83** » 01 Oct 2012, 19:23

Pourriez vous nous avancer encore un peu s'il vous plaît ? Cela me tiendrai vraiment à coeur de pouvoir terminer cet exercice avant d'aller dormir

par **Siriuss** » 01 Oct 2012, 19:23

Oui svp parce que là nous sommes completement bloqués...

par **rambo83** » 01 Oct 2012, 19:38

Je déprime ... :cry:

par **rambo83** » 01 Oct 2012, 19:48

Pour utiliser un compteur c'est bien tab[] , non ?

par **Siriuss** » 01 Oct 2012, 19:49

Je sais pas...

par **Anonyme** » 01 Oct 2012, 19:50

@Siriuss et rambo83
Pour aider C.Ret, voici quelques explications supllémentaires

j PREND_LA_VALEUR algobox_alea_ent(1,3)
18; // j == 1 pour le jeton noir
19; // j == 2 pour le jeton bicolore
20; // j == 3 pour le jeton rouge
21; SI (j==1) ALORS
22; DEBUT_SI // jeton noir a été tiré

Il faut 2 compteurs pour comptabiliser le nombre de tirage de la couleur Noir ,
et le nombre de tirage de la couleur Rouge

exemple :
JN compteur qui compte le nombre de tirage du jeton noir (à initialiser à 0 avant la boucle)
JR compteur qui compte le nombre de tirage du jeton rouge (à initialiser à 0 avant la boucle)

si j=1 alors JN=JN+1
si j=3 alors JR=JR+1

Attention ce n'est pas fini à cause du jeton bicolore....
qu'il faut aussi programmer....

Bonne chance

par **C.Ret** » 01 Oct 2012, 19:54

Pour le compteur en général on suit le shema suivant :

Code: Tout sélectionner: i prend la valeur initaile Boucle/Test ... i prend la valeur suivante fin_boucle

La plupart du temps le compteur est initalisé à 0 et on augmente de 1 à chaque apparition.
C'est bien le cas qui nous concerne :
i = 0, 1, 2, 3, ...

L'algorithme correspondant est donc simplement

Code: Tout sélectionner: i prend la valeur 0 Boucle/Test ... i prend la valeur i+1 fin_boucle/Test

A chaque fois, on prend la valeur actuellemetn dans la variable et on lui ajoute une unité et on oublie pas de remettre la nouvelle valeur dans la variable.

Il faut se rapellé que l'algorithme c'est pour faire faire par un ordinateur, le varaible sont donc en quelque sorte les boites qui permettent à celui-ci de mémoriser les valeurs et les nombres. DOnc tout passe par ces variables.
En général, on utilise souvent les même boites et on fait progresser leur contenu vers leur résultat final. Dans le cas d'un compteur ce sera le nombre total de tirage (d'occurence), mais pour une variable qui représenterait autre-chose, ce peut être un peu plus compliqué.

Pour compter les Jetons Noirs, nous ajouterons donc ces deux instructions dans l'algorithme; l'initialisation JN <-- 0 avant de commencer (car aucun jeton n'a encore été tiré), puis on incrémente de une unité à chaque tirage.
L'instruction JN <-- JN+1 sera placé dans le Test pour lequel la varaible J désigne le jeton noir.

Concernant le calcul de la fréquance, le rapport à effectuer dépend de ce que l'on veut mettre ne évidence.
Si on veut estimer la probabilité de tirage des Jetons Noirs, comme on a fait 2500 tirages au total, on calculera JN/2500 qui devrait (si 2500 est suffisemment grand pour que notre estimation converge vers la probabilité) donner P(n)= 1/3 )

Si on calcule JN/FN où FN est le nombre de face noires observées, alors on obtient la proportion de faces noires obtenues à partir des jetons noirs. L'autre partie étant les face noir observées en tirant un jeton bicolore.

Notre algorithme est maintenant finit, à vous de la complèter et de voir comme il fonctionne sur
ALGOBOX.

Code: Tout sélectionner: VARIABLES // Nombre de fois que le jeton Noir est tiré JN EST_DU_TYPE NOMBRE // Fréquence (probabilité) de tirage (Noir,Noir) PN EST_DU_TYPE NOMBRE // type de jeton tiré 1= noir, 2=bicolore 3=rouge j EST_DU_TYPE NOMBRE // variable pour itérations r EST_DU_TYPE NOMBRE DEBUT_ALGORITHME // Initialisation des compteurs de jeton et de face JN PREND_LA_VALEUR 0 // Boucle de réalisation de 2500 simulations POUR r ALLANT_DE 1 A 2500 DEBUT_POUR // simulation // ================ Simule tirage et compte jetons ==== j PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,3) // j == 1 pour le jeton noir // j == 2 pour le jeton bicolore // j == 3 pour le jeton rouge // -------------------- Cas Jeton Noir (j==1) SI (j==1) ALORS DEBUT_SI JN PREND_LA_VALEUR JN+1 FIN_SI FIN_POUR // simulations // Calcule les fréquences/probabilités/proportions PN PREND_LA_VALEUR 100*JN/2500 // Affichage des résultats AFFICHER* "A l'issue de 25000 réalisations: " AFFICHER "Le jeton noir est apparu " AFFICHER JN AFFICHER* " fois "* AFFICHER* " " AFFICHER PN AFFICHER* "% de jetons noirs" FIN_ALGORITHME

Faite le tourner, ajouter le caclul des probabilités ou proportion pour voir si vous retrouvez des valeur proches des proba de la question 1).

Pour ma part, je vous donne ma vision de cet algorithme; il donne bien plsu d'information que le votre car il ne se limite pas uniquemetn aux seuls jetons noirs, mais tient compte des trois jeton et compte aussi l'apparition des face noires ou rouges :

Code: Tout sélectionner: VARIABLES // Nombre de fois que le jeton Noir, Bicolore ou Rouge sont tirés JN EST_DU_TYPE NOMBRE JB EST_DU_TYPE NOMBRE JR EST_DU_TYPE NOMBRE // Nombre de fois que la face Noire ou Rouge sont obtenues FN EST_DU_TYPE NOMBRE FR EST_DU_TYPE NOMBRE // Fréquence (probabilité) de tirage (Noir,Noir) PN EST_DU_TYPE NOMBRE PB EST_DU_TYPE NOMBRE // Fréquence (probabilité) de tirage (Rouge,Rouge) PR EST_DU_TYPE NOMBRE PA EST_DU_TYPE NOMBRE // type de jeton tiré 1= noir, 2=bicolore 3=rouge j EST_DU_TYPE NOMBRE // couleur face tirée 1 == noire 2 == rouge f EST_DU_TYPE NOMBRE // variable pour itérations r EST_DU_TYPE NOMBRE DEBUT_ALGORITHME // Initialisation des compteurs de jeton et de face JN PREND_LA_VALEUR 0 JB PREND_LA_VALEUR 0 JR PREND_LA_VALEUR 0 FN PREND_LA_VALEUR 0 FR PREND_LA_VALEUR 0 // Boucle de réalisation de 25000 simulations POUR r ALLANT_DE 1 A 25000 DEBUT_POUR // simulation // ================ Simule tirage et compte jetons ==== j PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,3) // j == 1 pour le jeton noir // j == 2 pour le jeton bicolore // j == 3 pour le jeton rouge // -------------------- Cas Jeton Noir (j==1) SI (j==1) ALORS DEBUT_SI JN PREND_LA_VALEUR JN+1 f PREND_LA_VALEUR 1 FIN_SI // ------------------- Cas jeton bicolore (j==2) SI (j==2) ALORS DEBUT_SI JB PREND_LA_VALEUR JB+1 f PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,2) FIN_SI // -------------------- Cas jeton rouge (j==3) SI (j==3) ALORS DEBUT_SI JR PREND_LA_VALEUR JR+1 f PREND_LA_VALEUR 2 FIN_SI // ==================== Compte faces ==== SI (f==1) ALORS // face noire (f==1) DEBUT_SI FN PREND_LA_VALEUR FN+1 FIN_SI SINON // face rouge (f==2) DEBUT_SINON FR PREND_LA_VALEUR FR+1 FIN_SINON FIN_POUR // Calcule les fréquences/probabilités/proportions PN PREND_LA_VALEUR 100*JN / FN PB PREND_LA_VALEUR 100*(FN-JN) / FN PR PREND_LA_VALEUR 100*JR / FR PA PREND_LA_VALEUR 100*(FR-JR) / FR // Affichage des résultats AFFICHER* "A l'issue de 25000 réalisations: " AFFICHER "Le jeton noir est apparu " AFFICHER JN AFFICHER* " fois "* AFFICHER "Le jeton bicolore est apparu " AFFICHER JB AFFICHER* " fois "* AFFICHER "Le jeton rouge est apparu " AFFICHER JR AFFICHER* " fois "* AFFICHER* " " AFFICHER "Il y a eut au total " AFFICHER FN AFFICHER* " faces noires" AFFICHER "dont " AFFICHER PN AFFICHER* "% proviennent des jetons noirs" AFFICHER "dont " AFFICHER PA AFFICHER* "% proviennent des jetons bicolores" AFFICHER* " " AFFICHER "Il y a eut au total " AFFICHER FR AFFICHER* " faces rouges" AFFICHER "dont " AFFICHER PR AFFICHER* "% proviennent des jetons rouges" AFFICHER "dont " AFFICHER PA AFFICHER* "% proviennent des jetons bicolores" FIN_ALGORITHME

par **rambo83** » 01 Oct 2012, 20:00

Merci énormément de votre soutien ! Je vous en suis très reconnaissant !

par **rambo83** » 01 Oct 2012, 20:01

Donc pour résumer mon algorithme fait cela :
VARIABLES

JN EST_DU_TYPE NOMBRE

i EST_DU_TYPE NOMBRE

j EST_DU_TYPE NOMBRE

PN EST_DU_TYPE NOMBRE

JR EST_DU_TYPE NOMBRE

JB EST_DU_TYPE NOMBRE

DEBUT_ALGORITHME

JB PREND_LA_VALEUR 0

JN PREND_LA_VALEUR 0

JR PREND_LA_VALEUR 0

POUR i ALLANT_DE 1 A 2500

DEBUT_POUR

j PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,3)

SI (j==1) ALORS

DEBUT_SI

JN PREND_LA_VALEUR JN+1

FIN_SI

SI (j==3) ALORS

DEBUT_SI

JR PREND_LA_VALEUR JR+1

FIN_SI

SI (j==2) ALORS

DEBUT_SI

JB PREND_LA_VALEUR JB+1

FIN_SI

FIN_POUR

AFFICHER "Au bout des 2500 réalisations :"

AFFICHER "Le jeton noir est apparu :"

AFFICHER JN
AFFICHER "fois"

FIN_ALGORITHME

Est-ce bon ? En le testant j'obtiens souvent autour de 800-850

par **C.Ret** » 01 Oct 2012, 20:11

rambo83 a écrit:Merci énormément de votre soutien ! Je vous en suis très reconnaissant !

De rien

Exemple d'éxécution :

Code: Tout sélectionner: ***Algorithme lancé*** A l'issue de 25000 réalisations: Le jeton noir est apparu 8237 fois Le jeton bicolore est apparu 8503 fois Le jeton rouge est apparu 8260 fois Il y a eut au total 12449 faces noires dont 66.165957% proviennent des jetons noirs dont 34.188511% proviennent des jetons bicolores Il y a eut au total 12551 faces rouges dont 65.811489% proviennent des jetons rouges dont 34.188511% proviennent des jetons bicolores ***Algorithme terminé***

par **Siriuss** » 01 Oct 2012, 20:13

C.Ret, vous avez marqué 25000 au lieu de 2500 dans votre algorithme
Et merci !

par **Siriuss** » 01 Oct 2012, 20:17

Faite le tourner, ajouter le caclul des probabilités ou proportion pour voir si vous retrouvez des valeur proches des proba de la question 1).

Comment faire pour cela ?

par **rambo83** » 01 Oct 2012, 20:22

C'est bon c'est parfait mon algorithme marche à merveille ! J'obtiens les mêmes résultats que vous ! Je l'envois direct à mon prof ! Encore merci et à bientôt sur ce forum ! Vous expliquez très clairement et avec patience vous feriez un très bon professeur si vous ne l'êtes pas déjà ! Sur ce bonne soirée. Bye

par **Siriuss** » 01 Oct 2012, 20:29

J'obtiens environ 33%, donc 33/100 = 0.33 c'est a dire 1/3
Donc dans la question 1, p(n) serait donc égal à 1/3 et non à 1/2 comme ce que j'avais dit dans la question 1 ?

par **Siriuss** » 01 Oct 2012, 20:49

Variables
N est du type nombre
f est du type nombre
d est du type nombre
Début algorithmique
f prend la valeur 0
Pour N allant de 1 à 2500
Debut pour
d prend la valeur floor(random()*6)+1
Si (d<=3) alors
Début si
f prend la valeur f+1
Fin si
Fin pour
f prend la valeur f/2500
Afficher f
Fin algorithme

Est-ce que cet algorithme est juste ?

par **C.Ret** » 01 Oct 2012, 21:40

Siriuss a écrit:C.Ret, vous avez marqué 25000 au lieu de 2500 dans votre algorithme
Et merci !

Oui, c'est pour avoir une meilleure statistique

Siriuss a écrit:J'obtiens environ 33%, donc 33/100 = 0.33 c'est a dire 1/3
Donc dans la question 1, p(n) serait donc égal à 1/3 et non à 1/2 comme ce que j'avais dit dans la question 1 ?

Oui, attention :
Il y a trois jetons, donc chaque jeton est tiré 1/3 (soit environ 33.333%)

Mais, concernant la couleur des faces, c'est bien soit noir, soit rouge, donc proba 1/2 (soit 50%).

On a bien 66.666% des face noires observée qui sont dues au jeton noir et les 33.333% restant provenant du jeton bicolore.

Et pour les face rouge, c'est symétrique 66.666% proviennent du jeton rouge et 33.333% restant du jeton bicolore.

Evidemment, si l'on ne considère que les sortie du jeton bicolore, on obtient 50% de noir et 50% de rouge.

En comparant l'évolution des nombres de jeton et des nombre de face après 250, 2500, 25000, 250000 réalisation, on se rend compte des variations. Plus les nombres sont grands, plus on se rapproche des probabilité théorique (loi des grands nombres). Cependant cel se fait à la justesse du générateur de nombre aléatoire près.

par **C.Ret** » 01 Oct 2012, 21:48

Attention aux indentations, c'est important :

Code: Tout sélectionner: **Variables** N est du type nombre f est du type nombre d est du type nombre **Début algorithmique** f prend la valeur 0 Pour N allant de 1 à 2500 Debut pour d prend la valeur floor(random()*6)+1 Si (d<=3) alors Début si f prend la valeur f+1 Fin si Fin pour f prend la valeur f/2500 Afficher f **Fin algorithme**

OUi, c'est bon, cet algorithme est basé sur un principe qui fonctionne :
d=1 Jeton noir face 1 (noire)
d=2 Jeton noir face 2 (noire)
d=3 Jeton bicolore face 1 (noire)

Les autres valeur de d correspond à des faces rouges :
d=4 Jeton bicolore face 2 (rouge)
d=5 Jeton rouge face 1 (rouge)
d=6 Jeton rouge face 2 (rouge)

C'est très bien, cela correspond aux 6 événements qui peuvent survenir à chaque tirage, chacun des trois Jetons pouvant apparaitre pile ou face. :zen:

On peut ajouter des compteur pour indiquer le nombre de chaque jeton ou compter les apparation des faces rouges ou noires.

Je vois que le principe est compris.

par **C.Ret** » 01 Oct 2012, 22:00

rambo83 a écrit:Donc pour résumer mon algorithme fait cela :
Est-ce bon ? En le testant j'obtiens souvent autour de 800-850

Oui, c'est bon, manque juste l'affichage de PB et PR à la fin.

Code: Tout sélectionner: **VARIABLES** JN EST_DU_TYPE NOMBRE i EST_DU_TYPE NOMBRE j EST_DU_TYPE NOMBRE PN EST_DU_TYPE NOMBRE JR EST_DU_TYPE NOMBRE JB EST_DU_TYPE NOMBRE **DEBUT_ALGORITHME** JB PREND_LA_VALEUR 0 JN PREND_LA_VALEUR 0 JR PREND_LA_VALEUR 0 POUR i ALLANT_DE 1 A 2500 DEBUT_POUR j PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,3) SI (j==1) ALORS DEBUT_SI JN PREND_LA_VALEUR JN+1 FIN_SI SI (j==3) ALORS DEBUT_SI JR PREND_LA_VALEUR JR+1 FIN_SI SI (j==2) ALORS DEBUT_SI JB PREND_LA_VALEUR JB+1 FIN_SI FIN_POUR AFFICHER "Au bout des 2500 réalisations :" AFFICHER "Le jeton noir est apparu :" AFFICHER JN AFFICHER "fois" AFFICHER "Le jeton rouge est apparu :" AFFICHER JR AFFICHER "fois" AFFICHER "Le jeton bicolore est apparu :" AFFICHER JB AFFICHER "fois" **FIN_ALGORITHME**

Dm algorithme

Qui est en ligne