diff --git a/src/animal.class.ts b/src/animal.class.ts
index 63da713..210901a 100644
--- a/src/animal.class.ts
+++ b/src/animal.class.ts
@@ -1,12 +1,29 @@
 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
+// par défaut, la méthode eat augmente le weight de l'animal de 10
+// par défaut, la méthode sleep réduit le weight de l'animal de 10
+// le weight 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{
+      this.weight+= 10;
+    }
+
+    sleep(): void {
+      this.weight > 10 ? this.weight -= 10 : this.weight = 0 ;
+    }
+  
+  }
   // CODER ICI
 
-}
diff --git a/src/animal.interface.ts b/src/animal.interface.ts
index 32d5c62..dc40ef3 100644
--- a/src/animal.interface.ts
+++ b/src/animal.interface.ts
@@ -5,5 +5,6 @@
 import Food from './food/food';
 
 export default interface IAnimal {
-  // CODER ICI
+  eat(food: Food): string | void;
+  sleep(): void;
 }
diff --git a/src/array.ts b/src/array.ts
index 74d328e..00de855 100644
--- a/src/array.ts
+++ b/src/array.ts
@@ -3,23 +3,26 @@ 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 arr2: number[] = arr.filter(function(a){
+      return (a % 2 !== 0)});
+    return arr2;
   }
 
   // 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((a) => a.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() == b.toString() && a.toString() == c.toString() && b.toString() == c.toString()); 
   }
 }
diff --git a/src/calculator.ts b/src/calculator.ts
index 412d171..e61e549 100644
--- a/src/calculator.ts
+++ b/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) {
+    return b ? a / b : 0;
+    //on ne peut pas diviser par 0 donc on teste si le dénominateur est false/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
+  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
+  isPrime = (a: number) => {
+    if (a < 2) {
+      return false;
+    }
+  
+    for (let i: number = 2; i < a; i++) {
+      if (a % i === 0) {
+        return false;
+      }
+    }
+    return true;
   }
 
 }
diff --git a/src/hippopotamus.ts b/src/hippopotamus.ts
index 0c5a55b..1746fcf 100644
--- a/src/hippopotamus.ts
+++ b/src/hippopotamus.ts
@@ -1,12 +1,36 @@
 // Créer une class Hippopotamus qui hérite de la classe Animal
-// modifier la méthode eat pour que l'hippopotame prenne 20 de poids si l'aliment qu'il mange est un légume
-// 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.
+// modifier la méthode eat pour que l'hippopotame prenne 20 de weight si l'aliment qu'il mange est un légume
+// si l'aliment qu'il mange est de la viande, il pousse (renvoie) un cri de dégout : "beurk" et son weight n'augmente pas
+// l'hippopotame perd 20 de weight lorsqu'il dort
+// ajouter une méthode swim() qui ne renvoie rien mais baisse le weight de 50.
 
+import Animal from './animal.class';
 import Food from './food/food';
+import Meat from './food/meat';
+import Vegetable from './food/vegetable';
 
-export default class Hippopotamus {
+export default class Hippopotamus extends Animal{
+   name: string;
+   weight: number;
+  constructor(name: string, weight: number) {
+    super(name, weight);
+    this.name = name;
+  }
+  eat(food: Food): string | void {
 
-  // CODER ICI
+    if(food.isVegan()){
+      this.weight += 20;
+      return;
+    }else{
+      return 'beurk';
+    }
+  }
+
+  sleep(): void {
+    this.weight > 20 ? this.weight -= 20 : this.weight = 0;
+  }
+
+  swim(): void {
+    this.weight > 50 ? this.weight -= 50 : this.weight = 0;
+  }
 }
diff --git a/src/vehicle.ts b/src/vehicle.ts
index 63e999d..b9cbe89 100644
--- a/src/vehicle.ts
+++ b/src/vehicle.ts
@@ -1,12 +1,12 @@
 import { VehicleType } from './vehicletype.enum';
 
 export default class Vehicle {
-  type: VehicleType
-  name: string
+  type: VehicleType;
+  name: string;
 
   constructor(type: VehicleType, name: string) {
-    this.type = type
-    this.name = name
+    this.type = type;
+    this.name = name;
   }
 
   // Coder une méthode nois qui switchera sur le type du véhicule et renverra
@@ -14,19 +14,28 @@ 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();
   }