algobox lancé de dé

bonjours, je dois faire un dm sur algobox et l'énoncé est le suivant:
on dispose d'un dé cubique équilibré dont les faces sont numérotées de 1à6.
le jeu consiste à lancer le dé jusqu'à obtenir 6, et à compter le nombre de coups nécessaires.
le programme doit afficher les numéros sortis et le nombre de coups nécessaires pour obtenir 6.

j' ai déjà fais ça:

variables:
n est du type nombre
début algorithme
n prend_la_valeur floor(random()*6)+1
afficher lancé

j'ai aussi essayé de créer des boucles avec tant que mais chaque tantatives se finissaient par un échec. A un moment la boucle additionnait que des zéro 00000000000000000000000000000000000000000000000000000000
quand n était inférieur à 6 et le programme s'arrête tout seul faute de place mais je n'ai pas trop compris pourquoi.

je vous remercie de m'aider et de me donner des pistes.
merci.

Bonjour ring,

Ton début me semble correct.

Tu peux utiliser effectivement un boucle tant que n différent de 6 (n!=6) ... mais il te faut avant cela déclarer une autre variable de type nombre pour compter les lancers.

un variable "p" par ex que tu affectes à 0 au départ et que tu fais augmenter de 1 à chaque pas de la boucle.

merci pour ces conseils mais je n'ai pas bien compris comment compter les lancés, j'ai fais ça:

n est du type nombre
p est du type nombre
debut algorithme
n prend la valeur floor(random()*6)+1
p prend la valeur 0
tant que x!=0 faire
debut tant que
p prend la valeur n+1
fin tant que
afficher n
afficher p

le programme me dit que je dépasse la capacité autorisé pour les boucles donc si vous pouvez m'expliquer comment additionner le nombre de lancé plus précisément ce serait super et il faut aussi que je fasse apparaître chaque résultats.

merci d'avance pour vos réponses.
ps: je ne suis pas très fort dans la programmation informatique.

Bonjour

Pour compter il suffit d'initialiser une variable à 0 et de lui additionner 1 à chaque fois qu'on l'utilise

par exemple pour compter le nombre de fois il faut additionner 3 à 25 pour trouver un nombre supérieur à 50

n est un nombre
y est un nombre

n prend la valeur 0
y prend la valeur 25

tant que y < 50
n prend la valeur n+1
y prend la valeur y + 3
fin tant que

afficher n

Comprends tu comment tu peux utiliser ce raisonnement pour

ring
n est du type nombre
p est du type nombre
debut algorithme
n prend la valeur floor(random()*6)+1
p prend la valeur 0
tant que
x!=0faire
debut tant que
p prend la valeur n+1
fin tant que
afficher n
afficher p

Plusieurs remarques :

Tu attribues à n une valeur aléatoire entre 1 et 6, c'est correct. Mais tu le fais en tout début d'algo et en dehors de la boucle "tant que". Ton algo tel qu'il est conçu n'attribuera qu'une seule valeur à n et puis c'est tout ... ce n'est pas ce que l'on souhaite.
La boucle doit s'effectuer tant que la valeur aléatoire entre 1 et 6 (c'est à dire n et non pas x) est différente de 6 (et non pas de 0)
p compte le nombre de lancés, cette valeur est indépendante de n ... pourquoi lui attribuer la valeur "n+1"
Tu as initialisé p à 0, c'est correct mais, à chaque pas de la boucle, p doit prendre la valeur p+1 (et non pas n+1)
Tu affiches la valeur de n après la "fin tant que". De cette façon, ton algo ne pourra afficher que la toute dernière valeur de n trouvée (c'est à dire 6 en toute logique) alors que l'on te demande de faire afficher chacune des valeurs de n. L'affichage de n est donc mal placé.