diff --git a/.gitignore b/.gitignore
index 49e0fc6b4d..77adfa81a2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,3 @@
+pruebas.js
 /node_modules
 /package-lock.json
\ No newline at end of file
diff --git a/M03 JavaScript Fundamentos/Ejercicio 01.js b/M03 JavaScript Fundamentos/Ejercicio 01.js
index 655f3d38af..82b195f313 100644
--- a/M03 JavaScript Fundamentos/Ejercicio 01.js	
+++ b/M03 JavaScript Fundamentos/Ejercicio 01.js	
@@ -5,22 +5,22 @@
 // por el correspondiente.
 
 // Crea una variable de tipo string.
-const nuevoString = null;
+const nuevoString = 'null';
 
 // Crea una variable de tipo number.
-const nuevoNumero = null;
+const nuevoNumero = 5;
 
 // Crea una variable de tipo boolean.
-const nuevoBoolean = null;
+const nuevoBoolean = true;
 
 // Resuelve el siguiente problema matemático.
-const nuevaResta = 10 - null === 3;
+const nuevaResta = 10 - 7 === 3;
 
 // Resuelve el siguiente problema matemático.
-const nuevaMultiplicacion = 10 * null === 40;
+const nuevaMultiplicacion = 10 * 4 === 40;
 
 // Resuelve el siguiente problema matemático.
-const nuevoModulo = 21 % 5 === null;
+const nuevoModulo = 21 % 5 === 1;
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
 module.exports = {
diff --git a/M03 JavaScript Fundamentos/Ejercicio 02.js b/M03 JavaScript Fundamentos/Ejercicio 02.js
index 5f1acc08fe..00b022368f 100644
--- a/M03 JavaScript Fundamentos/Ejercicio 02.js	
+++ b/M03 JavaScript Fundamentos/Ejercicio 02.js	
@@ -3,34 +3,34 @@
 
 function devolverString(string) {
    // Debe retornar un string.
-   // Tu código:
+   return string;
 }
 
 // ⛔️ "X" e "Y" son números.
 
 function suma(x, y) {
    // Retorna el resultado de su suma.
-   // Tu código:
+   return (x + y)
 }
 
 function resta(x, y) {
    // Retorna el resultado de la resta.
-   // Tu código:
+   return (x - y);
 }
 
 function divide(x, y) {
    // Retorna el resultado de su división.
-   // Tu código:
+   return (x / y);
 }
 
 function multiplica(x, y) {
    // Retorna el resultado de su multiplicación.
-   // Tu código:
+   return (x * y)
 }
 
 function obtenerResto(x, y) {
    // Obten el resto de la división de "x" entre "y".
-   // Tu código:
+   return (x % y)
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M03 JavaScript Fundamentos/Ejercicio 03.js b/M03 JavaScript Fundamentos/Ejercicio 03.js
index 03cd0c9477..bcf9cd249e 100644
--- a/M03 JavaScript Fundamentos/Ejercicio 03.js	
+++ b/M03 JavaScript Fundamentos/Ejercicio 03.js	
@@ -4,37 +4,43 @@
 function sonIguales(x, y) {
    // Retorna true si "x" e "y" son iguales.
    // De lo contrario, retorna false.
-   // Tu código:
+   if (x === y) return true
+   else return false
 }
 
 function tienenMismaLongitud(str1, str2) {
    // Retorna true si los dos strings tienen la misma longitud.
    // De lo contrario, retorna false.
-   // Tu código:
+   if(str1.length === str2.length) return true
+   else return false
 }
 
 function menosQueNoventa(num) {
    // Retorna true si el argumento "num" es menor que noventa.
    // De lo contrario, retorna false.
-   // Tu código:
+   if(num < 90) return true
+   else return false
 }
 
 function mayorQueCincuenta(num) {
    // Retorna true si el argumento "num" es mayor que cincuenta.
    // De lo contrario, retorna false.
-   // Tu código:
+   if(num > 50) return true
+   else return false
 }
 
 function esPar(num) {
    // Retorna true si "num" es par.
    // De lo contrario, retorna false.
-   // Tu código:
+   if(num % 2 == 0) return true
+   else return false
 }
 
 function esImpar(num) {
    // Retorna true si "num" es impar.
    // De lo contrario, retorna false.
-   // Tu código:
+   if(num % 2 != 0) return true
+   else return false
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M03 JavaScript Fundamentos/Ejercicio 04.js b/M03 JavaScript Fundamentos/Ejercicio 04.js
index ff7dbe2dcc..d55ce50d51 100644
--- a/M03 JavaScript Fundamentos/Ejercicio 04.js	
+++ b/M03 JavaScript Fundamentos/Ejercicio 04.js	
@@ -5,32 +5,32 @@
 
 function elevarAlCuadrado(num) {
    // Retorna el valor de "num" elevado al cuadrado.
-   // Tu código:
+   return Math.pow(num, 2)
 }
 
 function elevarAlCubo(num) {
    // Retorna el valor de "num" elevado al cubo.
-   // Tu código:
+   return Math.pow(num, 3)
 }
 
 function elevar(num, exponent) {
    // Retorna el valor de "num" elevado al exponente "exponent".
-   // Tu código:
+   return Math.pow(num, exponent)
 }
 
 function redondearNumero(num) {
    // Redondea "num" al entero más próximo y retórnalo.
-   // Tu código:
+   return Math.round(num)
 }
 
 function redondearHaciaArriba(num) {
    // Redondea "num" hacia arriba y retórnalo.
-   // Tu código:
+   return Math.ceil(num)
 }
 
 function numeroRandom() {
    // Genera un número al azar entre 0 y 1 y retórnalo.
-   // Tu código:
+   return Math.random()
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M03 JavaScript Fundamentos/Ejercicio 05.js b/M03 JavaScript Fundamentos/Ejercicio 05.js
index f82c3e3f07..2c0b53954e 100644
--- a/M03 JavaScript Fundamentos/Ejercicio 05.js	
+++ b/M03 JavaScript Fundamentos/Ejercicio 05.js	
@@ -7,47 +7,50 @@ function esPositivo(num) {
    // Si el número es positivo ---> "Es positivo".
    // Si el número es negativo ---> "Es negativo".
    // Si el número es 0, devuelve false.
-   // Tu código:
+   if(num > 0) return 'Es positivo'
+   else if (num < 0) return 'Es negativo'
+   else return false
 }
 
 function agregarSimboloExclamacion(str) {
    // Agrega un símbolo de exclamación al final del string "str" y retórnalo
    // Ejemplo: "hello world" ---> "hello world!"
-   // Tu código:
+   return str + '!'
 }
 
 function combinarNombres(nombre, apellido) {
    // Retorna "nombre" y "apellido" combinados en un mismo string pero separados por un espacio.
    // Ejemplo: ("Soy", "Henry") ---> "Soy Henry"
-   // Tu código:
+   return nombre + ' ' + apellido
 }
 
 function obtenerSaludo(nombre) {
    // Toma el string "nombre" y concatena otra string en la cadena para que tome la siguiente forma:
    // Ejemplo: "Martin" ---> "Hola Martin!"
-   // Tu código:
+   return 'Hola ' + nombre + '!'
 }
 
 function obtenerAreaRectangulo(alto, ancho) {
    // Retornar el área de un rectángulo teniendo su altura y ancho.
-   // Tu código:
+   return alto * ancho
 }
 
 function retornarPerimetro(lado) {
    // La función recibe como argumento la medida de un lado de un cuadrado.
    // Debes retornar su perímetro.
-   // Tu código:
+   return lado + lado + lado + lado 
 }
 
 function areaDelTriangulo(base, altura) {
    // Calcula el área de un triángulo y retorna el resultado.
-   // Tu código:
+   return (base * altura)/2
 }
 
 function deEuroAdolar(euro) {
    // Supongamos que 1 euro equivale a 1.20 dólares.
    // Debes calcular el valor recibido como argumento pasándolo a dolares.
    // Tu código:
+   return euro * 1.2
 }
 
 function esVocal(letra) {
@@ -55,6 +58,9 @@ function esVocal(letra) {
    // Si el usuario ingresa un string de más de un caracter debes retornar el mensaje: "Dato incorrecto".
    // Si no es vocal, tambien debe retornar "Dato incorrecto".
    // Tu código:
+   if(letra === 'a' || letra === 'e' || letra === 'i' || letra === 'o' || letra === 'u') return 'Es vocal'
+   else if (letra.length > 1) return 'Dato incorrecto'
+   else if (letra !== 'a' || letra !== 'e' || letra !== 'i' || letra !== 'o' || letra !== 'u') return 'Dato incorrecto'
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M04 JavaScript Bucles/homework.js b/M04 JavaScript Bucles/homework.js
index 4195354dd9..e6effcf002 100644
--- a/M04 JavaScript Bucles/homework.js	
+++ b/M04 JavaScript Bucles/homework.js	
@@ -4,14 +4,15 @@ function obtenerMayor(x, y) {
    // "x" e "y" son números enteros.
    // Retornar el número más grande.
    // Si son iguales, retornar cualquiera de los dos.
-   // Tu código:
+   return Math.max(x, y)
 }
 
 function mayoriaDeEdad(edad) {
    // Determinar si la persona puede ingresar al evento según su edad.
    // Si tiene 18 años ó más debe retornar el string: "Allowed".
    // Caso contrario: "Not allowed".
-   // Tu código:
+   if(edad > 17) return "Allowed"
+   else return "Not allowed"
 }
 
 function conection(status) {
@@ -20,7 +21,9 @@ function conection(status) {
    // Si el estado es igual a 2, el usuario está "Away".
    // De lo contrario, presumimos que el usuario está "Offline".
    // Retornar el estado de conexión del usuario.
-   // Tu código:
+   if(status === 1) return "Online"
+   else if(status === 2) return "Away"
+   else return "Offline"
 }
 
 function saludo(idioma) {
@@ -29,7 +32,20 @@ function saludo(idioma) {
    // Si "idioma" es "mandarin", devuelve "Ni Hao!".
    // Si "idioma" es "ingles", devuelve "Hello!".
    // Si "idioma" no es ninguno de los anteriores o es `undefined` devuelve "Hola!".
-   // Tu código:
+   switch (idioma) {
+      case "aleman":
+          return ("Guten Tag!");
+          break;
+      case "mandarin":
+          return ("Ni Hao!");
+          break;
+      case  "ingles":
+          return ("Hello!");
+          break;
+      default:
+          return ("Hola!");
+          break;
+   }
 }
 
 function colors(color) {
@@ -40,19 +56,37 @@ function colors(color) {
    // En caso que el color recibido sea "orange" --> "This is orange".
    // Si no es ninguno de esos colores           --> "Color not found".
    // IMPORTANTE: utilizar el statement SWITCH.
-   // Tu código:
+   switch (color) {
+      case "blue" :
+         return "This is blue"
+         break;
+      case "red" :
+         return "This is red"
+         break;
+      case "green" :
+         return "This is green"
+         break;
+      case "orange" :
+         return "This is orange"
+         break;
+      default:
+         return "Color not found"
+         break;
+   }
 }
 
 function esDiezOCinco(num) {
    // Retornar true si "num" es 10 o 5.
    // De lo contrario, retornar false.
-   // Tu código:
+   if(num === 10 || num === 5) return true
+   else return false
 }
 
 function estaEnRango(num) {
    // Retornar true si "num" es menor que 50 y mayor que 20.
    // De lo contrario, retornar false.
-   // Tu código:
+   if(num < 50 && num > 20) return true
+   else return false
 }
 
 function esEntero(num) {
@@ -61,7 +95,8 @@ function esEntero(num) {
    // Ejemplo: 1     ---> true
    // Ejemplo: (-10) ---> true
    // De lo contrario, retorna false.
-   // Tu código:
+   if(num % 1 == 0) return true
+   else return false
 }
 
 function fizzBuzz(num) {
@@ -69,7 +104,10 @@ function fizzBuzz(num) {
    // Si "num" es divisible entre 5, retorna "buzz".
    // Si "num" es divisible entre 3 y 5 (ambos), retorna "fizzbuzz".
    // De lo contrario, retorna false.
-   // Tu código:
+   if(num % 15 == 0) return "fizzbuzz"
+   else if(num % 5 == 0) return "buzz"
+   else if(num % 3 == 0) return "fizz"
+   else return false
 }
 
 function operadoresLogicos(num1, num2, num3) {
@@ -79,7 +117,11 @@ function operadoresLogicos(num1, num2, num3) {
    // Si num3 es más grande que num1 y num2, aumentar su valor en 1 y retornar el nuevo valor.
    // Si todos los argumentos son cero, retornar ---> "Error".
    // Si no se cumple ninguna de las condiciones anteriores, retornar false.
-   // Tu código:
+   if (num1 > num2 && num1 > num3 && num1 > 0) return "Numero 1 es mayor y positivo"
+   else if (num1 < 0 || num2 < 0 || num3 < 0) return "Hay negativos";
+   else if (num3 > num1 && num3 > num2) return num3 ++
+   else if (num1 === 0 && num2 === 0 && num3 === 0) return "Error";
+   else return false;
 }
 
 function esPrimo(num) {
@@ -88,26 +130,38 @@ function esPrimo(num) {
    // [Pista 1]: un número primo sólo es divisible por sí mismo y por 1.
    // [Pista 2]: puedes resolverlo utilizando un `bucle for`.
    // [Nota]: los números negativos, 0 y 1 NO son números primos.
-   // Tu código:
+   if (num <= 1) return false;
+   for (var i = 2; i <= num - 1; i++)
+      if (num % i == 0) return false;
+   return true;
 }
 
 function esVerdadero(valor) {
    // Si "valor" es verdadero retornar "Soy verdadero".
    // Caso contrario, retornar "Soy falso".
-   // Tu código:
+   if (valor === true) return "Soy verdadero"
+   else return "Soy falso"
 }
 
 function tieneTresDigitos(num) {
    // Si el número recibido tiene tres dígitos retornar true.
    // Caso contrario, retornar false.
-   // Tu código:
+   if(num < 1000 && num >= 100) return true
+   else return false
 }
 
 function doWhile(num) {
    // Implementar una función que aumente el valor recibido en 5 hasta un límite de 8 veces.
    // Retornar el valor final.
    // Utilizar el bucle Do-While.
-   // Tu código:
+   let i = 0;
+
+    do {
+        i = i + 1;
+        num = num + 5
+    } while (i < 8);
+    
+    return num;
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M05 JavaScript Arrays/homework.js b/M05 JavaScript Arrays/homework.js
index f736cfe9f6..e7f27c2bb8 100644
--- a/M05 JavaScript Arrays/homework.js	
+++ b/M05 JavaScript Arrays/homework.js	
@@ -3,34 +3,40 @@
 function devolverPrimerElemento(array) {
    // Retornar el primer elemento del arreglo recibido por parámetro.
    // Tu código:
+   return array[0]
 }
 
 function devolverUltimoElemento(array) {
    // Retornar el último elemento del arreglo recibido por parámetro.
-   // Tu código:
+   return array.pop()
 }
 
 function obtenerLargoDelArray(array) {
    // Retornar la longitud del arreglo recibido por parámetro.
-   // Tu código:
+   return array.length
 }
 
 function incrementarPorUno(array) {
    // El arreglo recibido por parámetro contiene números.
    // Retornar un arreglo con los elementos incrementados en +1.
-   // Tu código:
+   let newArr = []
+   array.forEach(e => newArr.push(e+1));
+
+   return newArr
 }
 
 function agregarItemAlFinalDelArray(array, elemento) {
    // Agrega el "elemento" al final del arreglo recibido.
    // Retorna el arreglo.
-   // Tu código:
+   array.push(elemento)
+   return array
 }
 
 function agregarItemAlComienzoDelArray(array, elemento) {
    // Agrega el "elemento" al comienzo del arreglo recibido.
    // Retorna el arreglo.
-   // Tu código:
+   array.unshift(elemento)
+   return array
 }
 
 function dePalabrasAFrase(palabras) {
@@ -38,81 +44,123 @@ function dePalabrasAFrase(palabras) {
    // Retornar un string donde todas las palabras estén concatenadas
    // con un espacio entre cada palabra.
    // Ejemplo: ['Hello', 'world!'] -> 'Hello world!'.
-   // Tu código:
+   return palabras.join(' ')
 }
 
 function arrayContiene(array, elemento) {
    // Verifica si el elemento existe dentro del arreglo recibido.
    // Retornar true si está, o false si no está.
-   // Tu código:
+   return array.includes(elemento)
 }
 
 function agregarNumeros(arrayOfNums) {
    // El parámetro "arrayOfNums" debe ser un arreglo de números.
    // Suma todos los elementos y retorna el resultado.
-   // Tu código:
+   let sum = 0
+   arrayOfNums.forEach(e => sum += e)
+
+   return  sum
 }
 
 function promedioResultadosTest(resultadosTest) {
    // El parámetro "resultadosTest" es un arreglo de números.
    // Itera (en un bucle) los elementos del arreglo y devuelve el promedio de las notas.
-   // Tu código:
+   let sum = 0
+   let prom = 0
+
+   resultadosTest.forEach(e => sum += e)
+   prom = sum/resultadosTest.length
+
+   return prom
 }
 
 function numeroMasGrande(arrayOfNums) {
    // El parámetro "arrayOfNums" es un arreglo de números.
    // Retornar el número más grande.
-   // Tu código:
+   return Math.max.apply(null, arrayOfNums)
 }
 
 function multiplicarArgumentos() {
    // Usa la palabra clave `arguments` para multiplicar todos los argumentos y devolver el producto.
    // Si no se pasan argumentos retorna 0. Si se pasa un argumento, simplemente retórnalo.
    // [PISTA]: "arguments" es un arreglo.
-   // Tu código:
+   var args = Array.prototype.slice.call(arguments);
+   if(args.length === 0) return 0
+   else {
+      var total = 1;
+      for( var i = 0; i < args.length; i++){
+         total *= args[i]
+      };
+      return total;
+   }
 }
 
 function cuentoElementos(array) {
    // Desarrolla una función que retorne la cantidad de elementos del arreglo cuyo valor sea mayor que 18.
-   // Tu código:
+   let count = array.filter(i => i > 18)
+
+   return count.length
 }
 
 function diaDeLaSemana(numeroDeDia) {
    // Supongamos que los días de la semana se codifican como 1 = Domingo, 2 = Lunes y así sucesivamente.
    // Realiza una función que, dado el número del día de la semana, retorne: "Es fin de semana"
    // si el día corresponde a "Sábado" o "Domingo", y "Es dia laboral" en caso contrario.
-   // Tu código:
+   
+   if (numeroDeDia === 1 || numeroDeDia === 7) {
+      return "Es fin de semana"
+   } else {
+      return "Es dia laboral"
+   }
 }
 
 function empiezaConNueve(num) {
    // Esta función recibe por parámetro un número.
    // Debe retornar true si el entero inicia con 9 y false en otro caso.
-   // Tu código:
+   let startNum = num.toString().startsWith(9)
+    return startNum
 }
 
 function todosIguales(array) {
    // Si todos los elementos del arreglo son iguales, retornar true.
    // Caso contrario retornar false.
-   // Tu código:
+   for (let i = 0; i < array.length; i++) {
+      const el = array[i];
+      return array.every(e => e === el)
+   }
 }
 
 function mesesDelAño(array) {
    // El arreglo contiene algunos meses del año desordenados. Debes recorrerlo, buscar los meses "Enero",
    // "Marzo" y "Noviembre", guardarlos en un nuevo arreglo y retornarlo.
    // Si alguno de los meses no está, retornar el string: "No se encontraron los meses pedidos".
-   // Tu código:
+   let findMonths = ["Enero", "Marzo", "Noviembre"]
+   let mesesHallados = array.filter((mes) => {
+      if(findMonths.indexOf(mes) >= 0) return true
+      else return false
+   })
+
+   if(mesesHallados.length == findMonths.length) return mesesHallados
+   else return "No se encontraron los meses pedidos"
 }
 
 function tablaDelSeis() {
    // Escribe una función que muestre la tabla de multiplicar del 6 (del 0 al 60).
    // La función devuelve un arreglo con los resultados de la tabla de multiplicar del 6 en orden creciente.
-   // Tu código:
+   const tabla = []
+   for (let i = 0; i <= 10; i++) {
+      let iter = 0
+      iter += i * 6
+      tabla.push(iter)
+   }
+   return tabla
 }
 
 function mayorACien(array) {
    // La función recibe un arreglo con enteros entre 0 y 200.
    // Recorrerlo y retornar un arreglo con todos los valores mayores a 100 (no incluye el 100).
-   // Tu código:
+   const newArray = array.filter(e => e > 100)
+   return newArray
 }
 
 /* ----------------------------------------------------------------------------------
@@ -125,7 +173,20 @@ function breakStatement(num) {
    // Si en algún momento el valor de la suma y la cantidad de iteraciones coinciden, debe interrumpirse
    // la ejecución y retornar el string: "Se interrumpió la ejecución".
    // [PISTA]: utiliza el statement 'break'.
-   // Tu código:
+   var newArray = [];
+   var suma = num;
+   for (var i = 0; i < 10; i++) {
+      suma = suma + 2;
+      if (suma === i) {
+         var bool = false
+         break;
+      }
+      else {
+         newArray.push(suma);
+      }
+   }
+   if (bool === false) return "Se interrumpió la ejecución"
+   else return newArray; 
 }
 
 function continueStatement(num) {
@@ -134,7 +195,13 @@ function continueStatement(num) {
    // Cuando el número de iteraciones alcance el valor 5, no se suma ese caso y
    // se continua con la siguiente iteración.
    // [PISTA]: utiliza el statement 'continue'.
-   // Tu código:
+   var newArray = [];
+   for (var i = 0; i < 10; i++) {
+      if (i === 5)  continue
+      num += 2;
+      newArray.push(num);
+   }
+   return newArray;
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M06 JavaScript Objetos/homework.js b/M06 JavaScript Objetos/homework.js
index c2b9c9f9a0..7d3fcf6b98 100644
--- a/M06 JavaScript Objetos/homework.js	
+++ b/M06 JavaScript Objetos/homework.js	
@@ -6,14 +6,24 @@ function crearGato(nombre, edad) {
    // Además, agregar una propiedad con el nombre "meow".
    // La propiedad "meow" será una función que retorne el string: "Meow!".
    // Retornar el objeto.
-   // Tu código:
+   var cats = {
+      nombre: nombre,
+      edad: edad,
+      meow: () => { return 'Meow!' }
+  }
+  return cats
 }
 
 function nuevoUsuario(nombre, email, password) {
    // Debes crear un nuevo objeto.
    // Este debe tener las propiedades: "nombre", "email" y "password" con sus respectivos valores.
    // Retornar el objeto.
-   // Tu código:
+   var user = {
+      nombre: nombre,
+      email: email,
+      password: password
+   }
+   return user
 }
 
 function agregarPropiedad(objeto, propiedad) {
@@ -21,58 +31,64 @@ function agregarPropiedad(objeto, propiedad) {
    // Debes agregarle una propiedad con el nombre recibido por parámetro.
    // Esta propiedad será igual al valor `null`.
    // Retornar el objeto.
-   // Tu código:
+   objeto[propiedad] = null
+
+   return objeto
 }
 
 function invocarMetodo(objeto, metodo) {
    // El parámetro "metodo" es un string que coincide con el nombre de una propiedad del objeto recibido.
    // Esta propiedad contiene una función en su interior. Debes invocarla/ejecutarla.
    // [NOTA]: no necesitar retornar nada.
-   // Tu código:
+   objeto[metodo]()
 }
 
 function multiplicarNumeroDesconocidoPorCinco(objetoMisterioso) {
    // El parámetro "objetoMisterioso" posee una propiedad con el nombre "numeroMisterioso".
    // Debes multiplicar este número por 5 y retornar el resultado.
-   // Tu código:
+   const porCinco = objetoMisterioso['numeroMisterioso'] * 5
+   return porCinco
 }
 
 function eliminarPropiedad(objeto, propiedad) {
    // El parámetro "propiedad" es una propiedad del objeto que recibes.
    // Debes eliminarla del objeto y retornarlo finalmente.
-   // Tu código:
+   delete objeto[propiedad]
+   return objeto
 }
 
 function tieneEmail(objetoUsuario) {
    // Verifica si el "objetoUsuario", en su propiedad "email", posee un valor definido.
    // En ese caso retornar true. Caso contrario, false.
-   // Tu código:
+   return 'email' in objetoUsuario && objetoUsuario.email !== undefined && objetoUsuario.email !== null
 }
 
 function tienePropiedad(objeto, propiedad) {
    // Verifica si el objeto recibido posee una propiedad con el mismo nombre que el parámetro "propiedad".
    // En ese caso retornar true. Caso contrario, false.
-   // Tu código:
+   return propiedad in objeto
 }
 
 function verificarPassword(objetoUsuario, password) {
    // Verifica si la propiedad "password" del "objetoUsuario" coincide con el parámetro "password".
    // En ese caso retornar true. Caso contrario, false.
-   // Tu código:
+   return objetoUsuario.password === password
 }
 
 function actualizarPassword(objetoUsuario, nuevaPassword) {
    // Reemplaza la contrseña guardada en la propiedad "password" del "objetoUsuario".
    // La nueva contraseña la recibes por parámetro.
    // Retornar el objeto.
-   // Tu código:
+   objetoUsuario.password = nuevaPassword
+   return objetoUsuario
 }
 
 function agregarAmigo(objetoUsuario, nuevoAmigo) {
    // El parámetro "objetoUsuario" tiene una propiedad llamada "amigos" igual a un arreglo.
    // Debes agregar el "nuevoAmigo" al final de este arreglo.
    // Retornar el objeto.
-   // Tu código:
+   objetoUsuario['amigos'].push(nuevoAmigo)
+   return objetoUsuario
 }
 
 function pasarUsuarioAPremium(objetoMuchosUsuarios) {
@@ -80,7 +96,10 @@ function pasarUsuarioAPremium(objetoMuchosUsuarios) {
    // Cada usuario tiene una propiedad llamada "esPremium".
    // Define esta propiedad de todos los usuarios como true.
    // Retornar el arreglo.
-   // Tu código:
+   for (let i = 0; i < objetoMuchosUsuarios.length; i++) {
+      objetoMuchosUsuarios[i].esPremium = true;
+   }
+   return objetoMuchosUsuarios;
 }
 
 function sumarLikesDeUsuario(objetoUsuario) {
@@ -88,7 +107,11 @@ function sumarLikesDeUsuario(objetoUsuario) {
    // Este arreglo contiene objetos (post).
    // Cada post posee una propiedad llamada "likes". Esta propiedad es un número.
    // Debes sumar los likes de todos los post y retornar el resultado.
-   // Tu código:
+   let sumaLikes = 0
+   for (let i = 0; i < objetoUsuario.posts.length; i++) {
+      sumaLikes += objetoUsuario.posts[i].likes 
+   }
+   return sumaLikes
 }
 
 function agregarMetodoCalculoDescuento(objetoProducto) {
@@ -101,7 +124,11 @@ function agregarMetodoCalculoDescuento(objetoProducto) {
    // Precio ---> 10
    // PorcentajeDeDescuento ---> 0.2
    // Precio final ---> 8
-   // Tu código:
+   objetoProducto.calcularPrecioDescuento = function() {
+      if(this.porcentajeDeDescuento % 1 == 0) return this.precio - (this.precio * (this.porcentajeDeDescuento / 100))
+      else return this.precio - (this.precio * this.porcentajeDeDescuento)
+   }
+   return objetoProducto
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M07 JavaScript Clases/Ejercicio 01.js b/M07 JavaScript Clases/Ejercicio 01.js
index 23586970d5..5ea9817eb8 100644
--- a/M07 JavaScript Clases/Ejercicio 01.js	
+++ b/M07 JavaScript Clases/Ejercicio 01.js	
@@ -9,19 +9,39 @@ function crearUsuario() {
    // Este método debe retornar el string: 'Hola, mi nombre es {{nombre}}'.
    // El valor {{nombre}} debe ser el nombre definido para la instancia de la clase.
    // Retornar la clase.
-   // Tu código:
+   class Usuario {
+      constructor(usuario, nombre, email, password) {
+         this.usuario = usuario,
+         this.nombre = nombre,
+         this.email = email,
+         this.password = password
+      }
+
+      saludar() {
+         return `Hola, mi nombre es ${this.nombre}`
+      }
+   }
+
+   return Usuario
 }
 
 function agregarMetodoPrototype(Usuario) {
    // Agrega un método al prototipo de "Usuario".
    // El método debe llamarse "saludar" y debe devolver el string "Hello World!".
-   // Tu código:
+   Usuario.prototype.saludar = function () {
+      return 'Hello World!'
+   }
+
+   return Usuario
 }
 
 function agregarStringInvertida() {
    // Agrega un método al prototipo de "String" que devuelva la misma cadena de caracteres, pero invertida.
    // El método debe llamarse "reverse".
    // [PISTA]: necesitarás utilizar el objeto "this".
+   String.prototype.reverse = function () {
+      return this.split('').reverse().join('')
+   }
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M07 JavaScript Clases/Ejercicio 02.js b/M07 JavaScript Clases/Ejercicio 02.js
index ed07493e66..5375f2d8a0 100644
--- a/M07 JavaScript Clases/Ejercicio 02.js	
+++ b/M07 JavaScript Clases/Ejercicio 02.js	
@@ -6,20 +6,38 @@ class Persona {
    // Debe tener las propiedades: "nombre", "apellido", "edad" y "domicilio".
    // Debe tener un método llamado "detalle" que nos devuelva un objeto con las propiedades de la persona y
    // sus valores.
+   constructor(nombre, apellido, edad, domicilio) {
+      this.nombre = nombre,
+      this.apellido = apellido,
+      this.edad = edad,
+      this.domicilio = domicilio
+   }
+
+   detalle() {
+      return {
+         nombre: this.nombre,
+         apellido: this.apellido,
+         edad: this.edad,
+         domicilio: this.domicilio
+      }
+   }
 }
 
 function crearInstanciaPersona(nombre, apellido, edad, domicilio) {
    // En este ejercicio debes crear una instancia de la clase construida en el ejercicio anterior.
    // Recibirás las propiedades por parámetro.
    // Retornar la instancia creada.
-   // Tu código:
+   var newUser = new Persona(nombre, apellido, edad, domicilio)
+   return newUser
 }
 
 function agregarMetodo() {
    // La función agrega un método "datos" a la clase "Persona".
    // Este método toma la propiedad "nombre" y "edad", y devuelve el string:
    // Ejemplo: "Juan, 22 años".
-   // Tu código:
+   Persona.prototype.datos = function() {
+      return `${this.nombre}, ${this.edad} años`
+   }
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M08 JavaScript Callback/homework.js b/M08 JavaScript Callback/homework.js
index b14ff4b6f6..5a0557ce77 100644
--- a/M08 JavaScript Callback/homework.js	
+++ b/M08 JavaScript Callback/homework.js	
@@ -4,20 +4,20 @@ function mayuscula(nombre) {
    // Esta función recibe un nombre (string).
    // Debe devolver el mismo nombre, pero con la primera letra en mayúscula.
    // [Ejemplo]: "mario" ----> "Mario".
-   // Tu código:
+   return nombre[0].toUpperCase() + nombre.substring(1)
 }
 
 function invocarCallback(cb) {
    // Invoca/ejecuta el callback `cb`.
    // [NOTA]: no debes reotrnar nada.
-   // Tu código:
+   cb()
 }
 
 function operacionMatematica(num1, num2, cb) {
    // En este ejercicio recibirás dos números y un callback.
    // El callback realiza una operación matemática, por lo que necesita de los dos números.
    // Retorna el resultado del callback pasándole como parámetros los números.
-   // Tu código:
+   return cb(num1,num2)
 }
 
 function sumarArray(arrayOfNumbers, cb) {
@@ -25,27 +25,30 @@ function sumarArray(arrayOfNumbers, cb) {
    // Suma todos los números del arreglo.
    // Este resultado debes pasárselo como argumento al callback recibido.
    // [NOTA]: no debes reotrnar nada.
-   // Tu código:
+   var suma = arrayOfNumbers.reduce((a,b) => { return a + b })
+   cb(suma)
 }
 
 function forEach(array, cb) {
    // Recibes un arreglo y un callback.
    // Debes iterar sobre el arreglo, y por cada elemento ejecutar el callback.
    // Debes pasarle el elemento como argumento al callback.
-   // Tu código:
+   array.forEach(i => cb(i))
 }
 
 function map(array, cb) {
    // Debes iterar sobre el arreglo, y cada elemento pasárselo como arguemento al callback.
    // Tiene que guardar el resultado devuelto por el callback en cada elemento dentro de un nuevo arreglo.
    // Retorna el nuevo arreglo.
-   // Tu código:
+   let iterar = array.map(i => cb(i))
+   return iterar
 }
 
 function filter(arrayOfStrings) {
    // Debes identificar todos los elementos el arreglo que comiencen con la letra "a".
    // Luego retorna un nuevo arreglo con estos elementos.
-   // Tu código:
+   let arr = arrayOfStrings.filter(i => i[0] == 'a')
+   return arr
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M09 Ejercicios Extra/Ejercicios Extra.js b/M09 Ejercicios Extra/Ejercicios Extra.js
index 84c1863d6f..77168b5932 100644
--- a/M09 Ejercicios Extra/Ejercicios Extra.js	
+++ b/M09 Ejercicios Extra/Ejercicios Extra.js	
@@ -5,7 +5,9 @@ function deObjetoAarray(objeto) {
    // Cada elemento del arreglo padre será un nuevo arreglo que contendrá dos elementos.
    // Estos elementos debe ser cada par clave:valor del objeto recibido.
    // [EJEMPLO]: {D: 1, B: 2, C: 3} ---> [['D', 1], ['B', 2], ['C', 3]].
-   // Tu código:
+   return Object.entries(objeto).map(i => {
+      return [i[0], i[1]];
+    });
 }
 
 function numberOfCharacters(string) {
@@ -13,7 +15,23 @@ function numberOfCharacters(string) {
    // letras del string, y su valor es la cantidad de veces que se repite en el string.
    // Las letras deben estar en orden alfabético.
    // [EJEMPLO]: "adsjfdsfsfjsdjfhacabcsbajda" ---> { a: 5, b: 2, c: 2, d: 4, f: 4, h:1, j: 4, s: 5 }
-   // Tu código:
+   let contador = {}
+
+   for (let i = 0; i < string.length; i++) {
+      let letra = string[i]
+      if(contador[letra]) { contador[letra]++ }
+      else { contador[letra] = 1 }      
+   }
+
+   let letrasOrdenadas = Object.keys(contador).sort()
+
+   let resultado = {}
+   for (let i = 0; i < letrasOrdenadas.length; i++) {
+      let letra = letrasOrdenadas[i];
+      resultado[letra] = contador[letra]
+   }
+
+   return resultado
 }
 
 function capToFront(string) {
@@ -21,26 +39,43 @@ function capToFront(string) {
    // Debes enviar todas las letras en mayúscula al comienzo del string.
    // Retornar el string.
    // [EJEMPLO]: soyHENRY ---> HENRYsoy
-   // Tu código:
+   var mayusculas = ''
+   var minusculas = ''
+   for (let i = 0; i < string.length; i++) {
+      var letra = string[i];
+      if (letra === letra.toUpperCase()) { mayusculas += letra }
+      else { minusculas += letra }
+   }
+
+   return mayusculas + minusculas
 }
 
 function asAmirror(frase) {
    // Recibes una frase. Tu tarea es retornar un nuevo string en el que el orden de las palabras sea el mismo.
    // La diferencia es que cada palabra estará escrita al inverso.
    // [EJEMPLO]: "The Henry Challenge is close!"  ---> "ehT yrneH egnellahC si !esolc"
-   // Tu código:
+   const palabras = frase.split(" ")
+   const resultado = []
+   for (let i = 0; i < palabras.length; i++) {
+      const fraseEspejo = palabras[i].split("").reverse().join("");
+      resultado.push(fraseEspejo)
+   }
+
+   return resultado.join(" ")
 }
 
 function capicua(numero) {
    // Si el número que recibes es capicúa debes retornar el string: "Es capicua".
    // Caso contrario: "No es capicua".
-   // Tu código:
+   const capicua = parseInt(numero.toString().split("").reverse().join(""))
+   if(numero === capicua) return 'Es capicua'
+   else return "No es capicua"
 }
 
 function deleteAbc(string) {
    // Tu tarea es eliminar las letras "a", "b" y "c" del string recibido.
    // Retorna el string sin estas letras.
-   // Tu código:
+   return string.replace(/[abc]/g, "")
 }
 
 function sortArray(arrayOfStrings) {
@@ -48,7 +83,7 @@ function sortArray(arrayOfStrings) {
    // Debe retornar un nuevo arreglo, pero con las palabras ordenadas en orden creciente a partir
    // de la longitud de cada string.
    // [EJEMPLO]: ["You", "are", "beautiful", "looking"]  ---> [“You", "are", "looking", "beautiful"]
-   // Tu código:
+   return arrayOfStrings.sort((a,b) => a.length - b.length)
 }
 
 function buscoInterseccion(array1, array2) {
@@ -57,7 +92,7 @@ function buscoInterseccion(array1, array2) {
    // [EJEMPLO]: [4,2,3] U [1,3,4] = [3,4].
    // Si no tienen elementos en común, retornar un arreglo vacío.
    // [PISTA]: los arreglos no necesariamente tienen la misma longitud.
-   // Tu código:
+   return array1.filter(e => array2.includes(e))
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/pruebas.js b/pruebas.js
new file mode 100644
index 0000000000..08b109ea3d
--- /dev/null
+++ b/pruebas.js
@@ -0,0 +1,267 @@
+function capicua(numero) {
+    // Si el número que recibes es capicúa debes retornar el string: "Es capicua".
+    // Caso contrario: "No es capicua".
+    const capicua = parseInt(numero.toString().split("").reverse().join(""))
+    if(numero === capicua) return 'Es capicua'
+    else return "No es capicua"
+ }
+
+ console.log(capicua(123));
+
+/* function numberOfCharacters(string) {
+    // La función recibe un string. Debes recorrerlo y retornar un objeto donde cada propiedad es una de las
+    // letras del string, y su valor es la cantidad de veces que se repite en el string.
+    // Las letras deben estar en orden alfabético.
+    // [EJEMPLO]: "adsjfdsfsfjsdjfhacabcsbajda" ---> { a: 5, b: 2, c: 2, d: 4, f: 4, h:1, j: 4, s: 5 }
+    let contador = {};
+   
+    for (let i = 0; i < string.length; i++) {
+       let letra = string[i];
+       if (contador[letra]) {
+          contador[letra]++;
+       } else {
+          contador[letra] = 1;
+       }
+    }
+ 
+    let letrasOrdenadas = Object.keys(contador).sort();
+ 
+    let resultado = {};
+    for (let i = 0; i < letrasOrdenadas.length; i++) {
+       let letra = letrasOrdenadas[i];
+       resultado[letra] = contador[letra];
+    }
+ 
+    return resultado;
+ }
+ */
+/* function sumarArray(arrayOfNumbers, cb) {
+    // Recibes un arreglo de números y un callback.
+    // Suma todos los números del arreglo.
+    // Este resultado debes pasárselo como argumento al callback recibido.
+    // [NOTA]: no debes reotrnar nada.
+    var suma = arrayOfNumbers.reduce((a,b) => { return a + b })
+    cb(suma)
+}
+arr = [1, 2, 3, 4, 5]
+var callback = function(cb) {
+    return cb
+}
+// var suma = arr.reduce((a,b) => { return a + b })
+// console.log(suma);
+console.log(sumarArray(arr, callback)); */
+
+/* function mayuscula(nombre) {
+    // Esta función recibe un nombre (string).
+    // Debe devolver el mismo nombre, pero con la primera letra en mayúscula.
+    // [Ejemplo]: "mario" ----> "Mario".
+    var upperCase = function(letra) {
+        return letra[0].toUpperCase() + letra.substring(1)
+    }
+
+    var  firstUppercase = function(cb1) {
+        return nombre + ' - ' + cb1(nombre)
+    }
+
+    return firstUppercase(upperCase)
+}
+console.log(mayuscula('ana')); */
+
+/* var devuelvoFrase = function(comida) {
+    return 'Hoy quiero comer: ' + comida
+}
+
+var hablar = function (comida, cb) {
+    return cb(comida)
+}
+
+var fraseFinal = hablar('Pizza', devuelvoFrase)
+console.log(fraseFinal); */
+
+/* function crearUsuario() {
+    // Crea una Clase de ES6 o una función constructora llamada "Usuario".
+    // El constructor de esta clase debe tener las propiedades: "usuario", "nombre", "email" y "password".
+    // El valor de cada propiedad la recibirá por parámetro.
+    // Además, esta clase debe tener un método llamado "saludar".
+    // Este método debe retornar el string: 'Hola, mi nombre es {{nombre}}'.
+    // El valor {{nombre}} debe ser el nombre definido para la instancia de la clase.
+    // Retornar la clase.
+    class Usuario {
+       constructor(usuario, nombre, email, password) {
+          this.usuario = usuario,
+          this.nombre = nombre,
+          this.email = email,
+          this.password = password
+       }
+    
+       saludar() {
+          return 'Hola, mi nombre es ' + this.nombre
+       }
+    }
+    
+    return Usuario
+}
+
+console.log();
+console.log(John.saludar());
+
+console.log(crearUsuario); */
+
+/* function agregarMetodoCalculoDescuento(objetoProducto) {
+    // Agrega una propiedad al "objetoProducto" con el nombre "calcularPrecioDescuento".
+    // Esta propiedad debe ser una función que multiplique el precio del producto por el porcentajeDeDescuento.
+    // El "objetoProducto" posee una propiedad "precio" y una propiedad "porcentajeDeDescuento".
+    // Luego debes restar del precio total del producto ese valor de descuento.
+    // Retornar el precio final.
+    // Ejemplo:
+    // Precio ---> 10
+    // PorcentajeDeDescuento ---> 0.2
+    // Precio final ---> 8
+
+    objetoProducto.calcularPrecioDescuento = function() {
+        if(this.porcentajeDeDescuento % 1 == 0) return this.precio - (this.precio * (this.porcentajeDeDescuento / 100))
+        else return this.precio - (this.precio * this.porcentajeDeDescuento)
+    }
+    return objetoProducto
+}
+finalPrice = {
+    precio: 10,
+    porcentajeDeDescuento: 20
+}
+console.log(agregarMetodoCalculoDescuento(finalPrice)); */
+
+/* let objetoProducto = {
+    precio: 10,
+    porcentajeDeDescuento: 20,
+    calcularPrecioDescuento: function() {
+      let descuento = this.precio * (this.porcentajeDeDescuento / 100);
+      let precioFinal = this.precio - descuento;
+      return precioFinal;
+    }
+};
+  
+console.log(objetoProducto.calcularPrecioDescuento()); */
+  
+
+/* function pasarUsuarioAPremium(objetoMuchosUsuarios) {
+    // El parámetro "objetoMuchosUsuarios" es un arreglo de objetos (usuarios).
+    // Cada usuario tiene una propiedad llamada "esPremium".
+    // Define esta propiedad de todos los usuarios como true.
+    // Retornar el arreglo.
+    for (let i = 0; i < objetoMuchosUsuarios.length; i++) {
+        objetoMuchosUsuarios[i].esPremium = true;
+      }
+      return objetoMuchosUsuarios;
+}
+
+var object = [{esPremium: null}, {esPremium: null}, {esPremium: null}]
+console.log(pasarUsuarioAPremium(true)) */
+
+/* function agregarAmigo(objetoUsuario, nuevoAmigo) {
+    // El parámetro "objetoUsuario" tiene una propiedad llamada "amigos" igual a un arreglo.
+    // Debes agregar el "nuevoAmigo" al final de este arreglo.
+    // Retornar el objeto.
+    objetoUsuario.amigos.push(nuevoAmigo)
+    return objetoUsuario
+ }
+ var object = {name: 'John', password: 'pass', amigos: ['amigo']}
+ console.log(agregarAmigo(object, 'nuevo Amigo')) */
+
+/* function actualizarPassword(objetoUsuario, nuevaPassword) {
+    // Reemplaza la contrseña guardada en la propiedad "password" del "objetoUsuario".
+    // La nueva contraseña la recibes por parámetro.
+    // Retornar el objeto.
+    objetoUsuario.password = nuevaPassword
+    return objetoUsuario
+}
+var object = {name: 'John', password: 'pass'}
+console.log(actualizarPassword(object, 'other')) */
+
+/* function verificarPassword(objetoUsuario, password) {
+    // Verifica si la propiedad "password" del "objetoUsuario" coincide con el parámetro "password".
+    // En ese caso retornar true. Caso contrario, false.
+    return objetoUsuario.password === password
+}
+var object = {name: 'John', password: 'pass'}
+console.log(verificarPassword(object, 'pass')); */
+
+/* function crearGato(nombre, edad) {
+    // Debes crear un nuevo objeto con las propiedades "nombre" y "edad".
+    // Ambas propiedades deben tener el valor correspondiente recibido por parámetro.
+    // Además, agregar una propiedad con el nombre "meow".
+    // La propiedad "meow" será una función que retorne el string: "Meow!".
+    // Retornar el objeto.
+    var cats = {
+        nombre: nombre,
+        edad: edad,
+        meow: () => { console.log('Meow!'); }
+    }
+    return cats
+}
+console.log(crearGato('misifu', 5)); */
+
+/* function continueStatement(num) {
+    // Iterar en un bucle aumentando en 2 el número recibido hasta un límite de 10 veces.
+    // Guardar cada nuevo valor en un array y retornarlo.
+    // Cuando el número de iteraciones alcance el valor 5, no se suma ese caso y
+    // se continua con la siguiente iteración.
+    // [PISTA]: utiliza el statement 'continue'.
+    var newArray = [];
+    for (var i = 0; i < 10; i++) {
+        if (i === 5)  continue
+        num += 2;
+        newArray.push(num);
+    }
+    return newArray;
+}
+const arr = [50]
+console.log(continueStatement(50)) */
+//  const arr = [100, 4, 56, 78, 200, 120, 7, 160, 148, 22]
+//  const arr = ['V','a','l','e','n','t','i','n','a']
+//  console.log(funcionEjemplo(arr));
+// multiplicarArgumentos(1,2,3,4)
+ 
+/* function tabla() {
+    const tabla = []
+    for (let i = 0; i <= 10; i++) {
+        let iter = 0
+        iter += i * 6
+        tabla.push(iter)
+    }
+    return tabla
+}
+
+console.log(tabla()); */
+
+/* const cond = ("Enero","Marzo","Noviembre")
+const newArray = []
+
+return newArray.push(cond)
+const mounth = array.includes(cond)
+if(mounth) 
+return "No se encontraron los meses pedidos"  */
+
+/* function multiplicarArgumentos() {
+    var args = Array.prototype.slice.call(arguments);
+    if(args.length === 0) return 0
+    else {
+        var total = 1;
+        for( var i = 0; i < args.length; i++){
+            total *= args[i]
+        };
+        return total;
+    }
+} 
+console.log(multiplicarArgumentos(0)) */
+
+/* const mesesDelAño = (array) => {
+    let findMonths = ["Enero", "Marzo", "Noviembre"]
+    let mesesHallados = array.filter((mes) => {
+        if(findMonths.indexOf(mes) >= 0) return true
+        else return false
+    })
+
+    if(mesesHallados.length == findMonths.length) return mesesHallados
+    else return "No se encontraron los meses pedidos"
+}
+const arr = ["Enero","Marzo","Noviembre","Mayo"] */
\ No newline at end of file