diff --git a/src/animal.class.ts b/src/animal.class.ts
index 63da713..d0b8a44 100644
--- a/src/animal.class.ts
+++ b/src/animal.class.ts
@@ -1,3 +1,4 @@
+import IAnimal from './animal.interface';
 import Food from './food/food';
 
 // Créer une class Animal qui implémente l'interface IAnimal
@@ -5,8 +6,25 @@ import Food from './food/food';
 // 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;
 
-  // CODER ICI
+  constructor(name : string, weight : number) {
+    this.name = name
+    this.weight = weight
+  }
 
+  eat<T extends Food>(arg : T)  : string | void{
+    this.weight = this.weight + 10;
+  }
+
+  sleep() : void{
+    if(this.weight >= 10){
+      this.weight = this.weight-10;
+    }
+    else{
+      this.weight = 0;
+    } 
+  }
 }
diff --git a/src/animal.interface.ts b/src/animal.interface.ts
index 32d5c62..d153d9b 100644
--- a/src/animal.interface.ts
+++ b/src/animal.interface.ts
@@ -5,5 +5,8 @@
 import Food from './food/food';
 
 export default interface IAnimal {
-  // CODER ICI
+  name : string;
+  weight : number;
+  eat<T extends Food>(arg : T) : string | void;
+  sleep() : void;
 }
diff --git a/src/array.ts b/src/array.ts
index 74d328e..498b27a 100644
--- a/src/array.ts
+++ b/src/array.ts
@@ -3,23 +3,51 @@ 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(a => a % 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
+    for(var i=0; i < arr.length-1; i++) {
+      if(arr[0].length != arr[i].length ) {
+        return "relou ta fonction";
+      }
+    }
+    return true;
   }
 
   // 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 !== null){
+      if(a.length === b.length){
+        for(var i=0; i < a.length; i++) {
+          if(a[i] !== b[i]){
+            return false;
+          }
+        }
+      }
+      else{
+        return false;
+      }
+    }else{
+      if(a.length === b.length && a.length === c.length){
+        for(var i=0; i < a.length; i++) {
+          if(a[i] !== b[i] || a[i] !== c[i]){
+            return false;
+          }
+        }
+      }
+      else{
+        return false;
+      }
+    }
+    return true;
   }
 }
diff --git a/src/calculator.ts b/src/calculator.ts
index 412d171..4b9b9b1 100644
--- a/src/calculator.ts
+++ b/src/calculator.ts
@@ -1,38 +1,55 @@
 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 a/b;
+    }
+    else{
+      return 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) {
+    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) => {
+    for(var i = 2; i < a; i++){
+      if(a%i === 0){
+        return false;
+      } 
+      return a > 1;
+    }
   }
 
 }
diff --git a/src/hippopotamus.ts b/src/hippopotamus.ts
index 0c5a55b..bbf1938 100644
--- a/src/hippopotamus.ts
+++ b/src/hippopotamus.ts
@@ -5,8 +5,33 @@
 // 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 {
+export default class Hippopotamus extends Animal{
+  eat<T extends Food>(arg: T): string | void {
+    if(arg.isVegan()){
+      this.weight = this.weight+20;
+    }
+    else{
+      return "beurk";
+    }
+  }
 
-  // CODER ICI
+  sleep() : void{
+    if(this.weight >= 20){
+      this.weight = this.weight-20;
+    }
+    else{
+      this.weight = 0;
+    } 
+  }
+
+  swim(): void{
+    if(this.weight >= 50){
+      this.weight = this.weight-50;
+    }
+    else{
+      this.weight = 0;
+    }  
+  }
 }
diff --git a/src/vehicle.ts b/src/vehicle.ts
index 63e999d..992a07f 100644
--- a/src/vehicle.ts
+++ b/src/vehicle.ts
@@ -15,19 +15,33 @@ 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
+    var maj = cb();
+    var min = this.noise()
+    return min+maj;
   }
 
-
-}
+}
\ No newline at end of file