Chapitres Maths en Terminale Générale

Cours sur les algorithmes au programme de Maths en Terminale

Name: Groupe Réussite: Cours particuliers, stages intensifs de révision
Brand: Groupe Réussite
SKU: Cours Particuliers
Rating: 4.8 (1000 reviews)

Résumé de cours Exercices et corrigés

Cours en ligne de Maths en Terminale

Revoyez le cours au programme de maths en Terminale sur les algorithmes grâce à ce cours en ligne en terminale, vous pouvez aussi le reviser à l’aide de la recherche d’un prof de maths à domicile. Dans ce cours vous trouverez, des définitions de cours, des explications de cours ainsi que des exemples d’algorithmes. Le cours complet au programme de terminale ainsi que tous les exercices corrigés se trouvent dans l’application mobile gratuite PrepApp.

1. Affectation, égalités, inégalités en algorithmique en Terminale

$\bullet$ affectation à la variable $V$ de $Resultat$ (une donnée ou le résultat d’opérations sur des variables)
$\boxed{V = Resultat}$

$\bullet$ Comparer deux variables $V1$ et $V2$ à valeurs réelles
$\ast$ Elles sont égales $\boxed{V1 \, ==\, V2}$
$\ast$ Elles ne sont pas égales $\boxed{V1 \, != \, V2}$
$\ast$ Le contenu de $V1$ est plus petit (resp plus grand) que celui de $V2$ : $\boxed{V1 \,<=\,V2}$ (resp $\boxed{V1 \,>=\, V2}$ )
$\ast$ Le contenu de $V1$ est strictement plus petit (resp plus grand) que celui de $V2$ : $\boxed{V1 \, <\, V2}$ (resp $\boxed{V1 \,>\, V2}$ )

$\bullet$ Utiliser deux conditions :
$\ast$ Condition1 $\boxed{ and }$ Condition2 : vraie si les deux conditions sont vraies
$\ast$ Condition1 $\boxed{ or}$ Condition2 : vraie lorsque l’une au moins est vraie

$\bullet$ Négation d’une condition
$\boxed{not}$ (condition) qui est vraie (resp. Fausse) lorsque condition est fausse (resp. vraie)

COURS DE MATHS

Nous avons recruté pour vous les meilleurs professeurs particuliers de maths

S'EXERCER ET APPRENDRE

Avis Google France ★★★★★ 4,8 sur 5

2. Définir une fonction en algorithmique en Terminale

2.1. Syntaxe :

def NomDeLaFonction (parametres) :
$\vert\qquad \vert$ Instruction 1
$\vert\qquad \vert$
$\vert\qquad \vert$ Derniere Instruction
$\vert\qquad \vert$ return (… , … , … )

Il peut y avoir 0, 1 ou plusieurs paramètres.
Le « return » final renvoie les résultats de la fonction s’il y en a et rien s’il est seul.
Il est possible quand il y a des tests avec des conditions s’excluant mutuellement d’écrire plusieurs « return » dans la même fonction.

Il est indispensable de respecter l’indentation.

On appelle la fonction par
NomDeLaFonction (….) en introduisant les paramètres dans l’ordre de définition.

2.2. Que font ces fonctions en algorithmique ?

Exemple :
Les paramètres $a$ et $b$ sont réels

def f(a , b) :
$\vert\qquad \vert$ a = a + b
$\vert\qquad \vert$ b = a – b
$\vert\qquad \vert$ a = a – b
$\vert\qquad \vert$ return (a , b)

Qu’obtient- on en appelant f(28 , 5 ) ?

Réponse de l’exemple :
(5,28)

$\begin{matrix} \textrm{ } &\vert & a&\vert & b \\ \textrm{------------}&\vert &\textrm{--}&\vert &\textrm{--} \\ \textrm{entré e} &\vert & 28&\vert & 5 \\\textrm{a = a} +\textrm{ b}&\vert & 33&\vert & 5\\ \textrm {b = a }- \textrm{b}&\vert & 33&\vert &28\\ \textrm{a = a}-\textrm{ b}&\vert & 5&\vert &28\\ \textrm{sortie}&\vert &5&\vert &28 \end{matrix}$

Plus généralement, si $a$ contient $x$ et $b$ contient $y$
$\ast$ après la première instruction,
$a$ contient $x + y$ et $b$ contient $y$
$\ast$ après la deuxième instruction,
$a$ contient $x + y$
et $b$ contient $x + y - y = x$
$\ast$ après la troisième instruction,
$a$ contient $x + y - x = y$ et $b$ contient $x$

La fonction a échangé les contenus des variables $a$ et $b$ .

2.3. Utiliser le package maths en algorithmique

Il faut importer le package math

import math

Il permet d’obtenir :
$\bullet$ une valeur approchée de $\pi$ : math.pi
$\bullet$ et si $x$ est une variable réelle
$\ast$ $\sqrt{x}$ : math.sqrt{x}
$\ast$ $\textrm{e} ^x$ : math. exp (x)
$\ast$ $\sin(x)$ : math.sin(x)
$\ast$ $\cos(x)$ : math.cos(x)
$\ast$ $\vert x \vert$ : math.fabs(x)
$\ast$ $\ln(x)$ : math.log(x)
$\ast$ la partie entière de $x$ : math.trunc(x) (c’est un entier)

3. Test conditionnel pour les algorithmes en Terminale

Respecter l’indentation dans toutes les rédactions suivantes :

$\bullet$ Si Condition alors …
Syntaxe :
if Condition :
$\vert\qquad \vert$ Instruction1
$\vert\qquad \vert$
$\vert\qquad \vert$ Instruction finale

$\bullet$ Si Condition alors … sinon …
Syntaxe :
if Condition :
$\vert\qquad \vert$ Instruction1
$\vert\qquad \vert$
$\vert\qquad \vert$ Instruction finale
else
$\vert\qquad \vert$ Autre Instruction1
$\vert\qquad \vert$
$\vert\qquad \vert$ Autre Instruction finale

$\bullet$ if … elif …. else …
Syntaxe
if Condition1 :
$\vert\qquad \vert$ Series d’Instruction1
elif Condition 2 :
$\vert\qquad \vert$ Serie d’Instruction2
elif Condition 3 :
$\vert\qquad \vert$ ….
else :
$\vert\qquad \vert$ série d’instructions finales.

Exemple :
Que fait la fonction suivante si $a$ et $b$ sont des variables réelles ?

def Mystere (a , b):
$\vert\qquad \vert$ c $=$ b
$\vert \qquad \vert$ if a $>$ b :
$\vert\qquad\vert \qquad \vert$ c $=$ a
$\vert\qquad \vert$ return c

Réponse de l’exemple :

Elle renvoie le maximum des contenus des variables $a$ et $b$ .
En effet la valeur provisoire de $c$ est celle de $b$ .
Si la variable $a$ a une valeur supérieure à celle de $b$ , on place la valeur de $a$ dans $c$ .
A l’issue de la manipulation, $c$ contient le maximum des variables $a$ et $b$ .

4. Boucles pour les algorithmes en Terminale

4.1. Boucles for en algorithmique en Terminale

Syntaxe Si $a < b$ sont entiers, on effectue la suite d’instructions pour les valeurs $k =a$ à la valeur $k = b - 1$

for k in range (a , b) :
$\vert\qquad \vert$ Instruction1
$\vert\qquad \vert$
$\vert\qquad \vert$ Instruction finale
$\dots$

range (b) = range(0 , b)

Exemple :
$n$ étant une variable entière et $a$ une variable réelle, quel est le résultat de cette fonction ?

def f (n , a) :
$\vert\qquad \vert$ x = 1
$\vert\qquad \vert$ for k in range (n):
$\qquad \vert \qquad \vert \qquad \vert$ x = a * x
$\vert\qquad \vert$ return x

Réponse de l’exemple :
La fonction multiplie l’entier 1 , $n$ fois (pour $0 \leqslant k \leqsln n - 1$ par $a$ : on obtient $a ^n$ .

4.2. Boucles while en algorithmique en Terminale

Syntaxe
while condition do :
$\vert\qquad \vert$ Instruction1
$\vert\qquad \vert$
$\vert\qquad \vert$ Instruction finale
$\cdots$

Exemple :
Que fait la fonction suivante :

def f(A) :
$\vert\qquad \vert$ S $=$ 0
$\vert\qquad \vert$ n $=$ 0
$\vert\qquad \vert$ while S $<=$ A :
$\qquad \vert \qquad\vert \qquad\vert$ n $=$ n $+ 1$
$\qquad \vert \qquad\vert \qquad\vert$ S $=$ S $+$ 1/n
$\vert\qquad \vert$ return n

Réponse de l’exemple :
La fonction f calcule les valeurs successives de $S_n = \displaystyle 1 + \frac 1 2 + \cdots + \frac 1 n$ et détermine le plus petit entier $N$ tel que $S_N > A$ . Vous verrez certainement cette somme dans le cours sur les suites en terminale.
Attention à ne pas utiliser un nombre $A$ trop grand

f(10) renvoie 12 367
f(20) met assez longtemps à renvoyer 27 2400 600

4.3. Comment choisir entre une boucle for et une boucle while ?

On sait le nombre d’itérations à faire : en général une boucle for est plus simple
On ne sait pas le nombre d’itérations à faire : il faut utiliser une boule while.
Une boucle for peut toujours être remplacée par une boucle while.

PROF DE MATHS PARTICULIER

Des cours de qualité et enseignants aguerris

Préparer des concours ou s'exercer

Avis Google France ★★★★★ 4,9 sur 5

5. Manipulations de listes en algorithmique

C’est une variable Python dans laquelle on peut mettre plusieurs variables
par exemple [2,5,3.14, 1.414 , python, 3] est une liste

5.1. Définir une liste pour des algorithmes en Terminale

$\bullet$ On peut créer une liste vide
liste = [] ou par la donnée des premiers éléments
liste = [1 , 2 , 3] et ajouter le contenu de la variable V à la fin
liste.append(V)
(cela peut être fait avec une boucle)

$\bullet$ liste en compréhension :
liste = [expression de f , for k in range (debut, fin)]

5.2. Manipuler une liste en algorithmique

$\ast$ liste [0] est le premier terme de la liste
$\ast$ $liste [k]$ est le $k + 1$ ème terme
$\ast$ $liste[ - 1]$ est le dernier terme
$\ast$ len(liste) donne le nombre de termes de liste

5.3. Représenter un ensemble de points pour les algorithmes en Terminale

Il faut importer un package :

import matplotlib.pyplot as pl

$\bullet$ Pour représenter les points $(x_i , y_i) _{0 \leqslant i \leqslant n - 1}$
$\ast$ Former
a) la liste des abscisses
$Lx = [x_0 \, , x_1\, , \cdots \, , x_{n - 1}]$
b) la liste des ordonnées
$Ly = [y_0\, , y_1\, , \cdots \, , y_{n - 1}]$

$\ast$ demander
pl.scatter(Lx , Ly)
on peut choisir la couleur avec par exemple
pl.scatter(Lx , Ly , color = ‘red’)

$\bullet$ Cela peut être plus simple pour les points $(k , u_k) _{0\leqslant k \leqslant n}$
$\ast$ Introduire la liste
Suite $= [u_0\,,\, \cdots \,,\, u_n]$
$\ast$ demander (pour des points en rouge)
pl.plot (Suite , ‘r.’)

6. Représenter une fonction en algorithmique en Terminale

Je ne donne pas les fonctions les plus efficaces mais simplement un minimum de compléments qui permettent de tracer des courbes, en restant au plus proche du programme de terminale.

Si vous voulez tracer des courbes représentative, il est indispensable de charger le package matplotlibpyplot grâce à l’instruction
import matplotlib.pyplot as plt

Explication du principe
$\bullet$ : on ne peut tracer que la restriction d’une courbe à un segment
$\bullet$ : on définit avant la fonction $f$ que que l’on veut tracer par
def : f(x) : etc…
$\bullet$ : on décide l’intervalle $[a, b]$ sur lequel on veut représenter la fonction $f$ et le nombre de points $n$ qui vont servir à tracer cette fonction. (prendre $n$ au moins égal à 5000.
$\bullet$ : on définit deux listes de points : la liste des abscisse (abs) et la liste des ordonnées (ord).
Pour cela dans $abs$ on place la liste des $\displaystyle a \frac {k (b - a)} n$ et dans $ord$ la liste des images âr $f$ de ces points.
La courbe sera remplacée par des segments joignant le point $\displaystyle M_k \left ( a + \frac {k(b - a)} n , \, f\left (a + \frac {k (b - a)} n \right ) \right )$ au suivant .
(plus le nombre de points est grand, meilleur est le rendu).
et c’est l’appel à plt.plot(abs, ord) qui trace la courbe.

Cas où la fonction $f$ admet une limite infinie en un ou plusieurs points de $[a , b]$ . N’hésitez pas revoir le cours sur les limites en terminale.
Il faut imposer en plus la fenêtre de représentation.
Pour les $x$ , on le fait avec plt.xlim(a, b) (ce qui est logique)
Pour les $y$ , j’ai arbitrairement mis plt.ylim(-5 , 5) : vous pourrez éventuellement modifier cette place de valeur de $y$ dans la deuxième fonction.

6.1. Représenter une fonction sans point de discontinuité

Définir avant une fonction $f$

import matplotlib.pyplot as plt

def graphe(f,a,b, n):
$\qquad \vert$ abs = [] $\qquad \vert$ ord =[] $\qquad \vert$ pas = (b – a) /n
$\qquad \vert$ x = a
$\qquad \vert$ for k in range (n + 1) :
$\qquad \vert \qquad \vert$ abs.append(x)
$\qquad \vert \qquad \vert$ ord.append (f(x))
$\qquad \vert \qquad \vert$ x = x + pas
$\qquad \vert$ plt.plot(abs,ord)
$\qquad \vert$ return

Fermer la fenêtre graphique avant de relancer

N’hésitez pas à revoir le cours sur la continuité en terminale avant de vous attaquer à ce type d’algorithme.

6.2. Représenter une fonction avec au moins un point de discontinuité

Cas d’une fonction admettant des asymptotes verticales (elles seront automatiquement tracées , lorsque les limites à droite et à gauche sont de signe contraire)

Définir avant une fonction $f$

import matplotlib.pyplot as plt

def graphe(f,a,b, ymin, ymax , n):
$\qquad \vert$ abs = [] $\qquad \vert$ ord =[] $\qquad \vert$ pas = (b – a) /n
$\qquad \vert$ x = a
$\qquad \vert$ for k in range (n + 1) :
$\qquad \vert \qquad \vert$ abs.append(x)
$\qquad \vert \qquad \vert$ ord.append (f(x))
$\qquad \vert \qquad \vert$ x = x + pas
$\qquad \vert$ plt.xlim(a,b)
$\qquad \vert$ plt.ylim(ymin,ymax)
$\qquad \vert$ plt.plot(abs,ord)
$\qquad \vert$ return

Fermer la fenêtre graphique avant de relancer

ajustez au mieux les valeurs ymin et ymax à la vue du graphique.
Vous pouvez commencer avec ymin = – 10 et ymax = 10

AVOIR LES MEILLEURS PROFS DE MATHS

C'est gagner en autonomie

Pour des révisions complètes sur l’ensemble des chapitres de maths en Terminale, entraînez-vous également sur les annales de maths au bac. Pour les élèves qui souhaitent être accompagnés dans leurs révisions et leur préparation au bac, il est aussi possible de suivre des cours particuliers de maths à domicile. Entre les différentes sessions de cours particuliers, les élèves de Terminale peuvent aussi revoir et se tester sur les chapitres de maths en ligne de Terminale, comme par exemple :

Cours sur les algorithmes au programme de Maths en Terminale

1. Affectation, égalités, inégalités en algorithmique en Terminale

COURS DE MATHS

Nous avons recruté pour vous les meilleurs professeurs particuliers de maths

S'EXERCER ET APPRENDRE

2. Définir une fonction en algorithmique en Terminale

2.1. Syntaxe :

2.2. Que font ces fonctions en algorithmique ?

2.3. Utiliser le package maths en algorithmique

3. Test conditionnel pour les algorithmes en Terminale

4. Boucles pour les algorithmes en Terminale

4.1. Boucles for en algorithmique en Terminale

4.2. Boucles while en algorithmique en Terminale

4.3. Comment choisir entre une boucle for et une boucle while ?

PROF DE MATHS PARTICULIER

Des cours de qualité et enseignants aguerris

Préparer des concours ou s'exercer

5. Manipulations de listes en algorithmique

5.1. Définir une liste pour des algorithmes en Terminale

5.2. Manipuler une liste en algorithmique

5.3. Représenter un ensemble de points pour les algorithmes en Terminale

6. Représenter une fonction en algorithmique en Terminale

6.1. Représenter une fonction sans point de discontinuité

6.2. Représenter une fonction avec au moins un point de discontinuité

AVOIR LES MEILLEURS PROFS DE MATHS

C'est gagner en autonomie

Contact

Qui sommes-nous ?

Nous rejoindre

Copyright @ GROUPE REUSSITE - Mentions légales