Tu vois qu'il va falloir une grande boucle tantQue et des variables (valant par exemple 1 ou 0 suivant que le dé est sorti ou pas (une variable de type LISTE est un bon choix))
puis une variable F qui vaut la somme maliste[1]+maliste[2]+maliste[3]+maliste[4]+maliste[5]+maliste[6] et enfin une variable qui compte le nombre de coups
en gros le principe après avoir déclaré et initialisé correctement les variables c'est :

TantQue F est différent de 6
on tire un chiffre au hasard entre 1 et 6 (il y a une instruction algobox pour ça) et on le met dans une variable D
si la variable maliste[D] = 0 alors maliste[D] prend la valeur 1
on incrémente N de 1
F prend la valeur maliste[1]+maliste[2]+maliste[3]+maliste[4]+maliste[5]+maliste[6]
FinTantque
afficher N

je suis assez débutant avec les algorithmes alors je voudrais bien un peu plus de détails si c'est possible^^

ça aurait été bien que tu te lances avec les indications que je t'ai données parce que sinon ça revient à ce que je te donne le résultat tout fait.
les algorithmes pour progresser il faut se battre un peu avec

cela dit si tu as des questions sur des points que tu ne comprends pas, je suis à ta disposition.

d'accord je tente et je vous redis alors ^^

Quand on met une variable de type liste qu'est ce que ça change?

ça permet de stocker les 6 valeurs dans une variable tableau
mais si ça te parait difficile, prends 6 variables D1 ; D2 ; D3; .... et on n'en parle plus

1 VARIABLES
2 jets EST_DU_TYPE NOMBRE
3 1 EST_DU_TYPE NOMBRE
4 2 EST_DU_TYPE NOMBRE
5 3 EST_DU_TYPE NOMBRE
6 4 EST_DU_TYPE NOMBRE
7 5 EST_DU_TYPE NOMBRE
8 6 EST_DU_TYPE NOMBRE
9 S EST_DU_TYPE NOMBRE
10 i EST_DU_TYPE NOMBRE
11 n EST_DU_TYPE NOMBRE
12 DEBUT_ALGORITHME
13 1 PREND_LA_VALEUR 0
14 2 PREND_LA_VALEUR 0
15 3 PREND_LA_VALEUR 0
16 4 PREND_LA_VALEUR 0
17 5 PREND_LA_VALEUR 0
18 6 PREND_LA_VALEUR 0
19 jets PREND_LA_VALEUR 0
20 TANT_QUE (S=0) FAIRE
21 DEBUT_TANT_QUE
22 S PREND_LA_VALEUR 1*2*3*4*5*6
23 jets PREND_LA_VALEUR jets+1
24 FIN_TANT_QUE
25 AFFICHER jets
26 FIN_ALGORITHME

je ne comprends pas pourquoi mon algorithme ne veut pas fonctionner

j'ai essayé autrement:

2 jets EST_DU_TYPE NOMBRE
3 2 EST_DU_TYPE NOMBRE
4 3 EST_DU_TYPE NOMBRE
5 4 EST_DU_TYPE NOMBRE
6 5 EST_DU_TYPE NOMBRE
7 6 EST_DU_TYPE NOMBRE
8 S EST_DU_TYPE NOMBRE
9 D1 EST_DU_TYPE NOMBRE
10 DEBUT_ALGORITHME
11 D1 PREND_LA_VALEUR 0
12 2 PREND_LA_VALEUR 0
13 3 PREND_LA_VALEUR 0
14 4 PREND_LA_VALEUR 0
15 5 PREND_LA_VALEUR 0
16 6 PREND_LA_VALEUR 0
17 jets PREND_LA_VALEUR 0
18 POUR i ALLANT_DE 1 A 6
19 DEBUT_POUR
20 TANT_QUE (S=0) FAIRE
21 DEBUT_TANT_QUE
22 SI (1) ALORS
23 DEBUT_SI
24 D1 PREND_LA_VALEUR D1+1
25 FIN_SI
26 SI (2) ALORS
27 DEBUT_SI
28 2 PREND_LA_VALEUR 2+1
29 FIN_SI
30 SI (3) ALORS
31 DEBUT_SI
32 3 PREND_LA_VALEUR 3+1
33 FIN_SI
34 SI (4) ALORS
35 DEBUT_SI
36 4 PREND_LA_VALEUR 4+1
37 FIN_SI
38 SI (5) ALORS
39 DEBUT_SI
40 5 PREND_LA_VALEUR 5+1
41 FIN_SI
42 SI (6) ALORS
43 DEBUT_SI
44 6 PREND_LA_VALEUR 6+1
45 FIN_SI
46 jets PREND_LA_VALEUR jets+1
47 S PREND_LA_VALEUR 1*2*3*4*5*6
48 FIN_TANT_QUE
49 FIN_POUR
50 AFFICHER jets
51 FIN_ALGORITHME

Essaie de comprendre ceci :

VARIABLES
resultat EST_DU_TYPE NOMBRE
reussi EST_DU_TYPE NOMBRE
compteur EST_DU_TYPE NOMBRE
un EST_DU_TYPE NOMBRE
deux EST_DU_TYPE NOMBRE
trois EST_DU_TYPE NOMBRE
quatre EST_DU_TYPE NOMBRE
cinq EST_DU_TYPE NOMBRE
six EST_DU_TYPE NOMBRE

DEBUT_ALGORITHME
  un PREND_LA_VALEUR 0
  deux PREND_LA_VALEUR 0
  trois PREND_LA_VALEUR 0
  quatre PREND_LA_VALEUR 0
  cinq PREND_LA_VALEUR 0
  six PREND_LA_VALEUR 0
	reussi PREND_LA_VALEUR 0
	compteur PREND_LA_VALEUR 0
	TANT_QUE (reussi==0) FAIRE
		DEBUT_TANT_QUE
		compteur PREND_LA_VALEUR compteur + 1
		resultat PREND_LA_VALEUR floor(6*random()+1)
		AFFICHER resultat
		SI (resultat == 1) ALORS
			DEBUT_SI
			un PREND_LA_VALEUR 1
			FIN_SI
			SI (resultat == 2) ALORS
			DEBUT_SI
			deux PREND_LA_VALEUR 1
			FIN_SI
			SI (resultat == 3) ALORS
			DEBUT_SI
			trois PREND_LA_VALEUR 1
			FIN_SI
			SI (resultat == 4) ALORS
			DEBUT_SI
			quatre PREND_LA_VALEUR 1
			FIN_SI
			SI (resultat == 5) ALORS
			DEBUT_SI
			cinq PREND_LA_VALEUR 1
			FIN_SI
			SI (resultat == 6) ALORS
			DEBUT_SI
			six PREND_LA_VALEUR 1
			FIN_SI
			SI (un==1 ET deux ==1 ET trois ==1 ET quatre ==1 ET cinq ==1 ET six ==1) ALORS
				DEBUT_SI
				reussi PREND_LA_VALEUR 1
				FIN_SI
		FIN_TANT_QUE
		AFFICHER "nombre de jets :"
	  AFFICHER* compteur
	
FIN_ALGORITHME

Legarsdu70 à aucun moment tu faisais un tirage aléatoire du dé
(comme l'instruction de J-P : floor(6*random()+1)
ou bien ALGOBOX_ALEA_ENT(1,6) qui est faite exprès pour ça

ton idée de faire TANT_QUE (S=0) était excellente (par contre il faut mettre ==)
par contre je ne suis pas sûr qu'algobox fait la différence entre 1*2*3*4*5*6 produit des nombres et produits des variables. c'est imprudent de prendre des nombres comme nom de variables.

je te donne quand même un code que je considère plus optimisé (pour le plaisir) :

VARIABLES
	L EST_DU_TYPE LISTE
	D EST_DU_TYPE NOMBRE
	N EST_DU_TYPE NOMBRE
	P EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
	L[1] PREND_LA_VALEUR 0:0:0:0:0:0
	// ça initialise toute la liste à 0
	N PREND_LA_VALEUR 0
	// le compteur du nombre de coups
	P PREND_LA_VALEUR 0
	// le produit des termes de la liste, tant qu'elle est nulle il faut continuer
	TANT_QUE (P==0) FAIRE
		DEBUT_TANT_QUE
		D PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,6)
		L[D] PREND_LA_VALEUR L[D]+1
		P PREND_LA_VALEUR L[1]*L[2]*L[3]*L[4]*L[5]*L[6]
		N PREND_LA_VALEUR N+1
		FIN_TANT_QUE
	AFFICHER N
FIN_ALGORITHME

(tu peux le copier/coller dans algobox en mode éditeur de texte, ou bien directement en ligne dans proglab )

Merci bien pour vos algorithmes, j'ai toujours un souci avec le ....
2. Ecrire un algorithme répétant n fois l'algorithme précédent et restituant la moyenne des lancers nécessaires à l'obtention
de chacune des faces une fois au moins.

tu demandes une variable M (N est déjà pris) (tu rajoutes un LIRE M au début), tu encadres l'algorithme précédent par une boucle Pour I allant de 1 à M
tu rajoutes une variable S que tu incrémentes à chaque passage dans la boucle par la valeur que tu as trouvé pour N et en sortie de boucle tu divises S par M et tu affiches la moyenne obtenue.

Je dois avoir un petit souci?
VARIABLES
  L EST_DU_TYPE LISTE
  D EST_DU_TYPE NOMBRE
  N EST_DU_TYPE NOMBRE
  P EST_DU_TYPE NOMBRE
  M EST_DU_TYPE NOMBRE
  S EST_DU_TYPE NOMBRE
  I EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
LIRE M
POUR I ALLANT_DE 1 A M
DEBUT_POUR
L[1] PREND_LA_VALEUR 0:0:0:0:0:0
  // ça initialise toute la liste à 0
  N PREND_LA_VALEUR 0
  // le compteur du nombre de coups
  P PREND_LA_VALEUR 0
  // le produit des termes de la liste, tant qu'elle est nulle il faut continuer
  TANT_QUE (P==0) FAIRE
    DEBUT_TANT_QUE
    D PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,6)
    L[D] PREND_LA_VALEUR L[D]+1
    P PREND_LA_VALEUR L[1]*L[2]*L[3]*L[4]*L[5]*L[6]
    N PREND_LA_VALEUR N+1
    S PREND_LA_VALEUR N
    FIN_TANT_QUE
FIN_POUR
S PREND_LA_VALEUR S/M
  AFFICHER N
  AFFICHER S
FIN_ALGORITHME

plusieurs fautes :
il faut initialiser S à 0
c'est S PREND_LA_VALEUR S+N si on veut que S contienne la somme
et il faut mettre cette instruction en dehors de la boucle TantQue (sinon on a pas le N définitif)

 VARIABLES
	L EST_DU_TYPE LISTE
	D EST_DU_TYPE NOMBRE
	N EST_DU_TYPE NOMBRE
	P EST_DU_TYPE NOMBRE
	M EST_DU_TYPE NOMBRE
	S EST_DU_TYPE NOMBRE
	I EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
	LIRE M
	S PREND_LA_VALEUR 0
	POUR I ALLANT_DE 1 A M
		DEBUT_POUR
		L[1] PREND_LA_VALEUR 0:0:0:0:0:0
		N PREND_LA_VALEUR 0
		P PREND_LA_VALEUR 0
		TANT_QUE (P==0) FAIRE
			DEBUT_TANT_QUE
			D PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,6)
			L[D] PREND_LA_VALEUR L[D]+1
			P PREND_LA_VALEUR L[1]*L[2]*L[3]*L[4]*L[5]*L[6]
			N PREND_LA_VALEUR N+1
			FIN_TANT_QUE
		S PREND_LA_VALEUR S+N
		FIN_POUR
	S PREND_LA_VALEUR S/M
	AFFICHER S
FIN_ALGORITHME

Il faut pas faire la moyenne de chaque face? c'est pas ce qui est dit dans la consigne?

non, il est demandé "la moyenne des lancés nécessaires à l'obtention de chacune des faces une fois au moins." donc c'est la moyenne des N.
et donc l'algorithme calcule bien la somme des N obtenus dans les M lancés / M c.a.d la moyenne

Donc c'est cet algorithme qui est attendu. merci!^^