ECV- DIGITAL ALAN DUFAIL

src/animal.class.ts

@@ -1,12 +1,37 @@
+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 {
   // CODER ICI
 
+  name: string;
+  weight: number;
+
+  constructor(name: string, weight: number) {
+    this.name = name;
+    this.newWeight(weight);
+  }
+
+  eat(food: Food): void | 'beurk' {
+    this.newWeight(10);
+  }
+
+  sleep(): void {
+    if (this.weight > 10) {
+      this.newWeight(-10);
+    }
+  } 
+
+  newWeight(muscle: number): void {
+    if (this.weight + muscle >= 0) {
+      this.weight += muscle;
+    } else {
+      this.weight = 0;
+    }
+  }
 }

src/animal.interface.ts

@@ -1,9 +1,13 @@
 // Créer une interface Animal 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
+// 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
+
+   sleep(): void;
+
+   eat(food: Food): string | void;
 }

src/array.ts

@@ -1,25 +1,41 @@
 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
+    let oddNumbers: number[] = [];
+
+    for (let i = 0; i < arr.length; i++) {
+      if (arr[i] % 2 !== 0) {
+        oddNumbers.push(arr[i]);
+      }
+    }
+    return oddNumbers;
   }
 
   // Coder une méthode sort qui renvoie le tableau passé en paramètre trié par ordre croissant
   sort(arr: number[]) {
-    return undefined
+    return arr.reduce((acc: number[], cur: number) => {
+      const index = acc.findIndex((val) => val > cur);
+      if (index === -1) {
+        return [...acc, cur];
+      }
+
+      return arr = [...acc.slice(0, index), cur, ...acc.slice(index)];
+    }, []);
   }
 
   // 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((val) => val.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[]) {
+   // every js
+
+
+    return a.toString() == b.toString() || (a.toString() == b.toString() && a.toString() == c.toString() && b.toString()) ;
   }
 }

src/calculator.ts

@@ -1,38 +1,39 @@
 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
+  // // Coder une methode multiply qui prend 2 nombres en paramètre et renvoie le produit des deux
+  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
+  // // Coder une methode divide qui prend 2 nombres en paramètre et renvoie le quotient des deux
+  divide(a: number, b: number) {
+    return b ? a / b : 0;
   }
 
   // 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
+  // // Coder une méthode squareRoot qui prend un nombre en paramètre et renvoie sa racine carrée
+  squareRoot(a: number) {
+    return a < 0 ? 0 : 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
+  // // Coder une fonction fléchée qui renvoie true si le chiffre en paramètre est premier, false sinon
+  isPrime = (a: number): boolean => {
+    for (let i = 2; i < a; i++) {
+      if (a % i === 0) return false;
+    }
+    return a > 1 ? true : false;
   }
-
 }

src/hippopotamus.ts

@@ -4,9 +4,31 @@
 // 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 extends Animal {
   // CODER ICI
+
+  constructor(name: string, weight: number) {
+    super(name, weight);
+    this.name = name;
+    this.newWeight(weight);
+  }
+  eat(food: Food): void | 'beurk' {
+    if (food.isVegan()) {
+      this.newWeight(20);
+      return;
+    }
+    return 'beurk';
+  }
+
+  sleep(): void {
+    this.newWeight(-20);
+  }
+
+  swim(): void {
+    this.newWeight(-50);
+  }
 }

src/vehicle.ts

@@ -14,19 +14,33 @@ export default class Vehicle {
   // bep bep si le vehicule est une moto
   // brrrrrrrrrrrrr si le vehicule est un camion
   // skrrrt skrrrt dans tout autre cas
-  noise() {
-    return undefined
+  noise(): string {
+    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
+  myCb = (): string => {
+    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
+  accelerate(cb: () => string): string {
+    return `${this.noise()}${cb()}`;
   }
 
 

test/array.spec.ts

@@ -13,8 +13,10 @@ describe("Array", () => {
       .toStrictEqual([1, 6, 13, 76, 245,343, 934, 1391, 1839]);
   })
 
+
+
   test("should return true if array items are the same length", () => {
-    expect(array.boringFunction(["hihi", "haha", "hoho"])).toBe(true)
+    expect(array.boringFunction(["hifi", "haha", "hoho"])).toBe(true)
   })
 
   test("should return relou ta fonction if array items are not the same length", () => {

test/calculator.spec.ts

@@ -1,67 +1,65 @@
-import MyCalculator from "../src/calculator";
-
-describe("Calculator", () => {
+import MyCalculator from '../src/calculator';
 
+describe('Calculator', () => {
   let myCalculator: MyCalculator = new MyCalculator();
 
-  test('should add positive numbers correctly', () => {
+  test.only('should add positive numbers correctly', () => {
     expect(myCalculator.add(1, 2)).toBe(3);
   });
 
-  test('should add negative numbers correctly', () => {
+  test.only('should add negative numbers correctly', () => {
     expect(myCalculator.add(1, -2)).toBe(-1);
   });
 
-  test('should subtract positive numbers correctly', () => {
+  test.only('should subtract positive numbers correctly', () => {
     expect(myCalculator.subtract(1, 2)).toBe(-1);
   });
 
-  test('should subtract negative numbers correctly', () => {
+  test.only('should subtract negative numbers correctly', () => {
     expect(myCalculator.subtract(1, -2)).toBe(3);
   });
 
-  test('should multiply positive numbers correctly', () => {
+  test.only('should multiply positive numbers correctly', () => {
     expect(myCalculator.multiply(1, 2)).toBe(2);
   });
 
-  test('should multiply negative numbers correctly', () => {
+  test.only('should multiply negative numbers correctly', () => {
     expect(myCalculator.multiply(1, -2)).toBe(-2);
   });
 
-  test('should divide positive numbers correctly', () => {
+  test.only('should divide positive numbers correctly', () => {
     expect(myCalculator.divide(1, 2)).toBe(0.5);
   });
 
-  test('should divide negative numbers correctly', () => {
+  test.only('should divide negative numbers correctly', () => {
     expect(myCalculator.divide(-3, 2)).toBe(-1.5);
   });
 
-  test('should not divide any number by 0', () => {
+  test.only('should not divide any number by 0', () => {
     expect(myCalculator.divide(1, 0)).toBe(0);
   });
 
-  test('should power positive numbers correctly', () => {
+  test.only('should power positive numbers correctly', () => {
     expect(myCalculator.power(3, 2)).toBe(9);
   });
 
-  test('should power negative numbers correctly', () => {
+  test.only('should power negative numbers correctly', () => {
     expect(myCalculator.power(-3, 2)).toBe(9);
   });
 
-  test('should return square root of positive numbers correctly', () => {
+  test.only('should return square root of positive numbers correctly', () => {
     expect(myCalculator.squareRoot(16744464)).toBe(4092);
   });
 
-  test('should not return square root of negative numbers', () => {
+  test.only('should not return square root of negative numbers', () => {
     expect(myCalculator.squareRoot(-16744464)).toBe(0);
   });
 
-  test('should return true on prime number', () => {
+  test.only('should return true on prime number', () => {
     expect(myCalculator.isPrime(7919)).toBe(true);
   });
 
-  test('should return false on not prime number', () => {
+  test.only('should return false on not prime number', () => {
     expect(myCalculator.isPrime(8)).toBe(false);
   });
-
-})
+});