TD1 introduction à git

.gitignore

+.vscode/

src/Cararactere.ts

+class Caractere {
+    cara: string;
+
+    constructor(cara: string= ''){
+        this.cara= cara; 
+    }
+  }
+
+  function estVoyelle(): boolean{
+    let voy =['a', 'e', 'i', 'o', ]
+    return voy.includes(this.cara);
+  }
+
+class Rectangle{
+    longueur:number;
+    largeur:number;
+    
+}
\ No newline at end of file

src/cercle.ts

+// Définition de la classe Point
+class Point {
+  x!: number;
+  y!: number;
+}
+
+// Définition de la classe Cercle
+class Cercle {
+  centre!: Point;
+  rayon!: number;
+}
+
+// Définition de la classe Rectangle
+class Rectangle {
+  coinSupGauche!: Point;
+  largeur!: number;
+  hauteur!: number;
+}
+
+// Instanciation d'un objet Cercle
+let centreCercle = new Point();
+centreCercle.x = 150;
+centreCercle.y = 100;
+
+let monCercle = new Cercle();
+monCercle.centre = centreCercle;
+monCercle.rayon = 75;
+
+// Fonction pour vérifier si un point est dans un cercle
+function pointDansCercle(cercle: Cercle, point: Point): boolean {
+  let distance = Math.sqrt(
+    (point.x - cercle.centre.x) ** 2 +
+      (point.y - cercle.centre.y) ** 2,
+  );
+  return distance <= cercle.rayon;
+}
+
+// Fonction pour vérifier si un rectangle est complétement dans un cercle
+function rectangleDansCercle(cercle: Cercle, rectangle: Rectangle): boolean {
+  let coin1: Point = rectangle.coinSupGauche;
+  let coin2: Point = { x: coin1.x + rectangle.largeur, y: coin1.y };
+  let coin3: Point = { x: coin1.x, y: coin1.y + rectangle.hauteur };
+  let coin4: Point = {
+    x: coin1.x + rectangle.largeur,
+    y: coin1.y + rectangle.hauteur,
+  };
+
+  return pointDansCercle(cercle, coin1) && pointDansCercle(cercle, coin2) &&
+    pointDansCercle(cercle, coin3) && pointDansCercle(cercle, coin4);
+}
+
+// Fonction pour vérifier s'il y a chevauchement entre un cercle et un rectangle
+function chevauchement(cercle: Cercle, rectangle: Rectangle): boolean {
+  let coin1: Point = rectangle.coinSupGauche;
+  let coin2: Point = { x: coin1.x + rectangle.largeur, y: coin1.y };
+  let coin3: Point = { x: coin1.x, y: coin1.y + rectangle.hauteur };
+  let coin4: Point = {
+    x: coin1.x + rectangle.largeur,
+    y: coin1.y + rectangle.hauteur,
+  };
+
+  return pointDansCercle(cercle, coin1) || pointDansCercle(cercle, coin2) ||
+    pointDansCercle(cercle, coin3) || pointDansCercle(cercle, coin4);
+}
+
+// Instanciation d'un rectangle
+let coinRectangle = new Point();
+coinRectangle.x = 130;
+coinRectangle.y = 90;
+
+let monRectangle = new Rectangle();
+monRectangle.coinSupGauche = coinRectangle;
+monRectangle.largeur = 30;
+monRectangle.hauteur = 20;
+
+// Test de la fonction pointDansCercle()
+let testPoint = new Point();
+testPoint.x = 140;
+testPoint.y = 100;
+
+console.log(
+  "Le point est dans le cercle ?",
+  pointDansCercle(monCercle, testPoint),
+);
+
+// Test de la fonction rectangleDansCercle()
+console.log(
+  "Le rectangle est entièrement dans le cercle ?",
+  rectangleDansCercle(monCercle, monRectangle),
+);
+
+// Test de la fonction chevauchement()
+console.log(
+  "Le rectangle chevauche-t-il le cercle ?",
+  chevauchement(monCercle, monRectangle),
+);

src/complexe.ts

+class complexe {
+    
+}
\ No newline at end of file

src/personne.ts

+class Personne {
+    ine: string;
+
+    constructor(ine: string) {
+        this.ine = ine;
+    }
+}
+
+let p = new Personne("123456789");
+p.ine = "987654321";
\ No newline at end of file

src/piste.ts

+class Piste {
+    private titre: string;
+    private duree: number;
+
+    constructor(titre: string, duree: number) {
+        this.titre = titre;
+        this.duree = duree;
+    }
+
+    getTitre(): string {
+        return this.titre;
+    }
+
+    getDuree(): number {
+        return this.duree;
+    }
+
+    egale(x: Piste): boolean {
+        if ((x.duree === this.getDuree()) && (x.titre === this.getTitre())) {
+            return true
+        }
+        return false;
+    }
+
+    toString(x: Piste): string {
+        return ("Le titre est" + x.titre, "et la durre est" + x.duree);
+
+    }
+}
+
+let p = new Piste("titreeee", 55);
+let g = new Piste("eeeea", 554);
+
+p.egale(g);
+
+class Album {
+    private titre: string;
+    private nbpiste: number;
+    private table: Array<Piste>;
+
+    constructor(titre: string, nbpiste: number, table: Array<Piste>) {
+        this.titre = titre;
+        this.nbpiste = nbpiste;
+        this.table = table;
+    }
+
+    estFini(): boolean {
+        if (this.nbpiste > 0) {
+            return true;
+        }
+        return true;
+    }
+
+    contient(): {
+
+    }
+}
\ No newline at end of file

src/reservoir.ts

+class Reservoir {
+    capacite: number;
+    contenu: number;
+
+    constructor(capacite: number) {
+        this.capacite = capacite;
+        this.contenu = 0;
+    }
+
+    verse(quantite: number): number {
+        let dispo = this.capacite = this.contenu;
+        if (quantite <= dispo) {
+            this.contenu += quantite;
+            return 0;
+        } else {
+            this.contenu = this.capacite;
+            return quantite - dispo;
+        }
+    }
+
+    puise(avantite: number) {
+        if (quantite < this.contenu) {
+            this.contenu -= this.quantite;
+            return quantite;
+        } else {
+            this.contenu = 0;
+            return quantite;
+        }
+
+        jauge(): Number{
+            return this.contenu;
+        }
+    }
+}
\ No newline at end of file

src/temps.ts

+class Temps {
+    heure!: number;
+    minute!: number;
+    second!: number;
+}
+
+function temps2Number(t: Temps): number {
+    let totalsec: number = t.heure * 60 * 60 + t.minute * 60 + t.second;
+    return totalsec;
+}
+
+function number2Temps(ts: number): Temps {
+    let t = new Temps();
+    t.heure = Math.floor(ts / 3600);
+    ts %= 3600;
+    t.minute = Math.floor(ts / 60);
+    t.second = ts % 60;
+    return t;
+}
+
+function multiplieTemps(t: Temps, ts: number): Temps {
+    let multipl = temps2Number(t) * ts;
+    return number2Temps(multipl);
+}
+
+function multiplie(t: Temps, nb: number): Temps {
+    return number2Temps(temps2Number(t) * nb);
+}
+
+function km(t: Temps, kill: number): number {
+    let tk = kill / (temps2Number(t) / 3600);
+    return tk;
+}
+