Actions

Cours

Différences entre versions de « Technologies avancées du eLearning 2/exercices/Saisie de notes »

De GBLL, TAL, ALAO, etc.

< Cours:Technologies avancées du eLearning 2
(Page créée avec « {{encart|Le code écrit ici réutilise des fonctions issues des Utilisateur:Mathieu_Loiseau/Cours/Master_DDL_—_Parcours_DILIPEM/M2_—_technologies_avancées_du_eLearn... »)
 
 
(8 versions intermédiaires par le même utilisateur non affichées)
Ligne 1 : Ligne 1 :
{{encart|Le code écrit ici réutilise des fonctions issues des [[Utilisateur:Mathieu_Loiseau/Cours/Master_DDL_—_Parcours_DILIPEM/M2_—_technologies_avancées_du_eLearning_2/exercices/Saisie_de_nombres|exercices de saisie de nombres}}
+
{{encart|Énoncé dans le [[:File:775-M2_DILIPEM_TechnosAv2.pdf|support de cours]] diapo 25}}
 +
[[:File:775-JS_Saisie de notes.zip|Une correction]] (ci-dessous la même sans le HTML).
 +
== Fonctions issues des [[Utilisateur:Mathieu_Loiseau/Cours/Master_DDL_—_Parcours_DILIPEM/M2_—_technologies_avancées_du_eLearning_2/exercices/Saisie_de_nombres|exercices de saisie de nombres]] ==
 +
<syntaxhighlight lang="javascript" line>function isDigit(caractere){
 +
var result;
 +
switch(caractere.toString()){
 +
case "0":
 +
case "1":
 +
case "2":
 +
case "3":
 +
case "4":
 +
case "5":
 +
case "6":
 +
case "7":
 +
case "8":
 +
case "9":
 +
result = true;
 +
break ;
 +
default:
 +
result = false;
 +
}
 +
return result;
 +
}
 +
 
 +
//Prend une chaine de caractère et dit si c'est un nombre
 +
function isNumber(word,min,max){
 +
//déclaration de variables
 +
//isFloat : booléen qui dit si le “word” comporte (déjà) une virgule
 +
var isFloat = word.charAt(0)=="," || word.charAt(0)==".",
 +
//result : booléen qui dit si le word est (pour le moment) un nombre
 +
result = isDigit(word.charAt(0))
 +
|| ( word.length > 1
 +
&& (isFloat || word.charAt(0)=="-"));
 +
//On initialise result à vrai si le premier caractère est un chiffre ou
 +
//si c'est une virgule ou un moins, mais que le word contient d'autres caractères
 +
/*On parcourt le reste du word (mais on s'arrête dès qu'on est sûr que ce n'est pas un
 +
  nombre. Dès que résultat sera faux, (result && i<word.length) sera faux.*/
 +
for(let i=1;result && i<word.length;i++){
 +
if(word.charAt(i)=="," || word.charAt(i)=="."){
 +
if(isFloat){
 +
result = false;
 +
}
 +
else{
 +
isFloat = true;
 +
}
 +
}
 +
else if(!isDigit(word.charAt(i))){
 +
result = false;
 +
}
 +
}
 +
//modification pour pouvoir demander un nombre compris entre min et max
 +
if( (result!==false)
 +
&& (typeof min != "undefined")//paramètre optionnel
 +
&& (min !== false) // pas pris en compte s'il vaut faux
 +
&& (Number(word) < min)){
 +
result = false ;
 +
}
 +
if( (result!==false)
 +
&& (typeof max != "undefined")//paramètre optionnel
 +
&& (max !== false) // pas pris en compte s'il vaut faux
 +
&& (Number(word) > max)){
 +
result = false ;
 +
}
 +
return result;
 +
}
 +
 
 +
function arrayToTable(theArray, tableId){
 +
var elt = document.getElementById(tableId),
 +
res = theArray;
 +
if(elt == null){
 +
//L'identifiant n'existe pas
 +
console.error("arrayToTable : "+tableId + " n'existe pas dans le document.");
 +
res = false;
 +
}
 +
else if(elt.tagName != "TABLE"){
 +
//L'identifiant n'existe pas
 +
console.error("arrayToTable : "+tableId + " n'est pas une table ("+elt.tagName+").");
 +
res = false;
 +
}
 +
else{
 +
//on crée du contenu
 +
var line = document.createElement("tr");
 +
for(let i=0;i<theArray.length;i++){
 +
line.innerHTML += "<td>"+theArray[i]+"</td>";
 +
}
 +
//on le met dans l'élément
 +
elt.appendChild(line);
 +
}
 +
return res;
 +
}</syntaxhighlight>
 +
== Nouvelles Fonctions ==
 +
<syntaxhighlight lang="javascript" line>//renvoie un nombre de notes (≥ 1) ou false
 +
function getNbCount(){
 +
var res = window.prompt("Combien y a-t-il eu de notes dans le trimestre ?");
 +
//Tant que l'utilisateur saisit une valeur qui n'est pas un nombre ≥ 1 on continue
 +
while(res != null && (res == "" || !isNumber(res,1)) ){
 +
res = window.prompt("Combien y a-t-il eu de notes dans le trimestre ?");
 +
}
 +
if(res == null){
 +
res = false;
 +
}
 +
else{
 +
res = Number(res);
 +
}
 +
return res;
 +
}
 +
 
 +
//Renvoie un nom (ou false)
 +
function getName(){
 +
var userText = window.prompt("Entrez le nom de l'élève");
 +
//on renvoie faux si l'utilisateur dit stop (ou annuler)
 +
if((userText == null) || (userText =="stop")){
 +
userText = false;
 +
}
 +
return userText ;
 +
}
 +
 
 +
//Récupère le nom et les notes
 +
function getLine(nb){
 +
var res = false,
 +
userText = getName();
 +
//si la saisie ne demande pas la fin du travail, on modifie res
 +
if(userText!==false){
 +
nb = Number(nb);
 +
res = [] ;
 +
res.push(userText);
 +
//on ajoute les notes (on interrompt le travail si l'utilisateur appuie sur annuler)
 +
while( (res.length <= nb) && (userText != null) ){
 +
userText = window.prompt("Entrez la note n°"+res.length+"/"+nb+" de "+res[0]);
 +
if(userText=="-"){
 +
//autoriser les absences
 +
res.push("-");
 +
}
 +
else if(isNumber(userText,0,20)){
 +
//refuser les notes non comprises entre 0 et 20
 +
res.push(Number(userText));
 +
}
 +
}
 +
if(userText == null){
 +
res = false;
 +
}
 +
}
 +
return res ;
 +
}
 +
 
 +
//Gère les interactions pour remplir la table
 +
function fillTable(tableId){
 +
var count = getNbCount();
 +
if(count !== false){
 +
line = getLine(count);
 +
while(line !== false){
 +
line.push(mean(line,false,1));
 +
arrayToTable(line, tableId);
 +
line = getLine(count);
 +
}
 +
}
 +
}</syntaxhighlight>
 +
== Version avec les moyennes ==
 +
<syntaxhighlight lang="javascript" line>//Remplit les tables et ajoute des moyennes
 +
function fillTableWithMeans(tableId){
 +
var count = getNbCount();
 +
let completeTable = [] ;
 +
if(count !== false){
 +
line = getLine(count);
 +
while(line !== false){
 +
line.push(mean(line,false,1));
 +
completeTable.push(line);
 +
line = getLine(count);
 +
}
 +
let means=["Moyenne"];
 +
for(let i=1;i<completeTable[0].length;i++){
 +
means.push(mean(completeTable,i));
 +
}
 +
completeTable.push(means);
 +
}
 +
for(let i=0;i<completeTable.length;i++){
 +
arrayToTable(completeTable[i], tableId);
 +
}
 +
}
 +
 
 +
/***************
 +
* calcule une moyenne dans un tableau à une ou deux entrées
 +
* entre les cases min et max
 +
***
 +
* anArray : le tableau dans lequel calculer la moyenne
 +
* columnId : entier → indice de la colonne sur laquelle on calcule la moyenne
 +
*            false  → calcul dans un tableau à 1 dimension
 +
* min (optionnel) : entier → indice de la première case concernée
 +
*                          (permet d'ignorer celles qui précèdent)
 +
* max (optionnel) : entier → indice de la première case concernée
 +
*                            (permet d'ignorer celles qui suivent ex: moyenne calculée)
 +
**************/
 +
function mean(anArray,columnId,min,max){
 +
var res = 0,
 +
nbNotes = 0;
 +
if(typeof min=="undefined"){
 +
//valeur par défaut de min
 +
min = 0;
 +
}
 +
if(typeof max == 'undefined'){
 +
//valeur par défaut de max
 +
max = anArray.length;
 +
}
 +
//parcours en ligne
 +
if(typeof columnId == "undefined" || columnId === false){
 +
for (let i=min;i<max;i++){
 +
if(typeof anArray[i] == "number" ){
 +
res += anArray[i] ; // ←→ res + anArray[i]
 +
nbNotes++;
 +
}
 +
}
 +
}
 +
else{//parcours en colonne, pour la colonne d'id columnId
 +
for (let i=min;i<max;i++){
 +
if(typeof anArray[i][columnId] == "number" ){
 +
res += anArray[i][columnId] ; // ←→ res + anArray[i]
 +
nbNotes++ ;
 +
}
 +
}
 +
}
 +
return res/nbNotes;
 +
}
 +
</syntaxhighlight>
 +
== Version avec les tris ==
 +
<syntaxhighlight lang="javascript" line>
 +
//Remplit les tables et ajoute des moyennes et trie la table
 +
//selon l'algo (à définir) de la fonction de tri sortFunction
 +
function fillSortedTableWithMeans(tableId,sortFunction){
 +
var count = getNbCount();
 +
let completeTable = [] ;
 +
if(count !== false){
 +
line = getLine(count);
 +
while(line !== false){
 +
line.push(mean(line,false,1));
 +
completeTable.push(line);
 +
line = getLine(count);
 +
}
 +
completeTable = sortFunction(completeTable) ;
 +
let means=["Moyenne"];
 +
//count = nb notes + 1 pour la moyenne générale
 +
for(let i=1;i<=count+1;i++){
 +
means.push(mean(completeTable,i));
 +
}
 +
completeTable.push(means);
 +
}
 +
for(let i=0;i<completeTable.length;i++){
 +
arrayToTable(completeTable[i], tableId);
 +
}
 +
}
 +
 
 +
//La partie suivante utilise le fait que javascript
 +
//traite les fonctions comme des variables normales
 +
//cf. affectation d'événements
 +
//voir aussi la notion de fonction anonyme
 +
//https://ulea-wiki.univ-grenoble-alpes.fr/_/Utilisateur:Mathieu_Loiseau/Cours/Master_DDL_%e2%80%94_Parcours_DILIPEM/M2_%e2%80%94_technologies_avanc%c3%a9es_du_eLearning_2/TOUT_ce_qu'il_y_a_%c3%a0_savoir#Fonction_anonyme
 +
 
 +
//Comparaison alphabétique de 2 lignes de tableau telles que construites par notre programme
 +
function compareAlpha(tr1, tr2){
 +
var elt1 = tr1[0], //le nom est toujours dans la première case de la ligne
 +
elt2 = tr2[0], //le nom est toujours dans la première case de la ligne
 +
res = 0 ; //égalité des valeurs par défaut
 +
if(elt1 < elt2){ //si le premier est inférieur au second valeur négative
 +
res = -1 ;
 +
}
 +
else if(elt2 < elt1){//sinon valeur positive
 +
res = 1 ;
 +
}
 +
return res ;
 +
}
 +
 
 +
//Comparaison de la moyenne de 2 lignes de tableau telles que construites par notre programme
 +
function compareMean(tr1, tr2){
 +
var elt1 = tr1[tr1.length-1], //la moyenne est toujours dans la dernière case du tableau
 +
elt2 = tr2[tr2.length-1], //la moyenne est toujours dans la dernière case du tableau
 +
res = 0 ; //égalité des valeurs par défaut
 +
if(elt1 < elt2){ //si le premier est inférieur au second valeur négative
 +
res = -1 ;
 +
}
 +
else if(elt2 < elt1){ //sinon valeur positive
 +
res = 1 ;
 +
}
 +
return res ;
 +
}
 +
 
 +
//Interversion de deux cases d'indice i1 et i2 d'un tableau tab
 +
function invertTr(tab, i1, i2){
 +
//pour intervertir 2 cases, il faut une case intermédiaire
 +
let tmp = tab[i1];
 +
tab[i1]=tab[i2];
 +
tab[i2]=tmp;
 +
return tab;
 +
}
 +
 
 +
function alphaSort(table){
 +
//Pour un tri alphabétique, il faut une comparaison de la case des noms
 +
return triMin(table, compareAlpha, invertTr);
 +
}
 +
 
 +
function meanSort(table){
 +
//Pour un tri par moyenne, il faut une comparaison de la case des moyennes
 +
return triAlan(table, compareMean, invertTr);
 +
}
 +
 
 +
/*Un tri par minimum :
 +
* parcourt la partie non triée d'un tableau pour trouver la plus petite valeur
 +
* la met dans la première case non triée
 +
* recommence ce processus à partir de la case suivante
 +
* Jusqu'à ce que le tableau soit trié*/
 +
function triMin(table, comparaison, inversion){
 +
var min,tmpElt;
 +
for (var j=0;j<table.length;j++){
 +
//par défaut la case minimale est la première case non triée
 +
min = j;
 +
for (var i=j+1;i<table.length;i++){
 +
if(comparaison(table[min], table[i])>0){
 +
//si la case i est plus petite que la cas min
 +
//elle devient la case minimale
 +
min=i;
 +
}
 +
}
 +
console.log("Le plus petit élément à partir de l'index "+j+" est "+min+". On les inverse");
 +
table = inversion(table, j, min);
 +
}
 +
return table;
 +
}
 +
alphaSort
 +
/*Le tri d'Alan est un tri par bulle amélioré
 +
*Le tri par bulle fait remonter la plus grande valeur à droite du tableau
 +
*    en comparant une case avec la suivante
 +
*    et en les intervertissant si la plus grande des deux n'est pas à droite
 +
*    à la fin du parcours, la plus grande valeur est à droite
 +
*puis recommence avec la partie non-triée du tableau
 +
*La version d'Alan garde triée la partie gauche du tableau en faisant redescendre
 +
*jusqu'à sa position toute valeur intervertie*/
 +
function triAlan(table, comparaison, inversion){
 +
for (var i=0;i<table.length - 1;i++){
 +
if(comparaison(table[i], table[i+1]) > 0){
 +
//les cases i et i+1 ne sont pas dans le bon ordre
 +
//on les intervertit.
 +
table = inversion(table, i, i+1) ;
 +
let j = i ;
 +
//on vérifie que la case j+1 (devenue j) n'est pas
 +
//plus grande que les cases précédentes
 +
while(j > 0 && comparaison(table[j-1], table[j]) > 0){
 +
//tant qu'elle est plus grande on l'échange avec
 +
//avec la case précédente
 +
table = inversion(table, j, j-1) ;
 +
j--;
 +
}
 +
}
 +
}
 +
return table ;
 +
}</syntaxhighlight>

Version actuelle datée du 18 novembre 2020 à 12:28

Énoncé dans le support de cours diapo 25

Une correction (ci-dessous la même sans le HTML).

Fonctions issues des exercices de saisie de nombres

 1 function isDigit(caractere){
 2 	var result;
 3 	switch(caractere.toString()){
 4 		case "0":
 5 		case "1":
 6 		case "2":
 7 		case "3":
 8 		case "4":
 9 		case "5":
10 		case "6":
11 		case "7":
12 		case "8":
13 		case "9":
14 			result = true;
15 			break ;
16 		default:
17 			result = false;
18 	}
19 	return result;
20 }
21 
22 //Prend une chaine de caractère et dit si c'est un nombre
23 function isNumber(word,min,max){
24 	//déclaration de variables
25 		//isFloat : booléen qui dit si le “word” comporte (déjà) une virgule
26 	var isFloat = word.charAt(0)=="," || word.charAt(0)==".",
27 		//result : booléen qui dit si le word est (pour le moment) un nombre
28 		 result = isDigit(word.charAt(0))
29 						|| ( word.length > 1
30 							&& (isFloat || word.charAt(0)=="-"));
31 		//On initialise result à vrai si le premier caractère est un chiffre ou
32 			//si c'est une virgule ou un moins, mais que le word contient d'autres caractères
33 	/*On parcourt le reste du word (mais on s'arrête dès qu'on est sûr que ce n'est pas un
34 	  nombre. Dès que résultat sera faux, (result && i<word.length) sera faux.*/
35 	for(let i=1;result && i<word.length;i++){
36 		if(word.charAt(i)=="," || word.charAt(i)=="."){
37 			if(isFloat){
38 				result = false;
39 			}
40 			else{
41 				 isFloat = true;
42 			}
43 		}
44 		else if(!isDigit(word.charAt(i))){
45 			result = false;
46 		}
47 	}
48 	//modification pour pouvoir demander un nombre compris entre min et max
49 	if( (result!==false)
50 	 && (typeof min != "undefined")//paramètre optionnel
51 	 && (min !== false) // pas pris en compte s'il vaut faux
52 	 && (Number(word) < min)){
53 		result = false ;
54 	}
55 	if( (result!==false)
56 	 && (typeof max != "undefined")//paramètre optionnel
57 	 && (max !== false) // pas pris en compte s'il vaut faux
58 	 && (Number(word) > max)){
59 		result = false ;
60 	}
61 	return result;
62 }
63 
64 function arrayToTable(theArray, tableId){
65 	var elt = document.getElementById(tableId),
66 		 res = theArray;
67 	if(elt == null){
68 		//L'identifiant n'existe pas
69 		console.error("arrayToTable : "+tableId + " n'existe pas dans le document.");
70 		res = false;
71 	}
72 	else if(elt.tagName != "TABLE"){
73 		//L'identifiant n'existe pas
74 		console.error("arrayToTable : "+tableId + " n'est pas une table ("+elt.tagName+").");
75 		res = false;
76 	}
77 	else{
78 		//on crée du contenu
79 		var line = document.createElement("tr");
80 		for(let i=0;i<theArray.length;i++){
81 		line.innerHTML += "<td>"+theArray[i]+"</td>";
82 	}
83 	//on le met dans l'élément
84 	elt.appendChild(line);
85 	}
86 	return res;
87 }

Nouvelles Fonctions

 1 //renvoie un nombre de notes (≥ 1) ou false
 2 function getNbCount(){
 3 	var res = window.prompt("Combien y a-t-il eu de notes dans le trimestre ?");
 4 	//Tant que l'utilisateur saisit une valeur qui n'est pas un nombre ≥ 1 on continue
 5 	while(res != null && (res == "" || !isNumber(res,1)) ){
 6 		res = window.prompt("Combien y a-t-il eu de notes dans le trimestre ?");
 7 	}
 8 	if(res == null){
 9 		res = false;
10 	}
11 	else{
12 		res = Number(res);
13 	}
14 	return res;
15 }
16 
17 //Renvoie un nom (ou false)
18 function getName(){
19 	var userText = window.prompt("Entrez le nom de l'élève");
20 	//on renvoie faux si l'utilisateur dit stop (ou annuler)
21 	if((userText == null) || (userText =="stop")){
22 		userText = false;
23 	}
24 	return userText ;
25 }
26 
27 //Récupère le nom et les notes
28 function getLine(nb){
29 	var res = false,
30 		 userText = getName();
31 	//si la saisie ne demande pas la fin du travail, on modifie res
32 	if(userText!==false){
33 		nb = Number(nb);
34 		res = [] ;
35 		res.push(userText);
36 		//on ajoute les notes (on interrompt le travail si l'utilisateur appuie sur annuler)
37 		while( (res.length <= nb) && (userText != null) ){
38 			userText = window.prompt("Entrez la note n°"+res.length+"/"+nb+" de "+res[0]);
39 			if(userText=="-"){
40 				//autoriser les absences
41 				res.push("-");
42 			}
43 			else if(isNumber(userText,0,20)){
44 				//refuser les notes non comprises entre 0 et 20
45 				res.push(Number(userText));
46 			}
47 		}
48 		if(userText == null){
49 			res = false;
50 		}
51 	}
52 	return res ;
53 }
54 
55 //Gère les interactions pour remplir la table
56 function fillTable(tableId){
57 	var count = getNbCount();
58 	if(count !== false){
59 		line = getLine(count);
60 		while(line !== false){
61 			line.push(mean(line,false,1));
62 			arrayToTable(line, tableId);
63 			line = getLine(count);
64 		}
65 	}
66 }

Version avec les moyennes

 1 //Remplit les tables et ajoute des moyennes
 2 function fillTableWithMeans(tableId){
 3 	var count = getNbCount();
 4 	let completeTable = [] ;
 5 	if(count !== false){
 6 		line = getLine(count);
 7 		while(line !== false){
 8 			line.push(mean(line,false,1));
 9 			completeTable.push(line);
10 			line = getLine(count);
11 		}
12 		let means=["Moyenne"];
13 		for(let i=1;i<completeTable[0].length;i++){
14 			means.push(mean(completeTable,i));
15 		}
16 		completeTable.push(means);
17 	}
18 	for(let i=0;i<completeTable.length;i++){
19 		arrayToTable(completeTable[i], tableId);
20 	}
21 }
22 
23 /***************
24  * calcule une moyenne dans un tableau à une ou deux entrées
25  * entre les cases min et max
26  ***
27  * anArray : le tableau dans lequel calculer la moyenne
28  * columnId : entier → indice de la colonne sur laquelle on calcule la moyenne
29  *            false  → calcul dans un tableau à 1 dimension
30  * min (optionnel) : entier → indice de la première case concernée
31  *                           (permet d'ignorer celles qui précèdent)
32  * max (optionnel) : entier → indice de la première case concernée
33  *                            (permet d'ignorer celles qui suivent ex: moyenne calculée)
34  **************/
35 function mean(anArray,columnId,min,max){
36 	var res = 0,
37 		 nbNotes = 0;
38 	if(typeof min=="undefined"){
39 		//valeur par défaut de min
40 		min = 0;
41 	}
42 	if(typeof max == 'undefined'){
43 		//valeur par défaut de max
44 		max = anArray.length;
45 	}
46 	//parcours en ligne
47 	if(typeof columnId == "undefined" || columnId === false){
48 		for (let i=min;i<max;i++){
49 			if(typeof anArray[i] == "number" ){
50 				res += anArray[i] ; // ←→ res + anArray[i]
51 				nbNotes++;
52 			}
53 		}
54 	}
55 	else{//parcours en colonne, pour la colonne d'id columnId
56 		for (let i=min;i<max;i++){
57 			if(typeof anArray[i][columnId] == "number" ){
58 				res += anArray[i][columnId] ; // ←→ res + anArray[i]
59 				nbNotes++ ;
60 			}
61 		}
62 	}
63 	return res/nbNotes;
64 }

Version avec les tris

  1 //Remplit les tables et ajoute des moyennes et trie la table
  2 //selon l'algo (à définir) de la fonction de tri sortFunction
  3 function fillSortedTableWithMeans(tableId,sortFunction){
  4 	var count = getNbCount();
  5 	let completeTable = [] ;
  6 	if(count !== false){
  7 		line = getLine(count);
  8 		while(line !== false){
  9 			line.push(mean(line,false,1));
 10 			completeTable.push(line);
 11 			line = getLine(count);
 12 		}
 13 		completeTable = sortFunction(completeTable) ;
 14 		let means=["Moyenne"];
 15 		//count = nb notes + 1 pour la moyenne générale
 16 		for(let i=1;i<=count+1;i++){
 17 			means.push(mean(completeTable,i));
 18 		}
 19 		completeTable.push(means);
 20 	}
 21 	for(let i=0;i<completeTable.length;i++){
 22 		arrayToTable(completeTable[i], tableId);
 23 	}
 24 }
 25 
 26 //La partie suivante utilise le fait que javascript
 27 //traite les fonctions comme des variables normales
 28 //cf. affectation d'événements
 29 //voir aussi la notion de fonction anonyme
 30 //https://ulea-wiki.univ-grenoble-alpes.fr/_/Utilisateur:Mathieu_Loiseau/Cours/Master_DDL_%e2%80%94_Parcours_DILIPEM/M2_%e2%80%94_technologies_avanc%c3%a9es_du_eLearning_2/TOUT_ce_qu'il_y_a_%c3%a0_savoir#Fonction_anonyme
 31 
 32 //Comparaison alphabétique de 2 lignes de tableau telles que construites par notre programme
 33 function compareAlpha(tr1, tr2){
 34 	var elt1 = tr1[0], //le nom est toujours dans la première case de la ligne
 35 		 elt2 = tr2[0], //le nom est toujours dans la première case de la ligne
 36 		 res = 0 ; //égalité des valeurs par défaut
 37 	if(elt1 < elt2){ //si le premier est inférieur au second valeur négative
 38 		res = -1 ;
 39 	}
 40 	else if(elt2 < elt1){//sinon valeur positive
 41 		res = 1 ;
 42 	}
 43 	return res ;
 44 }
 45 
 46 //Comparaison de la moyenne de 2 lignes de tableau telles que construites par notre programme
 47 function compareMean(tr1, tr2){
 48 	var elt1 = tr1[tr1.length-1], //la moyenne est toujours dans la dernière case du tableau
 49 		 elt2 = tr2[tr2.length-1], //la moyenne est toujours dans la dernière case du tableau
 50 		 res = 0 ; //égalité des valeurs par défaut
 51 	if(elt1 < elt2){ //si le premier est inférieur au second valeur négative
 52 		res = -1 ;
 53 	}
 54 	else if(elt2 < elt1){ //sinon valeur positive
 55 		res = 1 ;
 56 	}
 57 	return res ;
 58 }
 59 
 60 //Interversion de deux cases d'indice i1 et i2 d'un tableau tab
 61 function invertTr(tab, i1, i2){
 62 	//pour intervertir 2 cases, il faut une case intermédiaire
 63 	let tmp = tab[i1];
 64 	tab[i1]=tab[i2];
 65 	tab[i2]=tmp;
 66 	return tab;
 67 }
 68 
 69 function alphaSort(table){
 70 	//Pour un tri alphabétique, il faut une comparaison de la case des noms
 71 	return triMin(table, compareAlpha, invertTr);
 72 }
 73 
 74 function meanSort(table){
 75 	//Pour un tri par moyenne, il faut une comparaison de la case des moyennes
 76 	return triAlan(table, compareMean, invertTr);
 77 }
 78 
 79 /*Un tri par minimum :
 80 	* parcourt la partie non triée d'un tableau pour trouver la plus petite valeur
 81 	* la met dans la première case non triée
 82 	* recommence ce processus à partir de la case suivante
 83  * Jusqu'à ce que le tableau soit trié*/
 84 function triMin(table, comparaison, inversion){
 85 	var min,tmpElt;
 86 	for (var j=0;j<table.length;j++){
 87 		//par défaut la case minimale est la première case non triée
 88 		min = j;
 89 		for (var i=j+1;i<table.length;i++){
 90 			if(comparaison(table[min], table[i])>0){
 91 				//si la case i est plus petite que la cas min
 92 				//elle devient la case minimale
 93 				min=i;
 94 			}
 95 		}
 96 		console.log("Le plus petit élément à partir de l'index "+j+" est "+min+". On les inverse");
 97 		table = inversion(table, j, min);
 98 	}
 99 	return table;
100 }
101 alphaSort
102 /*Le tri d'Alan est un tri par bulle amélioré
103  *Le tri par bulle fait remonter la plus grande valeur à droite du tableau
104  *    en comparant une case avec la suivante
105  *    et en les intervertissant si la plus grande des deux n'est pas à droite
106  *    à la fin du parcours, la plus grande valeur est à droite
107  *puis recommence avec la partie non-triée du tableau
108  *La version d'Alan garde triée la partie gauche du tableau en faisant redescendre
109  *jusqu'à sa position toute valeur intervertie*/
110 function triAlan(table, comparaison, inversion){
111 	for (var i=0;i<table.length - 1;i++){
112 		if(comparaison(table[i], table[i+1]) > 0){
113 			//les cases i et i+1 ne sont pas dans le bon ordre
114 			//on les intervertit.
115 			table = inversion(table, i, i+1) ;
116 			let j = i ;
117 			//on vérifie que la case j+1 (devenue j) n'est pas
118 			//plus grande que les cases précédentes
119 			while(j > 0 && comparaison(table[j-1], table[j]) > 0){
120 				//tant qu'elle est plus grande on l'échange avec
121 				//avec la case précédente
122 				table = inversion(table, j, j-1) ;
123 				j--;
124 			}
125 		}
126 	}
127 	return table ;
128 }