Bonjour a tous
 
J'ai quelques difficultés à faire un algo portant sur un jeu de hasard...
En voici l'énoncé:
 
Vous calculez 10 chiffres entre 0 et 9 de façon aléatoire. Vous mettez ces chiffres dans un tableau TAB.
Si sur ces 10 chiffres, 4 ou plus sont égaux, vous gagné 15€.
Si 3 sont égaux, vous ne touchez rien.
Si 2 sont égaux ou aucun pareils, vous perrdez 7€
Cous jouez 5 fois de suite et vous affichez le total gagné ou perdu à la fin de la partie.
 
Voila ce que j'ai fait:
 
Algo jeu_hasard
 
       var TAB : tableau(1..5, 1..10) de réel
            jeu, i, nb_egaux : ent
 
Debut
 
 pour jeu=1 à 5 faire
   pour i=1 à 10 faire
     TAB(jeu, i) <- generer(0..9)
   fpour
   nb_egaux <- 0
   pour i=1 à 10
     si
       ..
       ..
       ..
 
Voila, je bloque totalement au niveau des conditions, je ne vois pas comment je peux m'y prendre pour résoudre ce problème :s
ça serait vraiment super si quelqu'un m'aidait

Tu es bien parti. Tu prends le premier élément, et tu le compares à tous les autres éléments du tableau. Idem pour le 2è, le 3è... jusqu'au dernier. Il te faut une boucle imbriquée.
 

 
Après une première itération j, tu sauras combien d'éléments sont égaux à tab(i). Reste à déterminer, parmi toutes ces itérations j, laquelle aura révélé un maximum d'éléments identiques.
 
Essaye pour voir, repère l'un ou l'autre piège et ensuite on discutera cette solution.
 

Super
 
J'ai trouvé :
 

 
Dis moi, c'est bon ou pas?

 
Déroule mentalement tes boucles. Tu compares le premier elt avec les autres. Tu obtiens p.e. nb_egaux=3. Puis tu continue avec le 2è elt. nb_egaux vaut p.e. 5. Et tu continues. Ca ne va pas.
 
Tu dois comparer un i avec tous les autres éléments et obtenir un nb_egaux. Ensuite, tu recommences avec i+1, mais ton nb_egaux doit être remis à zéro! Après avoir effectué tes 10 itérations de i, tu as passé en revue 10 "nb_egaux", et tu dois prendre le plus grand!
 
tab(1) a 3 doublons.
tab(2) a 2 doublons.
tab(x) a y doublons.
 
==> Max = 3 ==> 3 des 10 nombres sont égaux.
 
Je te laisse déterminer le max(nb_egaux).

Oui c'est vrai qu'en réflechissant un peu TAB(i) = TAB(j) quand i et j valent 1
ça me donne une valeur égale c'eet vrai mais je ne voit pas comment je peux résoudre ce problème...
Quand tu me parle du max je vois pas trop ou tu veux en venir

Facilite-toi la vie avec des fonctions
 
algo principal
debut
  total <- 0
  pour i de 1 à 5 faire
     genere(tableau)
     total <- total + evaluer(tableau)
  fin pour
  si total = 0 alors  
       afficher("Vous n'avez rien gagné durant cette partie" )  
  sinon  
  si total > 0 alors  
        afficher("Vous avez gagné ",total," durant cette partie" )  
  sinon  
        afficher("Vous avez perdu ",total," durant cette partie" )  
  fin si  
fin
 
procedure generer(entier tableau[10])
debut
  pour i de 1 à 10 faire
    tableau(i) <- aleatoire(0,9)
  fin pour
fin
 
fonction evaluer(entier tableau[10]) renvoie entier
debut
  // on utilise un tableau intermédiaire de 10 valeurs
  // qui va permettre de compter les nombres de tableau
  // on suppose ce tableau initialisé avec des 0
  entier tab[10]
  // on remplit le tableau tab  
  pour i de 1 à 10 faire
    tab[tableau[i]] <- tab[tableau[i]] + 1
  fin pour
  // on parcourt le tableau pour trouver la valeur maximum
  max = tab[1];
  pour i de 2 à 10 faire
    si max < tab[i] alors
      max <- tab[i]
    fin si
  fin pour
  retour <- 0
  si max >= 4 alors  
     retour <- 15  
     afficher("Vous avez gagnez 15€" )  
   sinon  
   si max <= 2 alors  
     retour <-  - 7  
     afficher("Vous perdez 7€" )  
   fin si  
 
  renvoyer retour
fin

"le hasard n'existe pas" (c)

Trap D> Evite de donner une solution toute faite svp :
 
- C'est pas réglo -/- charte.
- Tu lui ôtes le plaisir de chercher.
- Tu utilises des fonctions : peut-être que cvex ne connaît pas encore.
 

Tu joues sur une particularité de l'énoncé, à savoir que les nombres générés sont compris entre 1 et 10 ??? C'est ça ? Je n'ai pas compris la suite:
 

(Sans doute une question de notation ou quoi ? )

Désolé, si j'ai donné une solution, mais il me semble en avoir lu une autre.  
 
Oui, j'ai pris un tableau intermédiaire de 10 valeurs puisque le tableau initial avait 10 valeurs.
J'ai supposé que "tab" était initialisé à 0
ensuite en supposant que tableau[1] = 5, la case numéro 5 de tab qui contient le nombre de 5 de tableau (tu me suis) doit être augmentée de 1 pour passer de 0 à 1 donc tab[tableau[1]] reçoit l'ancienne valeur (0) de tab[tableau[1]] + 1
On répète les opérations pour tous les nombres de tableau.

C'est une mauvaise idée, en quelque sorte, car que se passe-t-il si au lieu de générer des nombres de 1 à 10, on génère des nombres de 1 à 1000 ou plus ? Tu auras rapidement un sérieux soucis et cette optimisation se retournera contre toi.
 
Je la gardais justement comme optimisation pour un cas particulier (celui de l'énoncé). A ne pas proposer tel quel au TP...
 

Merci pour votre contribution mais je comprends toujours pas pourquoi on doit utiliser les variables max pour arriver a s'en sortir :s
 
De plus les fonctions, j'ai pas encore vu donc je veux arriver a résoudre ce problème sans les fonctions ^^
 
Merci encore

Je me suis limité à l'énoncé de l'algo, sans chercher de généralisation, j'y penserai dorénavant.

Reprenons calmement.
 
Soit t = {2, 4, 4, 5, 2, 4, x, x, x, x}
 
Tu commences : t(1) = 2.
 
Tu compares t(1)=1 à tous les autres t(x). Ton nb_egaux=2.
 
Tu recommences avec t(2) = 4.
 
Tu compares t(2)=4 à tous les autres t(x). Ton nb_egaux=3.
 
Et ainsi de suite jusque t(10).
 
Tu as donc 10 nb_egaux : Le premier valait 2, le 2è valait 3, les autres, mon exemple ne le dit pas.
 
Tu dois trouver le nb_egaux le plus grand. En l'occurence, il vaut 3, c'était celui lié à t(2).
 
OK ?

pour i = 1 à 10 faire
     pour j = 0 à 9 faire
       si TAB(i) = j
       alors nb_egaux <- nb_egaux + 1
       fsi
     fpou
    fpour

Oui. La suite ?

 
gliglou gligli glou
      glouglouglou
         glaglou <- glaglou +3
       fin glouglouglou
fin gliglou gligli glou