diff --git a/C5 Fundamentos Javascript/ejercicios/01.js b/C5 Fundamentos Javascript/ejercicios/01.js
index 62feaaf6f6..b889d03d8f 100644
--- a/C5 Fundamentos Javascript/ejercicios/01.js	
+++ b/C5 Fundamentos Javascript/ejercicios/01.js	
@@ -1,6 +1,6 @@
 // Crea una variable de tipo string.
 // Reemplaza el valor de null por el correspondiente.
 
-const nuevoString = null;
+const nuevoString = 'null';
 
 module.exports = nuevoString;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/02.js b/C5 Fundamentos Javascript/ejercicios/02.js
index d4f06a1b48..06674dc8fc 100644
--- a/C5 Fundamentos Javascript/ejercicios/02.js	
+++ b/C5 Fundamentos Javascript/ejercicios/02.js	
@@ -1,6 +1,6 @@
 // Crea una variable de tipo number.
 // Reemplaza el valor de null por el correspondiente.
 
-const nuevoNumero = null;
+const nuevoNumero = 5;
 
 module.exports = nuevoNumero;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/03.js b/C5 Fundamentos Javascript/ejercicios/03.js
index 189ca4b52d..f2f01ede6f 100644
--- a/C5 Fundamentos Javascript/ejercicios/03.js	
+++ b/C5 Fundamentos Javascript/ejercicios/03.js	
@@ -1,6 +1,6 @@
 // Crea una variable de tipo boolean.
 // Reemplaza el valor de null por el correspondiente.
 
-const nuevoBoolean = null;
+const nuevoBoolean = true;
 
 module.exports = nuevoBoolean;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/04.js b/C5 Fundamentos Javascript/ejercicios/04.js
index fff0fb6335..a52adb07c2 100644
--- a/C5 Fundamentos Javascript/ejercicios/04.js	
+++ b/C5 Fundamentos Javascript/ejercicios/04.js	
@@ -1,6 +1,6 @@
 // Resuelve el siguiente problema matemático.
 // Reemplaza el valor de null por el correspondiente.
 
-const nuevaResta = 10 - null === 3;
+const nuevaResta = 10 - 7 === 3;
 
 module.exports = nuevaResta;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/05.js b/C5 Fundamentos Javascript/ejercicios/05.js
index 82e2dac5fe..0dabb9307d 100644
--- a/C5 Fundamentos Javascript/ejercicios/05.js	
+++ b/C5 Fundamentos Javascript/ejercicios/05.js	
@@ -1,6 +1,6 @@
 // Resuelve el siguiente problema matemático.
 // Reemplaza el valor de null por el correspondiente.
 
-const nuevaMultiplicacion = 10 * null === 40;
+const nuevaMultiplicacion = 10 * 4 === 40;
 
 module.exports = nuevaMultiplicacion;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/06.js b/C5 Fundamentos Javascript/ejercicios/06.js
index 6debf25fc4..4fa4e9c7de 100644
--- a/C5 Fundamentos Javascript/ejercicios/06.js	
+++ b/C5 Fundamentos Javascript/ejercicios/06.js	
@@ -1,6 +1,6 @@
 // Resuelve el siguiente problema matemático.
 // Reemplaza el valor de null por el correspondiente.
 
-const nuevoModulo = 21 % 5 === null;
+const nuevoModulo = 21 % 5 === 1;
 
 module.exports = nuevoModulo;
diff --git a/C5 Fundamentos Javascript/ejercicios/07.js b/C5 Fundamentos Javascript/ejercicios/07.js
index 8eecae1d84..9e0a779057 100644
--- a/C5 Fundamentos Javascript/ejercicios/07.js	
+++ b/C5 Fundamentos Javascript/ejercicios/07.js	
@@ -3,6 +3,7 @@ function esTipoDato(valor) {
   // Retorna el tipo de dato de este valor.
   // Por ejemplo: "string", "number", "boolean", "object", etc.
   // Tu código:
+  return typeof valor;
 }
 
 module.exports = esTipoDato;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/08.js b/C5 Fundamentos Javascript/ejercicios/08.js
index b6594f3466..2c6c448620 100644
--- a/C5 Fundamentos Javascript/ejercicios/08.js	
+++ b/C5 Fundamentos Javascript/ejercicios/08.js	
@@ -7,6 +7,12 @@ function esNumeroEntero(numero) {
   // -1212 ---> true 
   // 121.212 ---> false 
   // Tu código:
+  if (Number.isInteger(numero)) {
+    return true
+  } else {
+    return false
+  }
 }
 
-module.exports = esNumeroEntero;
\ No newline at end of file
+module.exports = esNumeroEntero;
+
diff --git a/C5 Fundamentos Javascript/ejercicios/09.js b/C5 Fundamentos Javascript/ejercicios/09.js
index 665d437709..6fe2b8a073 100644
--- a/C5 Fundamentos Javascript/ejercicios/09.js	
+++ b/C5 Fundamentos Javascript/ejercicios/09.js	
@@ -8,6 +8,11 @@ function esNuloOIndefinido(valor) {
   // 22 ---> false
   // "texto" ---> false
   // Tu código:
+  if (valor === null || valor === undefined) {
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = esNuloOIndefinido;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/10.js b/C5 Fundamentos Javascript/ejercicios/10.js
index a2f730da93..b9ea975f69 100644
--- a/C5 Fundamentos Javascript/ejercicios/10.js	
+++ b/C5 Fundamentos Javascript/ejercicios/10.js	
@@ -6,6 +6,7 @@ function devolverString(string) {
   // "hola mundo" ---> "hola mundo" 
   // "SoyHenry" ---> "SoyHenry" 
   // Tu código:
+  return string;
 }
 
 module.exports = devolverString;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/11.js b/C5 Fundamentos Javascript/ejercicios/11.js
index 2a4d40a899..f12c53180f 100644
--- a/C5 Fundamentos Javascript/ejercicios/11.js	
+++ b/C5 Fundamentos Javascript/ejercicios/11.js	
@@ -6,6 +6,9 @@ function sonIguales(x, y) {
   // 5, 5 ---> true 
   // 5, 8 ---> false 
   // Tu código:
-}
+  if (x === y){
+    return true
+  } return false
+} 
 
-module.exports = sonIguales;
\ No newline at end of file
+module.exports = sonIguales;
diff --git a/C5 Fundamentos Javascript/ejercicios/12.js b/C5 Fundamentos Javascript/ejercicios/12.js
index bce832204b..8f5a6134ce 100644
--- a/C5 Fundamentos Javascript/ejercicios/12.js	
+++ b/C5 Fundamentos Javascript/ejercicios/12.js	
@@ -6,6 +6,18 @@ function tienenMismaLongitud(str1, str2) {
   // "SoyHenry", "HenrySoy" ---> true 
   // "hi", "there" ---> false 
   // Tu código:
+  // cualquier opcion esta bien
+  //if(str1.length === str2.length){
+    //return true
+  //} else {
+    //return false
+  //}
+
+  return str1.length === str2.length
 }
 
-module.exports = tienenMismaLongitud;
\ No newline at end of file
+
+module.exports = tienenMismaLongitud;
+
+var array = ['hola', 'puedo']
+console.log(tienenMismaLongitud('hola', 'pued'))
diff --git a/C5 Fundamentos Javascript/ejercicios/13.js b/C5 Fundamentos Javascript/ejercicios/13.js
index 5e4d000dd4..925d1d3f1d 100644
--- a/C5 Fundamentos Javascript/ejercicios/13.js	
+++ b/C5 Fundamentos Javascript/ejercicios/13.js	
@@ -6,6 +6,7 @@ function menosQueNoventa(num) {
   // 50 ---> true
   // 91 ---> false
   // Tu código:
+  return num <90;
 }
 
-module.exports = menosQueNoventa;
\ No newline at end of file
+module.exports = menosQueNoventa;
diff --git a/C5 Fundamentos Javascript/ejercicios/14.js b/C5 Fundamentos Javascript/ejercicios/14.js
index cd5d24fbd1..01160cb8ad 100644
--- a/C5 Fundamentos Javascript/ejercicios/14.js	
+++ b/C5 Fundamentos Javascript/ejercicios/14.js	
@@ -6,6 +6,7 @@ function mayorQueCincuenta(num) {
   // 51 ---> true
   // 15 ---> false
   // Tu código:
+  return num > 50;
 }
 
 module.exports = mayorQueCincuenta;
diff --git a/C5 Fundamentos Javascript/ejercicios/15.js b/C5 Fundamentos Javascript/ejercicios/15.js
index 98648a7167..94067e861d 100644
--- a/C5 Fundamentos Javascript/ejercicios/15.js	
+++ b/C5 Fundamentos Javascript/ejercicios/15.js	
@@ -6,6 +6,11 @@ function esPar(num) {
   // 14 ---> true
   // 15 ---> false
   // Tu código:
+  if (num % 2 === 0) {
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = esPar;
diff --git a/C5 Fundamentos Javascript/ejercicios/16.js b/C5 Fundamentos Javascript/ejercicios/16.js
index 7721e84f50..65e4ad82df 100644
--- a/C5 Fundamentos Javascript/ejercicios/16.js	
+++ b/C5 Fundamentos Javascript/ejercicios/16.js	
@@ -6,6 +6,11 @@ function esImpar(num) {
   // 15 ---> true
   // 14 ---> false
   // Tu código:
+  if (num % 2 !== 0) {
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = esImpar;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/17.js b/C5 Fundamentos Javascript/ejercicios/17.js
index dc0f6d6a95..2430b30ced 100644
--- a/C5 Fundamentos Javascript/ejercicios/17.js	
+++ b/C5 Fundamentos Javascript/ejercicios/17.js	
@@ -6,6 +6,18 @@ function esPositivo(num) {
   // 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 false
+  }// else if (num % 1 !== 0){
+    //return ('Es decimal')
+  //} 
+  else {
+    return ('Es negativo')
+  }
 }
 
-module.exports = esPositivo;
\ No newline at end of file
+module.exports = esPositivo;
+
+console.log(esPositivo(-1.5))
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/18.js b/C5 Fundamentos Javascript/ejercicios/18.js
index 180f3bff3d..e5558b3af6 100644
--- a/C5 Fundamentos Javascript/ejercicios/18.js	
+++ b/C5 Fundamentos Javascript/ejercicios/18.js	
@@ -8,6 +8,16 @@ function esVocal(letra) {
   // "n" ---> "Dato incorrecto"
   // "texto largo" ---> "Dato incorrecto"
   // Tu código:
+  //if (letra.length != 1){
+    //return ('Dato incorrecto')
+  //}
+
+  if(letra === 'a' || letra === 'e' || letra ==='i' || letra === 'o' || letra === 'u') {
+    return ('Es vocal')
+  } else {
+    return ('Dato incorrecto')
+  }
 }
 
 module.exports = esVocal;
+
diff --git a/C5 Fundamentos Javascript/ejercicios/19.js b/C5 Fundamentos Javascript/ejercicios/19.js
index eadd4aa24e..f7a8bd7a76 100644
--- a/C5 Fundamentos Javascript/ejercicios/19.js	
+++ b/C5 Fundamentos Javascript/ejercicios/19.js	
@@ -5,6 +5,7 @@ function suma(x, y) {
   // 5, 5 ---> 10
   // -5, 5 ---> 0
   // Tu código:
+  return x + y;
 }
 
-module.exports = suma; 
\ No newline at end of file
+module.exports = suma; 
diff --git a/C5 Fundamentos Javascript/ejercicios/20.js b/C5 Fundamentos Javascript/ejercicios/20.js
index 85e2de4890..8a3a3abb41 100644
--- a/C5 Fundamentos Javascript/ejercicios/20.js	
+++ b/C5 Fundamentos Javascript/ejercicios/20.js	
@@ -5,6 +5,7 @@ function resta(x, y) {
   // 10, 5 ---> 5
   // 5, 5 ---> 0
   // Tu código:
+  return x - y;
 }
 
 module.exports = resta;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/21.js b/C5 Fundamentos Javascript/ejercicios/21.js
index 747fe977f9..91af9a3c5a 100644
--- a/C5 Fundamentos Javascript/ejercicios/21.js	
+++ b/C5 Fundamentos Javascript/ejercicios/21.js	
@@ -5,6 +5,7 @@ function multiplica(x, y) {
   // 10, 5 ---> 50
   // 5, 5 ---> 25
   // Tu código:
+  return x * y;
 }
 
 module.exports = multiplica;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/22.js b/C5 Fundamentos Javascript/ejercicios/22.js
index 57e0e9c6e7..a366cead9c 100644
--- a/C5 Fundamentos Javascript/ejercicios/22.js	
+++ b/C5 Fundamentos Javascript/ejercicios/22.js	
@@ -5,6 +5,7 @@ function divide(x, y) {
   // 10, 5 ---> 2
   // 5, 5 ---> 1
   // Tu código:
+  return x / y;
 }
 
 module.exports = divide;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/23.js b/C5 Fundamentos Javascript/ejercicios/23.js
index 05b43b2135..a67c5eddbb 100644
--- a/C5 Fundamentos Javascript/ejercicios/23.js	
+++ b/C5 Fundamentos Javascript/ejercicios/23.js	
@@ -5,6 +5,7 @@ function obtenerResto(x, y) {
   // 10, 5 ---> 0
   // 16, 5 ---> 1
   // Tu código:
+  return x % y;
 }
 
-module.exports = obtenerResto;
\ No newline at end of file
+module.exports = obtenerResto;
diff --git a/C5 Fundamentos Javascript/ejercicios/24.js b/C5 Fundamentos Javascript/ejercicios/24.js
index 0c25f1a616..c4ffdec9e4 100644
--- a/C5 Fundamentos Javascript/ejercicios/24.js	
+++ b/C5 Fundamentos Javascript/ejercicios/24.js	
@@ -4,6 +4,8 @@ function agregarSimboloExclamacion(str) {
   // Por ejemplo: 
   // "hello world" ---> "hello world!"
   // Tu código:
+  return (str + ('!'));
 }
 
 module.exports = agregarSimboloExclamacion;
+
diff --git a/C5 Fundamentos Javascript/ejercicios/25.js b/C5 Fundamentos Javascript/ejercicios/25.js
index 6e2e9ed067..d1c6307c5a 100644
--- a/C5 Fundamentos Javascript/ejercicios/25.js	
+++ b/C5 Fundamentos Javascript/ejercicios/25.js	
@@ -4,6 +4,9 @@ function combinarNombres(nombre, apellido) {
   // Por ejemplo: 
   // "Soy", "Henry" ---> "Soy Henry"
   // Tu código:
+  return (nombre + ' ' + apellido)
 }
 
 module.exports = combinarNombres;
+
+console.log(combinarNombres('fabio', 'gomez'))
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/26.js b/C5 Fundamentos Javascript/ejercicios/26.js
index 2a0f6ceafc..68efb30c79 100644
--- a/C5 Fundamentos Javascript/ejercicios/26.js	
+++ b/C5 Fundamentos Javascript/ejercicios/26.js	
@@ -4,6 +4,8 @@ function obtenerSaludo(nombre) {
   // Ejemplo: "Martin" ---> "Hola Martin!"
   // Retorna el nuevo string. 
   // Tu código:
+  return ('Hola' + ' ' + nombre + '!');
 }
 
-module.exports = obtenerSaludo;
\ No newline at end of file
+module.exports = obtenerSaludo;
+
diff --git a/C5 Fundamentos Javascript/ejercicios/27.js b/C5 Fundamentos Javascript/ejercicios/27.js
index e786d71a11..f0887c42b4 100644
--- a/C5 Fundamentos Javascript/ejercicios/27.js	
+++ b/C5 Fundamentos Javascript/ejercicios/27.js	
@@ -5,6 +5,11 @@ function obtenerAreaRectangulo(alto, ancho) {
   // 2, 2 ---> 4
   // 0, 2 ---> 2
   // Tu código:
+
+  return alto * ancho;
+
 }
 
 module.exports = obtenerAreaRectangulo;
+
+
diff --git a/C5 Fundamentos Javascript/ejercicios/28.js b/C5 Fundamentos Javascript/ejercicios/28.js
index c86f27e883..2833d5b943 100644
--- a/C5 Fundamentos Javascript/ejercicios/28.js	
+++ b/C5 Fundamentos Javascript/ejercicios/28.js	
@@ -5,6 +5,8 @@ function retornarPerimetro(lado) {
    // 2 ---> 8
    // 0 ---> 0
    // Tu código:
+   return lado * 4
 }
 
 module.exports = retornarPerimetro;
+
diff --git a/C5 Fundamentos Javascript/ejercicios/29.js b/C5 Fundamentos Javascript/ejercicios/29.js
index 8e7d52ff15..591edb8fd2 100644
--- a/C5 Fundamentos Javascript/ejercicios/29.js	
+++ b/C5 Fundamentos Javascript/ejercicios/29.js	
@@ -5,6 +5,7 @@ function areaDelTriangulo(base, altura) {
   // 10, 5 ---> 25
   // 0, 10 ---> 0
   // Tu código:
+  return (base * altura) / 2;
 }
 
 module.exports = areaDelTriangulo;
diff --git a/C5 Fundamentos Javascript/ejercicios/30.js b/C5 Fundamentos Javascript/ejercicios/30.js
index 6f0882f77d..ec32944a79 100644
--- a/C5 Fundamentos Javascript/ejercicios/30.js	
+++ b/C5 Fundamentos Javascript/ejercicios/30.js	
@@ -7,6 +7,10 @@ function deEuroAdolar(euro) {
   // 1 ---> 1.20
   // 0 ---> 0
   // Tu código:
+  const EuroADolar = 1.20;
+  return euro * EuroADolar;
+  
 }
 
 module.exports = deEuroAdolar;
+
diff --git a/C5 Fundamentos Javascript/ejercicios/31.js b/C5 Fundamentos Javascript/ejercicios/31.js
index 823f0fb17b..81cd7e57d3 100644
--- a/C5 Fundamentos Javascript/ejercicios/31.js	
+++ b/C5 Fundamentos Javascript/ejercicios/31.js	
@@ -7,6 +7,10 @@ function elevarAlCuadrado(num) {
   // 6 ---> 36
   // 0 ---> 0
   // Tu código:
+  //return num ** 2
+  return Math.pow(num, 2)
 }
 
 module.exports = elevarAlCuadrado;
+
+console.log(elevarAlCuadrado(2))
diff --git a/C5 Fundamentos Javascript/ejercicios/32.js b/C5 Fundamentos Javascript/ejercicios/32.js
index 7150676698..6d2994ce44 100644
--- a/C5 Fundamentos Javascript/ejercicios/32.js	
+++ b/C5 Fundamentos Javascript/ejercicios/32.js	
@@ -7,6 +7,8 @@ function elevarAlCubo(num) {
   // 3 ---> 27
   // 0 ---> 0
   // Tu código:
+  return Math.pow(num, 3)
+
 }
 
 module.exports = elevarAlCubo;
diff --git a/C5 Fundamentos Javascript/ejercicios/33.js b/C5 Fundamentos Javascript/ejercicios/33.js
index 09944ed939..83a16c3411 100644
--- a/C5 Fundamentos Javascript/ejercicios/33.js	
+++ b/C5 Fundamentos Javascript/ejercicios/33.js	
@@ -7,6 +7,7 @@ function elevar(num, exponent) {
   // 2, 2 ---> 4
   // 0, 5 ---> 0
   // Tu código:
+  return Math.pow(num, exponent)
 }
 
 module.exports = elevar;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/34.js b/C5 Fundamentos Javascript/ejercicios/34.js
index 2fff9db0e4..2a433f0e90 100644
--- a/C5 Fundamentos Javascript/ejercicios/34.js	
+++ b/C5 Fundamentos Javascript/ejercicios/34.js	
@@ -7,6 +7,8 @@ function redondearNumero(num) {
    // 1.5 ---> 2
    // 0.1 ---> 0
    // Tu código:
+   return Math.round(num)
 }
 
 module.exports = redondearNumero;
+
diff --git a/C5 Fundamentos Javascript/ejercicios/35.js b/C5 Fundamentos Javascript/ejercicios/35.js
index 1987c119d4..34b2b888da 100644
--- a/C5 Fundamentos Javascript/ejercicios/35.js	
+++ b/C5 Fundamentos Javascript/ejercicios/35.js	
@@ -7,6 +7,7 @@ function redondearHaciaArriba(num) {
   // 2.5 ---> 3
   // 0.1 ---> 1
   // Tu código:
+  return Math.ceil(num)
 }
 
 module.exports = redondearHaciaArriba;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/36.js b/C5 Fundamentos Javascript/ejercicios/36.js
index d0288d803f..7246defa43 100644
--- a/C5 Fundamentos Javascript/ejercicios/36.js	
+++ b/C5 Fundamentos Javascript/ejercicios/36.js	
@@ -3,6 +3,7 @@
 function numeroRandom() {
   // La función numeroRandom debe generar un número al azar entre 0 y 1 y retornarlo.
   // Tu código:
+  return Math.random()
 }
 
 module.exports = numeroRandom;
diff --git a/C6 Bucles/ejercicios/01.js b/C6 Bucles/ejercicios/01.js
index 95f2825332..bd6dc6c635 100644
--- a/C6 Bucles/ejercicios/01.js	
+++ b/C6 Bucles/ejercicios/01.js	
@@ -3,6 +3,12 @@ function esIgualYNegativo(a, b) {
   // Determina si son iguales y son ambos negativos.
   // De ser así, retorna true, de lo contrario, retorna false.
   // Tu código:
+  if(a === b && (a < 0) && (b < 0)) {
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = esIgualYNegativo;
+
diff --git a/C6 Bucles/ejercicios/02.js b/C6 Bucles/ejercicios/02.js
index a98deee96a..438344d76a 100644
--- a/C6 Bucles/ejercicios/02.js	
+++ b/C6 Bucles/ejercicios/02.js	
@@ -2,6 +2,12 @@ function esVerdaderoYFalso(booleano1, booleano2) {
   // La función recibe dos argumentos "booleano1" y "booleano2".
   // Retorna true si ambos son verdaderos, caso contrario, retorna false.
   // Tu código:
+  if(booleano1 === true && booleano2 === true){
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = esVerdaderoYFalso;
+
diff --git a/C6 Bucles/ejercicios/03.js b/C6 Bucles/ejercicios/03.js
index 95d1b1f4c3..e5e46e32fc 100644
--- a/C6 Bucles/ejercicios/03.js	
+++ b/C6 Bucles/ejercicios/03.js	
@@ -3,6 +3,14 @@ function obtenerMayor(x, y) {
   // Retorna el número más grande.
   // Si son iguales, retornar cualquiera de los dos.
   // Tu código:
+  if(x > y){
+    return x
+  } else if (y > x){
+    return y
+  } else if (x === y) {
+    return (x || y)
+  }
 }
 
 module.exports = obtenerMayor;
+
diff --git a/C6 Bucles/ejercicios/04.js b/C6 Bucles/ejercicios/04.js
index 7ef7a58d03..f286e8e0b3 100644
--- a/C6 Bucles/ejercicios/04.js	
+++ b/C6 Bucles/ejercicios/04.js	
@@ -3,6 +3,12 @@ function mayoriaDeEdad(edad) {
   // Si tiene 18 años o más, retorna el string: "Allowed".
   // Caso contrario: "Not allowed".
   // Tu código:
+  if(edad >= 18){
+    return ('Allowed')
+  } else {
+    return ('Not allowed')
+  }
 }
 
 module.exports = mayoriaDeEdad;
+
diff --git a/C6 Bucles/ejercicios/05.js b/C6 Bucles/ejercicios/05.js
index ee7e89c431..a4d9b03249 100644
--- a/C6 Bucles/ejercicios/05.js	
+++ b/C6 Bucles/ejercicios/05.js	
@@ -2,6 +2,11 @@ function esVerdadero(valor) {
   // Si "valor" es verdadero, retorna "Soy verdadero".
   // Caso contrario, retorna "Soy falso".
   // Tu código:
+  if(valor === true) {
+    return ('Soy verdadero')
+  } else {
+    return ('Soy falso')
+  }
 }
 
 module.exports = esVerdadero;
diff --git a/C6 Bucles/ejercicios/06.js b/C6 Bucles/ejercicios/06.js
index b7c047365b..8dc482b42e 100644
--- a/C6 Bucles/ejercicios/06.js	
+++ b/C6 Bucles/ejercicios/06.js	
@@ -2,6 +2,14 @@ function tieneTresDigitos(num) {
   // Si el número recibido tiene tres dígitos, retorna true.
   // Caso contrario, retorna false.
   // Tu código:
+
+  if (Math.abs(num) > 100 && Math.abs(num) < 1000 ) {
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = tieneTresDigitos;
+
+console.log(tieneTresDigitos(-12))
diff --git a/C6 Bucles/ejercicios/07.js b/C6 Bucles/ejercicios/07.js
index 5191b315af..be60e56064 100644
--- a/C6 Bucles/ejercicios/07.js	
+++ b/C6 Bucles/ejercicios/07.js	
@@ -3,6 +3,11 @@ function esParYDivisiblePorTres(a) {
   // Retorna true si este es par y divisible por tres a la vez.
   // Retorna false si no lo es.
   // Tu código:
+  if(a % 2 === 0 && a % 3 === 0){
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = esParYDivisiblePorTres;
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/08.js b/C6 Bucles/ejercicios/08.js
index bb5f11d4c0..6176bd36da 100644
--- a/C6 Bucles/ejercicios/08.js	
+++ b/C6 Bucles/ejercicios/08.js	
@@ -3,6 +3,11 @@ function esPositivoOInferiorA10(a) {
    // Retorna true si es positivo y menor que 10.
    // Retorna false en caso contrario.
    // Tu código:
+   if(a > 0 && a < 10){
+      return true
+   } else {
+      return false
+   }
 }
 
 module.exports = esPositivoOInferiorA10;
diff --git a/C6 Bucles/ejercicios/09.js b/C6 Bucles/ejercicios/09.js
index f3898b19c7..acb8a70ea2 100644
--- a/C6 Bucles/ejercicios/09.js	
+++ b/C6 Bucles/ejercicios/09.js	
@@ -5,6 +5,15 @@ function conection(status) {
   // 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')
+  }
 }
 
 module.exports = conection;
+
+console.log(conection(3))
diff --git a/C6 Bucles/ejercicios/10.js b/C6 Bucles/ejercicios/10.js
index 2620c50f93..0df273387e 100644
--- a/C6 Bucles/ejercicios/10.js	
+++ b/C6 Bucles/ejercicios/10.js	
@@ -2,6 +2,11 @@ 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
+  }
 }
 
 module.exports = esDiezOCinco;
diff --git a/C6 Bucles/ejercicios/11.js b/C6 Bucles/ejercicios/11.js
index f35ed4ab3d..1b570f5045 100644
--- a/C6 Bucles/ejercicios/11.js	
+++ b/C6 Bucles/ejercicios/11.js	
@@ -2,6 +2,11 @@ function estaEnRango(num) {
   // Retorna 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
+  }
 }
 
 module.exports = estaEnRango;
diff --git a/C6 Bucles/ejercicios/12.js b/C6 Bucles/ejercicios/12.js
index b61a3aec43..4ac0e1e105 100644
--- a/C6 Bucles/ejercicios/12.js	
+++ b/C6 Bucles/ejercicios/12.js	
@@ -4,6 +4,17 @@ function fizzBuzz(num) {
   // Si "num" es divisible entre 3 y 5 (ambos), retorna "fizzbuzz".
   // De lo contrario, retorna false.
   // Tu código:
+  if(num % 3 === 0 && num % 5 === 0){
+    return ('fizzbuzz')
+  } else if(num % 5 === 0){
+    return ('buzz')
+  } else if(num % 3 === 0){
+    return ('fizz')
+  }else {
+    return false
+  }
 }
 
 module.exports = fizzBuzz;
+
+console.log(fizzBuzz(9))
diff --git a/C6 Bucles/ejercicios/13.js b/C6 Bucles/ejercicios/13.js
index 76e254264a..d2e3c8d071 100644
--- a/C6 Bucles/ejercicios/13.js	
+++ b/C6 Bucles/ejercicios/13.js	
@@ -5,6 +5,12 @@ function esEntero(num) {
   // Ejemplo: (-10) ---> true
   // De lo contrario, retorna false.
   // Tu código:
+  if(Number.isInteger(num)){
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = esEntero;
+
diff --git a/C6 Bucles/ejercicios/14.js b/C6 Bucles/ejercicios/14.js
index 285d4fdfe2..17c86bad13 100644
--- a/C6 Bucles/ejercicios/14.js	
+++ b/C6 Bucles/ejercicios/14.js	
@@ -6,6 +6,20 @@ function operadoresLogicos(num1, num2, num3) {
   // Si todos los argumentos son cero, retorna ---> "Error".
   // Si no se cumple ninguna de las condiciones anteriores, retorna false.
   // Tu código:
+  if(num1 > num2 && num1 > num3 > 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){
+    num3 += 1
+    return num3
+  }else if(num1===0 && num2===0 && num3===0){
+    return ('Error')
+  } else {
+    return false
+  }
 }
 
 module.exports = operadoresLogicos;
+
+console.log(operadoresLogicos(0,20,0))
diff --git a/C6 Bucles/ejercicios/15.js b/C6 Bucles/ejercicios/15.js
index 906f514225..728fd35b01 100644
--- a/C6 Bucles/ejercicios/15.js	
+++ b/C6 Bucles/ejercicios/15.js	
@@ -6,6 +6,26 @@ function obtenerDiaSemana(numero) {
   // Si el número no corresponde a un día de la semana, retorna
   // el string "No es un dia de la semana"
   // Tu código:
+  switch (numero){
+    case 1:
+      return ('Lunes');
+    case 2:
+      return ('Martes');
+    case 3:
+      return ('Miercoles');
+    case 4:
+      return ('Jueves');
+    case 5:
+      return ('Viernes');
+    case 6:
+      return ('Sabado');
+    case 7:
+      return ('Domingo');
+      break
+    default:
+      return ('No es un dia de la semana');
+  }
 }
 
-module.exports = obtenerDiaSemana;
\ No newline at end of file
+module.exports = obtenerDiaSemana;
+
diff --git a/C6 Bucles/ejercicios/16.js b/C6 Bucles/ejercicios/16.js
index 01a50c9f01..21a5243553 100644
--- a/C6 Bucles/ejercicios/16.js	
+++ b/C6 Bucles/ejercicios/16.js	
@@ -5,6 +5,20 @@ function saludo(idioma) {
   // 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!';
+    case 'mandarin':
+      return 'Ni Hao!'
+    case 'ingles':
+      return 'Hello!'
+      break
+    default:
+      return 'Hola!'
+  }
+
 }
 
 module.exports = saludo;
+
+console.log(saludo('aleman'))
diff --git a/C6 Bucles/ejercicios/17.js b/C6 Bucles/ejercicios/17.js
index 3dcc148517..f690f74d36 100644
--- a/C6 Bucles/ejercicios/17.js	
+++ b/C6 Bucles/ejercicios/17.js	
@@ -7,6 +7,20 @@ function colors(color) {
   // Si no es ninguno de esos colores           --> "Color not found".
   // PISTA: utilizar el statement SWITCH.
   // Tu código:
+  switch(color){
+    case 'blue':
+      return 'This is blue';
+    case 'red':
+      return 'This is red';
+    case 'green':
+      return 'This is green';
+    case 'orange':
+      return 'This is organge';
+      break
+    default:
+      return 'Color not found';
+  }
 }
 
 module.exports = colors;
+
diff --git a/C6 Bucles/ejercicios/18.js b/C6 Bucles/ejercicios/18.js
index e7183ff019..e3f4705d14 100644
--- a/C6 Bucles/ejercicios/18.js	
+++ b/C6 Bucles/ejercicios/18.js	
@@ -2,6 +2,14 @@ function productoEntreNúmeros(a, b) {
   // Dados dos argumentos "a" y "b", devuelve el producto de todos
   // los números entre a y b (inclusive).
   // Tu código:
+
+  var producto = 1;
+
+  for(var i = a; i<=b; i++)
+    producto *= i
+    return producto
 }
 
-module.exports = productoEntreNúmeros;
\ No newline at end of file
+module.exports = productoEntreNúmeros;
+
+console.log(productoEntreNúmeros(5,5))
diff --git a/C6 Bucles/ejercicios/19.js b/C6 Bucles/ejercicios/19.js
index 41c47d54eb..b588f8c69a 100644
--- a/C6 Bucles/ejercicios/19.js	
+++ b/C6 Bucles/ejercicios/19.js	
@@ -2,6 +2,16 @@ function sumarHastaN(n) {
   // La función recibe un número "n" por argumento.
   // Devuelve la suma de todos los números desde 1 hasta n.
   // Tu código:
+  var suma = 0;
+
+  for(var i = 1; i<=n; i++){
+    suma += i;
+  }
+
+  return suma;
+
 }
 
 module.exports = sumarHastaN;
+
+console.log(sumarHastaN(5))
diff --git a/C6 Bucles/ejercicios/20.js b/C6 Bucles/ejercicios/20.js
index 4c835a54d4..c0bc2fb316 100644
--- a/C6 Bucles/ejercicios/20.js	
+++ b/C6 Bucles/ejercicios/20.js	
@@ -3,6 +3,18 @@ function sumarHastaNConBreak(n) {
    // Devuelve la suma de todos los números desde 1 hasta n.
    // Si la suma supera a 100, detén el bucle usando break.
    // Tu código:
+   var suma = 0
+
+   for(var i = 1; i<= n; i++){
+      suma += i;
+      if(suma >100){
+         break
+      }
+   }
+
+   return suma
 }
 
 module.exports = sumarHastaNConBreak;
+
+console.log(sumarHastaNConBreak(5))
diff --git a/C6 Bucles/ejercicios/21.js b/C6 Bucles/ejercicios/21.js
index 1107bf2a11..4af76cdc62 100644
--- a/C6 Bucles/ejercicios/21.js	
+++ b/C6 Bucles/ejercicios/21.js	
@@ -4,6 +4,20 @@ function esPotenciaDeDos(numero) {
   // Devuelve true si lo es, sino devuelve false.
   // PISTA: Utiliza un bucle while.
   // Tu código:
+  if(numero <= 0){
+    return false 
+  }
+
+  while (numero !== 1){
+    if(numero % 2 !== 0){
+      return false //por que si no es divisible por 0 no es potencia de 2
+    }
+
+    numero = numero /2
+  }
+
+  return true
 }
 
 module.exports = esPotenciaDeDos;
+
diff --git a/C6 Bucles/ejercicios/22.js b/C6 Bucles/ejercicios/22.js
index 308536602f..b7aba578f5 100644
--- a/C6 Bucles/ejercicios/22.js	
+++ b/C6 Bucles/ejercicios/22.js	
@@ -3,6 +3,16 @@ function doWhile(num) {
   // Retorna el valor final.
   // PISTA: Utiliza el bucle do-while.
   // Tu código:
+ var i = 0
+ 
+ do {
+  num += 5
+  i++
+ }while (i<8);
+
+ return num
 }
 
-module.exports = doWhile;
\ No newline at end of file
+module.exports = doWhile;
+
+console.log(doWhile(100))
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/23.js b/C6 Bucles/ejercicios/23.js
index ebe222a114..d5bac3040e 100644
--- a/C6 Bucles/ejercicios/23.js	
+++ b/C6 Bucles/ejercicios/23.js	
@@ -6,6 +6,21 @@ function esNumeroPrimo(numero) {
   // IMPORTANTE: Recuerda que un número primo es aquel que
   // solo es divisible por sí mismo y por 1.
   // Tu código:
+  if(numero <= 1){
+    return false
+  }
+  // Verificamos la divisibilidad desde 2 hasta la raíz cuadrada del número
+  for(var i = 2; i<=Math.sqrt(numero); i++){
+    if(numero % i === 0){//verifamos que no hayan divisores
+      return false
+    }
+  }
+  return true
 }
 
 module.exports = esNumeroPrimo;
+
+console.log(esNumeroPrimo(2))
+
+var num = (4 % 2)
+console.log(num)
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/01.js b/C7 Arrays/ejercicios/01.js
index 508c5fd8a1..0c8e3abe00 100644
--- a/C7 Arrays/ejercicios/01.js	
+++ b/C7 Arrays/ejercicios/01.js	
@@ -1,6 +1,8 @@
 function devolverPrimerElemento(array) {
   // Retornar el primer elemento del arreglo recibido.
   // Tu código:
+  return array[0]
 }
 
 module.exports = devolverPrimerElemento;
+
diff --git a/C7 Arrays/ejercicios/02.js b/C7 Arrays/ejercicios/02.js
index 3c40692116..6dd4d4601b 100644
--- a/C7 Arrays/ejercicios/02.js	
+++ b/C7 Arrays/ejercicios/02.js	
@@ -1,6 +1,11 @@
 function devolverUltimoElemento(array) {
   // Retornar el último elemento del arreglo recibido.
   // Tu código:
+  return array [array.length -1]
 }
 
 module.exports = devolverUltimoElemento;
+
+var array = [1,2,3,4]
+
+console.log(devolverUltimoElemento(array))
diff --git a/C7 Arrays/ejercicios/03.js b/C7 Arrays/ejercicios/03.js
index 1170d0a120..16549656fd 100644
--- a/C7 Arrays/ejercicios/03.js	
+++ b/C7 Arrays/ejercicios/03.js	
@@ -1,6 +1,8 @@
 function obtenerLargoDelArray(array) {
   // Retornar la longitud del arreglo recibido.
   // Tu código:
+  return array.length
 }
 
 module.exports = obtenerLargoDelArray;
+
diff --git a/C7 Arrays/ejercicios/04.js b/C7 Arrays/ejercicios/04.js
index f8433b6134..45f8b35d8c 100644
--- a/C7 Arrays/ejercicios/04.js	
+++ b/C7 Arrays/ejercicios/04.js	
@@ -2,6 +2,10 @@ function agregarItemAlFinalDelArray(array, elemento) {
   // Agrega el "elemento" al final del arreglo recibido.
   // Retorna el arreglo.
   // Tu código:
+  var agregarElemento = array.push(elemento)
+
+  return agregarElemento
 }
 
 module.exports = agregarItemAlFinalDelArray;
+
diff --git a/C7 Arrays/ejercicios/05.js b/C7 Arrays/ejercicios/05.js
index 9d17508d9d..b38b48c1e2 100644
--- a/C7 Arrays/ejercicios/05.js	
+++ b/C7 Arrays/ejercicios/05.js	
@@ -2,6 +2,9 @@ function agregarItemAlComienzoDelArray(array, elemento) {
   // Agrega el "elemento" al comienzo del arreglo recibido.
   // Retorna el arreglo.
   // Tu código:
+  var agregarElemento = array.unshift(elemento)
+
+  return agregarElemento
 }
 
-module.exports = agregarItemAlComienzoDelArray;
+module.exports = agregarItemAlComienzoDelArray;
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/06.js b/C7 Arrays/ejercicios/06.js
index 0d093fec57..20b430c8b4 100644
--- a/C7 Arrays/ejercicios/06.js	
+++ b/C7 Arrays/ejercicios/06.js	
@@ -1,6 +1,22 @@
 function invertirArray(array) {
   // Invierte el arreglo array recibido por argumento.
   // Tu código:
+  //MANERA RECURSIVA
+
+  let invertirArray = []
+
+  for(let i = array.length - 1; i>=0 ; i--){
+    invertirArray.push(array[i])
+  }
+
+  return invertirArray
+  //MANERA CON .REVERSE
+  //var invertirArray = array.reverse()
+
+  //return invertirArray
 }
 
 module.exports = invertirArray;
+
+var array = [1,2,3,4,5]
+console.log(invertirArray(array))
diff --git a/C7 Arrays/ejercicios/07.js b/C7 Arrays/ejercicios/07.js
index ef9535455e..d8a2e005e1 100644
--- a/C7 Arrays/ejercicios/07.js	
+++ b/C7 Arrays/ejercicios/07.js	
@@ -2,6 +2,11 @@ function ordenarArray(array) {
   // Ordena los elementos del areglo array de menor a mayor.
   // Devuelve el arreglo resultante.
   // Tu código:
+  return array.sort()
+  return array.sort((a,b) => a - b)
 }
 
 module.exports = ordenarArray;
+
+var arreglo = [1,5,1,1,7,4,2,9,1]
+ console.log(ordenarArray(arreglo))
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/08.js b/C7 Arrays/ejercicios/08.js
index 46dcf9a08f..7fde4ea09a 100644
--- a/C7 Arrays/ejercicios/08.js	
+++ b/C7 Arrays/ejercicios/08.js	
@@ -3,6 +3,17 @@ function encontrarElemento(num, array) {
    // Si lo encuentras debes retornar el INDICE en el que se encuentra dentro del array.
    // Si no se encuentra, retorna -1.
    // Tu código:
+   var Elemento = array.findIndex(elemento => elemento === num)
+
+   return elemento
 }
 
 module.exports = encontrarElemento;
+
+
+
+
+
+
+
+
diff --git a/C7 Arrays/ejercicios/09.js b/C7 Arrays/ejercicios/09.js
index 5f9b6248d8..d06adda0d1 100644
--- a/C7 Arrays/ejercicios/09.js	
+++ b/C7 Arrays/ejercicios/09.js	
@@ -2,6 +2,16 @@ function obtenerElementoAleatorio(array) {
    // Devuelve un elemento aleatorio del arreglo array.
    // PISTA: Usa el método Math.random().
    // Tu código:
+   var verrandom = Math.random()
+   var elemento = Math.floor(verrandom * array.length)
+
+   console.log(verrandom)
+   return array[elemento]
+   
 }
 
 module.exports = obtenerElementoAleatorio;
+var array = [1,2,3,4]
+console.log(obtenerElementoAleatorio(array))
+
+
diff --git a/C7 Arrays/ejercicios/10.js b/C7 Arrays/ejercicios/10.js
index dea50da555..dd34142239 100644
--- a/C7 Arrays/ejercicios/10.js	
+++ b/C7 Arrays/ejercicios/10.js	
@@ -1,6 +1,19 @@
 function obtenerPrimerStringLargo(array) {
   // Devuelve el primer string con más de 5 caracteres en el array.
   // Tu código:
+  for(let i= 0; i<= array.length; i++){
+    if(array[i].length >= 5){
+      return array[i]
+    }
+  }
+  return 'No hay'
+
+  //return array.find(item => typeof item === 'string' && item.length > 5) || 'no hay' 
+
 }
 
 module.exports = obtenerPrimerStringLargo;
+
+var array = ['hola', 'hello1']
+console.log(obtenerPrimerStringLargo(array))
+
diff --git a/C7 Arrays/ejercicios/11.js b/C7 Arrays/ejercicios/11.js
index 3194c62196..4c21bd74e9 100644
--- a/C7 Arrays/ejercicios/11.js	
+++ b/C7 Arrays/ejercicios/11.js	
@@ -2,6 +2,11 @@ function duplicarElementos(array) {
   // Duplica (multiplica x2) cada elemento del array de números.
   // Devuelve un array con los duplicados.
   // Tu código:
+  var porDos = array.map(num =>{
+    return num * 2
+  })
+
+  return porDos
 }
 
 module.exports = duplicarElementos;
diff --git a/C7 Arrays/ejercicios/12.js b/C7 Arrays/ejercicios/12.js
index 2df8d8eb7d..bfce75b42b 100644
--- a/C7 Arrays/ejercicios/12.js	
+++ b/C7 Arrays/ejercicios/12.js	
@@ -2,6 +2,16 @@ function convertirStringAMayusculas(array) {
   // Convierte a mayúsculas todos los strings del array.
   // Retorna el arreglo resultante.
   // Tu código:
+  var Mayus = array.map(num => {
+    if (typeof num === 'string'){
+       return num.toUpperCase()
+    } else {
+      return num 
+    }
+  })
+
+  return Mayus
 }
 
 module.exports = convertirStringAMayusculas;
+
diff --git a/C7 Arrays/ejercicios/13.js b/C7 Arrays/ejercicios/13.js
index 037a01b1b9..02b45de341 100644
--- a/C7 Arrays/ejercicios/13.js	
+++ b/C7 Arrays/ejercicios/13.js	
@@ -1,6 +1,20 @@
 function filtrarNumerosPares(array) {
   // Devuelve un arreglo solo con los números pares presentes en el array.
   // Tu código:
+  // var par = array.map(num => {
+  //   if(num % 2 === 0){
+  //     return num
+  //   } else {
+  //     return false
+  //   }
+  // })
+
+  // return par
+
+  return array.filter (num => typeof num === 'number' && num % 2 === 0) || 'No hay pares'
 }
 
 module.exports = filtrarNumerosPares;
+
+let array = [2,4,5,7,8,20]
+console.log(filtrarNumerosPares(array))
diff --git a/C7 Arrays/ejercicios/14.js b/C7 Arrays/ejercicios/14.js
index 28cc42c259..ed06d458d4 100644
--- a/C7 Arrays/ejercicios/14.js	
+++ b/C7 Arrays/ejercicios/14.js	
@@ -1,6 +1,11 @@
 function contarElementosMayoresA10(array) {
   // Cuenta y devuelve la cantidad de elementos mayores a 10 en el array de números.
   // Tu código:
+
+  return array.filter(num => typeof num === 'number' && num > 10) || 'No hay elementos mayores a 10'
 }
 
 module.exports = contarElementosMayoresA10;
+
+let array = [1,3,4,5,70,83,12,45]
+console.log(contarElementosMayoresA10(array))
diff --git a/C7 Arrays/ejercicios/15.js b/C7 Arrays/ejercicios/15.js
index cf07316133..e886741ab2 100644
--- a/C7 Arrays/ejercicios/15.js	
+++ b/C7 Arrays/ejercicios/15.js	
@@ -2,6 +2,22 @@ function encontrarIndiceMayor(array) {
   // Encuentra el índice del número más grande en el array de números.
   // Devuelve el valor de este índice.
   // Tu código:
+  //return array.filter(num => typeof num === 'number' && )
+
+  let max = array[0]
+
+
+  array.filter(num => {
+    if(num > max){
+      max = num
+    }
+  })
+//2
+  return max
 }
 
+
 module.exports = encontrarIndiceMayor;
+
+var array = [1,2,3,4,6]
+console.log(encontrarIndiceMayor(array))
diff --git a/C7 Arrays/ejercicios/16.js b/C7 Arrays/ejercicios/16.js
index 6e6019e704..33166b0ee3 100644
--- a/C7 Arrays/ejercicios/16.js	
+++ b/C7 Arrays/ejercicios/16.js	
@@ -2,6 +2,11 @@ function multiplicarElementosPorIndice(array) {
   // Multiplica cada elemento del array por su índice.
   // Devuelve el nuevo arreglo con los resultados.
   // Tu código:
+  let indice = array.map((item, index) => item * index)
+
+  return indice
 }
 
 module.exports = multiplicarElementosPorIndice;
+let array = [1,2,3,4,5]
+console.log(multiplicarElementosPorIndice(array))
diff --git a/C7 Arrays/ejercicios/17.js b/C7 Arrays/ejercicios/17.js
index edf8ab42f2..bac0c4d973 100644
--- a/C7 Arrays/ejercicios/17.js	
+++ b/C7 Arrays/ejercicios/17.js	
@@ -1,6 +1,11 @@
 function agregarNumeros(arrayOfNums) {
   // Suma todos los elementos de arrayOfNums y retorna el resultado.
   // Tu código:
+
+  return arrayOfNums.reduce((acumuludaor, sumador) => acumuludaor + sumador, 0)
 }
 
 module.exports = agregarNumeros;
+
+var array = [1,2,3,4]
+console.log(agregarNumeros(array))
diff --git a/C7 Arrays/ejercicios/18.js b/C7 Arrays/ejercicios/18.js
index 580e26c583..7ab2054de7 100644
--- a/C7 Arrays/ejercicios/18.js	
+++ b/C7 Arrays/ejercicios/18.js	
@@ -1,6 +1,15 @@
 function promedioResultadosTest(resultadosTest) {
   // Itera sobre los elementos del arreglo resultadosTest y devuelve el promedio de las notas.
   // Tu código:
+
+  const sumaTotal = resultadosTest.reduce((suma, cantidad) => suma + cantidad, 0)
+
+  var promedio = sumaTotal / resultadosTest.length
+
+  return promedio
 }
 
 module.exports = promedioResultadosTest;
+
+var notas = [1.5,2,3,4]
+console.log(promedioResultadosTest(notas))
diff --git a/C7 Arrays/ejercicios/19.js b/C7 Arrays/ejercicios/19.js
index 4aed7fecae..aeb8afcc93 100644
--- a/C7 Arrays/ejercicios/19.js	
+++ b/C7 Arrays/ejercicios/19.js	
@@ -3,6 +3,24 @@ function multiplicarArgumentos() {
   // Si no se pasan argumentos retorna 0. Si se pasa un argumento, simplemente retórnalo.
   // [PISTA]: "arguments" es un arreglo.
   // Tu código:
+  if(arguments.length === 0) {
+    return 0
+  }
+
+  if(arguments.length === 1){
+    return arguments[0]
+  }
+  
+  let producto = 1 
+
+  for(let i = 0; i < arguments.length; i++){
+    producto *= arguments[i]
+  }
+
+  return producto
 }
 
 module.exports = multiplicarArgumentos;
+
+var array = [1,2,3,4]
+console.log(multiplicarArgumentos(1,2,3,4))
diff --git a/C7 Arrays/ejercicios/20.js b/C7 Arrays/ejercicios/20.js
index bcce3a3dbc..b73ea45532 100644
--- a/C7 Arrays/ejercicios/20.js	
+++ b/C7 Arrays/ejercicios/20.js	
@@ -2,6 +2,20 @@ function todosIguales(array) {
   // Si todos los elementos del arreglo son iguales, retornar true.
   // Caso contrario, retornar false.
   // Tu código:
+  if (array.length <= 1){
+    return false
+  }
+
+  for (let i = 0; i<array.length; i++){
+    if(array[i] !== array[0]){
+      return false
+    }
+  }
+
+  return true
 }
 
 module.exports = todosIguales;
+
+var array = [2,1,1,1]
+console.log(todosIguales(array))
diff --git a/C7 Arrays/ejercicios/21.js b/C7 Arrays/ejercicios/21.js
index 2dcba2d8e7..1e699c5373 100644
--- a/C7 Arrays/ejercicios/21.js	
+++ b/C7 Arrays/ejercicios/21.js	
@@ -3,6 +3,38 @@ function mesesDelAño(array) {
   // "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:
+
+  Nuevoarray = []
+  
+  // for(var i = 0; i<array.length; i++){
+  //   if(array[i] === 'Enero'){
+  //     Nuevoarray.unshift('Enero')
+  //   } else if(array[i] === 'Marzo'){
+  //     Nuevoarray.unshift('Marzo')
+  //   } else if(array[i] === 'Noviembre'){
+  //     Nuevoarray.unshift('Noviembre')
+  //   } else {
+  //     return ('No se encontraron los meses pedidos')
+  //   }
+  // }
+
+  // return Nuevoarray
+
+  for(var i = 0; i<array.length; i++){
+    if(array[i] === 'Enero' || array[i] === 'Marzo' || array[i] === 'Noviembre'){
+      Nuevoarray.push(array[i])
+    }
+  }
+
+  if(Nuevoarray.length === 3){
+    return Nuevoarray
+  } else {
+    return ('No se encontraron los meses pedidos')
+  }
+
 }
 
 module.exports = mesesDelAño;
+
+var array = ['Noviembre', 'Abril', 'Enero']
+console.log(mesesDelAño(array))
diff --git a/C7 Arrays/ejercicios/22.js b/C7 Arrays/ejercicios/22.js
index 00e9aae5e9..f48fd1a995 100644
--- a/C7 Arrays/ejercicios/22.js	
+++ b/C7 Arrays/ejercicios/22.js	
@@ -2,6 +2,18 @@ function tablaDelSeis() {
   // Devuelve un arreglo con los resultados de la tabla de multiplicar del 6 en orden creciente.
   // Desde 0 al 60.
   // Tu código:
+  var array = []
+
+  for(let i=0; i<=10; i++){
+    let resultado = 6 * i
+    
+    array.push(resultado)
+
+  }
+
+  return array
 }
 
 module.exports = tablaDelSeis;
+
+console.log(tablaDelSeis())
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/23.js b/C7 Arrays/ejercicios/23.js
index 408aebb292..3d965b6f7e 100644
--- a/C7 Arrays/ejercicios/23.js	
+++ b/C7 Arrays/ejercicios/23.js	
@@ -3,6 +3,25 @@ function breakStatement(num) {
   // Guardar cada nuevo valor en un arreglo y retórnarlo.
   // 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".
   // Tu código:
+  var array = []
+
+  for(let i=0; i<10; i++){
+    num += 2
+
+    if(num === i){
+      return ('Se interrumpio la ejecucion')
+    }
+
+    array.push(num)
+  
+  }
+  return array
+
 }
 
 module.exports = breakStatement;
+
+console.log(breakStatement(-4))
+
+
+
diff --git a/C7 Arrays/ejercicios/24.js b/C7 Arrays/ejercicios/24.js
index 522c2d5e4d..67709372ce 100644
--- a/C7 Arrays/ejercicios/24.js	
+++ b/C7 Arrays/ejercicios/24.js	
@@ -5,6 +5,23 @@ function continueStatement(num) {
   // se continúa con la siguiente iteración.
   // PISTA: Utiliza el statement 'continue'.
   // Tu código:
+  var array = []
+
+  for(let i=1; i<=10; i++){
+    num += 2
+
+    if(i === 5 ){
+      continue
+    }
+
+    array.push(num)
+  }
+
+  return array
 }
 
 module.exports = continueStatement;
+
+console.log(continueStatement(4))
+
+//1=6 2=8 3=10 4=12 5=12 6=14 7=16 8=18 9=20 10=22
diff --git a/C7 Arrays/ejercicios/25.js b/C7 Arrays/ejercicios/25.js
index 2d145505bb..1e1953812b 100644
--- a/C7 Arrays/ejercicios/25.js	
+++ b/C7 Arrays/ejercicios/25.js	
@@ -3,6 +3,19 @@ function contarParesConContinue(numeros) {
   // Devuelve la cantidad de números pares que hay en el array.
   // Evita los impares utilizando continue.
   // Tu código:
+  var contador = 0
+
+  for(let i=0; i<= numeros.length; i++){
+    if(numeros[i] % 2 !== 0){
+      continue
+    }
+     contador ++
+  }
+
+  return contador
 }
 
 module.exports = contarParesConContinue;
+
+var array = [1,2,3,4,5,6]
+console.log(contarParesConContinue(array))
diff --git a/C7 Arrays/ejercicios/26.js b/C7 Arrays/ejercicios/26.js
index 4d5a5d9aa4..67050a7161 100644
--- a/C7 Arrays/ejercicios/26.js	
+++ b/C7 Arrays/ejercicios/26.js	
@@ -3,6 +3,16 @@ function encontrarPrimerMultiploDeN(n, secuencia) {
   // Devuelve el primer múltiplo de n que encuentres en la secuencia de números.
   // Usa un break para detener el bucle una vez halles el múltiplo.
   // Tu código:
+  for(let i=0; i<secuencia.length; i ++){
+    if(secuencia[i] % n === 0 ){
+      return secuencia[i]
+    }
+  }
+  
+  return null
 }
 
-module.exports = encontrarPrimerMultiploDeN;
\ No newline at end of file
+module.exports = encontrarPrimerMultiploDeN;
+
+var array = [7,9]
+console.log(encontrarPrimerMultiploDeN(2, array))
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/27.js b/C7 Arrays/ejercicios/27.js
index b5d8565c5f..6bfc3f7634 100644
--- a/C7 Arrays/ejercicios/27.js	
+++ b/C7 Arrays/ejercicios/27.js	
@@ -4,6 +4,8 @@ function dePalabrasAFrase(palabras) {
   // con un espacio entre cada palabra.
   // Ejemplo: ['Hello', 'world!'] -> 'Hello world!'.
   // Tu código:
+  return palabras.join('')
+
 }
 
 module.exports = dePalabrasAFrase;
diff --git a/C7 Arrays/ejercicios/28.js b/C7 Arrays/ejercicios/28.js
index a1a65816b6..e289f7dfdd 100644
--- a/C7 Arrays/ejercicios/28.js	
+++ b/C7 Arrays/ejercicios/28.js	
@@ -3,6 +3,16 @@ function esArrayNoVacio(arr) {
   // Comprueba si este argumento es un array y si tiene al menos un elemento.
   // Si es así, retorna true, de lo contrario, retorna false.
   // Tu código:
+  if(Array.isArray(arr) && arr.length > 0){
+    return true
+  } else if(typeof arr === 'string'){
+    return false
+  }
 }
 
-module.exports = esArrayNoVacio;
\ No newline at end of file
+module.exports = esArrayNoVacio;
+
+var arr = [1,2,3,4]
+var arr1 = 'Sring'
+var arr2 = 1
+console.log(esArrayNoVacio(arr2))
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/29.js b/C7 Arrays/ejercicios/29.js
index de8a058efa..38815958df 100644
--- a/C7 Arrays/ejercicios/29.js	
+++ b/C7 Arrays/ejercicios/29.js	
@@ -4,6 +4,21 @@ function encontrarNumeroFaltante(numeros) {
   // y retórnalo.
   // Devuelve null si el array es vacío o si no hay números faltantes.
   // Tu código:
+  if(numeros.length === 0){
+    return null
+  }
+
+  //0=3,1=5,2=6
+  numeros.sort()
+  for(let i=0; i< numeros.length -1; i ++){
+    if(numeros[i + 1] !== numeros[i] + 1 ){
+      return numeros[i] + 1
+    }
+  }
+
+  return null
 }
 
-module.exports = encontrarNumeroFaltante;
\ No newline at end of file
+module.exports = encontrarNumeroFaltante;
+var array = [1,3,4]
+console.log(encontrarNumeroFaltante(array))
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/30.js b/C7 Arrays/ejercicios/30.js
index 74cdb5570d..057a85a67d 100644
--- a/C7 Arrays/ejercicios/30.js	
+++ b/C7 Arrays/ejercicios/30.js	
@@ -2,6 +2,16 @@ function encontrarElementoRepetido(numeros) {
   // La función recibe un argumento "numeros" que es un array de números.
   // Retorna el primer elemento repetido que se encuentre en el array.
   // Tu código:
+  for(let i=0; i<numeros.length; i++){
+    if(numeros[i + 1] === numeros[i]){
+      return numeros[i]
+    }
+  }
+
+  return null
 }
 
-module.exports = encontrarElementoRepetido;
\ No newline at end of file
+module.exports = encontrarElementoRepetido;
+
+var arr = [1,2,3,3,4]
+console.log(encontrarElementoRepetido(arr))
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/31.js b/C7 Arrays/ejercicios/31.js
index e75dcb7773..a9ce978a4e 100644
--- a/C7 Arrays/ejercicios/31.js	
+++ b/C7 Arrays/ejercicios/31.js	
@@ -2,6 +2,10 @@ function invertirTexto(texto) {
   // La función recibe un argumento "texto" que es un string.
   // Tu objetivo es invertir el string y devolver el string invertido.
   // Tu código:
+  return texto.split('').reverse().join('')
 }
 
 module.exports = invertirTexto;
+
+var arr = 'Hola, mundo'
+console.log(invertirTexto(arr))
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/32.js b/C7 Arrays/ejercicios/32.js
index 6e46790cd2..213f7fcb98 100644
--- a/C7 Arrays/ejercicios/32.js	
+++ b/C7 Arrays/ejercicios/32.js	
@@ -5,6 +5,18 @@ function esPalindromo(string) {
   // IMPORTANTE: Un palíndromo es una palabra o frase
   // que se lee igual hacia adelante que hacia atrás.
   // Tu código:
+
+  var stringInvertida = string.split('').reverse().join('')
+
+  if(string === stringInvertida){
+    return true
+  } else {
+    return false
+  }
+
 }
 
-module.exports = esPalindromo;
\ No newline at end of file
+module.exports = esPalindromo;
+
+var array = 'amar'
+console.log(esPalindromo('amar === rama'))
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/33.js b/C7 Arrays/ejercicios/33.js
index defe758f76..131781c003 100644
--- a/C7 Arrays/ejercicios/33.js	
+++ b/C7 Arrays/ejercicios/33.js	
@@ -7,6 +7,50 @@ function combine(str1, str2, str3) {
   // combine("abc", "12345", "") == "a1b2c345"
   // combine("abc", "12345", "67") == "a16b27c345"
   // Tu código:
+ let resultado = ''
+
+ var string1 = str1.length
+ var string2 = str2.length
+ var string3 = str3.length
+
+ let MaxLength = Math.max(string1, string2, string3)
+
+ for(let i = 0; i < MaxLength; i ++){
+  if(str1[i]) resultado += str1[i]
+  if(str2[i]) resultado += str2[i]
+  if(str3[i]) resultado += str3[i]
+ }
+
+ return resultado
+
+// str1 = str1 || "";
+// str2 = str2 || "";
+// str3 = str3 || "";
+
+// // Verifica y muestra los valores iniciales de las cadenas
+// console.log("str1:", str1);
+// console.log("str2:", str2);
+// console.log("str3:", str3);
+
+// // Encuentra la longitud máxima
+// const maxLength = Math.max(str1.length, str2.length, str3.length);
+// console.log("maxLength:", maxLength);
+
+// let resultado = "";
+
+// // Recorre hasta la longitud máxima
+// for (let i = 0; i < maxLength; i++) {
+//   if (str1[i]) resultado += str1[i];
+//   if (str2[i]) resultado += str2[i];
+//   if (str3[i]) resultado += str3[i];
+// }
+
+// return resultado;
 }
+ 
+
+module.exports = combine;
+
+var combinar = ('abc', '1234', 'dg5')
 
-module.exports = combine;
\ No newline at end of file
+console.log(combine('abc', '1234', 'dg5'))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/01.js b/C8 Objects + Callbacks/callbacks/ejercicios/01.js
index 9540c6b3b2..a2282e2833 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/01.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/01.js	
@@ -2,6 +2,8 @@ function invocarCallback(cb) {
    // Invoca/ejecuta el callback `cb`.
    // NOTA: no debes retornar nada.
    // Tu código:
+   cb()
 }
 
 module.exports = invocarCallback;
+
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/02.js b/C8 Objects + Callbacks/callbacks/ejercicios/02.js
index df7a401ef8..fb7def06b6 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/02.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/02.js	
@@ -3,6 +3,18 @@ function cambiarCadena(string, callback) {
    // La función de callback se encargará de recibir el string y devolverlo con los cambios.
    // Si no se recibe una función callback entonces se debe retornar el string original.
    // Tu código:
+   if(typeof callback === 'function'){
+      return callback(string)
+   } else {
+      return string
+   }
 }
 
+function aMayus(string) {
+   return string.toUpperCase()
+}
+
+var completo = cambiarCadena('Hola como vas', aMayus)
+console.log(completo)
+
 module.exports = cambiarCadena;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/03.js b/C8 Objects + Callbacks/callbacks/ejercicios/03.js
index 767f0a1808..d2416a6986 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/03.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/03.js	
@@ -3,6 +3,14 @@ function operacionMatematica(num1, num2, cb) {
   // El callback realiza una operación matemática, por lo que necesita de los dos números.
   // Retorna el resultado del callback pasándole por valores los números num1 y num2.
   // Tu código:
+  return cb(num1, num2)
 }
 
+function sumador(num1, num2){
+  return num1 + num2
+}
+
+var total = (operacionMatematica(1,2,sumador))
+console.log(total)
+
 module.exports = operacionMatematica;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/04.js b/C8 Objects + Callbacks/callbacks/ejercicios/04.js
index 04f18b1ec5..d117cc6bbd 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/04.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/04.js	
@@ -4,6 +4,16 @@ function sumarArray(arrayOfNumbers, cb) {
    // Este resultado debes pasárselo como argumento al callback recibido.
    // NOTA: no debes retornar nada.
    // Tu código:
+   var sumaTtotal = arrayOfNumbers.reduce((suma, valorActual)=> suma + valorActual,0)
+   return cb(sumaTtotal)
 }
 
+function verSuma(cb){
+   return ('la suma total es ' + cb) 
+} 
+
+const arreglo = [1,2,3,4]
+
+console.log(sumarArray(arreglo, verSuma))
+
 module.exports = sumarArray;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/05.js b/C8 Objects + Callbacks/callbacks/ejercicios/05.js
index cecc94504d..29d6c398fc 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/05.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/05.js	
@@ -2,6 +2,17 @@ function forEach(array, cb) {
   // Recibes un arreglo y un callback.
   // Itera sobre el arreglo y por cada elemento iterado, ejecuta el callback con este valor.
   // Tu código:
+
+  for(let i=0; i<array.length; i++){
+    cb(array[i])
+  }
+}
+
+function verArray(elemento){
+  console.log( 'Elemento: '+ elemento)
 }
 
+var array = [1,2,3,4,5]
+forEach(array, verArray)
+
 module.exports = forEach;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/06.js b/C8 Objects + Callbacks/callbacks/ejercicios/06.js
index e09a7bf8c4..5d49ab34f7 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/06.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/06.js	
@@ -3,6 +3,20 @@ function map(array, cb) {
   // Tiene que guardar el resultado devuelto por el callback en cada elemento dentro de un nuevo arreglo.
   // Retorna el nuevo arreglo.
   // Tu código:
+  nuevoArreglo = []
+
+  for(let i=0; i<array.length; i++){
+    nuevoArreglo[i] = cb(array[i] + ' ')
+  }
+
+  return nuevoArreglo
 }
 
+function duplicarCadaElemento(cb){
+  return cb * 2
+}
+
+var array = [1,2,3,4]
+console.log(map(array, duplicarCadaElemento))
+
 module.exports = map;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/07.js b/C8 Objects + Callbacks/callbacks/ejercicios/07.js
index d9983d4528..b5294e288d 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/07.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/07.js	
@@ -2,6 +2,22 @@ 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:
+   nuevoArreglo = []
+
+   for(let i=0; i<arrayOfStrings.length; i++){
+      if(arrayOfStrings[i][0] === 'a'){
+        nuevoArreglo.push(arrayOfStrings[i])
+      }
+   }
+
+   return nuevoArreglo
 }
 
+function verArray(cb){
+   return 'El nuevo array es: ' +  cb.join(' ,')
+}
+
+var string = ['hola', 'ameno', 'bueno' , 'amor', 'actualizar']
+console.log(verArray(filter(string)))
+
 module.exports = filter;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/08.js b/C8 Objects + Callbacks/callbacks/ejercicios/08.js
index b4c2cad28a..3e3849b593 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/08.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/08.js	
@@ -3,6 +3,20 @@ const buscarElemento = (array, callback) => {
   // Si el elemento no se encuentra, devuelve el mensje "No se encontró el elemento".
   // La función de callback es la encargada de evaluar si el elemento fue encontrado.
   // Tu código:
+
+  for(let i=0; i<array.length; i++){
+    if(callback(array[i])){
+      return array[i]
+    }
+  }
+  return 'No se encontro el elemento'
 };
 
+function Encontrar(elementoDelArray){
+  return elementoDelArray === 'hola'
+
+}
+
+var array = ['como estas', 'carro']
+console.log(buscarElemento(array, Encontrar))
 module.exports = buscarElemento;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/01.js b/C8 Objects + Callbacks/objects/ejercicios/01.js
index 4e28b4c584..8e1d03fabe 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/01.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/01.js	
@@ -8,3 +8,7 @@ const obtenerValorPropiedad = (objeto, propiedad) => {
 };
 
 module.exports = obtenerValorPropiedad;
+
+var carro = {nombre: 'Fabio'}
+
+console.log(obtenerValorPropiedad(carro, 'nombre'))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/objects/ejercicios/02.js b/C8 Objects + Callbacks/objects/ejercicios/02.js
index fd81338de0..7eed177736 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/02.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/02.js	
@@ -2,8 +2,19 @@ function actualizarValorPropiedad(objeto, propiedad, valor) {
    // Actualiza el valor de la propiedad del objeto recibidos en la función.
    // Retorna el objeto actualizado.
    // Tu código:
+   // Correcto: usando Bracket Notation para acceder a una propiedad dinámica
    objeto[propiedad] = valor;
+   
+   // Incorrecto: esto crearía una propiedad literal llamada 'propiedad'
+   // objeto.propiedad = valor;
+   //Dot notation se utiliza cuando se sabe el nombre de la propiedad y queremos actualizarla
    return objeto;
 }
 
 module.exports = actualizarValorPropiedad;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo'}
+
+console.log(actualizarValorPropiedad(carro, 'nombre', 'Ferrari'))
+
+
diff --git a/C8 Objects + Callbacks/objects/ejercicios/03.js b/C8 Objects + Callbacks/objects/ejercicios/03.js
index 9705c17350..b8e899032f 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/03.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/03.js	
@@ -1,6 +1,14 @@
 const agregarNuevaPropiedad = (objeto, propiedad, valor) => {
   // Añade una nueva propiedad al objeto con su respectivo valor pasado por la función.
   // Tu código:
+  objeto[propiedad] = valor
+
+  return objeto
 };
 
 module.exports = agregarNuevaPropiedad;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo'}
+
+console.log(agregarNuevaPropiedad(carro, 'llantas', 'nuevas'))
+
diff --git a/C8 Objects + Callbacks/objects/ejercicios/04.js b/C8 Objects + Callbacks/objects/ejercicios/04.js
index 8dbc773948..d1dfe56ba7 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/04.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/04.js	
@@ -3,6 +3,13 @@ function verificarPropiedad(objeto, propiedad) {
    // Retorna true si la tiene, sino retorna false.
    // PISTA: puedes usar el método hasOwnProperty().
    // Tu código:
+   var tienePropiedad = objeto.hasOwnProperty(propiedad)
+
+   return tienePropiedad
 }
 
 module.exports = verificarPropiedad;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo'}
+
+console.log(verificarPropiedad(carro, 'color'))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/05.js b/C8 Objects + Callbacks/objects/ejercicios/05.js
index 57485922a9..af5ed5916a 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/05.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/05.js	
@@ -2,6 +2,13 @@ const listarPropiedades = (objeto) => {
   // Lista y retorna todas las propiedades que posee el objeto recibido por la función.
   // PISTA: Puedes usar el método Object.keys().
   // Tu código:
+  var MostrarPropiedades = Object.keys(objeto)
+
+  return MostrarPropiedades
 };
 
 module.exports = listarPropiedades;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo'}
+
+console.log(listarPropiedades(carro))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/06.js b/C8 Objects + Callbacks/objects/ejercicios/06.js
index da96759653..198ce6e91b 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/06.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/06.js	
@@ -2,6 +2,17 @@ const contarPropiedades = (objeto) => {
   // Cuenta y retorna el total de propiedades que tiene el objeto.
   // PISTA: Puedes iterarlo usando el bucle for-in.
   // Tu código:
+  let sumador = 0
+
+  for(let prop in objeto){
+    sumador ++
+  }
+
+  return sumador
 };
 
 module.exports = contarPropiedades;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo'}
+
+console.log(contarPropiedades(carro))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/07.js b/C8 Objects + Callbacks/objects/ejercicios/07.js
index 38b33c7db6..48177f7479 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/07.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/07.js	
@@ -7,6 +7,21 @@ function sort(sortBy, list) {
    // recibes --> ("a", [{ a: 1, b: 3 }, { a: 3, b: 2 }, { a: 2, b: 40 }])
    // retorna --> [{ a: 3, b: 2 }, { a: 2, b: 40 }, { a: 1, b: 3 }]
    // Tu código:
+
+   return list.sort((obj1,obj2) => {
+      return obj2[sortBy] - obj1[sortBy]
+   })
 }
 
 module.exports = sort;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo'}
+const list = [
+   { a: 1, b: 3 },
+   { a: 3, b: 2 },
+   { a: 2, b: 40 }
+ ];
+console.log(sort('a', list))
+
+
+
diff --git a/C8 Objects + Callbacks/objects/ejercicios/08.js b/C8 Objects + Callbacks/objects/ejercicios/08.js
index b6915259c4..1aeee111ba 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/08.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/08.js	
@@ -5,6 +5,20 @@ function crearGato(nombre, edad) {
   // La propiedad "meow" será una función que retorne el string: "Meow!".
   // Retornar el objeto.
   // Tu código:
+  var gato = {
+    Nombre: nombre,
+    Edad: edad,
+    meow: function(){
+      return ('Meow!')
+    }
+  }
+
+  return gato
 }
 
 module.exports = crearGato;
+
+const migato = crearGato('Sox', 2)
+
+console.log(migato.Nombre)
+console.log(migato.meow())
diff --git a/C8 Objects + Callbacks/objects/ejercicios/09.js b/C8 Objects + Callbacks/objects/ejercicios/09.js
index ff0b379077..21f8c04e21 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/09.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/09.js	
@@ -3,6 +3,16 @@ function nuevoUsuario(nombre, email, password) {
   // Este debe tener las propiedades: "nombre", "email" y "password" con sus respectivos valores.
   // Retorna el objeto creado.
   // Tu código:
+  var cliente = {
+    nombre: nombre,
+    email: email,
+    password: password,
+  }
+
+  return cliente
 }
 
 module.exports = nuevoUsuario;
+
+var cliente = nuevoUsuario('Fabio', 'fabioandfe@gm.oc', 'password')
+console.log(cliente.nombre)
diff --git a/C8 Objects + Callbacks/objects/ejercicios/10.js b/C8 Objects + Callbacks/objects/ejercicios/10.js
index b307e660e3..4ec9df184c 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/10.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/10.js	
@@ -4,6 +4,13 @@ function agregarPropiedad(objeto, propiedad) {
   // Esta propiedad será igual al valor `null`.
   // Retornar el objeto.
   // Tu código:
+  objeto[propiedad] = null
+
+  return objeto
 }
 
 module.exports = agregarPropiedad;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo'}
+
+console.log(agregarPropiedad(carro, 'como'))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/11.js b/C8 Objects + Callbacks/objects/ejercicios/11.js
index 85579d0d92..d21d917146 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/11.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/11.js	
@@ -3,6 +3,20 @@ function invocarMetodo(objeto, metodo) {
   // Esta propiedad contiene una función en su interior. Debes invocarla/ejecutarla.
   // NOTA: no necesitas retornar nada.
   // Tu código:
+  objeto[metodo](metodo)
+
+  //return objeto
 }
 
 module.exports = invocarMetodo;
+
+var carro = {
+  nombre: 'BMW', 
+  km: 6000, 
+  estado: 'Semi Nuevo',
+  saludar: function(){
+    console.log('Hola me llamo ' + this.nombre)
+  }
+}
+
+invocarMetodo(carro, 'saludar')
diff --git a/C8 Objects + Callbacks/objects/ejercicios/12.js b/C8 Objects + Callbacks/objects/ejercicios/12.js
index 976cd317d3..ed3a2f8692 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/12.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/12.js	
@@ -2,6 +2,14 @@ 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:
+  if(typeof objetoMisterioso['numeroMisterioso'] === 'number'){
+    return objetoMisterioso['numeroMisterioso'] * 5
+  } else {
+    return 'No es un numero'
+  }
 }
 
 module.exports = multiplicarNumeroDesconocidoPorCinco;
+
+var carro = {numeroMisterioso: 5}
+console.log(multiplicarNumeroDesconocidoPorCinco(carro))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/13.js b/C8 Objects + Callbacks/objects/ejercicios/13.js
index 26b71ad81e..c29011ea96 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/13.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/13.js	
@@ -2,6 +2,12 @@ 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
 }
 
 module.exports = eliminarPropiedad;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo'}
+console.log(eliminarPropiedad(carro, 'nombre'))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/14.js b/C8 Objects + Callbacks/objects/ejercicios/14.js
index 21b96699d2..6f434c569c 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/14.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/14.js	
@@ -2,6 +2,15 @@ function tieneEmail(objetoUsuario) {
   // Verifica si el "objetoUsuario", en su propiedad "email", posee un valor definido.
   // En ese caso, retorna true. Caso contrario, false.
   // Tu código:
+  if(objetoUsuario.hasOwnProperty('email')){
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = tieneEmail;
+
+var carro = {nombre: 'BMW', email: 6000, estado: 'Semi Nuevo'}
+
+console.log(tieneEmail(carro))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/15.js b/C8 Objects + Callbacks/objects/ejercicios/15.js
index 9fe787b8fb..adba3e655d 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/15.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/15.js	
@@ -2,6 +2,14 @@ function tienePropiedad(objeto, propiedad) {
   // Verifica si el objeto recibido posee una propiedad con el mismo nombre que el parámetro "propiedad".
   // En ese caso, retorna true. Caso contrario, false.
   // Tu código:
+  if(objeto.hasOwnProperty(propiedad)){
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = tienePropiedad;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo', propiedad: 'hola'}
+console.log(tienePropiedad(carro, 'propiedad'))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/objects/ejercicios/16.js b/C8 Objects + Callbacks/objects/ejercicios/16.js
index 27c5dd2f47..3749233b55 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/16.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/16.js	
@@ -2,6 +2,26 @@ function verificarPassword(objetoUsuario, password) {
   // Verifica si la propiedad "password" del "objetoUsuario" coincide con el parámetro "password".
   // En ese caso, retorna true. Caso contrario, false.
   // Tu código:
+
+  //TODAS ESTAS MANERAS ESTAN CORRECTAS
+  //return password in objetoUsuario
+
+  //return objetoUsuario.hasOwnProperty(password)
+
+  // if(password in objetoUsuario){
+  //   return true
+  // } else {
+  //   return false
+  // }
+
+  if(objetoUsuario.hasOwnProperty(password)){
+    return true
+  } else {
+    return false
+  }
 }
 
 module.exports = verificarPassword;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo', propiedad: 'hola', password: 'gfgd'}
+console.log(verificarPassword(carro, 'password'))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/17.js b/C8 Objects + Callbacks/objects/ejercicios/17.js
index acdbae5590..b4e2461e11 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/17.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/17.js	
@@ -3,6 +3,14 @@ function actualizarPassword(objetoUsuario, nuevaPassword) {
   // La nueva contraseña la recibes por parámetro.
   // Retornar el objeto.
   // Tu código:
+
+  objetoUsuario['password'] = nuevaPassword
+
+  return objetoUsuario
 }
 
 module.exports = actualizarPassword;
+
+var carro = {nombre: 'BMW', km: 6000, estado: 'Semi Nuevo', propiedad: 'hola'}
+
+console.log(actualizarPassword(carro, 'hola'))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/18.js b/C8 Objects + Callbacks/objects/ejercicios/18.js
index 1af064c1bf..2a8a6014a2 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/18.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/18.js	
@@ -3,6 +3,30 @@ function agregarAmigo(objetoUsuario, nuevoAmigo) {
   // Debes agregar el "nuevoAmigo" al final de este arreglo.
   // Retornar el objeto.
   // Tu código:
+
+  if(objetoUsuario.hasOwnProperty('amigos')){
+    objetoUsuario['amigos'].push(nuevoAmigo)
+  }else {
+    return 'No hay propiedad amigos'
+  }
+  // if(Array.isArray(objetoUsuario['amigos'])){
+  //   objetoUsuario['amigos'].push(nuevoAmigo)
+  // } else {
+  //   return 'No hay propiedad amigos'
+  // }
+  //objetoUsuario['amigos'].push(nuevoAmigo)
+
+  return objetoUsuario
 }
 
 module.exports = agregarAmigo;
+
+var carro = {
+  nombre: 'BMW', 
+  km: 6000, 
+  estado: 'Semi Nuevo', 
+  propiedad: 'hola', 
+  password: 'gfgd', 
+  amigos: ['maria']
+}
+console.log(agregarAmigo(carro, 'fabio'))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/19.js b/C8 Objects + Callbacks/objects/ejercicios/19.js
index ccf3d4db4f..249f9d7a23 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/19.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/19.js	
@@ -4,6 +4,23 @@ function pasarUsuarioAPremium(objetoMuchosUsuarios) {
   // Define esta propiedad de todos los usuarios como true.
   // Retornar el arreglo.
   // Tu código:
+  for(let i = 0; i< objetoMuchosUsuarios.length; i++){
+    if(objetoMuchosUsuarios[i].hasOwnProperty('esPremium')){
+      objetoMuchosUsuarios[i]['esPremium'] = true
+    } else {
+      return 'No existe la propiedad'
+    }
+  }
+  return objetoMuchosUsuarios
 }
 
 module.exports = pasarUsuarioAPremium;
+
+var usuarios = [
+  {nombre: 'Fabio', edad: 21, esPremium: false},
+  {nombre: 'Camila', edad: 19, esPremium: false}
+]
+
+console.log(pasarUsuarioAPremium(usuarios))
+
+console.log(usuarios[0]['esPremium'])
diff --git a/C8 Objects + Callbacks/objects/ejercicios/20.js b/C8 Objects + Callbacks/objects/ejercicios/20.js
index b2ed3cce78..9c6405c3e0 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/20.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/20.js	
@@ -4,6 +4,24 @@ function sumarLikesDeUsuario(objetoUsuario) {
   // 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 sumador = 0
+  
+  for(let i = 0; i<objetoUsuario['post'].length; i++){
+    sumador += objetoUsuario.post[i]['likes']
+  }
+
+  return sumador
 }
 
 module.exports = sumarLikesDeUsuario;
+
+var usuario = {
+  nombre: 'Fabio',
+  post: [
+    {titulo: 'post1', likes: 10},
+    {titulo: 'post2', likes: 20},
+    {titulo: 'post3', likes: 30}
+  ]
+}
+
+console.log(sumarLikesDeUsuario(usuario))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/21.js b/C8 Objects + Callbacks/objects/ejercicios/21.js
index 6533392cef..1d7254e0b4 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/21.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/21.js	
@@ -9,6 +9,24 @@ function agregarMetodoCalculoDescuento(objetoProducto) {
   // PorcentajeDeDescuento ---> 0.2
   // Precio final ---> 8
   // Tu código:
+
+  objetoProducto['calcularPrecioDescuento'] = function(){
+    const descuento = this.precio * this.porcentajeDeDescuento
+    const precioTotal = this.precio - descuento
+
+    return precioTotal
+  }
+
+  return objetoProducto
 }
 
 module.exports = agregarMetodoCalculoDescuento;
+
+var precio = {
+  precio: 10 ,
+  porcentajeDeDescuento: 0.5
+}
+var precioTotal = agregarMetodoCalculoDescuento(precio)
+console.log(precioTotal.calcularPrecioDescuento())
+
+
diff --git a/C8 Objects + Callbacks/objects/ejercicios/22.js b/C8 Objects + Callbacks/objects/ejercicios/22.js
index f14b686ac4..258b802e77 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/22.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/22.js	
@@ -5,6 +5,9 @@ function esAnagrama(str1, str2) {
    // IMPORTANTE: Un anagrama es una palabra que se forma
    // con las mismas letras que otra, pero en orden diferente.
    // Tu código:
+   return str1.split().sort().join() === str2.split().sort().join()
 }
 
 module.exports = esAnagrama;
+
+console.log(esAnagrama('roma', 'apple'))
diff --git a/C9 Ejercicios Extra/Ejercicios Extra.js b/C9 Ejercicios Extra/Ejercicios Extra.js
index d921ce5d0d..d93766f1cf 100644
--- a/C9 Ejercicios Extra/Ejercicios Extra.js	
+++ b/C9 Ejercicios Extra/Ejercicios Extra.js	
@@ -6,51 +6,138 @@ function deObjetoAarray(objeto) {
   // 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)
 }
 
+var objeto = {D: 1, B: 2, C: 3}
+console.log(deObjetoAarray(objeto))
+
 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 }
   // 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 objetoOrdenado = {}
+  Object.keys(contador).sort().forEach((letra => {
+    objetoOrdenado[letra] = contador[letra]
+  }))
+
+  return contador
+
 }
 
+var strin = "adsjfdsfsfjsdjfhacabcsbajda"
+console.log(numberOfCharacters(strin))
+
 function capToFront(string) {
   // Recibes un string con algunas letras en mayúscula y otras en minúscula.
   // Debes enviar todas las letras en mayúscula al comienzo del string.
   // Retornar el string.
   // [EJEMPLO]: soyHENRY ---> HENRYsoy
   // Tu código:
+  let mayus = []
+  let minu = []
+
+  for(let i=0; i<string.length; i++){
+    if(string[i] === string[i].toUpperCase()){
+      mayus.push(string[i])
+    }
+
+    if(string[i] === string[i].toLowerCase()){
+      minu.push(string[i])
+    }
+  }
+
+  return mayus.join('') + minu.join('')
 }
 
+var mayus = 'soyHENRYs'
+console.log(capToFront(mayus))
+
 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:
+  let nuevoArray = []
+
+  let frasePartida = frase.split(' ')
+
+  for(let i=0; i<frasePartida.length; i++){
+    let palabraInvertida = frasePartida[i].split('').reverse().join('')
+    nuevoArray.push(palabraInvertida)
+  }
+
+  return nuevoArray.join(' ')
 }
 
+var frase = 'The Henry Challenge is close!'
+console.log(asAmirror(frase))
+
 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:
+  var numeroaStr = numero.toString()
+
+  //var numero = numeroaStr.split('').reverse().join('')
+  
+  if(numeroaStr.split('').reverse().join('') === numeroaStr){
+    return 'Es capicua'
+  } else {
+    return 'No es capicua'
+  }
 }
 
+var numero = 1881
+console.log(capicua(numero))
+
+
 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:
+  let array = ''
+  
+  for(let i=0; i<string.length; i++){
+    let contador = string[i]
+
+    if(contador !== 'a'  && contador !== 'b'  && contador !== 'c'){
+      array += contador
+    }
+  }
+
+  return array
 }
 
+var array = 'abgdfdc'
+console.log(deleteAbc(array))
+
 function sortArray(arrayOfStrings) {
   // Recibes un arreglo de strings.
   // 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)
 }
 
+var array = ["You", "are", "beautiful", "looking"]
+console.log(sortArray(array))
+
 function buscoInterseccion(array1, array2) {
   // Recibes dos arreglos de números.
   // Debes retornar un nuevo arreglo en el que se guarden los elementos en común entre ambos arreglos.
@@ -58,8 +145,22 @@ function buscoInterseccion(array1, array2) {
   // Si no tienen elementos en común, retornar un arreglo vacío.
   // [PISTA]: los arreglos no necesariamente tienen la misma longitud.
   // Tu código:
+  let nuevoArray = []
+
+  for(let i=0; i<array1.length; i++){
+    if(array2.includes(array1[i])){
+      nuevoArray.push(array1[i])
+    }
+  }
+
+  return nuevoArray
 }
 
+var array1 = [4,2,3]
+var array2= [1,3,4]
+
+console.log(buscoInterseccion(array1, array2))
+
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
 module.exports = {
   deObjetoAarray,
diff --git a/README.md b/README.md
index 7845492974..653aab02d4 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,4 @@
-![HenryLogo](./assets/logoBannerHenry.png)
+gi![HenryLogo](./assets/logoBannerHenry.png)
 
 # **🧑‍💻 PREP COURSE | HENRY 👩‍💻**
 
@@ -7,6 +7,7 @@
 ¡Hola 😄! Bienvenid@ al Prep Course para la carrera de Desarrollo Web Full Stack.
 
 En este curso introductorio podrás aprender y practicar todo el contenido que necesitas para convertirte en un desarrollador de JavaScript. Encontrarás todo el material que necesitas para lograr avanzar en la evaluación del Henry Challenge (último paso para ingresar a la carrera de Desarrollo Web Full Stack).
+hola soy fabio
 
 </br >
 
diff --git a/package-lock.json b/package-lock.json
index bbf7bb73b8..9eabdfec8d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1211,11 +1211,12 @@
          }
       },
       "node_modules/braces": {
-         "version": "3.0.2",
-         "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
-         "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+         "version": "3.0.3",
+         "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+         "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
+         "license": "MIT",
          "dependencies": {
-            "fill-range": "^7.0.1"
+            "fill-range": "^7.1.1"
          },
          "engines": {
             "node": ">=8"
@@ -1597,9 +1598,10 @@
          }
       },
       "node_modules/fill-range": {
-         "version": "7.0.1",
-         "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
-         "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+         "version": "7.1.1",
+         "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+         "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
+         "license": "MIT",
          "dependencies": {
             "to-regex-range": "^5.0.1"
          },
@@ -1820,6 +1822,7 @@
          "version": "7.0.0",
          "resolved": "https://registry.npmjs.org/is-number/-/is-number-7.0.0.tgz",
          "integrity": "sha512-41Cifkg6e8TylSpdtTpeLVMqvSBEVzTttHvERD741+pnZ8ANv0004MRL43QKPDlK9cGvNp6NZWZUBlbGXYxxng==",
+         "license": "MIT",
          "engines": {
             "node": ">=0.12.0"
          }
@@ -3149,6 +3152,7 @@
          "version": "5.0.1",
          "resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",
          "integrity": "sha512-65P7iz6X5yEr1cwcgvQxbbIw7Uk3gOy5dIdtZ4rDveLqhrdJP+Li/Hx6tyK0NEb+2GCyneCMJiGqrADCSNk8sQ==",
+         "license": "MIT",
          "dependencies": {
             "is-number": "^7.0.0"
          },
@@ -4257,11 +4261,11 @@
          }
       },
       "braces": {
-         "version": "3.0.2",
-         "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.2.tgz",
-         "integrity": "sha512-b8um+L1RzM3WDSzvhm6gIz1yfTbBt6YTlcEKAvsmqCZZFw46z626lVj9j1yEPW33H5H+lBQpZMP1k8l+78Ha0A==",
+         "version": "3.0.3",
+         "resolved": "https://registry.npmjs.org/braces/-/braces-3.0.3.tgz",
+         "integrity": "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA==",
          "requires": {
-            "fill-range": "^7.0.1"
+            "fill-range": "^7.1.1"
          }
       },
       "browserslist": {
@@ -4508,9 +4512,9 @@
          }
       },
       "fill-range": {
-         "version": "7.0.1",
-         "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.0.1.tgz",
-         "integrity": "sha512-qOo9F+dMUmC2Lcb4BbVvnKJxTPjCm+RRpe4gDuGrzkL7mEVl/djYSu2OdQ2Pa302N4oqkSg9ir6jaLWJ2USVpQ==",
+         "version": "7.1.1",
+         "resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",
+         "integrity": "sha512-YsGpe3WHLK8ZYi4tWDg2Jy3ebRz2rXowDxnld4bkQB00cc/1Zw9AWnC0i9ztDJitivtQvaI9KaLyKrc+hBW0yg==",
          "requires": {
             "to-regex-range": "^5.0.1"
          }