Javascript et Programmation

Table des matières

I programmer en javascript 5

1 généralités sur javascript 7

1.1 principe général . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.2 Les références internationales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3 Pour tester le code source et voir le résultat en ligne . . . . . . . . . . . . . . . . . . 10
1.4 écrire et lire un document en javascript . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.5 quelles sont les règles d’écriture d’un programme en javascript ? . . . . . . . . . . . . 12
1.5.1 balise de début et de fin de programme . . . . . . . . . . . . . . . . . . . . . . . 13
1.5.2 symbole de commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.5.3 séparateur d’instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
1.5.4 entrée des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.5.5 sortie des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.6 traitement des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.6.1 différents types de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.6.2 calcul avec des nombres et fonctions mathématiques . . . . . . . . . . . . . . . 20
1.6.3 variables et affectations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.6.4 instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.6.5 boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
1.6.6 opérateurs logiques et égalité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
1.6.7 fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
1.7 exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
1.7.1 entrées sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
1.7.2 instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
1.7.3 boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

II applications Mathématiques 43

2 fonctions affines 45
2.1 image d’un nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.2 placer des points dans un repère . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.3 trouver la formule d’une fonction connaissant deux nombres et leurs images . . . . . 53
2.4 signe de la fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
2.5 résolution d’équation ou d’inéquations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

3 géométrie analytique dans le plan 57

3.1 distance entre deux points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
3.2 coordonnées du milieu d’un segment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

4 statistiques 61
4.1 angle diagramme circulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.2 hauteur histogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
4.3 moyenne sans coefficients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.4 moyenne avec coefficients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
4.5 écart type sans coefficients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.6 écart type avec coefficients . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

3
5 fonctions généralités 69
5.1 image d’un nombre et tableau de valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . 70
5.2 construction de points d’une courbe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.3 recherche d’extremum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.4 recherche de valeur d’annulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.5 recherche de solutions d’équations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
 Première partie

programmer en javascript

5
Chapitre 1

généralités sur javascript

7
1.1 principe général
Un ordinateur contient un fichier de nom "ma_page_web.html "
(avec l’extension .html obligatoirement)

Fichier dans le PC

ma_page_web.html

Dans ce fichier est écrit du "code source" dans le langage "javascript "
( ce fichier est ouvert en écriture et édité avec un simple éditeur de texte comme "Block-
notes" sous window ou "gedit" sous linux)

ouvert en écriture avec Block-notes

ma_page_web.html

Affiche le
Code source javascript
de ma page Web

Un "navigateur web" (firefox par exemple) peut ouvrir ce fichier en lecture,

il interprète le code source et affiche alors la page web correspondante
ouvert en lecture avec Firefox
ma_page_web.html

Affiche le
Contenu interprété
de ma page Web

Bilan :
✞ ☎
Il suffit d’apprendre à écrire un fichier en javascript
✝ ✆
✞ ☎
pour obtenir une page Web qui éxécute le programme
✝ ✆
1.2 Les références internationales
http://www.w3schools.com/
1.3 Pour tester le code source et voir le résultat en ligne
http://www.cssdesk.com/
http://site.math.free.fr/site_2010/pre_envoi_programme_js.php
1.4 écrire et lire un document en javascript
Règle 1 : (où écrire le programme en javascript ?)
On écrit usuellement le programme en javascript dans un fichier informatique,
avec un simple éditeur de texte et on le nomme avec une extension .htm
afin qu’il puisse être interprété par un navigateur internet (firefox, ...)

♦ par exemple : mon_programme.htm

 remarque : un traitement de texte (comme Word ) ne convient pas, il suffit d’un éditeur de
texte (comme Bloc-notes)
⋆ essayez :
créer un document vierge avec un éditeur et le sauver sous le nom mon_programme.htm
sur le bureau, double-cliquer sur l’icône correspondant au programme apparue sur le bureau
le navigateur (Firefox par exemple) affiche alors une page blanche
1.5 quelles sont les règles d’écriture d’un programme en javascript ?
1.5.1 balise de début et de fin de programme
Règle 2 : (balise de début et de fin de programme)
le programme commence par la balise : <script>
il se termine par la balise : </script>

<script>

</script>
⋆ essayez : recopier ces deux lignes dans l’éditeur de texte puis sauvegarder,
relancer la page ouverte par le navigateur avec la touche F5 ( il ne se passe rien )
1.5.2 symbole de commentaires
Règle 3 : (symbole de commentaires)
Il est conseillé de commenter certaines étapes du programme pour plus de clarté.
Les commentaires sur une ligne sont toujours précédés de // (double slash)
Les commentaires sur plusieurs lignes commencent par /* et finissent par */
<script>
// ceci est un commentaire sur une ligne
/* ceci est un commentaire
sur deux lignes */
</script>
⋆ essayez : recopier les nouvelles lignes dans l’éditeur puis sauvegarder, relancer la page ouverte
par le navigateur avec la touche F5 ( il ne se passe toujours rien )
1.5.3 séparateur d’instructions
Règle 4 : (séparateur)
les instructions du programme sont séparées d’un point virgule ( ; )
et on passe (non obligatoirement) à la ligne entre chaque instruction
<script>
instruction 1 ;
instruction 2 ;
...
</script>
remarque : il n’est pas obligatoire de passer à la ligne entre chaque instruction, mais, il vaut
mieux le faire par soucis de clarté ( "indenter" un programme le rend encore plus clair )
1.5.4 entrée des données
Il est possible d’utiliser les mémoires d’un ordinateur pour y stocker des données (comme un
buffet dans lequel on range des affaires). Voici comment, en javascript, on demande à l’utilisateur
ce qu’il veut mémoriser
Règle 5 : (entrées)
pour demander à l’utilisateur d’entrer une donnée on utilise la méthode prompt()
Il s’affiche sur l’écran de l’utilisateur une fenêtre qui l’invite à entrer une donnée
<script>
x = prompt() ; // affecte à la variable x la valeur entrée par l’utilisateur
x = prompt("x= ") ; // idem avec le message "x= " dans la fenêtre d’invite
</script>
 remarques : le message "x= " est écrit entre guillemets
la valeur entrée par l’utilisateur peut-être un nombre, une chaine de caractères, ... (vu plus
loin)
⋆ essayez : obtenez ces lignes dans l’éditeur, sauvegardez puis relancer la page du navigateur
(F5), entrer une "valeur", puis validez.

⇒ il existe maintenant, dans la mémoire de l’ordinateur, une "case mémoire" appelée "x" qui
contient la valeur entrée
1.5.5 sortie des données
Pour afficher à l’écran, le contenu d’une "case mémoire", ou/et un message, on procède ainsi :
Règle 6 : (sortie dans une fenêtre)
pour afficher à l’utilisateur une donnée on peut utiliser la méthode alert().
Il s’affiche sur l’écran une fenêtre qui indique ce qui est précisé entre parenthèses
<script>
alert(x) ; // la valeur de x s’affiche dans une fenêtre
alert("x= " + x) ; // idem avec le message : "x=" suivi de la valeur de x
</script>
 remarque :
on utilise des guillemets pour le message et le symbole + pour "mettre au bout" (concaté-
ner) la valeur de x

⋆ essayez :
<script>
x = prompt("veuillez entrer une donnée : ") ;
alert("vous avez entré la donnée : " + x) ;
</script>
obtenez ces lignes dans l’éditeur, sauvegardez puis relancer la page du navigateur (F5)

Règle 7 : (sortie dans une page)

pour afficher à l’utilisateur une donnée on peut utiliser la méthode document.write()
la donnée est affichée directement dans "la page web"
<script>
document.write(x) ; // la valeur de x s’affiche dans la page web
document.write("x= " + x) ; // idem avec le message : "x=" suivi de la valeur de x
</script>
⋆ essayez :
<script>
x = prompt("veuillez entrer une donnée ") ;
document.write("vous avez entré la donnée suivante : " + x) ;
</script>
obtenez ces lignes dans l’éditeur, sauvegardez puis relancer la page du navigateur (F5)
1.6 traitement des données
L’utilité d’un programme est d’obtenir automatiquement des résultats (ceux qui nous inté-
ressent) à partir de données entrées
Il faut en général traiter les données entrées pour obtenir en sortie le résultat attendu

Entrées ⇒ Traitement des données ⇒ Sorties

1.6.1 différents types de données
On considérera essentiellement les types de données suivants :


 "nombres réels" : 3, 3.14, 0.0008, ...
"chaines de caractères" : "coucou", "x=", ...

sur lesquels on effectuera des "opérations"

 "booléens" : true, false
"tableaux" : [1,2,3,4], ["un","coucou","x="], ...

1.6.2 calcul avec des nombres et fonctions mathématiques
Règle 8 : (calculs)
on utilise le point pour la virgule : 3.14 à la place de 3,14
on utilise * pour la multiplication : 3*4 donne 12
javascript respecte l’ordre des opérations et les parenthèses : 3+2*(5+1) donne 15

⋆ essayez :
obtenez les lignes suivantes dans l’éditeur, sauvegardez, relancer la page du navigateur (F5)
<script>
alert(3*4) ;
alert(10 + 2*(5+1)) ;
alert(1/3) ;
alert(3*0.3) ;
</script>
 Remarque :
dans certain cas, javascript donne un résultat approché, comme pour :
3*0.3 = 0.9 qui n’est pa égal à 0.8999999999999999
soit une erreur "infime" de 0.0000000000000001 = 10−16
(il y a moyen de palier à ce manque en utilisant des arrondis vus plus tard )

Il est aussi possible d’utiliser des fonction mathématiques pré-définies dont voici une liste ( non
exhaustive)

Règle 9 : (fonctions Mathématiques)

cosinus Math.cos()
sinus Math.sin()
tangente Math.tan()
xy Math.pow(x,y)
nombre aléatoire dans [0; 1] Math.random()

⋆ essayez :
obtenez les lignes suivantes dans l’éditeur, sauvegardez, relancer la page du navigateur (F5)
<script>
alert(Math.cos(3.14)) ;
alert(Math.sin(3.14)) ;
alert(Math.tan(3.14)) ;
alert(Math.pow(2,3)) ;
alert(Math.random()) ;
</script>
 Remarque : Quand les variables sont des chaines de caractère ( "bon" et "jour" ) , javascript
utilise le symbole + pour concaténer les deux chaines de caractère
"bon"+"jour" donnera "bonjour"
"1"+"2" donnera "12"
1+2 donnera 3
"bon"+ 2 donnera "bon2" car le 2 sera interprété comme "2" à cause du "bon"

Il faudra parfois tenir compte de cette interprétation de javascript surtout lors d’entrées
de données avec la méthode prompt(), en effet, prompt() interprète les données comme des
chaines de caractères et non comme des nombres. (voir ci dessous)
1.6.3 variables et affectations
variables simples

les données entrées puis traitées sont stockées dans des "cases mémoire" de l’ordinateur.
On peut nommer ces cases mémoire pour y "stocker" ou y "récupérer" des données.
Par exemple, on déclare la variable "longueur" en faisant précéder son nom du mot clé "var"
puis on peut stocker la valeur 10 dans la mémoire "longueur" en écrivant tout simplement : lon-
gueur=10 ;
On dit que l’on a affecté à la variable "longueur" la valeur 10

⋆ essayez :
obtenez les lignes suivantes dans l’éditeur, sauvegardez, relancer la page du navigateur (F5)
<script>
var longueur ;
longueur = 10 ;
alert(longueur) ;
</script>
puis
<script>
var longueur ;
longueur = prompt("quelle est la longueur ? ") ;
alert(longueur) ;
</script>
puis
<script>
var longueur ;
var largeur ;
var aire_rectangle ;
longueur = prompt("quelle est la longueur ? ") ;
largeur = prompt("quelle est la largeur ? ") ;
aire_rectangle = longueur*largeur ;
alert("l’aire vaut : " + aire_rectangle) ;
</script>
On peut ainsi "dialoguer" avec l’ordinateur et lui faire effectuer des calculs à notre place.

⋆⋆ le javascript est "orienté" web, ainsi, toute valeur entrée avec la méthode alert() sera consi-
dérée comme une chaine de caractère, ce qui a une incidence si on fait une seule addition,
essayez par exemple :
<script>
var longueur ;
var largeur ;
var somme ;
longueur = prompt("quelle est la longueur ? ") ;
largeur = prompt("quelle est la largeur ? ") ;
somme = longueur+largeur ;
alert(" ceci n’est pas la somme : " + somme) ;
</script>
le résultat n’est pas la somme des deux valeurs entrées mais la "concaténation" des deux
chaines entrées : 10 + 2 = 12 mais "10" + "2" = "102"
car les entrées 10 et 2 sont vues comme des chaines de caractères et non comme des nombres
si vous entrez fifi puis riri qu’obtiendrez vous en sortie ?

pour transformer les chaines de caractères entrées en nombres, il suffit d’utiliser la méthode
Number()

⋆⋆ essayez :
 <script>
var longueur ;
var largeur ;
var somme ;
longueur = prompt("quelle est la longueur ? ") ;
longueur = Number(longueur) ; // pour transformer la chaine en un nombre
largeur = prompt("quelle est la largeur ? ") ;
largeur = Number(largeur) ; // pour transformer la chaine en un nombre
somme = longueur+largeur ;
alert(" ceci est la somme : " + somme) ;
</script>
 Remarque : on ne traite ainsi que les valeurs entrées avec la méthode prompt()

Il est utile de donner un nom "explicite" aux variables, il est ainsi plus facile de corriger le
programme en cas d’erreur (longueur est plus explicite que lgr )
cependant,
tous les noms de variables ne sont pas acceptés, par exemple "alert", prompt", ... sont des "mots
réservés"
un nom de variable commencera toujours par une lettre, et ne contiendra que des chiffres ou des
lettres avec éventuellement le symbole _ (tiret du bas) pour remplacer les espaces qui ne sont pas
acceptés non plus.

Règle 10 : (variables et affectation)

(1) toute donnée entrée avec la méthode prompt() est vue comme une chaine de caractère,
si on veut calculer avec, on la transforme en un nombre avec la méthode Number()
(2) pour déclarer une variable, on utilise le mot clé "var" suivi du nom de la variable
(3) le nom de la variable commence par une lettre, ne contient que des chiffres ou des lettres
et pas d’espaces (remplacés par le tiret _)
(4) pour affecter la variable ma_variable de la valeur ma_valeur, il suffit d’écrire :
ma_variable = ma_valeur ;

⋆ essayez :
obtenez un programme où l’on rentre la longueur, la largeur et la hauteur d’un pavé droit
et qui donne en sortie le volume de ce pavé ( rappel : V = l × L × h)
<script>

à vous

</script>
tableau
Il est parfois nécessaire de stocker un certain nombre (inconnu) de valeurs, il faudrait donc
déclarer un nombre inconnu de variables.
Pour se faire, l’utilisation d’un tableau rend la chose aisée.

voici une schématisation de la variable de type tableau pour la variable de nom, mon_tableau :
rang 0 1 2 3
contenu "coucou" 32.46 "chien"
accès au contenu mon_tableau[0] mon_tableau[1] mon_tableau[2] mon_tableau[3]

pour le tableau ci dessus :

il a pour nom : mon_tableau
il a pour longueur : 4 (car il a 4 "cases")
il contient dans sa première case la valeur : "coucou" ( chaine de caractères)
sa deuxième case contient la valeur : 32.46
sa troisième case est vide
on écrit, mon_tableau[0], pour accéder au contenu de la première case, ...
✞ ☎ ✞
1. comment déclarer un tableau ? : var mon_tableau = new Array() ou bien var mon_tableau = [
✝ ✆ ✝
on ajoute "= new Array()" ou bien "= [ ]" au nom choisi pour le tableau
pour signaler que cette variables est de type tableau

2. comment entrer des valeurs dans un tableau ? :

mon_tableau[0] = "homme" (ceci met "homme" dans la première case du tableau)

mon_tableau[1] = "femme" (ceci met "femme" dans la seconde case du tableau)
mon_tableau[2] = 20,42 (ceci met 20,42 dans la troisième case du tableau)
...
3. comment accéder aux valeurs stockées dans les cases du tableau ?

alert(mon_tableau[0])
(ceci affichera dans une boite de dialogue, ce que contient la première case du tableau)

document.write(mon_tableau[1])
(ceci écrira dans une page web ce que contient la seconde case du tableau)

x = mon_tableau[2]
(ceci affectera à la variable de nom x la valeur contenue dans la troisième case du tableau)

⋆ essayez :
voici comment stocker un certain nombre de valeurs dans un tableau
<script>
var mon_tableau = [ ] ;
mon_tableau[0] = prompt("première donnée à stocker ? :" ) ;
mon_tableau[1] = prompt("deuxième donnée à stocker ? :" ) ;
mon_tableau[2] = prompt("troisième donnée à stocker ? :" ) ;
alert("voici les données mémorisées") ;
alert(mon_tableau[0]) ;
alert(mon_tableau[1]) ;
alert(mon_tableau[2]) ;
</script>
obtenez les lignes précédentes dans l’éditeur, sauvegardez, relancer la page du navigateur
(F5)

Règle 11 : (tableau)
 ✞ ☎
(1) on déclare un tableau comme ceci : var mon_tableau = new Array()
✞ ☎ ✝ ✆
ou bien var mon_tableau = [ ]
✝ ✆
(2) on accède au contenu de la première case par : mon_tableau[0]
on accède au contenu de la seconde case par : mon_tableau[1]
etc ...
(3) on met dans la première case du tableau la valeur "coucou" ainsi :
mon_tableau[0] = "coucou"

remarques :
la première case du tableau a pour indice 0 et non pas 1
si la dernière case du tableau a pour indice 10 alors la longueur du tableau est 11
1.6.4 instructions conditionnelles
si (condition) alors {action}
Il est parfois utilise de ne réaliser une certaine action que si une condition est réalisée ( si "il
pleut" alors "prendre le parapluie" ), on parle alors d’instruction conditionnelle
⋆⋆ essayez :
<script>
var nombre_inconnu = 10 ;
var nombre_entre ;
nombre_entre = prompt("quel est le nombre inconnu ? ") ;
if(nombre_entre > nombre_inconnu) { alert("trop grand (F5 pour rejouer)") } ;
if(nombre_entre < nombre_inconnu) { alert("trop petit (F5 pour rejouer) ") } ;
if(nombre_entre == nombre_inconnu){ alert("c’est gagné")} ;
</script>
✞ ☎
 on remarque la syntaxe : si(condition){action}
✝ ✆
avec les parenthèses () pour la condition et les accolades {} pour l’action
de plus, pour tester l’égalité on utilise == (double égal) et non pas = qui est réservé à
l’affectation
si (condition) alors {action1} sinon {action2}
on peut aussi, si besoin est, préciser l’action à effectuer si la condition n’est pas réalisée
⋆⋆ essayez :
<script>
var age_limite = 18 ;
var age_entre ;
age_entre = prompt("quel est vôtre âge ? ") ;
if(age_entre <= age_limite) { alert("bienvenue") }
else {alert("vous êtes trop âgé ") }
</script>

Règle 12 : (instruction conditionnelle)

(1) pour effectuer une l’ instruction
✞ 1 uniquement si la condition ☎ 1 est réalisée
on utilise la syntaxe suivante : si(condition){instruction 1}
✝ ✆
(2) pour effectuer une l’ instruction
✞ 1 si la condition 1 est réalisée et l’instruction 2 sinon
☎
on utilise la syntaxe suivante : si(condition 1){instruction 1 1} else {instruction 2}
✝ ✆

⋆ essayez :
obtenez un programme où l’on rentre un nombre et qui donne en sortie le signe de ce nombre
<script>

(positif strict, négatif strict, nul ) à vous

</script>
1.6.5 boucles
Il est souvent utile de répéter une instruction ou une suite d’instructions tans qu’une certaine
condition n’est pas réalisée, on utilise alors une "boucle"
il existe plusieurs variantes dont les deux principales ci dessous
boucle for
✞ ☎
La syntaxe est la suivante : for( i = a ; i <= n ; i++){instruction1}
✝ ✆
pour i allant de a jusqu’à n, répéter l’instruction 1
( i + + signifie que i augmente de 1 à chaque boucle)

⋆ essayez :
<script>
var n ;
n = prompt("veuillez entrer un nombre entier n = ") ;
for(i=0 ; i<=10 ; i++ ){ document.write(n*i + "<br>") }
</script>
le : + "<br>" est pour effectuer un passage à la ligne
( essayez de l’enlever pour constater ce qui se passe)
boucle while
✞ ☎
La syntaxe est la suivante : while(condition 1){instruction 1}
✝ ✆
Tans que la condition 1 est vérifiée, on effectue l’instruction 1
⋆ essayez :
<script>
var n ;
var resultat ;
var compteur ; // le compteur pour la boucle
compteur = 0 ; // on initialise le compteur à 0
resultat = 0 ; // on initialise le résultat à 0
n = prompt("veuillez entrer un nombre entier n = ") ;
while(resultat < 1000 )
{ resultat = n*compteur ; compteur = compteur+1 ; document.write(resultat + "<br>") }
</script>
Il ne faut pas oublier "d’incrémenter" le compteur de 1 à chaque boucle, sous peine de créer
une "boucle infinie"
Essayez de comprendre pourquoi la valeur affichée peut dépasser 1000 (avec n = 3 par
exemple)

Règle 13 : (boucles)
(1) pour effectuer une l’ instruction
✞ 1 pour i allant de a à n ☎
on utilise la syntaxe suivante : for(i = a; i <= n; i + +){instruction 1}
✝ ✆

(2) pour effectuer une l’ instruction

✞ 1 tans que la condition 1 est réalisée
☎
on utilise la syntaxe suivante : while(condition 1){ instruction 1 }
✝ ✆

(1) l’instruction 1 peut-être une suite d’instructions

(2) il faut bien vérifier que la boucle a une fin dans le cas de la boucle "while" sous peine
de créer une boucle infinie
1.6.6 opérateurs logiques et égalité
Dans le cas d’utilisation d’une instruction conditionnelle ou d’une boucle, on doit tester si une
condition est vérifiée, par exemple : if(condition){instruction} ,while(condition){instruction}
Parfois, la condition est composée de plusieurs conditions combinées avec les connecteurs
logiques : ET, OU, NON
si( (il pleut) && (il y a beaucoup de vent) ) { je prend la voiture}
si( (il grêle) || ( je suis pressé){ je prend la voiture}
si( !( j’ai le temps ) ){ je prend la voiture}
✄ ✄
Les test d’égalité ou de non égalité sont : ✂== ✁ et ✂ != ✁ :
si( nombre de cotés == 4) { afficher "quadrilatère" }
si( nombre de cotés != 4) { afficher " n’est pas un quadrilatère" }

Règle 14 : (ET, OU, NON)

✄
(1) ET se traduit en ✂&& ✁ :
(condition1 && condition2) est vraie si et seulement si les deux conditions sont vraies
(elle est fausse sinon)
c1 c2 c1&&c2
V V V
V F F
F V F
F F F
✄
(2) OU se traduit en || :
✂ ✁
(condition1 || condition2) est vraie si et seulement si au moins une des deux conditions est vrai
(elle est fausse sinon)
c1 c2 c1||c2
V V V
V F V
F V V
F F F
✄
(3) NON se traduit en ✂ ! ✁ :
!(condition1) est vraie si et seulement si condition 1 est fausse
(elle est fausse sinon)
c1 !c1
V F
F V
✄
(4) EST EGAL se traduit en ✂== ✁ :
A == B est vraie si et seulement si A et B ont la même valeur
(elle est fausse sinon)
✄
(5) EST DIFFERENT se traduit en ✂ != ✁ :
A != B est vraie si et seulement si A et B n’ont pas la même valeur
(elle est fausse sinon)

 Remarque :
1 == 0 a pour valeur : faux
1 != 0 a pour valeur : vrai
("titi" == "toto" || 0 == 0) a pour valeur : vrai
⋆ essayez :
<script>
var age ;
age = prompt("veuillez entrer votre âge ") ;
if( (age < 10) || (age > 80) ){ alert(" trop jeune ou trop âgé" )} ;
if( (age > 10) && (age < 15) ){ alert(" plus que trois ans à attendre " )} ;
if( age == 18){ alert(" c’est juste limite " )} ;
if( (age >= 18 ) && ( age <= 80) ){ alert(" accepté " )} ;
if( !(age < 80) ){ alert(" trop âgé " )} ;
</script>
1.6.7 fonction
Il est possible de définir une fonction (un sous programme) que l’on peut appeler autant de fois
que l’on veut sans avoir à ré-écrire les lignes de commandes correspondantes

⋆ essayez :
<script>
//début de la déclaration de la fonction
function ma_fonction_affine(a,b,x)
{
var image ;
image = Number(a)*Number(x)+Number(b) ;
document.write(" l’image de " + x + " est " + image + "<br>") ;
};
//fin de la déclaration de la fonction
var a = prompt(" valeur de a ? ") ;
var b = prompt(" valeur de b ? ") ;
var x = prompt(" valeur de x ? ") ;
ma_fonction_affine(a,b,0) ;
ma_fonction_affine(a,b,1) ;
ma_fonction_affine(a,b,x) ;
</script>

Règle 15 : (fonction)
(1) on déclare une fonction avec le mot clé "function",
suivi du nom de la fonction,
suivi des paramètres entre parenthèses séparés d’une virgule (s’il y en a),
suivi
✞ entre accolades, des lignes d’instructions de la fonction. ☎
function ma_fonction( paramètre1, paramètre2, ...) { instructions }
✝ ✆

(2) on appelle la fonction où l’on veut dans le programme en remplaçant les paramètres
par les valeur désirées
1.7 exercices
1.7.1 entrées sorties
exercice 1 : ( entrées, sorties avec les méthodes prompt() et alert() )

1. sauvegarder sur le bureau, le programme suivant, dans un fichier appelé : entree_sortie_1.htm

<script>
//déclaration des variables
var nom ;
var prenom ;
var age ;
// entrées
prenom = prompt(" quel est votre prenom ? ") ;
age = prompt("quel est votre age ? ") ;
//sorties
alert("bonjour " + prenom) ;
alert(age + " ans, c’est jeune !") ;
</script>
2. lancer le programme en cliquant sur l’icône apparue sur le bureau
3. compléter
(a) la balise <script> sert à délimiter le ... du programme
la balise </script> la ... du programme
(b) les // servent à indiquer que ce qui est sur la même ... est un ... non pris en
compte par l’ordinateur
(c) le mot clé var sert à déclarer une ... dont le ... suit
(d) pour plus de clarté, on déclare une instruction par ligne séparées d’un ...
(e) pour demander à l’utilisateur d’entrer une valeur dans la variable prenom, on écrit :

(f ) pour afficher une fenêtre dans laquelle apparaîtra un message disant bonjour suivi du
prénom entré on écrit :

(g) quand on veut écrire du texte dans un message on met le texte entre ...

(h) quand on veut mettre bout à bout (concaténer) du texte et une valeur contenu dans
une variable on utilise le symbole ... qui ne correspond pas içi à une ...
(i) modifier le programme ci dessus pour qu’il demande aussi le nom, le numéro de télé-
phone, la date de naissance et l’activité favorite et qu’il affiche dans une seule fenêtre
un message contenant toutes les information entrées ( bonjour ..., vous avez ... ,vous
êtes né le ...,votre téléphone est..., vous aimez ... )
exercice 2 : ( entrées, sorties avec les méthodes prompt() et document.write() )

1. sauvegarder sur le bureau, le programme suivant, dans un fichier appelé : entree_sortie_2.htm

<script>
//déclaration des variables
var nom ;
var prenom ;
var age ;
// entrées
prenom = prompt(" quel est votre prenom ? ") ;
age = prompt("quel est votre age ? ") ;
//sorties
document.write("bonjour " + prenom + "<br>") ;
document.write(age + " ans, c’est jeune !") ;
</script>
2. lancer le programme en cliquant sur l’icône apparue sur le bureau
3. compléter
(a) pour afficher dans la page web, un message disant bonjour suivi du prénom entré on
écrit :

(b) pour passer à la ligne à la fin du message on "ajoute" à la fin du message : ...

(c) quelle est la différence essentielle entre les méthodes alert() et document.write() ?
(d) modifier le programme ci dessus pour qu’il demande aussi le nom, le numéro de té-
léphone, la date de naissance et l’activité favorite et qu’il affiche dans la page un
message contenant toutes les information entrées ( bonjour ..., vous avez ... ,vous êtes
né le ...,votre téléphone est..., vous aimez ... )
exercice 3 : (alert() avec le cas de chiffres en entrée)
1. sauvegarder sur le bureau, le programme suivant, dans un fichier appelé : entree_sortie_3.htm
<script>
//déclaration des variables
var nombre_1 ;
var nombre_2 ;
var somme ;
var s = 1+2 ; // entrées
nombre_1 = prompt(" premier nombre ? ") ;
nombre_2 = prompt(" deuxième nombre ? ") ;
// traitement des données
somme = nombre_1+nombre_2 ;
//sorties
alert(nombre_1 + "+" + nombre_2 + "=" + somme ) ;
alert( "s = " + s ) ; document.write(nombre_1 + "+" + nombre_2 + "=" + somme ) ;
document.write( "s = " + s ) ;
</script>
2. lancer le programme en cliquant sur l’icône apparue sur le bureau avec les nombres 1 et
2
3. compléter
(a) le programme ne donne pas : 1 + 2 = ... mais 1 + 2 = ...
car la méthode prompt() interprétes les entrées comme des chaines de caractères et
non comme des ...
l’ordinateur procède alors à une concaténation et non pas à une ...
(b) par contre on a bien s = 1 + 2 = ... car les nombres ne sont pas entrés avec la méthod
prompt() mais sont directement dans le programme
4. il faudra penser (dans le cas où une addition est effectuée sur des nombres entrés avec
la méthode prompt) à convertir en nombres, les chaines de caractères entrées grâce à la
méthode Number() comme suit :
(a) sauvegarder et lancer le programme suivant sous le nom entree_sortie_4.htm
<script>
//déclaration des variables
var nombre_1 ;
var nombre_2 ;
// entrées
nombre_1 = Number(prompt(" premier nombre ? ")) ;
nombre_2 = Number(prompt(" deuxième nombre ? ")) ;
// traitement des données
somme = nombre_1+nombre_2 ;
//sorties
alert(nombre_1 + "+" + nombre_2 + "=" + somme ) ;
document.write(nombre_1 + "+" + nombre_2 + "=" + somme ) ;
</script>
(b) obtient-on le bon résultat ? (1+2=3) : ...
(c) dans le cas d’addition de nombre entrés avec la méthode prompt(), il faut penser à
utiliser aussi la méthode : ...
 remarque : avec les autres opérations (/,*,-, ... ) , il n’y a aucun problème
(d) écrire et sauvegarder un programme entree_sortie_5.htm qui effectue et qui affiche
la division, le produit et la différence de deux nombres entrés.
1.7.2 instructions conditionnelles
exercice 4 : ( if )
1. sauvegarder sur le bureau, le programme suivant, dans un fichier appelé : test_1.htm
<script>
//déclaration des variables
var note_finale ;
// entrées
note_finale = prompt(" la note finale est ? : ") ;
//sorties
if(note_finale == 0){alert("éliminé")} ; if(note_finale < 10 ){alert("non admis")} ;
if( note_finale == 10 ){alert("admis de justesse")} ;
if(note_finale > 10){alert("admis")} ;
</script>
2. lancer le programme en cliquant sur l’icône apparue sur le bureau
3. compléter
(a) pour tester si la note entrée est égale à 0 on n’écrit pas :
if(note_finale = 0) mais ...

(b) pour tester si la note entrée est égale à 10 on écrit :

(c) l’instruction {alert("non admis")}n’est éxécutée que si la condition

(note_finale < 10 ) est : ...
donc si la note finales est ...

(d) si on entre 0 pour note finale, que se passe t-il ? :

exercice 5 : ( if else)
1. sauvegarder sur le bureau, le programme suivant, dans un fichier appelé : test_2.htm
<script>
//déclaration des variables
var note_finale ;
// entrées
note_finale = prompt(" la note finale est ? : ") ;
//sorties
if(note_finale == 0){alert("éliminé")}
else { if(note_finale < 10 ){alert("non admis")}
else{alert("admis")}
};
</script>
2. lancer le programme en cliquant sur l’icône apparue sur le bureau
3. compléter
(a) l’instruction {alert("non admis")}n’est éxécutée que si la condition
(note_finale ==0 ) est : ... et la condition (note_finale < 10 ) est ...
donc si la note finales est ...

(b) si on entre 0 pour note finale, que se passe t-il ? :

(c) sous quelles conditions le message "admis" s’affiche t-il ?

(d) on remarque qu’un else n’est jamais précédé d’un point ...
 (e) par soucis de clarté, des lignes du programme ont été décalées vers la droite, on dit
que l’on a ... l’écriture du programme

exercice 6 :
écrire un programme qui demande un mot de passe à l’utilisateur et qui affiche "bienvenue"
si le mot de passe est correct et "erreur de mot de passe" sinon.
(penser à déclarer une variable mot_de_passe et à lui donner une valeur )
(n’oubliez pas que 6= (différent de) s’écrit != en javascript )

exercice 7 : ( conditions avec ET/OU/NON)

1. sauvegarder sur le bureau, le programme suivant, dans un fichier appelé : test_3.htm
<script>
//déclaration des variables
var presence_carnet ;
var presence_carte ;
// entrées
presence_carnet = prompt(" le carnet est-il présent ? (oui/non) : ") ;
presence_carte = prompt(" la carte est-elle présente ? (oui/non) : ") ;
//sorties
if( (presence_carnet == "oui") && (presence_carte == "oui") )
{alert("parfait ! entrez !")} ;
if( (presence_carnet == "oui") || (presence_carte == "oui") )
{alert(" c’est juste mais vous pouvez entrer !")} ;
if( (presence_carnet != "oui") && (presence_carte != "oui") )
{alert(" là c’est beaucoup, vous ne pouvez pas entrer !")}
</script>
2. lancer le programme en cliquant sur l’icône apparue sur le bureau
3. compléter
(a) Dans le Lycée en question, un élève n’entre que s’il dispose de sa carte ou de son
carnet, sinon il ne rentre pas.
vérifier que le programme ci dessus fonctionne sauf pour le cas où un élève dispose de
la carte et de son carnet auquel cas il y a eux messages
(b) modifier le programme pour qu’il fonctionne et qu’il donne un seul message à l’élève
qui est en possession de sa carte et de son carnet
1.7.3 boucles
exercice 8 : (boucle for)
1. sauvegarder sur le bureau, le programme suivant, dans un fichier appelé : boucle_1.htm
<script>
var n ;
n = prompt("veuillez entrer un nombre entier n = ") ;
for(i=0 ; i<=10 ; i++ ){ document.write(n*i + "<br>") }
</script>
2. lancer le programme avec différentes valeurs entrées
3. modifier le programme pour qu’il demande à l’utilisateur le nombre x de lignes à afficher
puis qu’il affiche le nombre de lignes en question
4. modifier le programme pour qu’il affiche un message "le nombre de lignes est trop grand"
si la valeur entrée dépasse 1000 et qu’il affiche les lignes demandées sinon
5. de même avec un message " le nombre de lignes est trop petit" s’il est inférieur ou égal
à0

exercice 9 : (boucle while)

1. sauvegarder sur le bureau, le programme suivant, dans un fichier appelé : boucle_1.htm
<script>
var n ;
var resultat ;
var compteur ; // le compteur pour la boucle
compteur = 0 ; // on initialise le compteur à 0
resultat = 0 ; // on initialise le résultat à 0
n = prompt("veuillez entrer un nombre entier n = ") ;
while(resultat < 1000 )
{ resultat = n*compteur ; compteur = compteur+1 ; document.write(resultat + "<br>") }
</script>
2. lancer le programme avec différentes valeurs entrées
3. modifier le programme pour qu’il demande à l’utilisateur le nombre x à ne pas dépasser
puis qu’il affiche le nombre de lignes en question
4. modifier le programme pour qu’il affiche au maximum 10 lignes
 Deuxième partie

applications Mathématiques

43
Chapitre 2

fonctions affines

45
2.1 image d’un nombre
exercice 1 : (image d’un nombre et tableau de valeurs)
1. soit la fonction affine f telle que f (x) = 2x − 3 pour tout x ∈ R
(a) écrire un algorithme qui donne l’image d’un nombre quelconque
(par exemple : f (10) = 2 × 10 − 3 = 17)
(b) écrire le programme correspondant en javascript et le tester
(c) écrire un algorithme (et le programme js ) qui écrit les valeurs de x et de f (x) de la
fonction précédente pour x allant de 0 à 10 avec un pas de 1
0 7−→ −3
1 7−→ −1
...
(d) modifier l’algorithme précédent pour obtenir les valeurs pour x allant de deb à f in avec
un pas de 1 où deb et f in sont deux entiers choisis par l’utilisateur
2. soit une fonction affine quelconque f telle que f (x) = ax + b pour tout x ∈ R où a et b sont
deux réels fixés quelconques.
(a) modifier l’algorithme précédent pour qu’il écrive les valeurs de x et de f (x) pour x
allant de deb à f in avec un pas de 1 où a, b, deb, f in sont choisis par l’utilisateur (deb
et f in des entiers)
(b) écrire le programme correspondant en javascript et le tester
corrigé exercice 1 : (image d’un nombre)
1. soit la fonction affine f telle que f (x) = 2x − 3 pour tout x ∈ R
(a) écrire un algorithme qui qui donne l’image d’un nombre quelconque
(par exemple : f (10) = 2 × 10 − 3 = 17)

Début
//Variables
x un nombre réel
f _de_x un nombre réel

//Entrées
Demander à l’utilisateur la valeur de x

//Initialisations

//Traitements
affecter à f _de_x la valeur 2 ∗ x − 3

//Sortie
afficher f _de_x
Fin

(b) écrire le programme correspondant en javascript et le tester

<script>

//Variables
var x ;
var f _de_x ;

//Entrées
x = prompt("x=") ;

//Initialisations
x = Number(x) ;
// (transforme la "chaine" x en un nombre)

//Traitements
f _de_x = 2 ∗ x − 3 ;

//Sortie
alert( x + " -> " +f _de_x) ;

</script>
(c) écrire un algorithme (et le programme js ) qui écrit les valeurs de x et de f (x) de la
fonction précédente pour x allant de 0 à 10 avec un pas de 1
0 7−→ −3
1 7−→ −1
...

Début
//Variables
x un nombre réel
f _de_x un nombre réel

//Entrées

//Initialisations

//Traitements et Sorties
Pour i allant de 0 jusqu’à 10
affecter à x la valeur i
affecter à f _de_x la valeur 2 ∗ x − 3
écrire x et f _de_x
FinPour
Fin
le programme en javascript

<script>
//Variables
var x ;
var f _de_x ;
var i ;

//Entrées

//Initialisation

//Traitements et Sorties
for(i=0 ; i <= 10 ; i + +)
{
x = i;
f _de_x = 2 ∗ x − 3 ;
document.write("<br>"+x+"->"+f _de_x) ;
};
</script>
(d) modifier l’algorithme précédent pour obtenir les valeurs pour x allant de deb à f in avec
un pas de 1 où deb et f in sont deux entiers choisis par l’utilisateur

Début
//Variables
x un nombre réel
f _de_x un nombre réel
deb un entier naturel
f in un entier naturel

//Entrées
Demander à l’utilisateur la valeur de deb
Demander à l’utilisateur la valeur de f in

//Initialisations

//Traitements et Sorties
Pouri allant de deb jusqu’à f in
affecter à x la valeur i
affecter à f _de_x la valeur 2 ∗ x − 3
écrire x et f _de_x
FinPour
Fin
le programme en javascript

<script>
//Variables
var x ;
var f _de_x ;
var deb ;
var f in ;

//Entrées
deb = prompt("début=") ;
f in = prompt("f in=") ;

//Initialisations
deb = Number(deb) ;
f in = Number(f in) ;

//Traitements et Sorties
for(i=deb ; i<=f in ; i++)
{
x = i;
f _de_x = 2 ∗ x − 3 ;
document.write("<br>"+x+"->"+f _de_x) ;
};
</script>
2. soit une fonction affine quelconque f telle que f (x) = ax + b pour tout x ∈ R où a et b sont
deux réels fixés quelconques.
(a) modifier l’algorithme précédent pour qu’il écrive les valeurs de x et de f (x) pour x
allant de deb à f in avec un pas de 1 où a, b, deb, f in sont choisis par l’utilisateur (deb
et f in des entiers)

Début
//Variables
a un nombre réel
b un nombre réel
x un nombre réel
f _de_x un nombre réel
deb un entier naturel
f in un entier naturel

//Entrées
Demander à l’utilisateur la valeur de a
Demander à l’utilisateur la valeur de b
Demander à l’utilisateur la valeur de deb
Demander à l’utilisateur la valeur de f in

//Initialisations

//Traitements et Sorties
Pouri allant de deb jusqu’à f in
affecter à x la valeur i
affecter à f _de_x la valeur a ∗ x + b
écrire x et f _de_x
FinPour
Fin
(b) le programme en javascript

<script>
//Variables
var a ;
var b ;
var x ;
var f _de_x ;
var deb ;
var f in ;

//Entrées
a = prompt("a=") ;
b = prompt("b=") ;
deb = prompt("début=") ;
f in = prompt("f in=") ;

//Initialisations
a = Number(a) ;
b = Number(b) ;

deb = Number(deb) ;
f in = Number(f in) ;

//Traitements et Sorties
for(i=deb ; i<=f in ; i++)
{
x = i;
f _de_x = a ∗ x + b ;
document.write("<br>"+x+"->"+f _de_x) ;
};
</script>
2.2 placer des points dans un repère
exercice 2 : (placer des points dans un repère)
on utilisera la syntaxe suivante dans ce qui suit :
⋆ pour créer un repère avec xmin , xmax , ymin et ymax pour valeurs extrêmes en x et en y on
écrira :
creer_repere(xmin, xmax , ymin , ymax )
⋆ pour ajouter un point de coordonnées (x, y) dans le repère précédent, on écrira :
ajouter_point(x,y)
1. soit la fonction affine f telle que f (x) = 2x − 3 pour tout x ∈ R
(a) écrire un algorithme qui :
crée un repère avec pour valeurs extrêmes xmin = 0, xmax = 10, ymin = −10 et ymax = 20
puis qui ajoute dans ce repère les points de la courbe de f pour x allant de 0 à 10
(b) écrire le programme correspondant en javascript et le tester
(c) modifier l’algorithme précédent pour obtenir les points pour x allant de deb à f in avec
un pas de 1 où deb et f in sont deux entiers choisis par l’utilisateur (il faudra déterminer
les valeurs extrêmes du repère)
(pour le programme javascript, penser à utiliser la méthode Number() pour formater
en nombre les chaînes de caractères entrées avec la méthode prompt() )
2. soit une fonction affine quelconque f telle que f (x) = ax + b pour tout x ∈ R où a et b sont
deux réels fixés quelconques.
(a) modifier l’algorithme précédent pour obtenir les points pour x allant de deb à f in avec
un pas de 1 où a, b, deb, f in sont choisis par l’utilisateur (deb et f in des entiers et a
positif ) (pour les plus courageux distinguer les cas où a est positif ou négatif )
(b) écrire le programme correspondant en javascript et le tester
2.3 trouver la formule d’une fonction connaissant deux nombres et leurs
images
exercice 3 : (trouver la formule d’une fonction connaissant deux nombres et leurs images)

f (2) = 5
1. soit une fonction affine f telle que :
f (5) = 11
(a) écrire un algorithme qui donne le coefficient directeur a et l’ordonnées à l’origine b de
la fonction f (le traduire en javascript et le vérifier)
(b) modifier l’ algorithme précédent pour qu’il fasse la même chose quand l’utilisateur
entre les valeurs de x1 , x2 et de y1 et y2 , leurs images respectives par f (penser au cas
où x1 = x2 )
(c) retrouver les valeurs obtenues à la première question
2.4 signe de la fonction
exercice 4 :
soit la fonction affine définie par : f (x) = −4x + 20
i. écrire un algorithme qui affiche :
la valeur d’annulation x0 de f
le signe de f (x) en fonction de va valeur de x par rapport à x0
( f (x) > 0 si x...x0 , ... )
ii. modifier l’algorithme précédent pour qu’il fasse la même chose, mais, où cette fois,
l’utilisateur donne en entrée les valeurs de a et b
(distinguer les trois cas où a = 0, a < 0 et a > 0)
(pour les plus courageux, dans le cas où a = 0, distinguer les cas où b = 0, b > 0 et b < 0)
2.5 résolution d’équation ou d’inéquations
exercice 5 :
une personne place initialement 500 euros sur un compte rémunéré à 3% d’intérêts simples
par mois (chaque mois, la banque crédite le compte de 3% de 500 e)
i. montrer que le solde du compte dans x mois est donné par f (x) = 15x + 500
ii. écrire un algorithme qui donne la plus petite valeur de x pour laquelle le solde du
compte dépasse 800 e
(utiliser une boucle : tans que(condition)instructions )
iii. modifier l’algorithme précédent pour qu’il fasse la même chose, mais, où cette fois,
l’utilisateur donne en entrée les valeurs du taux de placement t% ainsi que le capital
initial placé ainsi que le seuil s à dépasser

exercice 6 :
voici deux tarifs de deux entreprises de location de voitures
tarif A : 10 e d’assurance plus 50 e la journée plus 0,2 e du km
tarif B : 5 e d’assurance plus 20 e la journée plus 0,4 e du km

i. montrer que le tarif A pour x km et une journée, est donné par A(x) = 0, 2x + 60 et que
le tarif est donné par B(x) = 0, 4x + 25
ii. écrire un algorithme qui donne l’entreprise de location la plus avantageuse quand on
entre le nombre de km à faire pour une journée de location

iii. écrire un algorithme qui donne la plus petite valeur de x pour laquelle le tarif B est
plus avantageux que le tarif A
(utiliser une boucle : tans que(condition)instructions )
Chapitre 3

géométrie analytique dans le plan

57
3.1 distance entre deux points
exercice 7 :
soient les points A(2; 5) et B(7; 3) dans un repère orthogonal
i. écrire un algorithme qui calcule et affiche la distance AB
ii. modifier l’algorithme pour qu’il donne la distance AB quand l’utilisateur entre les
coordonnées des point A et B

exercice 8 :
Dans un repère orthogonal
i. écrire un algorithme qui calcule les distances AB, AC et BC quand on entre les coor-
données des trois points
ii. modifier l’algorithme pour qu’il affiche si le triangle ABC est rectangle en A ou en B
ou en C ou bien s’il n’est pas rectangle,
qui affiche aussi s’il est isocèle A ou en B ou en C ou bien s’il n’est pas isocèle,
qui affiche finalement, s’il est équilatéral ou non
(en javascript pour la racine carrée on utilise la méthode : Math.sqrt()
pour les tests, penser que les résultats sont approchés, on pourra alors comparer les
différences à 0 en prenant une tolérance de 0.01, par exemple, si la valeur absolue de
a − b est inférieure à 0, 01 on pourra considérer que a est quasiment égal à b
pour la valeur absolue : Math.abs() )
3.2 coordonnées du milieu d’un segment
exercice 9 :
Dans un repère on a : A(1; 6), B(7; 8)
i. écrire un algorithme qui calcule les coordonnées du milieu I du segment [AB]
ii. modifier l’algorithme précédent afin qu’il fasse la même chose que le précédent si on
entre les coordonnées des point A et B

exercice 10 :
Dans un repère
i. écrire un algorithme qui calcule les coordonnées du milieu I du segment [AB] ainsi que
celles du segment [CD] si on entre les coordonnées des points.
ii. modifier l’algorithme précédent afin qu’il dise si ABCD est un parallélogramme ou non
iii. pour les plus courageux, modifier l’algorithme afin qu’il dise si ABCD est un rectangle
ou non, un losange ou non, un carré ou non.
Chapitre 4

statistiques

61
4.1 angle diagramme circulaire
exercice 11 : (angle diagramme circulaire)
suite aux épreuve du premier groupe d’un examen on obtient :
Admis : 212 ; Convoqués au rattrapage : 84 ; Refusés : 42
1. écrire un algorithme qui calcule et affiche les trois angles angle_A, angle_C et angle_R
du diagramme circulaire qui représente les données précédentes
2. modifier l’algorithme précédent afin qu’il fasse la même chose quand on entre :
_ le nombre de catégories distinctes (il peut y en avoir de 2 à autant que l’on veut)
_ les effectifs de chacune des catégories
(pour le stockage des effectifs on utilisera un tableau indicé)
(pour l’entrée des effectifs dans le tableau, pour le calcul de l’effectif total et pour
l’affichage des résultats on utilisera une "boucle pour" )
( en javascript un tableau se déclare : mon_tableau = new Array()
4.2 hauteur histogramme
exercice 12 : (hauteur histogramme)
suite aux épreuve du premier groupe d’un examen on obtient :
[0; 8[: 42 (Refusés) ; [8; 10[: 84 (rattrapage) ;[10; 20] : 212 (Admis)
1. écrire un algorithme qui calcule et affiche les trois hauteurs hauteur_A, hauteur_C
et hauteur_R de l’histogramme qui représente les données précédentes
2. modifier l’algorithme précédent afin qu’il fasse la même chose quand on entre :
_ le nombre d’intervalles (il peut y en avoir de 2 à autant que l’on veut)
_ les effectifs de chacun des intervalles
_ les bornes des intervalles (pour le stockage des effectifs et des bornes on utilisera
un tableau indicé)
(pour l’entrée des effectifs dans le tableau, pour le calcul de l’effectif total et pour
l’affichage des résultats on utilisera une "boucle pour" )
( en javascript un tableau se déclare : mon_tableau = new Array()
4.3 moyenne sans coefficients
exercice 13 : (moyenne sans coefficients)
suite aux épreuves à un examen un candidat obtient les notes suivantes : 8; 12; 7; 14; 11; 12
1. écrire un algorithme qui calcule et affiche la moyenne des notes précédentes
2. modifier l’algorithme précédent afin qu’il fasse la même chose quand on entre :
_ le nombre de notes (il peut y en avoir de 2 à autant que l’on veut)
_ les notes (pour le stockage des notes on utilisera un tableau indicé)
(pour l’entrée des notes dans le tableau et pour le calcul du total, on utilisera une
"boucle pour" )
( en javascript un tableau se déclare : mon_tableau = new Array()
4.4 moyenne avec coefficients
exercice 14 : (moyenne avec coefficients)
suite aux épreuves à un examen un candidat obtient les notes suivantes : 8; 12; 7; 14; 11; 12
avec pour coefficients respectifs 2; 3; 5; 7; 2; 4
1. écrire un algorithme qui calcule et affiche la moyenne des notes précédentes
2. modifier l’algorithme précédent afin qu’il fasse la même chose quand on entre :
_ le nombre de notes (il peut y en avoir de 2 à autant que l’on veut)
_ les notes _ les coefficients (pour le stockage des notes, des coefficients on utilisera
un tableau indicé)
(pour l’entrée des notes et des coefficients dans le tableau puis pour le calcul du total,
on utilisera une "boucle pour" )
( en javascript un tableau se déclare : mon_tableau = new Array()
4.5 écart type sans coefficients
exercice 15 : (écart type sans coefficients)
suite aux épreuves à un examen un candidat obtient les notes suivantes : 8; 12; 7; 14; 11; 12
1. écrire un algorithme qui calcule et affiche l’écart type des notes précédentes
2. modifier l’algorithme précédent afin qu’il fasse la même chose quand on entre :
_ le nombre de notes (il peut y en avoir de 2 à autant que l’on veut)
_ les notes (pour le stockage des notes on utilisera un tableau indicé)
(pour l’entrée des notes dans le tableau et pour le calcul du total, on utilisera une
"boucle pour" )
( en javascript un tableau se déclare : mon_tableau = new Array()
4.6 écart type avec coefficients
exercice 16 : (écart type avec coefficients)
suite aux épreuves à un examen un candidat obtient les notes suivantes : 8; 12; 7; 14; 11; 12
avec pour coefficients respectifs 2; 3; 5; 7; 2; 4
1. écrire un algorithme qui calcule et affiche l’écart type des notes précédentes
2. modifier l’algorithme précédent afin qu’il fasse la même chose quand on entre :
_ le nombre de notes (il peut y en avoir de 2 à autant que l’on veut)
_ les notes _ les coefficients (pour le stockage des notes, des coefficients on utilisera
un tableau indicé)
(pour l’entrée des notes et des coefficients dans le tableau puis pour le calcul du total,
on utilisera une "boucle pour" )
( en javascript un tableau se déclare : mon_tableau = new Array()
Chapitre 5

fonctions généralités

69
5.1 image d’un nombre et tableau de valeurs
exercice 17 : (image d’un nombre et tableau de valeurs)
1
1. soit la fonction f telle que f (x) = 2x + 3 + pour tout x ∈ R∗
x
(a) écrire un algorithme qui donne l’image d’un nombre quelconque
1
(par exemple : f (2) = 2 × 1 + 3 + = 5.5)
2
(b) écrire le programme correspondant en javascript et le tester
(c) écrire un algorithme (et le programme js ) qui écrit les valeurs de x et de f (x) de la
fonction précédente pour x allant de 1 à 10 avec un pas de 1
1 7−→ 6
2 7−→ 5.5
...
(d) modifier l’algorithme précédent pour obtenir les valeurs pour x allant de deb à f in avec
un pas de 1 où deb et f in sont deux entiers choisis par l’utilisateur
2. soit une fonction affine quelconque f telle que f (x) = ax + b pour tout x ∈ R où a et b sont
deux réels fixés quelconques.
(a) modifier l’algorithme précédent pour qu’il écrive les valeurs de x et de f (x) pour x
allant de deb à f in avec un pas de 1 où a, b, deb, f in sont choisis par l’utilisateur (deb
et f in des entiers)
(b) écrire le programme correspondant en javascript et le tester
5.2 construction de points d’une courbe
exercice 18 : (placer des points dans un repère)
on utilisera la syntaxe suivante dans ce qui suit :
⋆ pour créer un repère avec xmin , xmax , ymin et ymax pour valeurs extrêmes en x et en y on
écrira :
creer_repere(xmin, xmax , ymin , ymax )
⋆ pour ajouter un point de coordonnées (x, y) dans le repère précédent, on écrira :
ajouter_point(x,y)
100
1. soit la fonction f telle que f (x) = 2x + 3 + pour tout x ∈ R
x
(a) écrire un algorithme qui :
crée un repère avec pour valeurs extrêmes xmin = 1, xmax = 20, ymin = 0 et ymax = 120
puis qui ajoute dans ce repère les points de la courbe de f pour x allant de 1 à 20
(b) écrire le programme correspondant en javascript et le tester
5.3 recherche d’extremum
exercice 19 : (recherche d’extremum)

100
1. soit la fonction f telle que f (x) = 2x + 3 + pour tout x ∈ R
x
On cherche à déterminer à 0,01 près, la valeur de x qui minimise f (x) pour x compris
entre 1 et 20 ainsi que la valeur de ce minimum de f (x)
(a) écrire un algorithme qui utilise une "boucle pour" afin de calculer toutes les valeurs
de f (x) pour x allant de 1 à 20 au pas de 0.01
à chaque boucle on comparera la valeur trouvée à une valeur "min_de_f" initialement
affectée de la valeur +infini
on mémorisera les valeurs de x et de f (x) dans le cas où la valeur de f (x) est inférieure
à min_de_f
on affichera les valeurs de min_de_f et de x correspondante en fin de boucle
(b) traduire cet algorithme en javascript
(en javascript, la valeur +infini est notée : Number.POSITIVE_INFINITY )
2. modifier l’algorithme précédent afin qu’il fasse la même chose quand l’utilisateur entre
les valeurs de début de recherche (1 ci dessus), de fin de recherche (20 ci dessus) ainsi
que le pas ( 0.01 ci dessus)
3. reprendre l’algorithme ci dessus et le modifier afin qu’il donne à 0,01 près, la valeur de
x qui maximise f (x) pour x compris entre 1 et 20 ainsi que la valeur de ce maximum de
f (x)
(en javascript, la valeur -infini est notée : Number.NEGATIVE_INFINITY )
5.4 recherche de valeur d’annulation
5.5 recherche de solutions d’équations