Mehdi Khalil TYPESCRIPT

src/animal.class.ts

@@ -1,12 +1,30 @@
 import Food from './food/food';
+import IAnimal from './animal.interface';
 
 // Créer une class Animal qui implémente l'interface IAnimal
 // par défaut, la méthode eat augmente le poids de l'animal de 10
 // par défaut, la méthode sleep réduit le poids de l'animal de 10
 // le poids d'un animal ne peut pas être négatif
 
-export default class Animal {
 
-  // CODER ICI
+export default class Animal implements IAnimal {
+  weight: number;
+  name: string
 
+  constructor(name: string, weight: number) {
+    this.name = name;
+    this.weight = weight;
+  }
+
+  public eat(food: Food): string | void {
+    this.weight += 10;
+  }
+
+  public sleep(): void {
+    const newWeight = this.weight -= 10;
+    if (newWeight >= 0) {
+      this.weight = newWeight;
+    }
+    else this.weight = 0
+  }
 }

src/animal.interface.ts

@@ -1,9 +1,11 @@
-// Créer une interface Animal qui aura 2 méthodes : eat() et sleep()
+// Créer une interface IAnimal qui aura 2 méthodes : eat() et sleep()
 // eat() prendra un argument generic qui hérite de Food qui ne renvoie soit rien soit une chaine de caractere
 // sleep() ne prend pas d'argument et ne renvoie rien
 
 import Food from './food/food';
 
 export default interface IAnimal {
-  // CODER ICI
+  weight: number;
+  eat<T extends Food>(food:T):void | string ;
+  sleep():void;
 }

src/array.ts

@@ -3,23 +3,23 @@ export default class MyArray {
   // Coder une méthode oddNumbers qui prend en paramètre un tableau d'entier, et renvoie un tableau uniquement composé
   // des entiers impairs de ce dernier
   oddNumbers(arr: number[]) {
-    return undefined
+    return arr.filter((n) => n % 2 === 1 );
   }
 
   // Coder une méthode sort qui renvoie le tableau passé en paramètre trié par ordre croissant
   sort(arr: number[]) {
-    return undefined
+    return arr.sort((a,b)=> a-b);
   }
 
   // Coder une méthode boringFunction qui renvoie true si les string du tableaux ont toutes la même longueur,
   // ou renvoie "relou ta fonction" sinon
   boringFunction(arr: string[]) {
-    return undefined
+    return arr.every((str) => str.length === arr[0].length) || 'relou ta fonction';
   }
 
   // Coder une méthode optionalArray qui renvoie true si les 2 arrays d'entiers passés en paramètres sont égaux, false sinon
   // Faire de même avec un 3e tableau passé en paramètre qui sera optionnel
-  optionalArray(a, b, c?) {
-    return undefined
+  optionalArray(a: number[], b: number[], c?: number[]) {
+    return a.toString() === b.toString() && (!c || a.toString() === c?.toString());
   }
 }

src/calculator.ts

@@ -1,38 +1,37 @@
 export default class MyCalculator {
 
   // Coder une methode add qui prend 2 nombres en paramètre et renvoie la somme des deux
-  add(a, b) {
-    return undefined
+  add(a:number, b:number): number {
+    return a + b
   }
 
   // Coder une methode subtract qui prend 2 nombres en paramètre et renvoie la différence des deux
-  subtract(a, b) {
-    return undefined
+  subtract(a:number, b:number): number {
+    return a - b
   }
 
   // Coder une methode multiply qui prend 2 nombres en paramètre et renvoie le produit des deux
-  multiply(a, b) {
-    return undefined
+  multiply(a:number, b:number): number {
+    return a*b
   }
 
   // Coder une methode divide qui prend 2 nombres en paramètre et renvoie le quotient des deux
-  divide(a, b) {
-    return undefined
+  divide(a:number, b:number): number {
+    return b === 0 ? 0 : (a / b);
   }
 
   // Coder une méthode power qui prend 2 nombres en paramètre et renvoie le premier élevé à la puissance de l'autre
-  power(a, b) {
-    return undefined
+  power(a:number, b:number): number  {
+    return Math.pow(a,b)
   }
 
   // Coder une méthode squareRoot qui prend un nombre en paramètre et renvoie sa racine carrée
-  squareRoot(a) {
-    return undefined
+  squareRoot(a: number): number  {
+    return a > 0 ? Math.sqrt(a) : 0;
   }
 
   // Coder une fonction fléchée qui renvoie true si le chiffre en paramètre est premier, false sinon
-  isPrime = (a) => {
-    return undefined
-  }
-
+   isPrime = (a: number): boolean => {
+    return a % 2 === 1;
+  };
 }

src/hippopotamus.ts

@@ -3,10 +3,32 @@
 // si l'aliment qu'il mange est de la viande, il pousse (renvoie) un cri de dégout : "beurk" et son poids n'augmente pas
 // l'hippopotame perd 20 de poids lorsqu'il dort
 // ajouter une méthode swim() qui ne renvoie rien mais baisse le poids de 50.
-
+import Animal from './animal.class';
+import Vegetable from './food/vegetable';
 import Food from './food/food';
 
-export default class Hippopotamus {
 
-  // CODER ICI
+export default class Hippopotamus extends Animal {
+  eat(food:Food): void | string {
+    if (food instanceof Vegetable) {
+      this.weight += 20;
+    }
+    else return "beurk"
+  };
+
+  sleep():void {
+    const newWeight =  this.weight -= 20;
+    if (newWeight >= 0) {
+      this.weight = newWeight;
+    }
+    else this.weight = 0
+  }
+
+  swim():void {
+    const newWeight = this.weight - 50;
+    if (newWeight >= 0) {
+      this.weight = newWeight;
+    }
+    else this.weight = 0
+  }
 }

src/vehicle.ts

@@ -15,18 +15,23 @@ export default class Vehicle {
   // brrrrrrrrrrrrr si le vehicule est un camion
   // skrrrt skrrrt dans tout autre cas
   noise() {
-    return undefined
+      switch(this.type) {
+      case VehicleType.Car: return 'vrooooom';
+      case VehicleType.Moto: return 'bep bep';
+      case VehicleType.Truck: return 'brrrrrrrrrrrrr';
+      default: return 'skrrrt skrrrt';
+    }
   }
 
   // Coder un callback qui renverra la methode noise précedemment codée
   // mais transformera la valeur de retour en majuscule
   myCb = () => {
-    return undefined
+    return this.noise().toUpperCase();
   }
 
   // Coder une méthode accelerate qui prend en paramètre un callback et renvoie la valeur de noise() concaténée au callback
   accelerate(cb: () => string) {
-    return undefined
+    return this.noise().concat(cb());
   }