Ali Saïd MOHAMADOU

src/animal.class.ts

@@ -1,12 +1,37 @@
-import Food from './food/food';
-
 // 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 {
+import Food from './food/food';
+import IAnimal from './animal.interface';
+
+export default class Animal implements IAnimal {
+
+  name: string;
+  weight: number = 0;
+
+   constructor(name: string, weight: number){
+
+    this.weight = weight;
+    this.name = name;
+
+  }
+
+  eat(argument:Food): string | void {
+    this.weight += 10;
+  }
+
+  sleep(): void {
+    if(this.weight >= 10){
+
+      this.weight -= 10;
+    } else{
+
+      this.weight = 0;
+    }
+
+  }
 
-  // CODER ICI
 
 }

src/animal.interface.ts

@@ -5,5 +5,8 @@
 import Food from './food/food';
 
 export default interface IAnimal {
-  // CODER ICI
+
+  eat(argument:Food) : string | void;
+
+  sleep() : void;
 }

src/array.ts

@@ -3,23 +3,56 @@ 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 !== 0);
+
   }
 
   // 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
+
+    var firstStringTable = arr[0].length;
+    var allStringsTable = arr.every((str) => str.length === firstStringTable);
+
+    return allStringsTable ? true : "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[]): boolean {
+
+    if (a.length !== b.length) {
+
+      return false;
+
+    }
+    if (c && a.length !== c.length) {
+
+      return false;
+
+    }
+    for (let i = 0; i < a.length; i++) {
+
+      if (a[i] !== b[i]) {
+        return false;
+
+      }
+      if (c && a[i] !== c[i]) {
+
+        return false;
+
+      }
+    }
+    return true;
+
   }
 }

src/calculator.ts

@@ -1,38 +1,77 @@
 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
-  }
+    // Coder une methode add qui prend 2 nombres en paramètre et renvoie la somme des deux
+    add(a: number, b: 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) {
+
+    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) {
+
+    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) {
+
+    if (b === 0) {
+
+      return 0;
+
+    }
+
+    return 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) {
+
+    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) {
+
+    if (a > 0) {
+
+      return Math.sqrt(a);
+
+    } else {
+
+      return 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) => {
+    if (a <= 1) {
+
+      return false;
+
+    }
+    for (let i = 2; i <= Math.sqrt(a); i++) {
+      if (a % i === 0) {
+
+        return false;
+
+      }
+    }
+
+    return true;
+
   }
 
 }

src/hippopotamus.ts

@@ -5,8 +5,45 @@
 // ajouter une méthode swim() qui ne renvoie rien mais baisse le poids de 50.
 
 import Food from './food/food';
+import Animal from './animal.class';
 
-export default class Hippopotamus {
 
-  // CODER ICI
+export default class Hippopotamus extends Animal {
+
+
+  eat(argument: Food){
+
+    if(argument.isVegan()) 
+    {
+      this.weight = this.weight + 20;
+    }
+    else {
+
+      return 'beurk';
+    }
+  }
+
+  sleep(){
+    if(this.weight >= 20)
+    {
+
+      this.weight -= 20;
+    } else{
+
+      this.weight = 0;
+    }
+  }
+
+  swim(): void{
+
+    if(this.weight >= 50){
+
+      this.weight -= 50;
+    } else{
+
+      this.weight = 0;
+    }
+
+  }
 }
+

src/vehicle.ts

@@ -1,5 +1,6 @@
 import { VehicleType } from './vehicletype.enum';
 
+
 export default class Vehicle {
   type: VehicleType
   name: string
@@ -8,26 +9,50 @@ export default class Vehicle {
     this.type = type
     this.name = name
   }
-
+  
   // Coder une méthode nois qui switchera sur le type du véhicule et renverra
   // vrooooom si le vehicule est une voiture
   // bep bep si le vehicule est une moto
   // 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"
+
+      case VehicleType.Rocket:
+        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
+
+
+
+  myCb = ()  => {
+
+    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()}${cb()}`;
+
   }
 
 
 }
+