Algorithme roulettes

Bonjour, je m'appelle Assia et je suis en seconde. J'ai un grand problème dans l'écriture d'algorithmes car je ne visualise pas les étapes nécessaires.
J'ai cependant un algorithme à écrire. Voilà la consigne : Chacune de ces deux roulettes est partagées en trois secteurs égaux marqués 1,2 et 3. Le joueur fait tourner les deux roulettes et note les deux numéros obtenus (a;b): il garde alors le plus grand des nombres a ou b. S'il obtient (a;a) il garde a.
Je n'arrive pas du tout à faire cet exercice même ayant passée 2 heures devant le logiciel Algobox impuissante. Pouvez-vous me donner quelques idées.

bonjour ralalah

Pas facile de t'aider sur un exo de ce type ...

pour obtenir de la part d'un logiciel ou calculatrice un nombre aléatoire entre 1 et 3, il faut :

. prendre un nombre aléatoire entre 0 et 1 (tous les logiciels le font)
. le multiplier par 3
. prendre la partie entière du résultat
. ajouter 1

Tu as peut-être déjà fait ça en classe

Avec algobox, je te propose quelque chose comme ceci :

VARIABLES
a EST_DU_TYPE NOMBRE
b EST_DU_TYPE NOMBRE
i EST_DU_TYPE NOMBRE
j EST_DU_TYPE NOMBRE
R EST_DU_TYPE NOMBRE

DEBUT_ALGORITHME
i PREND_LA_VALEUR random()
j PREND_LA_VALEUR random()
a PREND_LA_VALEUR floor(3i)+1
b PREND_LA_VALEUR floor(3j)+1
AFFICHER "(a;b)=("
AFFICHER a
AFFICHER ";"
AFFICHER b
AFFICHER ")"
SI (a<=b) ALORS
DEBUT_SI
R PREND_LA_VALEUR b
FIN_SI
SINON
DEBUT_SINON
R PREND_LA_VALEUR a
FIN_SINON
AFFICHER "Résultat : "
AFFICHER R
FIN_ALGORITHME

Dans cet algo, a et b sont ceux de ton énoncé, i et j deux nombres aléatoires entre 0 et 1 édités automatiquement par algobox et R est le résultat retenu, soit le plus grand entier entre a et b

Edit : Recopier sans comprendre est inutile !

Résultat de l'algo proposé :

Algorithme lancé
(a;b)=(1;3)
Résultat : 3

Algorithme terminé

Merci Beaucoup ! C'est très gentil ! Vous m'avez vraiment éclairée !

Pourquoi +1 et si par exemple le nombre aléatoire est 1 alors ça revient à poser (3*1)+1 ce qui fait 4 ? et c'est exclu des 3 résultats possibles .. Je m'excuse si ma question est confuse.

Ta question est légitime ... Je tente une explication

random() = le logiciel génère un nombre aléatoire entre 0 et 1

on le note i

on a

0 ≤ i < 1

par exemple i = 0,625

on multiplie par 3

30 ≤ 3i < 3*1

0 ≤ 3i < 3 attention à droite c'est inférieur strictement, la valeur de 3i ne peut pas atteindre 3

pour i = 0,625 alors 3*i = 1,875

on prend la partie entière

ent(0) ≤ ent(3*i) < ent(3)

0 ≤ ent(3i) < 3 même remarque, à droite c'est inférieur strictement, la valeur de ent(3i) ne peut pas atteindre 3

ent(3i) étant un entier, ent(3i) ne peut prendre que les valeurs 0, 1 ou 2

enfin, on ajoute 1

1+0 ≤ 1+ent(3*i) < 1+3

1 ≤ 1+ent(3*i) < 4 inférieur strictement à droite

1+ent(3i) étant toujours un entier, 1+ent(3i) ne peut prendre que les valeurs 1, 2 ou 3

On obtiens bien un nombre aléatoire entre 1 et 3.

exemples :

pour i = 0,113 alors 3i = 0,339 alors ent(3i) = 0 alors 1+ent(3*i) = 1

pour i = 0,625 alors 3i = 1,875 alors ent(3i) = 1 alors 1+ent(3*i) = 2

pour i = 0,851 alors 3i = 2,553 alors ent(3i) = 2 alors 1+ent(3*i) = 3

C'est moins confus ?

En fait ce qui te trouble c'est que je dis que random() retourne un nombre aléatoire entre 0 et 1.

En fait, il ne peut pas atteindre la valeur 1

0 ≤ random()
<
**** 1

tout est là

valeur maxi retournée = 0,9999999999999999

pour i = 0,99999999 alors 3i = 2,999999 alors ent(3i) = 2 alors 1+ent(3*i) = 3

je crois que c'est plus facile à comprendre comme ça sans encadrement.

De plus, étant donné qu'il y a autant de valeur random() dans [0,3[ qui vont générer la valeur 1 que la valeur 2 et que la valeur 3. Le résultat est bien un nombre entier entre 1 et 3, chacune des valeurs ayant la même probabilité d'apparition.

Je comprends enfin !Merçi ! J'ai tapé l'algorithme sur ma calculatrice et je me suis souvenue que dans l'énoncé on disait que quand a=b eh bien on garde a . Et Quand on utilise if puis then et if end on peut réutiliser if une deuxieme fois ? Pareil sur algobox ?

À quoi ressemblerait l'algorithme à l'écrit ?
J'ai fais ça :
Variables:
a,b,v,w,R entiers
Traitement
V prend la valeur random
W prend la valeur random
a prend la valeur floor(3xv)+1
b prend la valeur floor(3xw)+1
Afficher "Les numéros (a;b) obtenus sont : ("
Afficher a
Afficher";"
Afficher b
Afficher")"
Si a<=b
Alors R prend la valeur b
Sinon R prend la valeur a
Afficher "la plus grande valeur est":
Afficher R
Sortie
Fin Pour
C'est juste ?

qques remarques : en langage naturel la partie entière n'est pas "floor" mais E(x)

Selon le logiciel, v et w seraient des réels pas des entiers ...

ralalah
... et je me suis souvenue que dans l'énoncé on disait que quand a=b eh bien on garde a . Et Quand on utilise if puis then et if end on peut réutiliser if une deuxieme fois ? Pareil sur algobox ?

"Si a≤b" considére déjà la cas où a=b, donc pas besoin d'ajouter encore une condition

En langage naturel, tu peux simplifier, par ex :

Variables
a, b, r des nombres entiers

Début
Affecter à a un nombre aléatoire entier entre 1 et 3
Affecter à b un nombre aléatoire entier entre 1 et 3
Si a<=b
Alors affecter à r la valeur b
Sinon affecter à r la valeur a
Fin Si
Afficher (a;b)
Afficher r

Fin

Sur la calculatrice, c’est plus simple qu’avec Algobox car Ti et Casio permettent de générer directement un entier entre 1 et 3 :
Avec TI : entAléat(1,3) ou ranInt(1,3) si elle est en anglais comme la mienne
Avec Casio : Ran(1,6)
(Donc pas besoin de passer par la partie entière)

Exemple sur TI :

$fichier math$

Résultat :

$fichier math$
qui marche aussi si A=B :

$fichier math$

attention : sur le prog TI, j'ai commencé involontairement par Si A≥B au lieu de A≤B du langage naturel

Mon prof n'aime pas vraiment tout ce qui est simplifié..
Donc pour le langage naturel je peux mettre :
a,b, R entiers
w,v réels
Traitement
V prend la valeur nombre aléatoire
W prend la valeur nombre aléatoire
a prend la valeur partie entière de (3xv)+1
b prend la valeur partie entière de (3xw)+1
Afficher "Les numéros (a;b) obtenus sont : ("
Afficher a
Afficher";"
Afficher b
Afficher")"
Si a<=b
Alors R prend la valeur b
Sinon R prend la valeur a
Fin Si
Afficher "la plus grande valeur est":
Afficher R
Sortie
Fin Pour

Va pour le "compliqué" alors !

Ce que tu proposes semble bien à condition que l'on comprenne que "nombre aléatoire" signifies "nombre aléatoire réel dans [0;1["

Le "Fin Pour" est inutile il me semble (pas de boucle Pour)

Tu dois le programmer sur Algobox ou sur calculette ?

Algobox

Je vois pas ce que vous voulez dire par "à condition que l'on comprenne que "nombre aléatoire" signifies"nombre aléatoire réel dans [0;1[" C'est logique ou je me trompe ? Ça voudrait dire que dans votre algorithme suivant :
Variables
a, b, r des nombres entiers
Début
Affecter à a un nombre aléatoire entier entre 1 et 3
Affecter à b un nombre aléatoire entier entre 1 et 3
Si a<=b
Alors affecter à r la valeur b
Sinon affecter à r la valeur a
Fin Si
Afficher (a;b)
Afficher r
Fin

Il faudrait également que "nombre aléatoire" signifies"nombre aléatoire réel dans [0;1[" Je me trompe sûrement.. Mais je voulais en être sûre

124,523 peut être un nombre aléatoire entre 0 et 1000

Pour générer un nombre aléatoire entre 1 et 3, tu as choisi de conserver cette méthode :

. prendre un nombre réel aléatoire dans l'intervalle [0;1[
. le multiplier par 3
. prendre la partie entière du résultat
. ajouter 1

Dans ton algo, mieux vaut préciser que le nombre aléatoire est réel et compris entre 0 et 1 (1 exclus)

Dans ma proposition du 05.03.2012, 12:13, il s'agissait de simplifier en évitant l'utilisation de la fonction "partie entière" que tu n'as peut-être pas vue en cours.

Comme je l'ai dit, les calculettes permettent de générer directement un entier compris dans un intervalle, ça simplifie grandement les choses.

Je ne sais pas si Algobox sait générer directement un entier dans un intervalle à préciser (je recherche si c'est le cas)

Après recherche dans l'aide Algobox, il ne semble pas possible de générer un entier aléatoire dans un intervalle donné.

je n'ai trouvé que ça :
Citation
Obtenir un nombre pseudo-aléatoire compris en 0 et 1 : random()

Apparemment, il faudra conserver la méthode qui fait appel à la partie entière.

PS : Ne te tracasse pas trop, si ça te gêne de préciser, tu peux laisser ce que tu as écrit "V prend la valeur nombre aléatoire" ... puisque par défaut, les logiciels retournent un réel de [0;1[

Non, non je vais préciser Merçi beaucoup

Je t'en prie, bonne soirée

À vous aussi !