examin

tpnote1003/corige_decathlon/td2_fichiers/package.json

+{
+  "scripts": {
+    "test": "jest"
+  },
+  "devDependencies": {
+    "@types/node": "^16.11.12",
+    "@types/readline-sync": "^1.4.4",
+    "@typescript-eslint/eslint-plugin": "^5.6.0",
+    "@typescript-eslint/parser": "^5.6.0",
+    "eslint": "^8.4.1",
+    "readline-sync": "^1.4.10",
+    "ts-node": "^10.4.0",
+    "typescript": "^4.5.2",
+    "@babel/core": "^7.17.8",
+    "@babel/preset-env": "^7.16.11",
+    "@babel/preset-typescript": "^7.16.7",
+    "@types/jest": "^27.4.1",
+    "babel-jest": "^27.5.1",
+    "jest": "^27.5.1"
+  }
+}

tpnote1003/corige_decathlon/td2_fichiers/readme.txt

+Lancement : npx ts-node src/main/Application.ts
+
+Corrigé tranmis aux étudiants
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/controleur/Menu.ts

+import readlineSync from "readline-sync";
+import { Decathlon } from "../modele/Decathlon";
+import { LigneClassement } from "../modele/resultats/LigneClassement";
+import { Resultat } from "../modele/resultats/Resultat";
+import { TypeEpreuve } from "../modele/epreuves/TypeEpreuve";
+
+export class Menu {
+  public static gestionCompetition(competition: Decathlon): void {
+    console.log(competition.toString());
+
+    Menu.afficheClassements(competition);
+
+    let quitter = false;
+    let compétition;
+    do {
+      compétition = readlineSync.questionInt(
+        "Quel compétition voulez-vous gérer (1 ou 2 ; 0 pour quitter) ? "
+      );
+    } while (compétition < 0 || compétition > 2);
+    if (compétition === 0){
+        quitter=true
+    }else if (compétition === 1) {
+      do {
+        let jour;
+        do {
+          jour = readlineSync.questionInt(
+            "Quel jour voulez-vous gérer (1 ou 2 ; 0 pour quitter) ? "
+          );
+        } while (jour < 0 || jour > 2);
+
+        quitter = jour === 0;
+        if (!quitter) {
+          console.log("Voici les épreuves de ce jour");
+          console.log(competition.epreuvesToString(jour));
+          const nbEpreuves = competition.getNbEpreuves(jour);
+          let noEpreuve;
+          do {
+            noEpreuve = readlineSync.questionInt("Quelle épreuve voulez-vous gérer ? ");
+          } while (noEpreuve < 1 || noEpreuve > nbEpreuves);
+
+          const epreuve = competition.getEpreuve(jour, noEpreuve);
+
+          let finEpreuve;
+          do {
+            console.log("Gestion du " + epreuve.toString());
+
+            console.log("Voici la liste des athlètes :");
+            console.log(competition.athletesToString());
+            let noAthlete;
+            do {
+              noAthlete = readlineSync.questionInt(
+                "Quel athlète voulez-vous gérer (0 pour sortir) ? "
+              );
+            } while (noAthlete < 0 || noAthlete > competition.athletes.length);
+
+            finEpreuve = noAthlete == 0;
+            if (!finEpreuve) {
+              const resultat = readlineSync.questionFloat(
+                "Veuillez saisir le résultat en " + epreuve.unite + " : "
+              );
+              try {
+                competition.addResultat(epreuve, competition.athletes[noAthlete - 1], resultat);
+              } catch (err) {
+                if (err instanceof Error) {
+                  console.log(err.message);
+                }
+              }
+            }
+          } while (!finEpreuve);
+          console.log("Voici le classement de cette épreuve : ");
+          let resultatEpreuve = competition.getClassement(epreuve);
+          console.log(Resultat.tableauToString(resultatEpreuve));
+
+          Menu.afficheClassements(competition);
+        }
+      } while (!quitter);////////////////////////////////////////////*******************////////// */
+    }else if (compétition===2){
+        do {
+            let jour;
+            do {
+              jour = readlineSync.questionInt(
+                "Quel jour voulez-vous gérer (1 ou 2 ; 0 pour quitter) ? "
+              );
+            } while (jour < 0 || jour > 2);
+    
+            quitter = jour === 0;
+            if (!quitter) {
+              console.log("Voici les épreuves de ce jour");
+              console.log(competition.epreuvesToString(jour));
+              const nbEpreuves = competition.getNbEpreuves(jour);
+              let noEpreuve;
+              do {
+                noEpreuve = readlineSync.questionInt("Quelle épreuve voulez-vous gérer ? ");
+              } while (noEpreuve < 1 || noEpreuve > nbEpreuves);
+    
+              const epreuve = competition.getEpreuve(jour, noEpreuve);
+    
+              let finEpreuve;
+              do {
+                console.log("Gestion du " + epreuve.toString());
+    
+                console.log("Voici la liste des athlètes :");
+                console.log(competition.athletesToString());
+                let noAthlete;
+                do {
+                  noAthlete = readlineSync.questionInt(
+                    "Quel athlète voulez-vous gérer (0 pour sortir) ? "
+                  );
+                } while (noAthlete < 0 || noAthlete > competition.athletes.length);
+    
+                finEpreuve = noAthlete == 0;
+                if (!finEpreuve) {
+                  const resultat = readlineSync.questionFloat(
+                    "Veuillez saisir le résultat en " + epreuve.unite + " : "
+                  );
+                  try {
+                    competition.addResultat(epreuve, competition.athletes[noAthlete - 1], resultat);
+                  } catch (err) {
+                    if (err instanceof Error) {
+                      console.log(err.message);
+                    }
+                  }
+                }
+              } while (!finEpreuve);
+              console.log("Voici le classement de cette épreuve : ");
+              let resultatEpreuve = competition.getClassement(epreuve);
+              console.log(Resultat.tableauToString(resultatEpreuve));
+    
+              Menu.afficheClassements(competition);
+            }
+          } while (!quitter);
+    }
+  }
+
+  private static afficheClassements(competition: Decathlon): void {
+    console.log("Voici le classement général : ");
+    let classement = competition.getClassementGeneral();
+    console.log(LigneClassement.classementToString(classement));
+
+    console.log("Les meilleurs sauteurs, lanceurs, coureurs : ");
+    // ligne suivante à décommenter pour comprendre la ligne d'après
+    //console.log(TypeEpreuve);
+    for (const type in Object.keys(TypeEpreuve).filter((item) =>
+      Number.isInteger(Number.parseInt(item))
+    )) {
+      console.log(TypeEpreuve[type]);
+
+      const lePremier = competition.getMeilleurParType(Number(type));
+      if (lePremier.nbPoints > 0) {
+        console.log(lePremier.toString());
+      } else {
+        console.log("Aucune épreuve de ce type n'a encore eu lieu.");
+      }
+    }
+
+    console.log("Le meilleur français : ");
+    console.log(competition.getMeilleurFrancais().toString());
+  }
+}

tpnote1003/corige_decathlon/td2_fichiers/src/dao/FileAthleteDAO.ts

+import fs from 'fs';
+import { Athlete } from '../modele/Athlete';
+
+export class FileAthleteDAO {
+
+    public static chargeAthletes(dossier:string) : Athlete[] {
+
+        let liste : Athlete[] = [];
+        const donnees = fs.readFileSync('./src/donnees/'+dossier+'/athletes.txt', 'utf8');
+
+        const lignes = donnees.split('\n');
+
+        for (const ligne of lignes) {
+            const infoAthlete = ligne.split(';');
+            let athlete = new Athlete(infoAthlete[0], infoAthlete[1], infoAthlete[2], Number.parseInt(infoAthlete[3]));
+            liste.push(athlete);
+        }
+        return liste;
+    }
+}
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/dao/FileEpreuveDAO.ts

+import fs from 'fs';
+import { Epreuve } from '../modele/epreuves/Epreuve';
+import { Bareme } from '../modele/resultats/Bareme';
+
+export class FileEpreuveDAO {
+
+    public static completeEpreuvesCompetition(dossier: string, epreuves : Epreuve[]) : void {
+
+        const donnees = fs.readFileSync('./src/donnees/'+dossier+'/epreuves.txt', 'utf8');
+
+        const lignes = donnees.split('\n');
+
+        for (const ligne of lignes) {
+            const infoEpreuve = ligne.split(';');
+            let recherche = epreuves.filter(e=>e.nom===infoEpreuve[0]);
+            if (recherche.length===0) {
+                throw new Error("l'épreuve " + infoEpreuve[0] + " est inconnue dans cette compétition !");
+            }
+            const epreuve = recherche[0];
+            epreuve.record = Number.parseFloat(infoEpreuve[1]);
+            
+            const sPoints = infoEpreuve[2].split(',');
+            const sScores = infoEpreuve[3].split(',');
+            const points = sPoints.map((valeur)=> Number.parseInt(valeur));
+            const scores = sScores.map((valeur)=> Number.parseFloat(valeur));
+            
+            epreuve.bareme = new Bareme(scores, points, scores[0] < scores[1]);
+        }
+
+    }
+}
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/dao/FileResultatDAO.ts

+import fs from 'fs';
+import { Athlete } from '../modele/Athlete';
+import { Epreuve } from '../modele/epreuves/Epreuve';
+import { Resultat } from '../modele/resultats/Resultat';
+
+export class FileResultatDAO {
+
+    public static chargeResultats(dossier: string, athletes: Athlete[], epreuves: Epreuve[]): Resultat[] {
+
+        let liste: Resultat[] = [];
+        const donnees = fs.readFileSync('./src/donnees/'+dossier+'/resultats.txt', 'utf8');
+
+        const lignes = donnees.split('\n');
+
+        for (const ligne of lignes) {
+            if (ligne.trim().length !== 0) {
+                const infoResultat = ligne.split(';');
+                const athlete = athletes.filter(item => item.dossard === Number.parseInt(infoResultat[0]))[0];
+                const epreuve = epreuves.filter(item => item.nom === infoResultat[1])[0];
+                let resultat = new Resultat(athlete, epreuve, Number.parseFloat(infoResultat[2]));
+                liste.push(resultat);
+            }
+        }
+        
+        return liste;
+    }
+
+    public static sauveResultats(dossier: string, resultats: Resultat[]): void {
+
+        let fd = fs.openSync('./src/donnees/'+dossier+'/resultats.txt', 'w');
+
+        for (const resultat of resultats) {
+            const ligne = resultat.athlete.dossard + ";" + resultat.epreuve.nom + ";" + resultat.resultat + "\n";
+            fs.writeSync(fd, ligne);
+        }
+        fs.closeSync(fd);
+    }
+}
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/donnees/decathlon/epreuves.txt

+100m;9.58;1000, 950, 900, 850, 800, 750, 700;10.39, 10.60, 10.82, 11.05, 11.27, 11.51, 11.75;
+Saut en longueur;8.95;1000, 950, 900, 850, 800, 750, 700;7.76, 7.56, 7.36, 7.15, 6.95, 6.73, 6.51;
+Lancer du poids;23.37;1000, 950, 900, 850, 800, 750, 700;18.40, 17.59, 16.79, 15.98, 15.16, 14.35, 13.53;
+Saut en hauteur;2.45;1000, 950, 900, 850, 800, 750, 700;2.21, 2.16, 2.11, 2.05, 2.00, 1.94, 1.89;
+400m;43.03;1000, 950, 900, 850, 800, 750, 700;46.17, 47.17, 48.19, 49.24, 50.32, 51.43, 52.58;
+110m haies;12.8;1000, 950, 900, 850, 800, 750, 700;13.81, 14.19, 14.59, 15.00, 15.41, 15.85, 16.29;
+Lancer du disque;74.08;1000, 950, 900, 850, 800, 750, 700;56.18, 53.80, 51.40, 49.00, 46.60, 44.16, 41.72;
+Saut à la perche;6.21;1000, 950, 900, 850, 800, 750, 700;5.29, 5.13, 4.97, 4.80, 4.64, 4.46, 4.30;
+Lancer du javelot;98.48;1000, 950, 900, 850, 800, 750, 700;77.2, 73.94, 70.68, 67.40, 64.10, 60.78, 57.46;
+1500m;206.00;1000, 950, 900, 850, 800, 750, 700;233.79, 240.53, 247.42, 254.50, 261.77, 269.25, 276.96;
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/donnees/talence2022/athletes.txt

+mayer;kévin;fra;1
+frölich;Stefan-josé;ger;156
+roka;zsuzsanna;hun;24
+prevost;arthur;fra;38
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/donnees/talence2022/resultats.txt

+1;100m;10.5
+156;100m;9
+24;100m;9.5
+38;100m;9.66
+1;Saut en hauteur;2.09
+24;Saut en hauteur;1.99
+38;Saut en hauteur;2.15
+156;Saut en hauteur;2.06
+1;400m;44
+24;400m;48.25
+38;400m;47.9
+1;Saut à la perche;5.5
+38;Saut à la perche;4.6

tpnote1003/corige_decathlon/td2_fichiers/src/main/Application.ts

+import { Decathlon } from "../modele/Decathlon";
+import { Menu } from "../controleur/Menu";
+import { FileAthleteDAO } from "../dao/FileAthleteDAO";
+import { FileEpreuveDAO } from "../dao/FileEpreuveDAO";
+import { FileResultatDAO } from "../dao/FileResultatDAO";
+
+const competition = new Decathlon("Décastar Talence", new Date(2022, 8, 17), new Date(2022, 8, 18));
+const competition2 = new Decathlon("Heptathlon", new Date(2022, 7, 23), new Date(2022, 7, 24));
+
+FileEpreuveDAO.completeEpreuvesCompetition("decathlon", competition.getEpreuves());
+FileEpreuveDAO.completeEpreuvesCompetition("Heptathlon", competition2.getEpreuves());
+
+const dossier = "talence2022";
+const dossier2 = "eugene2022";
+
+competition.athletes = FileAthleteDAO.chargeAthletes(dossier);
+competition2.athletes = FileAthleteDAO.chargeAthletes(dossier2);
+
+competition.resultats = FileResultatDAO.chargeResultats(
+  dossier,
+  competition.athletes,
+  competition.getEpreuves()
+);
+competition2.resultats = FileResultatDAO.chargeResultats(
+  dossier2,
+  competition2.athletes,
+  competition2.getEpreuves()
+);
+
+Menu.gestionCompetition(competition);
+Menu.gestionCompetition(competition2);
+
+FileResultatDAO.sauveResultats(dossier, competition.resultats);
+FileResultatDAO.sauveResultats(dossier2, competition2.resultats);

tpnote1003/corige_decathlon/td2_fichiers/src/modele/Athlete.ts

+export class Athlete {
+
+    private _nom: string;
+    private _prenom: string;
+    private _nationalite: string;
+    private _dossard: number;
+
+	constructor(nom:string, prenom:string, nationalite:string, dossard:number) {
+        this.nom=nom;
+        this.prenom=prenom;
+        this.nationalite=nationalite;
+        this.dossard=dossard;
+	}
+
+    public get nationalite(): string {
+        return this._nationalite;
+    }
+    public set nationalite(value:string) {
+
+        if (value.trim().length!==3) {
+            throw new Error("La nationalité doit comporter 3 caractères !");
+        }
+        this._nationalite = value.toUpperCase();
+    }
+
+    public get nom(): string {
+        return this._nom;
+    }
+    public set nom(value:string) {
+
+        if (value.trim().length < 2) {
+            throw new Error("Le nom doit comporter au moins 2 caractères !");
+        }
+        this._nom = value.toUpperCase();
+    }
+
+    public get prenom(): string {
+        return this._prenom;
+    }
+    
+    public set prenom(value:string) {
+        if (value.trim().length < 2) {
+            throw new Error("Le prénom doit comporter au moins 2 caractères !");
+        }
+
+        this._prenom = value.charAt(0).toUpperCase()+ value.substring(1).toLowerCase();
+        const tabPrenomsComposes = this._prenom.split("-");
+        for (let p=0; p < tabPrenomsComposes.length; p++) {
+            tabPrenomsComposes[p] = tabPrenomsComposes[p].charAt(0).toUpperCase() + tabPrenomsComposes[p].substring(1); 
+        }
+        this._prenom = tabPrenomsComposes.join("-");
+    }
+
+    public get dossard(): number {
+        return this._dossard;
+    }
+ 
+    public set dossard(value:number) {
+
+        if (!Number.isInteger(value) || value <= 0) {
+            throw new Error("Le n° de dossard doit être entier et positif !")
+        }
+        this._dossard = value;
+    }
+
+    public equals(a:Athlete) : boolean {
+        return this._dossard === a._dossard;
+    }
+
+    public toString() : string {
+
+        return this._nom + " " + this._prenom + " (" + this._nationalite + ")" + ", n°" + this._dossard;
+    }
+}
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/modele/Decathlon.ts

+import { Course } from './epreuves/Course';
+import { Saut } from './epreuves/Saut';
+import { Lancer } from './epreuves/Lancer';
+
+import { Epreuve } from './epreuves/Epreuve';
+import {TypeEpreuve} from './epreuves/TypeEpreuve';
+
+import { Athlete } from './Athlete';
+import { Resultat } from './resultats/Resultat';
+import { LigneClassement } from './resultats/LigneClassement';
+
+export class Decathlon {
+
+    private _nom: string;
+    private _dateDebut: Date;
+    private _dateFin: Date;
+    private _epreuvesJours: Epreuve[][];
+    private _athletes: Athlete[];
+    private _resultats: Resultat[];
+
+    public constructor(nom:string, debut:Date, fin:Date) {
+        this.nom = nom;
+        this.dateDebut = debut;
+        this.dateFin = fin;
+        this._athletes=[];
+        this._resultats=[];
+        this.setEpreuves();
+    }
+
+    public set nom(_nom:string) {
+        
+        if (_nom.trim().length===0) {
+            throw Error("Le nom du décathlon ne peut pas être vide !");
+        }
+        this._nom = _nom;
+    }
+
+    public set dateDebut(_dateDebut:Date) {
+        
+        this._dateDebut = _dateDebut;
+    }
+
+    public set dateFin(_dateFin:Date) {
+        
+        if (this._dateDebut===undefined) {
+            throw Error("La date de fin doit être définie après la date de début !");
+        }
+        if (_dateFin >= this._dateDebut) {
+            this._dateFin = _dateFin;
+        } else {
+            throw Error("La date de fin ne peut être antérieure à la date de début !");
+        }
+    }
+
+    public get athletes(): Athlete[] {
+        return this._athletes;
+    }
+
+    public set athletes(tab:Athlete[]) {
+        this._athletes = tab;
+    }
+
+    public athletesToString() : string {
+        let chaine = "";
+
+        for (let idx=0; idx < this._athletes.length; idx++) {
+            chaine += (idx+1) + " : " + this._athletes[idx].toString() + "\n" ;
+        }
+
+        return chaine;
+    }
+
+    protected setEpreuves() : void {
+
+        this._epreuvesJours = [];
+        this._epreuvesJours[0] = [];
+        this._epreuvesJours[0][0] = new Course("100m");
+        this._epreuvesJours[0][1] = new Saut("Saut en longueur");
+        this._epreuvesJours[0][2] = new Lancer("Lancer du poids");
+        this._epreuvesJours[0][3] = new Saut("Saut en hauteur");
+        this._epreuvesJours[0][4] = new Course("400m");
+
+        this._epreuvesJours[1] = [];
+        this._epreuvesJours[1][0] = new Course("110m haies");
+        this._epreuvesJours[1][1] = new Lancer("Lancer du disque");
+        this._epreuvesJours[1][2] = new Saut("Saut à la perche");
+        this._epreuvesJours[1][3] = new Lancer("Lancer du javelot");
+        this._epreuvesJours[1][4] = new Course("1500m");
+    }
+
+    public epreuvesToString(jour:number): string {
+        let chaine = "";
+
+        for (let idx=0; idx < this._epreuvesJours[jour-1].length; idx++) {
+            chaine += (idx+1) + " : " + this._epreuvesJours[jour-1][idx].nom + " - ";
+        }
+
+        return chaine.substring(0, chaine.length-3);
+    }
+
+    public getEpreuves(): Epreuve[] {
+
+        return [...this._epreuvesJours[0], ...this._epreuvesJours[1]];
+    }
+
+    public getEpreuve(jour:number, numero:number): Epreuve {
+        return this._epreuvesJours[jour-1][numero-1];
+    }
+
+    public getNbEpreuves(jour:number): number {
+        return this._epreuvesJours[jour-1].length;
+    }
+    
+    public set resultats(tab: Resultat[]) {
+        this._resultats = tab;
+    }
+
+    public get resultats(): Resultat[] {
+        return this._resultats;
+    } 
+
+    public addResultat(e:Epreuve, a:Athlete, valeur:number): void {
+        
+        if (this._resultats.filter(res => res.athlete.equals(a) && res.epreuve.equals(e)).length!==0) {
+            throw new Error("Un résultat a déjà été saisi pour cet athlète dans cette épreuve !")
+        }
+        this._resultats.push(new Resultat(a, e, valeur));
+    }
+
+    public getClassement(epreuve:Epreuve): Resultat[] {
+        
+        let resultatsEpreuve = this._resultats.filter(item => item.epreuve.equals(epreuve));
+
+        resultatsEpreuve.sort((r1, r2) => 
+                    epreuve.bareme.croissant?
+                            r1.resultat - r2.resultat:
+                            r2.resultat - r1.resultat);
+
+        return resultatsEpreuve;
+    }
+
+    public getClassementGeneral(): LigneClassement[] {
+    
+        // Recalcul et cumul de tous les 10 classements
+        let lesClassements : Resultat[][] = [];
+        for (let j=0; j < this._epreuvesJours.length; j++) {
+            for (const epreuve of this._epreuvesJours[j]) {
+                lesClassements.push(this.getClassement(epreuve));
+            }
+        }
+
+        return this.cumuleParAthlete(lesClassements);
+    }
+
+    public getMeilleurParType(type:TypeEpreuve): LigneClassement {
+        
+        // Recalcul des classements des sauts/courses/lancers
+        let lesClassements : Resultat[][] = [];
+        
+        for (let j=0; j < this._epreuvesJours.length; j++) {
+            const epreuves = this._epreuvesJours[j].filter(valeur=>valeur.type===type);
+            for (const epreuve of epreuves) {
+                lesClassements.push(this.getClassement(epreuve));
+            }
+        }
+
+        return this.cumuleParAthlete(lesClassements)[0];
+    }
+
+    private cumuleParAthlete(lesClassements:Resultat[][]): LigneClassement[] {
+
+        let classement : LigneClassement[] = [];
+
+        for (const unAthlete of this._athletes) {
+            let nbPoints=0;
+            for (const unClassement of lesClassements) {
+                let resultats = unClassement.filter(valeur=>valeur.athlete.dossard===unAthlete.dossard);
+                if (resultats.length!==0) {
+                    nbPoints+=resultats[0].nbPoints;
+                }
+            }
+            classement.push(new LigneClassement(unAthlete, nbPoints));
+        }
+
+        classement.sort((c1, c2) => c2.nbPoints - c1.nbPoints);
+
+        return classement;
+    }
+
+    public getMeilleurFrancais(): LigneClassement {
+
+        let general = this.getClassementGeneral();
+        return general.filter(valeur=>valeur.athlete.nationalite==="FRA")[0];
+    }
+
+    public toString(): string {
+        return "Décathlon " + this._nom + ", du " + this._dateDebut.toLocaleDateString() + " au " + this._dateFin.toLocaleDateString();
+    }
+
+}
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/modele/epreuves/Course.ts

+import {Epreuve} from './Epreuve';
+import {TypeEpreuve} from './TypeEpreuve';
+
+export class Course extends Epreuve {
+
+    constructor(nom:string) {
+        super(nom, "secondes", TypeEpreuve.Course);
+    }
+} 
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/modele/epreuves/Epreuve.ts

+import { Bareme } from "../resultats/Bareme";
+import {TypeEpreuve} from './TypeEpreuve';
+
+export abstract class Epreuve {
+
+    private _nom : string;
+    private _unite : string;
+    private _record : number;
+	private _bareme : Bareme;
+	private _type : TypeEpreuve;
+
+    protected constructor(nom:string, unite:string, type:TypeEpreuve) {
+        this.nom = nom;
+        this.unite = unite;
+		this._type = type;
+    }
+
+    public get nom(): string {
+		return this._nom;
+	}
+
+	public get unite(): string {
+		return this._unite;
+	}
+
+	public get record(): number {
+		return this._record;
+	}
+
+	public get bareme(): Bareme {
+		return this._bareme;
+	}
+
+	public get type(): TypeEpreuve {
+		return this._type;
+	}
+
+	public set nom(valeur: string) {
+		this._nom = valeur;
+	}
+
+	public set unite(valeur: string) {
+		this._unite = valeur;
+	}
+
+	public set record(valeur: number) {
+		this._record = valeur;
+	}
+ 
+	public set bareme(valeur: Bareme) {
+		this._bareme = valeur;
+	}
+ 
+	public getNbPoints(resultat: number): number {
+
+		return this._bareme.getNbPoints(resultat); 
+	}
+
+	public equals(e: Epreuve): boolean {
+
+		return this.nom === e.nom;
+	}
+
+	public toString(): string {
+		return this._nom;
+	}
+}
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/modele/epreuves/Lancer.ts

+import {Epreuve} from './Epreuve';
+import {TypeEpreuve} from './TypeEpreuve';
+
+export class Lancer extends Epreuve {
+
+    constructor(nom:string) {
+        super(nom, "mètres", TypeEpreuve.Lancer);
+    }
+} 
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/modele/epreuves/Saut.ts

+import {Epreuve} from './Epreuve';
+import {TypeEpreuve} from './TypeEpreuve';
+
+export class Saut extends Epreuve {
+
+    constructor(nom:string) {
+        super(nom, "mètres", TypeEpreuve.Saut);
+    }
+} 
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/modele/epreuves/TypeEpreuve.ts

+export enum TypeEpreuve {
+    Course,
+    Lancer,
+    Saut
+}
\ No newline at end of file

tpnote1003/corige_decathlon/td2_fichiers/src/modele/resultats/Bareme.ts

+export class Bareme {
+
+    private _resultats: number[];
+    private _nbPoints: number[];
+    private _croissant: boolean;
+
+    public constructor(resultats:number[], nbPoints:number[], croissant:boolean) {
+        this._resultats = resultats;
+        this._nbPoints = nbPoints;
+        this._croissant = croissant;
+    }
+
+	public set resultats(valeur: number[]) {
+		this._resultats = valeur;
+	}
+
+	public set nbPoints(valeur: number[]) {
+		this._nbPoints = valeur;
+	}
+
+    public set croissant(croissant: boolean) {
+		this._croissant = croissant;
+	}
+
+    public get croissant()  : boolean {
+        return this._croissant;
+    }
+
+    public getNbPoints(resultat: number): number {
+
+        let score = 0;
+
+        let i;
+        let horsTable;
+        if (this._croissant) {
+            i = 0;
+            while (i < this._resultats.length && resultat > this._resultats[i]) {
+                i++;
+            }
+            horsTable=(i===this._resultats.length);
+            if (!horsTable) {
+                score = this._nbPoints[i];
+            }    
+        } else {
+            i = this._resultats.length - 1;
+            while (i >= 0 && resultat > this._resultats[i]) {
+                i--;
+            }
+            horsTable=(i===this._resultats.length - 1);
+            if (!horsTable) {
+                score = this._nbPoints[i+1];
+            }    
+        }
+
+        return score;
+    }
+
+}
\ No newline at end of file