et c'est tout ce que ton énoncé dit ?
obtenir une série de 1 000 valeurs, sans autre contrainte ?

tiens, en voilà une :
1 2 3 4 5 6 7 8 9 .... 999 1000

J'ai du faire un algorithme (je l'

*(je l"

[désolée j'ai eu un beug]

J'ai du faire un algorithme et après je dois faire ce que je vous ai dis au-dessus mais avec l'algorithme en rentrant les formules dedans mais je sais pas c'est lesquelles ni où faut les mettre.

et comment veux-tu obtenir de l'aide si tu donnes si peu de détails ?
tu dois avoir 3 compteurs A, B et C initialisés à 0
dans la boucle qui génère les mille valeurs, tu incrémentes
- le premier compteur A si la valeur fournie est à 15,
- le deuxième compteur B si la valeur fournie est <15 et à 30
- le troisième compteur C si la valeur fournit est > 30

au sortir de la boucle,
- la première fréquence est A/1000
- la deuxième fréquence est B/1000
- la troisième fréquence est C/1000

Et comment on note ça dans Algobox ?

tu ne m'as toujours pas dit comment est sensé être générée la série

tiens, je suppose qu'on te demande ce genre de chose :

1     VARIABLES
2       i EST_DU_TYPE NOMBRE
3       n EST_DU_TYPE NOMBRE
4       alea EST_DU_TYPE NOMBRE
5       borne_inf EST_DU_TYPE NOMBRE
6       borne_sup EST_DU_TYPE NOMBRE
7       a EST_DU_TYPE NOMBRE
8       b EST_DU_TYPE NOMBRE
9       c EST_DU_TYPE NOMBRE
10    DEBUT_ALGORITHME
11      AFFICHER "Entrer la longueur de la série voulue"
12      LIRE n
13      AFFICHER "Entrer la borne inférieure de la série"
14      LIRE borne_inf
15      AFFICHER "Entrer la borne supérieure de la série"
16      LIRE borne_sup
17      AFFICHER "nombre de valeurs de la série : "
18      AFFICHER n
19      AFFICHER "borne inférieure : "
20      AFFICHER borne_inf
21      AFFICHER "borne supérieure : "
22      AFFICHER borne_sup
23      a PREND_LA_VALEUR 0
24      b PREND_LA_VALEUR 0
25      c PREND_LA_VALEUR 0
26      POUR i ALLANT_DE 1 A n
27        DEBUT_POUR
28        alea PREND_LA_VALEUR ALGOBOX_ALEA_ENT(borne_inf,borne_sup)
29        SI (alea <= 15) ALORS
30          DEBUT_SI
31          a PREND_LA_VALEUR a+1
32          FIN_SI
33          SINON
34            DEBUT_SINON
35            SI (alea <= 30) ALORS
36              DEBUT_SI
37              b PREND_LA_VALEUR b+1
38              FIN_SI
39              SINON
40                DEBUT_SINON
41                c PREND_LA_VALEUR c+1
42                FIN_SINON
43            FIN_SINON
44        FIN_POUR
45      a PREND_LA_VALEUR a/n
46      b PREND_LA_VALEUR b/n
47      c PREND_LA_VALEUR c/n
48      AFFICHER "La fréquence des nombres inférieurs ou égaux à 15 est "
49      AFFICHER a
50      AFFICHER "La fréquence des nombres supérieurs à 15 et inférieurs ou égaux à 30 est "
51      AFFICHER b
52      AFFICHER "La fréquence des nombres supérieurs à 30 est "
53      AFFICHER c
54    FIN_ALGORITHME

Résultats :
***Algorithme lancé***
Entrer la longueur de la série voulue
Entrer la borne inférieure de la série
Entrer la borne supérieure de la série
nombre de valeurs de la série : 100000
borne inférieure : 1
borne supérieure : 60
La fréquence des nombres inférieurs ou égaux à 15 est 0.24912
La fréquence des nombres supérieurs à 15 et inférieurs ou égaux à 30 est 0.25384
La fréquence des nombres supérieurs à 30 est 0.49704
***Algorithme terminé***

Votre algorithme est certainement exact mais le souci c'est que j'ai commencé mon algorithme avec mon prof et il a pas mis des trucs comme ça et j'aimerais vous montrer le mien mais le copier/coller marche pas.

depuis le début je t'incite à me le communiquer.
on y arrive enfin

alors tu te retrousses les manches, et si tu es incapable de faire un copié/collé, tu le recopies minutieusement.

si tu avais fait cet effort dès le début, ton problème serait déjà réglé.

1 VARIABLES
2 x EST_DU_TYPE NOMBRE
3 y EST_DU_TYPE NOMBRE
4 N EST_DU_TYPE NOMBRE
5 Z EST_DU_TYPE NOMBRE
6 DEBUT_ALGORITHME
7 LIRE x
8 LIRE y
9 LIRE N
10 TANT_QUE (sqrt(x*x+y*y)<=5) FAIRE
11 DEBUT_TANT_QUE
12 N PREND_LA_VALEUR N+1
13 Z PREND_LA_VALEUR ALGOBOX_ALEA_ENT(0,3)
14 SI (Z==0) ALORS
15 DEBUT_SI
16 x PREND_LA_VALEUR x+1
17 SI (Z==1) ALORS
18 DEBUT_SI
19 x PREND_LA-VALEUR x-1
20 FIN_SI
21 SI (Z==2) ALORS
22 DEBUT_SI
23 y PREND_LA_VALEUR y+1
24 FIN_SI
25 SI(Z==3) ALORS
26 DEBUT_SI
27 y PREND_LA_VALEUR y-1
28 FIN_SI
29 FIN_TANT_QUE
30 AFFICHER N
31 FIN_ALGORITHME

Deux erreurs de saisie, commentées dans le code
VARIABLES
  x EST_DU_TYPE NOMBRE
  y EST_DU_TYPE NOMBRE
  N EST_DU_TYPE NOMBRE
  Z EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
  LIRE x
  LIRE y
  LIRE N
  TANT_QUE (sqrt(x*x+y*y)<=5) FAIRE
    DEBUT_TANT_QUE
    N PREND_LA_VALEUR N+1
    Z PREND_LA_VALEUR ALGOBOX_ALEA_ENT(0,3)
    SI (Z==0) ALORS
      DEBUT_SI
      x PREND_LA_VALEUR x+1
// ICI : tu as oublié l'instruction FIN_SI      
      FIN_SI
    SI (Z==1) ALORS
      DEBUT_SI
      x PREND_LA_VALEUR x-1
      FIN_SI
    SI (Z==2) ALORS
      DEBUT_SI
// ICI : tu as mal recopié l'instruction PREND_LA-VALEUR
      y PREND_LA_VALEUR y+1
      FIN_SI
    SI (Z==3) ALORS
      DEBUT_SI
      y PREND_LA_VALEUR y-1
      FIN_SI
  FIN_TANT_QUE
  AFFICHER N
FIN_ALGORITHME

que fait l'algorithme ?
choix d'un point A par ses coordonnées (x;y)
choix d'une valeur initiale de N <--------- ah bon ???
tant que le point A est dans le cercle de centre O, de rayon 5
  incrémenter N
  tirer au hasard une valeur entière Z parmi 0, 1, 2, 3
  si Z est 0 : incrémenter x
  si Z est 1 : décrémenter x
  si Z est 2 : incrémenter y
  si Z est 3 : décrémenter y
fin tant que
afficher Z

en fait cet algo simule ce qu'on appelle le mouvement brownien d'une particule A et cherche à savoir combien de temps il va falloir pour que la particule sorte de la zone prédéfinie

Une remarque :
je suis étonné que l'algo fasse lire x, y, N
je crois plutôt qu'il doit initialiser x, y, N à 0


Voici une version qui te calcule expérimentalement le nombre moyen de mouvements nécessaires
1     VARIABLES
2       x EST_DU_TYPE NOMBRE
3       y EST_DU_TYPE NOMBRE
4       N EST_DU_TYPE NOMBRE
5       Z EST_DU_TYPE NOMBRE
6       rayon EST_DU_TYPE NOMBRE
7       nbTests EST_DU_TYPE NOMBRE
8       idxTest EST_DU_TYPE NOMBRE
9       nbMvt EST_DU_TYPE NOMBRE
10    DEBUT_ALGORITHME
11      LIRE nbTests
12      nbMvt PREND_LA_VALEUR 0
13      rayon PREND_LA_VALEUR 5
14      POUR idxTest ALLANT_DE 1 A nbTests
15        DEBUT_POUR
16        x PREND_LA_VALEUR 0
17        y PREND_LA_VALEUR 0
18        N PREND_LA_VALEUR 0
19        TANT_QUE (sqrt(x*x+y*y)<=rayon) FAIRE
20          DEBUT_TANT_QUE
21          N PREND_LA_VALEUR N+1
22          Z PREND_LA_VALEUR ALGOBOX_ALEA_ENT(0,3)
23          SI (Z==0) ALORS
24            DEBUT_SI
25            x PREND_LA_VALEUR x+1
26            FIN_SI
27          SI (Z==1) ALORS
28            DEBUT_SI
29            x PREND_LA_VALEUR x-1
30            FIN_SI
31          SI (Z==2) ALORS
32            DEBUT_SI
33            y PREND_LA_VALEUR y+1
34            FIN_SI
35          SI (Z==3) ALORS
36            DEBUT_SI
37            y PREND_LA_VALEUR y-1
38            FIN_SI
39          FIN_TANT_QUE
40        nbMvt PREND_LA_VALEUR nbMvt+N
41        FIN_POUR
42      nbMvt PREND_LA_VALEUR nbMvt / nbTests
43      AFFICHER "nombre moyen de mouvements "
44      AFFICHER nbMvt
45    FIN_ALGORITHME
Résultats :
***Algorithme lancé***
nombre moyen de mouvements 29.0059
***Algorithme terminé***

Et vous avez mis où pour que la série se répète 1 000 et pour les fréquences N15 , 15<N30 et N>30 ?

je te laisse le découvrir, il faut que tu bosses un peu quand même

voilà une version qui affiche des statistiques plus fines :
1     VARIABLES
2       x EST_DU_TYPE NOMBRE
3       y EST_DU_TYPE NOMBRE
4       N EST_DU_TYPE NOMBRE
5       Z EST_DU_TYPE NOMBRE
6       rayon EST_DU_TYPE NOMBRE
7       nbTests EST_DU_TYPE NOMBRE
8       idxTest EST_DU_TYPE NOMBRE
9       nbMvt EST_DU_TYPE NOMBRE
10      nbMaxMvt EST_DU_TYPE NOMBRE
11      stats EST_DU_TYPE LISTE
12    DEBUT_ALGORITHME
13      LIRE nbTests
14      nbMvt PREND_LA_VALEUR 0
15      rayon PREND_LA_VALEUR 5
16      nbMaxMvt PREND_LA_VALEUR 90
17      POUR idxTest ALLANT_DE 1 A nbMaxMvt
18        DEBUT_POUR
19        stats[idxTest] PREND_LA_VALEUR 0
20        FIN_POUR
21      POUR idxTest ALLANT_DE 1 A nbTests
22        DEBUT_POUR
23        x PREND_LA_VALEUR 0
24        y PREND_LA_VALEUR 0
25        N PREND_LA_VALEUR 0
26        TANT_QUE (sqrt(x*x+y*y)<=rayon) FAIRE
27          DEBUT_TANT_QUE
28          N PREND_LA_VALEUR N+1
29          Z PREND_LA_VALEUR ALGOBOX_ALEA_ENT(0,3)
30          SI (Z==0) ALORS
31            DEBUT_SI
32            x PREND_LA_VALEUR x+1
33            FIN_SI
34          SI (Z==1) ALORS
35            DEBUT_SI
36            x PREND_LA_VALEUR x-1
37            FIN_SI
38          SI (Z==2) ALORS
39            DEBUT_SI
40            y PREND_LA_VALEUR y+1
41            FIN_SI
42          SI (Z==3) ALORS
43            DEBUT_SI
44            y PREND_LA_VALEUR y-1
45            FIN_SI
46          FIN_TANT_QUE
47        nbMvt PREND_LA_VALEUR nbMvt+N
48        SI (N>nbMaxMvt) ALORS
49          DEBUT_SI
50          N PREND_LA_VALEUR nbMaxMvt
51          FIN_SI
52        stats[N] PREND_LA_VALEUR stats[N]+1
53        FIN_POUR
54      nbMvt PREND_LA_VALEUR nbMvt / nbTests
55      AFFICHER "nombre moyen de mouvements "
56      AFFICHER nbMvt
57      POUR idxTest ALLANT_DE 1 A nbMaxMvt
58        DEBUT_POUR
59        TRACER_SEGMENT (idxTest,0)->(idxTest,stats[idxTest]/nbTests)
60        FIN_POUR
61    FIN_ALGORITHME
Résultats :
***Algorithme lancé***
nombre moyen de mouvements 29.109
***Algorithme terminé***

le graphique indique par un trait rouge la fréquence correspondant à chaque nombre de mouvements

je suis étonné car il semble que les sorties sur un nombre de mouvements impairs soient toujours plus rares que celles avec un nombre de mouvements pairs contigu.

Votre premier algorithme convenait mieux à mon type d'exercice. Je vous remercie vraiment beaucoup d'avoir fait plusieurs algorithmes pour répondre à mon problème !
Encore merci beaucoup d'avoir pris de votre temps !

donne ta solution, je te la corrigerai

***Algorithme lancé***
Entrer la longueur de la série voulue :
Entrer la borne inférieure de la série :
Entrer la borne supérieure de la série :
Nombre de valeurs de la série :100000
borne inférieure : 1
borne supérieure :60
La fréquence des nombres inférieurs ou égaux à 15 est :0.25065
La fréquence des nombres supérieurs à 15 et inférieurs ou égaux à 30 est :  0.25309
La fréquence des nombres supérieurs à 30 est :0.49626
***Algorithme terminé***

Je pense que c'est bon.

je ne te demandais pas le résultat de ton algorithme mais ton algorithme lui-même.

là, manifestement, tu as fait fonctionner la première version que je t'avais fournie, avant que j'arrive à t'extirper la première version que tu m'as fournie, avec la racine carrée.

avant toutes choses, peux-tu (si tu souhaites que tout cela aboutisse) me dire si ce qui suit est correct :
1) le prof vous a donné, ou fait écrire un premier algorithme, celui qui faisait le test
TANT_QUE (sqrt(x*x+y*y)<=5) FAIRE

2) il vous a ensuite demandé de modifier cet algorithme pour le faire s'exécuter 1000 fois de suite, et

3) vous a demandé alors de compter le nombre de fois où N était <= 15, le nombre de fois où 15<N<=30, le nombre de fois où 30<N, pour ensuite afficher les fréquences de ces états


parce que les résultats que tu affiches sont alors totalement erronés.

Tout ce que vous dîtes est exactement mon énoncé et j'ai cru que votre algorithme était bon parce que j'ai des camarades qui trouve les mêmes résultats que vous ou au chiffre près.

je ne suis pas là pour te juger,
donc si ce que tu penses être la solution te convient, restons-en là

il est bien possible que ton exercice n'ait rien à voir avec le précédent, dans lequel il était testé (sqrt(x*x+y*y)<=5)

Bah enfaite on a commencé un algorithme avec mon prof que je vous ai montré et après on a du rajouter les 3 étapes que vous venez de dire mais le souci c'est que mon prof ne nous a pas dis si on devait le changer ou non c'est donc pourquoi j'ai pensé que votre algo était bon pour mon exo.

donc j'avais bien raison
et donc mon premier algorithme, que j'avais fait ne connaissant pas l'existence de ce premier exercice NE CONVIENT PAS.

et tu es bien sûr incapable de modifier ton propre exercice en t'inspirant des deux exemples que je t'ai donnés pour arriver au résultat.

--------------------------------------------
Simulation élémentaire mouvement brownien d'une particule et évaluation des fréquences du nombre de mouvements nécessaires pour qu'elle sorte d'un cercle centré sur son point de départ.
Chaque mouvement a une amplitude de 1 unité et se fait selon un des axes du repère.
(avec 100 000 tests, l'exécution peut durer plusieurs dizaines de secondes)
--------------------------------------------
Code de l'algorithme :
1     VARIABLES
2       x EST_DU_TYPE NOMBRE
3       y EST_DU_TYPE NOMBRE
4       N EST_DU_TYPE NOMBRE
5       Z EST_DU_TYPE NOMBRE
6       rayon EST_DU_TYPE NOMBRE
7       nbTests EST_DU_TYPE NOMBRE
8       idxTest EST_DU_TYPE NOMBRE
9       tranche1 EST_DU_TYPE NOMBRE
10      tranche2 EST_DU_TYPE NOMBRE
11      tranche3 EST_DU_TYPE NOMBRE
12    DEBUT_ALGORITHME
13      // Description des variables :
14      // (x;y) : Les coordonnées de la particule
15      // N : Compteur du nombre de mouvements qu'exécute la particule
16      // Z : Variable aléatoire permettant de choisir la direction du prochain mouvement
17      // nbTests : Saisie du nombre de tests effectués pour évaluer les fréquences
18      // idxTest : indice de boucle
19      // .
20      // tranche1, tranche2, tranche3 sont 3 compteurs :
21      // - le premier compte les situations où N <= 15
22      // - le deuxième compte les situations où 15 < N <= 30
23      // - le dernier compte les situations où 30 < N
24      // Cela permet ensuite d'afficher les fréquences de ces situations, besoin ultime de l'exercice d'un élève paumé
25      // .
26      // On laisse le choix de définir au début de l'algorithme le nombre de tests souhaités
27      LIRE nbTests
28      AFFICHER "nombre de tests effectués : "
29      AFFICHER nbTests
30      // Les constantes de l'algorithme
31      rayon PREND_LA_VALEUR 5
32      // Initialisation des variables (même si Algobox semble les initialiser lui-même, c'est une bonne pratique
33      // de programmation que de le faire explicitement)
34      tranche1 PREND_LA_VALEUR 0
35      tranche2 PREND_LA_VALEUR 0
36      tranche3 PREND_LA_VALEUR 0
37      // .
38      // Boucle principale exécutant "nbTests" tests
39      POUR idxTest ALLANT_DE 1 A nbTests
40        DEBUT_POUR
41        // Cette initialisation concerne les variables du test,
42        // donc doit être effectuée en début de chaque test
43        x PREND_LA_VALEUR 0
44        y PREND_LA_VALEUR 0
45        N PREND_LA_VALEUR 0
46        // Boucle potentiellement infinie (mais en pratique, la probabilité que
47        // la particule ne sorte jamais du cercle est quasi-nulle)
48        // Ce test est vrai si la particule est dans le cercle de rayon "rayon", centré
49        // au point de départ de la particule
50        TANT_QUE (sqrt(x*x+y*y)<=rayon) FAIRE
51          DEBUT_TANT_QUE
52          // On compte le nombre de mouvements effectués par la particule jusqu'à celui qui la fera sortir du cercle
53          N PREND_LA_VALEUR N+1
54          // On choisit aléatoirement la direction du mouvement de la particule
55          Z PREND_LA_VALEUR ALGOBOX_ALEA_ENT(0,3)
56          // Suivant cette direction, on va modifier les coordonnées de la particule
57          // (chaque mouvement a une amplitude de 1 unité et se fait selon un des axes du repère)
58          SI (Z==0) ALORS
59            DEBUT_SI
60            // Est
61            x PREND_LA_VALEUR x+1
62            FIN_SI
63          SI (Z==1) ALORS
64            DEBUT_SI
65            // Ouest
66            x PREND_LA_VALEUR x-1
67            FIN_SI
68          SI (Z==2) ALORS
69            DEBUT_SI
70            // Nord
71            y PREND_LA_VALEUR y+1
72            FIN_SI
73          SI (Z==3) ALORS
74            DEBUT_SI
75            // Sud
76            y PREND_LA_VALEUR y-1
77            FIN_SI
78          FIN_TANT_QUE
79        // .
80        // Au sortir de cette boucle TANT_QUE, la particule est hors du cercle
81        // et la variable N contient le nombre de mouvements qu'elle a effectués
82        // On alimente les compteurs de tranche
83        SI (N<=15) ALORS
84          DEBUT_SI
85          tranche1 PREND_LA_VALEUR tranche1+1
86          FIN_SI
87          SINON
88            DEBUT_SINON
89            SI (N<=30) ALORS
90              DEBUT_SI
91              tranche2 PREND_LA_VALEUR tranche2+1
92              FIN_SI
93              SINON
94                DEBUT_SINON
95                tranche3 PREND_LA_VALEUR tranche3+1
96                FIN_SINON
97            FIN_SINON
98        FIN_POUR
99      // .
100     // Au sortir de la boucle POUR, on a effectué tous les tests, on passe à l'affichage des résultats
101     // Affichage des fréquences des tranches
102     tranche1 PREND_LA_VALEUR tranche1/nbTests
103     tranche2 PREND_LA_VALEUR tranche2/nbTests
104     tranche3 PREND_LA_VALEUR tranche3/nbTests
105     AFFICHER "La fréquence des situations où le nombre de mouvements est inférieur ou égal à 15 est "
106     AFFICHER tranche1
107     AFFICHER "La fréquence des situations où le nombre de mouvements est supếrieur à 15 et inférieur ou égal à 30 est "
108     AFFICHER tranche2
109     AFFICHER "La fréquence des situations où le nombre de mouvements est supếrieur à 30 est "
110     AFFICHER tranche3
111   FIN_ALGORITHME
--------------------------------------------
Résultats :
***Algorithme lancé***
nombre de tests effectués : 100000
La fréquence des situations où le nombre de mouvements est inférieur ou égal à 15 est 0.25644
La fréquence des situations où le nombre de mouvements est supếrieur à 15 et inférieur ou égal à 30 est 0.39511
La fréquence des situations où le nombre de mouvements est supếrieur à 30 est 0.34845
***Algorithme terminé***
--------------------------------------------

J'ai rien modifié parce que je comprends rien du tout à l'utilisation d'algobox et mon prof nous explique rien pour comprendre..
Vos algorithme sont tous bons mais super durs c'est pour ça que je modifie rien..
En tout cas c'est gentil quand même de m'aider même si vous voyez que j'arrive à rien..

ah
veux-tu entamer quelques exercices plus simples pour au moins arriver à utiliser l'outil ?

écrire un algorithme qui :
1) déclare une variable de type nombre, qu'on appellera N
2) demander à l'utilisateur de saisir une valeur au clavier, qu'on affectera à cette variable
3) calculer le double de cette quantité et l'affecter à cette variable
4) afficher le contenu de cette variable.

arrives-tu à faire cet exercice avec Algobox ?
si tu le souhaites, donne-moi l'algorithme que tu auras écrit pour le réaliser