Bonjour ,
J'ai un dm faire pour Vendredi en maths TS, et je ne comprends strictement rien a ce sujet et aux algorithmes.( a faire a l'aide du logiciel algobox)
Si vous pourriez me donner un coup de pouce, ou conseil, il sera le bienvenu, vous en remerciant d'avance :
1)
S=Integrale de b vers a x² dx
Donner un encadrement de S en utilisant n rectangles
Le correcteur doit choisir a,b et n et l'algorithme doit donner une valeur approchée de S.
UN= Somme sous i (b-a)/n f(a+k(b-a/n)) lire a, b et n
k=0
2)
On lance 3 dès. On répète ce lancé 100 000 fois. Simuler cette expérience et calculer les fréquences/proba par la somme des 3 dès obtenus.
Pour simuler le lancé de 1 dé = touche floor (6x), random(x1)
Bonjour,
Donnez-moi la surface du rectangle bleu et du rectangle vert
Comment faites-vous ?
largeur des rectangles:
hauteur des rectangles :
La surface rouge est l'intégrale de la courbe (ici une petite tranche entre 1,8 et 2)
idem pour la première tranche verticale
idem pour la dernière tranche verticale
idem pour la k ième tranche verticale
merci glapion
https://www.ilemaths.net/sujet-algorithme-492618.html
Algorithme
je corrige:
(b-a)/n * f(a+ k*(b-a)/n))
Que pensez-vous du 2) ?
Bonjour Chatof et merci de pointer vers un de mes post,
En passant par hasard sur ce topic, et en regardant la question 2) ça m'a donné envie de voir si on pouvait écrire un programme simple pour résoudre le problème. Voilà une proposition qui utile une variable de type Liste pour stocker les valeurs :
(En mode d'édition "éditeur de texte" tu peux copier/coller ces lignes, ça marche) :
VARIABLES
frequence EST_DU_TYPE LISTE
I EST_DU_TYPE NOMBRE
S EST_DU_TYPE NOMBRE
Q EST_DU_TYPE NOMBRE
DEBUT_ALGORITHME
frequence[1] PREND_LA_VALEUR 0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0
POUR I ALLANT_DE 1 A 100000
DEBUT_POUR
S PREND_LA_VALEUR ALGOBOX_ALEA_ENT(1,6)+ALGOBOX_ALEA_ENT(1,6)+ALGOBOX_ALEA_ENT(1,6)
frequence[S] PREND_LA_VALEUR frequence[S]+1
FIN_POUR
POUR I ALLANT_DE 1 A 18
DEBUT_POUR
AFFICHER I
AFFICHER "--> "
S PREND_LA_VALEUR frequence[I]/100000
Q PREND_LA_VALEUR S
AFFICHER* S
TRACER_SEGMENT (I-1,Q)->(I,S)
FIN_POUR
FIN_ALGORITHME
(Si tu ne veux pas de graphe, enlève l'instruction TRACER_SEGMENT sinon il faudra cocher l'onglet "Utiliser un repère" et calibrer Xmin =0 Xmax=20 Ymin=0 Ymax=0.2 graduationX=1 graduationY=0.01)
Et bien sûr lolo06190, si tu ne comprends pas l'algorithme, n'hésite pas à demander, on t'expliquera.
Bonsoir,
Merci pour la question 2, mais je n'ai toujours pas compris le fonctionnement de la question 1, si vous pourriez en quelques lignes m'expliquer le pourquoi du comment je vous en remercierais ( ps: les algo c'est pas mon point fort )
Merci d'avance pour vos réponses.
Pour l'algorithme 2 je n'ai pas saisi la ligne : frequence[1] PREND_LA_VALEUR 0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0
Pourquoi la fréquence doit prendre cette valeur ? comment avez vous construit l'algorithme ?
Merci encore .
frequence[1] PREND_LA_VALEUR 0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0
c'est une instruction qui initialise toutes les valeurs du tableau à 0
ça revient à dire que frequence[I] = 0 pour I = 1 à 18
Merci, j'ai a peu près compris le fonctionnement même si je n'arriverais pas a le refaire :/, pour la question 1 par ou dois je commencer ? je ne sais même pas par ou commencer l'intégrale ou la suite ...
Merci de votre aide .
Comment puis je vous donner une surface d'un rectangle dont je n'est que l'intégrale, sans faire de calcul ?
on ne nous donne aucune données a part l'intégrale je pense qu'il faut donner un encadrement de l'intégrale avec la formule
(b-a/n)* la somme f(a+k(b-a/n))< aire< (b-a/n)* la somme (a+k(b-a/n))
Entre 1 et 3 nous coupons dix tranches d'épaisseur (3-1)/10 (b-a)/n
Les rectangles ont pour largeur (3-1)/10 =0,2 (b-a)/n
hauteur rectangle bleu = f(1,8)-0 =(1,8)²
hauteur rectangle vert = f(2)=2²
surface bleu= 0,2 * (1,8)²
surface verte= 0,2* 2²
ok ?
Premier rectangle bleu (inférieur) 0,2* 1² (b-a)/n * f(a)
kiéme rectangle bleu (inférieur) 0,2* (1 + (k-1)*0,2)² (b-a)/n * f(a + (k-1)* (b-a)/n)
dernier rectangle bleu (inférieur) 0,2* (1 + (10-1)*0,2)² (b-a)/n * f(a + (n-1)* (b-a)/n)
Premier rectangle vert (supérieur) 0,2* (1+0,2)² (b-a)/n * f(a + (b-a)/n)
kiéme rectangle vert (supérieur) 0,2* (1 + k*0,2)² (b-a)/n * f(a + k* (b-a)/n)
dernier rectangle vert (supérieur) 0,2* (1 + 10*0,2)² (b-a)/n * f(a + n* (b-a)/n)= (b-a)/n * f(b))
Donc :
la somme des surfaces bleues la somme des surfaces rouges
la somme des surfaces vertes
Il n'y a plus qu'a faire l'algorithme.
1 VARIABLES
2 a EST_DU_TYPE NOMBRE
3 b EST_DU_TYPE NOMBRE
4 n EST_DU_TYPE NOMBRE
5 k EST_DU_TYPE NOMBRE
6 Sbleu EST_DU_TYPE NOMBRE
7 Sverte EST_DU_TYPE NOMBRE
8 DEBUT_ALGORITHME
9 LIRE a
10 LIRE b
11 LIRE n
12 Sbleu PREND_LA_VALEUR 0
13 Sverte PREND_LA_VALEUR 0
14 POUR k ALLANT_DE 1 A n
15 DEBUT_POUR
16 Sbleu PREND_LA_VALEUR Sbleu + (b-a)/n * pow(a + (k-1)* (b-a)/n , 2)
17 Sverte PREND_LA_VALEUR Sverte + (b-a)/n * pow(a + k* (b-a)/n, 2)
18 FIN_POUR
19 AFFICHER Sbleu
20 AFFICHER " < S < "
21 AFFICHER Sverte
22 FIN_ALGORITHME
RÉSULTATS :
***Algorithme lancé***
2.185 < S < 2.485
***Algorithme terminé***
Généré par AlgoBox
2)
On lance 3 dès. On répète ce lancé 100 000 fois. Simuler cette expérience (programme de Glapion)
et calculer les fréquences/proba par la somme des 3 dès obtenus. (ci-dessous):
Comme l'arbre est trop grand pour être parcouru à la main, ce programme fait le travail.
GRAPHIQUE :
Xmin: 0 ; Xmax: 20 ; Ymin: 0 ; Ymax: 0.2 ; GradX: 1 ; GradY: 0.01
CODE DE L'ALGORITHME :
1 VARIABLES
2 frequence EST_DU_TYPE LISTE
3 I EST_DU_TYPE NOMBRE
4 S EST_DU_TYPE NOMBRE
5 D1 EST_DU_TYPE NOMBRE
6 D2 EST_DU_TYPE NOMBRE
7 D3 EST_DU_TYPE NOMBRE
8 Q EST_DU_TYPE NOMBRE
9 DEBUT_ALGORITHME
10 Q PREND_LA_VALEUR 0
11 frequence[1] PREND_LA_VALEUR 0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0:0
12 //Lancé dé N°1
13 POUR D1 ALLANT_DE 1 A 6
14 DEBUT_POUR
15 //Lancé dé N°2
16 POUR D2 ALLANT_DE 1 A 6
17 DEBUT_POUR
18 //Lancé dé N°3
19 POUR D3 ALLANT_DE 1 A 6
20 DEBUT_POUR
21 //Pour chaque feuille de l'arbre, on comtabilise l'issue
22 S PREND_LA_VALEUR D1+D2+D3
23 frequence[S] PREND_LA_VALEUR frequence[S]+1
24 FIN_POUR
25 FIN_POUR
26 FIN_POUR
27 POUR I ALLANT_DE 1 A 18
28 DEBUT_POUR
29 AFFICHER I
30 AFFICHER "--> "
31 S PREND_LA_VALEUR frequence[I]/(6*6*6)
32 AFFICHER S
33 TRACER_SEGMENT (I-1,Q)->(I,S)
34 Q PREND_LA_VALEUR S
35 FIN_POUR
36 FIN_ALGORITHME
RÉSULTATS :
***Algorithme lancé***
1--> 0
2--> 0
3--> 0.0046296296
4--> 0.013888889
5--> 0.027777778
6--> 0.046296296
7--> 0.069444444
8--> 0.097222222
9--> 0.11574074
10--> 0.125
11--> 0.125
12--> 0.11574074
13--> 0.097222222
14--> 0.069444444
15--> 0.046296296
16--> 0.027777778
17--> 0.013888889
18--> 0.0046296296
***Algorithme terminé***
Généré par AlgoBox
Dans le programme de Glapion, j'ai déplacé
Q PREND_LA_VALEUR S
Logiquement Q est la valeur de S pour (I-1)
Voir aussi un autre exemple d'algorithme qui parcourt l'arbre:
https://www.ilemaths.net/sujet-special-algorithme-496479.html
Spécial algorithme
Vous devez être membre accéder à ce service...
Pas encore inscrit ?
1 compte par personne, multi-compte interdit !
Ou identifiez-vous :