eliott raheriarisoa

src/animal.class.ts

@@ -1,12 +1,32 @@
+import IAnimal from './animal.interface';
 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 {
+export default class Animal implements IAnimal{
+  name: string;
+  weight: number;
 
+  constructor(name: string, weight: number){
+    this.name = name
+    this.weight = weight
+  }
+
+  eat(food: Food): void | string{ 
+    if(this.weight > 0){
+      this.weight += 10
+
+      return `Après avoir mangé ce produit : ${food}, le nouveau poids de l'animal ${this.name} est de ${this.weight}` 
+    }
+  }
+  sleep(): void {
+    if(this.weight >= 10){
+      this.weight -= 10
+    }
+  }
   // CODER ICI
 
 }

src/animal.interface.ts

@@ -6,4 +6,6 @@ import Food from './food/food';
 
 export default interface IAnimal {
   // CODER ICI
+  eat<T extends Food>(food: T): void | string;
+  sleep(): void;
 }

src/array.ts

@@ -3,23 +3,31 @@ 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((x: number) => x % 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: number, b: number) => 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
+    const length : number = arr[0].length
+    const checkLength : boolean = arr.every((str: string) => str.length === length)
+
+    return checkLength ? checkLength : "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[]) {
+      if(c){
+        return a.length === b.length && a.length === c.length && a.every((nb: number, index: number) => nb === b[index]) && a.every((nb: number, index: number) => nb === c[index]);
+      }
+      else{
+        return a.length === b.length && a.every((nb: number, index : number) => nb === b[index]);
+      }
   }
 }

src/calculator.ts

@@ -1,38 +1,48 @@
 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) {
+    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 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 0
+    }
+    return Math.sqrt(a)
   }
 
   // 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) => {
+    for(let i = 2; i< a; i++){
+      if(a%i === 0) return false;
+    }
+    return true
   }
 
 }

src/hippopotamus.ts

@@ -4,9 +4,41 @@
 // 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 Food from './food/food';
 
-export default class Hippopotamus {
+export default class Hippopotamus implements Animal {
+  name: string
+  weight: number
 
+  constructor(name: string, weight: number){
+    this.name = name
+    this.weight = weight
+  }
+
+  eat(food: Food): string | void {
+      if(food.isVegan()){
+        this.weight += 20
+      }
+      return "beurk"
+  }
+
+  sleep(): void {
+    if(this.weight >= 20){
+      this.weight -= 20
+    }
+    else{
+      this.weight = 0
+    }
+  }
+
+  swim(): void {
+    if(this.weight >= 50){
+      this.weight -= 50
+    }
+    else{
+      this.weight = 0
+    }
+  }
   // CODER ICI
 }

src/vehicle.ts

@@ -15,18 +15,30 @@ 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() + cb()
   }