From e6f3c30297cabcf31f13c421183f823cab7417f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Fernando=20Brice=C3=B1o=20Galindo?=
 <d.bricenogalindo@gmail.com>
Date: Thu, 16 Mar 2023 00:12:20 -0500
Subject: [PATCH 1/7] Recuperacion proceso

Envio de ejercicios 1 y 2
---
 M03 JavaScript Fundamentos/Ejercicio 01.js | 12 ++++++------
 M03 JavaScript Fundamentos/Ejercicio 02.js | 11 +++++++++++
 2 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/M03 JavaScript Fundamentos/Ejercicio 01.js b/M03 JavaScript Fundamentos/Ejercicio 01.js
index 655f3d38af..7572573867 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 = 1;
 
 // 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..1a9abccf3b 100644
--- a/M03 JavaScript Fundamentos/Ejercicio 02.js	
+++ b/M03 JavaScript Fundamentos/Ejercicio 02.js	
@@ -4,6 +4,7 @@
 function devolverString(string) {
    // Debe retornar un string.
    // Tu código:
+   return string
 }
 
 // ⛔️ "X" e "Y" son números.
@@ -11,26 +12,36 @@ function devolverString(string) {
 function suma(x, y) {
    // Retorna el resultado de su suma.
    // Tu código:
+   var resultado = x + y;
+   return resultado
 }
 
 function resta(x, y) {
    // Retorna el resultado de la resta.
    // Tu código:
+   var resultado = x - y;
+   return resultado
 }
 
 function divide(x, y) {
    // Retorna el resultado de su división.
    // Tu código:
+   var resultado = x / y;
+   return resultado
 }
 
 function multiplica(x, y) {
    // Retorna el resultado de su multiplicación.
    // Tu código:
+   var resultado = x * y;
+   return resultado
 }
 
 function obtenerResto(x, y) {
    // Obten el resto de la división de "x" entre "y".
    // Tu código:
+   var resultado = x % y;
+   return resultado
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/

From 0f25f20069134a331ee0af419fdcaca613bbd6fb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Fernando=20Brice=C3=B1o=20Galindo?=
 <d.bricenogalindo@gmail.com>
Date: Thu, 16 Mar 2023 00:15:51 -0500
Subject: [PATCH 2/7] Resolucion de ejercicios

Envio de ejercicios del Modulo 3 Al 5
---
 M03 JavaScript Fundamentos/Ejercicio 04.js |   7 ++
 M03 JavaScript Fundamentos/Ejercicio 05.js |  54 +++++++++
 M04 JavaScript Bucles/homework.js          | 106 ++++++++++++++++++
 M05 JavaScript Arrays/homework.js          | 122 +++++++++++++++++++++
 4 files changed, 289 insertions(+)

diff --git a/M03 JavaScript Fundamentos/Ejercicio 04.js b/M03 JavaScript Fundamentos/Ejercicio 04.js
index ff7dbe2dcc..d37a99714a 100644
--- a/M03 JavaScript Fundamentos/Ejercicio 04.js	
+++ b/M03 JavaScript Fundamentos/Ejercicio 04.js	
@@ -6,31 +6,38 @@
 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(0,1));
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M03 JavaScript Fundamentos/Ejercicio 05.js b/M03 JavaScript Fundamentos/Ejercicio 05.js
index f82c3e3f07..d795172815 100644
--- a/M03 JavaScript Fundamentos/Ejercicio 05.js	
+++ b/M03 JavaScript Fundamentos/Ejercicio 05.js	
@@ -2,59 +2,113 @@
 /*5️⃣ EJERCICIO 05 5️⃣*/
 
 function esPositivo(num) {
+
    // La función recibe un entero. Devuelve como resultado un string que indica si el número
    // es positivo o negativo.
    // 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(Math.sign(num) > 0){
+      return "Es positivo";
+   }else if (Math.sign(num) === 0){
+      return false;
+   }else{
+      return "Es negativo";
+   }
 }
 
 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:
+
+   var exclamacion = "!";
+   var concatena = str + exclamacion;
+   return concatena;
+
 }
 
 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:
+
+   var resultado = nombre + " " + apellido;
+   return resultado;
 }
 
 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:
+
+   var string = 'Hola';
+   var dango= '!';
+   var resultado = string + " " + nombre + dango;
+   return resultado;
 }
 
 function obtenerAreaRectangulo(alto, ancho) {
+
    // Retornar el área de un rectángulo teniendo su altura y ancho.
    // Tu código:
+
+   var area = alto * ancho;
+   return area
+
 }
 
 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:
+
+   var suma = lado +  lado +  lado +  lado;
+   return suma;
+
 }
 
 function areaDelTriangulo(base, altura) {
+
    // Calcula el área de un triángulo y retorna el resultado.
    // Tu código:
+
+   var area = (base * altura)/2;
+   return  area;
 }
 
 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:
+
+   var dolar  = euro * 1.20;
+   return (dolar);
+
 }
 
 function esVocal(letra) {
+
    // Escribe una función que reciba una letra y, si es una vocal, muestre el mensaje “Es vocal”.
    // 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.length > 1) {
+      return "Dato incorrecto";
+    } else if (letra === 'a' || letra === 'e' || letra === 'i' || letra === 'o' || letra ===  'u') {
+      return "Es vocal";
+    } else {
+      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..749cc90262 100644
--- a/M04 JavaScript Bucles/homework.js	
+++ b/M04 JavaScript Bucles/homework.js	
@@ -5,6 +5,11 @@ function obtenerMayor(x, y) {
    // Retornar 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;
+   }
 }
 
 function mayoriaDeEdad(edad) {
@@ -12,6 +17,11 @@ function mayoriaDeEdad(edad) {
    // Si tiene 18 años ó más debe retornar el string: "Allowed".
    // Caso contrario: "Not allowed".
    // Tu código:
+   if(edad >= 18){
+      return "Allowed";
+   }else{
+      return "Not allowed";
+   }
 }
 
 function conection(status) {
@@ -21,6 +31,14 @@ 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";
+   }
+
 }
 
 function saludo(idioma) {
@@ -30,6 +48,17 @@ 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:
+   if(idioma === "aleman"){
+      return "Guten Tag!";
+   }else if(idioma === "mandarin"){
+      return "Ni Hao!";
+   }else if(idioma === "ingles"){
+      return "Hello!";
+   }else if(idioma === "undefined"){
+      return "Hola!";
+   }else{
+      return "Hola!";
+   }
 }
 
 function colors(color) {
@@ -41,18 +70,45 @@ function colors(color) {
    // 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 "+color;
+      break;
+      case "red":
+         return "This is "+color;
+      break;
+      case "green":
+         return "This is "+color;
+      break;
+      case "orange":
+         return "This is "+color;
+      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) {
@@ -62,6 +118,11 @@ function esEntero(num) {
    // Ejemplo: (-10) ---> true
    // De lo contrario, retorna false.
    // Tu código:
+   if (Number.isInteger(num)) {
+      return true;
+    } else {
+      return false;
+    }
 }
 
 function fizzBuzz(num) {
@@ -70,6 +131,15 @@ 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 % 3 === 0) {
+      return "fizz";
+    } else if (num % 5 === 0) {
+      return "buzz";
+    } else {
+      return false;
+    }
 }
 
 function operadoresLogicos(num1, num2, num3) {
@@ -80,6 +150,17 @@ function operadoresLogicos(num1, num2, num3) {
    // 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 + 1;
+    } else if (num1 === 0 && num2 === 0 && num3 === 0) {
+      return "Error";
+    } else {
+      return false;
+    }
 }
 
 function esPrimo(num) {
@@ -89,18 +170,37 @@ function esPrimo(num) {
    // [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 (let i = 2; i <= Math.sqrt(num); 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) {
+      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 >= 100 && num <= 999){
+      return true;
+   }else{
+      return false;
+   }
 }
 
 function doWhile(num) {
@@ -108,6 +208,12 @@ function doWhile(num) {
    // Retornar el valor final.
    // Utilizar el bucle Do-While.
    // Tu código:
+   let contador = 0;
+  do {
+    num += 5;
+    contador++;
+  } while (contador < 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..f1505bff93 100644
--- a/M05 JavaScript Arrays/homework.js	
+++ b/M05 JavaScript Arrays/homework.js	
@@ -3,34 +3,58 @@
 function devolverPrimerElemento(array) {
    // Retornar el primer elemento del arreglo recibido por parámetro.
    // Tu código:
+   var prime; 
+   for(var i=0; i < array.length; i ++){
+      if(i === 0){
+         prime = array[i];
+      }
+   }
+   return prime;
 }
 
 function devolverUltimoElemento(array) {
    // Retornar el último elemento del arreglo recibido por parámetro.
    // Tu código:
+   var ulti; 
+   for(var i=0; i < array.length; i ++){
+      if(i === array.length -1){
+         ulti = array[i];
+      }
+   }
+   return ulti;
 }
 
 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:
+   const resultado = [];
+   for (let i = 0; i < array.length; i++) {
+    resultado.push(array[i] + 1);
+   }
+   return resultado;
 }
 
 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) {
@@ -39,30 +63,45 @@ function dePalabrasAFrase(palabras) {
    // 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 suma = 0;
+   for (let i = 0; i < arrayOfNums.length; i++) {
+    suma += arrayOfNums[i];
+   }
+   return suma;
 }
 
 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 suma = 0;
+   let contador = 0;
+   for (let i = 0; i < resultadosTest.length; i++) {
+    suma += resultadosTest[i];
+    contador += 1;
+   }
+   return (suma/contador); // resultadosTest.length;
 }
 
 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(arrayOfNums);
 }
 
 function multiplicarArgumentos() {
@@ -70,11 +109,29 @@ 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;
+    } else if (arguments.length === 1) {
+      return arguments[0];
+    } else {
+      let producto = 1;
+      for (let i = 0; i < arguments.length; i++) {
+        producto *= arguments[i];
+      }
+      return producto;
+    }
 }
 
 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 contador = 0;
+   for (let i = 0; i < arreglo.length; i++) {
+    if (arreglo[i] > 18) {
+      contador++;
+    }
+   }
+   return contador;
 }
 
 function diaDeLaSemana(numeroDeDia) {
@@ -82,18 +139,35 @@ function diaDeLaSemana(numeroDeDia) {
    // 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 día 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:
+   const primerDigito = num.toString()[0];
+   return primerDigito === "9";
 }
 
 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 true;
+    }
+    const primerElemento = array[0];
+    for (let i = 1; i < array.length; i++) {
+      if (array[i] !== primerElemento) {
+        return false;
+      }
+    }
+    return true;
 }
 
 function mesesDelAño(array) {
@@ -101,18 +175,46 @@ 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:
+   const mesesPedidos = ["Enero", "Marzo", "Noviembre"];
+  const mesesEncontrados = [];
+  for (let i = 0; i < array.length; i++) {
+    const mesActual = arreglo[i];
+    if (mesesPedidos.includes(mesActual)) {
+      mesesEncontrados.push(mesActual);
+    }
+  }
+  if (mesesEncontrados.length === 3) {
+    return mesesEncontrados;
+  } 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 resultados = [];
+   for (let i = 0; i <= 10; i++) {
+    const resultado = i * 6;
+    resultados.push(resultado);
+    console.log(`6 x ${i} = ${resultado}`);
+   }
+   return resultados;
 }
 
 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 mayoresA100 = [];
+   for (let i = 0; i < array.length; i++) {
+    const valor = array[i];
+    if (valor > 100) {
+      mayoresA100.push(valor);
+    }
+   }
+   return mayoresA100;
 }
 
 /* ----------------------------------------------------------------------------------
@@ -126,6 +228,16 @@ function breakStatement(num) {
    // la ejecución y retornar el string: "Se interrumpió la ejecución".
    // [PISTA]: utiliza el statement 'break'.
    // Tu código:
+   const resultado = [];
+   let suma = num;
+   for (let i = 1; i <= 10; i++) {
+     suma += 2;
+     resultado.push(suma);
+     if (suma === i) {
+       return "Se interrumpió la ejecución";
+     }
+   }
+   return resultado;
 }
 
 function continueStatement(num) {
@@ -135,6 +247,16 @@ function continueStatement(num) {
    // se continua con la siguiente iteración.
    // [PISTA]: utiliza el statement 'continue'.
    // Tu código:
+   const resultado = [];
+   let suma = num;
+   for (let i = 1; i <= 10; i++) {
+     if (i === 5) {
+       continue;
+     }
+     suma += 2;
+     resultado.push(suma);
+   }
+   return resultado;
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/

From 022c35b770f9604d10959484185eb767ea582231 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Fernando=20Brice=C3=B1o=20Galindo?=
 <d.bricenogalindo@gmail.com>
Date: Thu, 16 Mar 2023 00:20:21 -0500
Subject: [PATCH 3/7] Reorganizamiento

Se implemento la resolucion de ejercios del modulo 3
---
 M03 JavaScript Fundamentos/Ejercicio 03.js | 33 ++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/M03 JavaScript Fundamentos/Ejercicio 03.js b/M03 JavaScript Fundamentos/Ejercicio 03.js
index 03cd0c9477..4c51ac6301 100644
--- a/M03 JavaScript Fundamentos/Ejercicio 03.js	
+++ b/M03 JavaScript Fundamentos/Ejercicio 03.js	
@@ -5,36 +5,69 @@ 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:
+
+   var data1 = str1.length;
+   var data2 = str2.length;
+   if (data1 === data2) {
+      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 == 1){
+      return true;
+   }else{
+      return false;
+   }
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/

From 16c2b48901b1576f78661dfcb6978feed13557aa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Fernando=20Brice=C3=B1o=20Galindo?=
 <d.bricenogalindo@gmail.com>
Date: Thu, 16 Mar 2023 13:10:44 -0500
Subject: [PATCH 4/7] Terminacion de modulo 5

Ejercicios resultos modulo 5
---
 M05 JavaScript Arrays/homework.js | 46 +++++++++++++------------------
 1 file changed, 19 insertions(+), 27 deletions(-)

diff --git a/M05 JavaScript Arrays/homework.js b/M05 JavaScript Arrays/homework.js
index f1505bff93..672a481e03 100644
--- a/M05 JavaScript Arrays/homework.js	
+++ b/M05 JavaScript Arrays/homework.js	
@@ -101,7 +101,10 @@ 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(arrayOfNums);
+   if (arrayOfNums.length === 0) {
+      return undefined;
+   }
+   return Math.max(...arrayOfNums);
 }
 
 function multiplicarArgumentos() {
@@ -125,13 +128,8 @@ function multiplicarArgumentos() {
 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 contador = 0;
-   for (let i = 0; i < arreglo.length; i++) {
-    if (arreglo[i] > 18) {
-      contador++;
-    }
-   }
-   return contador;
+   const filteredArray = array.filter(elemento => elemento > 18);
+   return filteredArray.length;
 }
 
 function diaDeLaSemana(numeroDeDia) {
@@ -139,12 +137,12 @@ function diaDeLaSemana(numeroDeDia) {
    // 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 día laboral";
-    }
-}
+   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.
@@ -176,18 +174,12 @@ function mesesDelAño(array) {
    // Si alguno de los meses no está, retornar el string: "No se encontraron los meses pedidos".
    // Tu código:
    const mesesPedidos = ["Enero", "Marzo", "Noviembre"];
-  const mesesEncontrados = [];
-  for (let i = 0; i < array.length; i++) {
-    const mesActual = arreglo[i];
-    if (mesesPedidos.includes(mesActual)) {
-      mesesEncontrados.push(mesActual);
-    }
-  }
-  if (mesesEncontrados.length === 3) {
-    return mesesEncontrados;
-  } else {
-    return "No se encontraron los meses pedidos";
-  }
+   const mesesEncontrados = array.filter(mes => mesesPedidos.includes(mes));
+   if (mesesPedidos.every(mes => mesesEncontrados.includes(mes))) {
+      return mesesEncontrados;
+   } else {
+      return "No se encontraron los meses pedidos";
+   }
 }
 
 function tablaDelSeis() {
@@ -282,4 +274,4 @@ module.exports = {
    mayorACien,
    breakStatement,
    continueStatement,
-};
+};
\ No newline at end of file

From aa3bc6903dfd96d8e2d85613821d06202d2ef908 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Fernando=20Brice=C3=B1o=20Galindo?=
 <d.bricenogalindo@gmail.com>
Date: Fri, 17 Mar 2023 12:35:00 -0500
Subject: [PATCH 5/7] M06

Se resolvieron los ejercicios del modulo 6
---
 M06 JavaScript Objetos/homework.js | 47 ++++++++++++++++++++++++++++++
 1 file changed, 47 insertions(+)

diff --git a/M06 JavaScript Objetos/homework.js b/M06 JavaScript Objetos/homework.js
index c2b9c9f9a0..aa303a99ba 100644
--- a/M06 JavaScript Objetos/homework.js	
+++ b/M06 JavaScript Objetos/homework.js	
@@ -7,6 +7,14 @@ function crearGato(nombre, edad) {
    // La propiedad "meow" será una función que retorne el string: "Meow!".
    // Retornar el objeto.
    // Tu código:
+   const gato = {
+      nombre: nombre,
+      edad: edad,
+      meow: function() {
+        return "Meow!";
+      }
+   };
+   return gato;
 }
 
 function nuevoUsuario(nombre, email, password) {
@@ -14,6 +22,13 @@ function nuevoUsuario(nombre, email, password) {
    // Este debe tener las propiedades: "nombre", "email" y "password" con sus respectivos valores.
    // Retornar el objeto.
    // Tu código:
+   const usuario = {
+      nombre: nombre,
+      email: email,
+      password: password
+   };
+   return usuario;
+
 }
 
 function agregarPropiedad(objeto, propiedad) {
@@ -22,6 +37,9 @@ function agregarPropiedad(objeto, propiedad) {
    // Esta propiedad será igual al valor `null`.
    // Retornar el objeto.
    // Tu código:
+   objeto[propiedad] = null;
+   return objeto;
+
 }
 
 function invocarMetodo(objeto, metodo) {
@@ -29,36 +47,46 @@ function invocarMetodo(objeto, metodo) {
    // 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:
+   return objetoMisterioso.numeroMisterioso * 5;
 }
 
 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:
+   if(objetoUsuario.hasOwnProperty("email") && objetoUsuario.email !== null){
+      return true;
+   }
+   return false;
 }
 
 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 objeto.hasOwnProperty(propiedad);
 }
 
 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) {
@@ -66,6 +94,8 @@ function actualizarPassword(objetoUsuario, nuevaPassword) {
    // La nueva contraseña la recibes por parámetro.
    // Retornar el objeto.
    // Tu código:
+   objetoUsuario.password = nuevaPassword;
+   return objetoUsuario;
 }
 
 function agregarAmigo(objetoUsuario, nuevoAmigo) {
@@ -73,6 +103,8 @@ function agregarAmigo(objetoUsuario, nuevoAmigo) {
    // Debes agregar el "nuevoAmigo" al final de este arreglo.
    // Retornar el objeto.
    // Tu código:
+   objetoUsuario.amigos.push(nuevoAmigo);
+   return objetoUsuario;
 }
 
 function pasarUsuarioAPremium(objetoMuchosUsuarios) {
@@ -81,6 +113,10 @@ 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++) {
+      objetoMuchosUsuarios[i].esPremium = true;
+   }
+   return objetoMuchosUsuarios;
 }
 
 function sumarLikesDeUsuario(objetoUsuario) {
@@ -89,6 +125,11 @@ 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 likesTotales = 0;
+   objetoUsuario.posts.forEach(function(post) {
+     likesTotales += post.likes;
+   });
+   return likesTotales;   
 }
 
 function agregarMetodoCalculoDescuento(objetoProducto) {
@@ -102,6 +143,12 @@ function agregarMetodoCalculoDescuento(objetoProducto) {
    // PorcentajeDeDescuento ---> 0.2
    // Precio final ---> 8
    // Tu código:
+   objetoProducto.calcularPrecioDescuento = function() {
+      var descuento = this.precio * this.porcentajeDeDescuento;
+      var precioFinal = this.precio - descuento;
+      return precioFinal;
+    };
+    return objetoProducto;
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/

From 737f1279bd43fc4b7f3c078f7a85f95f6d911262 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Fernando=20Brice=C3=B1o=20Galindo?=
 <d.bricenogalindo@gmail.com>
Date: Fri, 17 Mar 2023 12:58:46 -0500
Subject: [PATCH 6/7] M07

Se resolvieron los ejercicios del modulo 07 las dos partes
---
 M07 JavaScript Clases/Ejercicio 01.js | 21 +++++++++++++++++++++
 M07 JavaScript Clases/Ejercicio 02.js | 22 ++++++++++++++++++++++
 2 files changed, 43 insertions(+)

diff --git a/M07 JavaScript Clases/Ejercicio 01.js b/M07 JavaScript Clases/Ejercicio 01.js
index 23586970d5..e2043f833b 100644
--- a/M07 JavaScript Clases/Ejercicio 01.js	
+++ b/M07 JavaScript Clases/Ejercicio 01.js	
@@ -10,18 +10,39 @@ function crearUsuario() {
    // 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!';
+   }
 }
 
+
 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..788b53bdb6 100644
--- a/M07 JavaScript Clases/Ejercicio 02.js	
+++ b/M07 JavaScript Clases/Ejercicio 02.js	
@@ -6,6 +6,23 @@ 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
+      };
+   }
+   datos() {
+      return `${this.nombre}, ${this.edad} años`;
+    }
 }
 
 function crearInstanciaPersona(nombre, apellido, edad, domicilio) {
@@ -13,6 +30,8 @@ function crearInstanciaPersona(nombre, apellido, edad, domicilio) {
    // Recibirás las propiedades por parámetro.
    // Retornar la instancia creada.
    // Tu código:
+   const persona = new Persona(nombre, apellido, edad, domicilio);
+   return persona;
 }
 
 function agregarMetodo() {
@@ -20,6 +39,9 @@ function agregarMetodo() {
    // 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 ⚠️*/

From adc3f89527f4bc9f5992e8d85f0c42de51766d22 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Fernando=20Brice=C3=B1o=20Galindo?=
 <d.bricenogalindo@gmail.com>
Date: Fri, 17 Mar 2023 17:18:04 -0500
Subject: [PATCH 7/7] Resolver todo

Resolver todos los datos faltantes y optimizacion de datos
---
 M03 JavaScript Fundamentos/Ejercicio 02.js | 15 +++----
 M08 JavaScript Callback/homework.js        | 25 ++++++++++-
 M09 Ejercicios Extra/Ejercicios Extra.js   | 52 ++++++++++++++++++++++
 3 files changed, 81 insertions(+), 11 deletions(-)

diff --git a/M03 JavaScript Fundamentos/Ejercicio 02.js b/M03 JavaScript Fundamentos/Ejercicio 02.js
index 1a9abccf3b..11b22f2a2e 100644
--- a/M03 JavaScript Fundamentos/Ejercicio 02.js	
+++ b/M03 JavaScript Fundamentos/Ejercicio 02.js	
@@ -12,36 +12,31 @@ function devolverString(string) {
 function suma(x, y) {
    // Retorna el resultado de su suma.
    // Tu código:
-   var resultado = x + y;
-   return resultado
+   return x + y;
 }
 
 function resta(x, y) {
    // Retorna el resultado de la resta.
    // Tu código:
-   var resultado = x - y;
-   return resultado
+   return x - y;
 }
 
 function divide(x, y) {
    // Retorna el resultado de su división.
    // Tu código:
-   var resultado = x / y;
-   return resultado
+   return x / y;
 }
 
 function multiplica(x, y) {
    // Retorna el resultado de su multiplicación.
    // Tu código:
-   var resultado = x * y;
-   return resultado
+   return x * y;
 }
 
 function obtenerResto(x, y) {
    // Obten el resto de la división de "x" entre "y".
    // Tu código:
-   var resultado = x % y;
-   return resultado
+   return x % y;
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M08 JavaScript Callback/homework.js b/M08 JavaScript Callback/homework.js
index b14ff4b6f6..51953da1d8 100644
--- a/M08 JavaScript Callback/homework.js	
+++ b/M08 JavaScript Callback/homework.js	
@@ -5,12 +5,14 @@ function mayuscula(nombre) {
    // Debe devolver el mismo nombre, pero con la primera letra en mayúscula.
    // [Ejemplo]: "mario" ----> "Mario".
    // Tu código:
+   return nombre.charAt(0).toUpperCase() + nombre.slice(1);
 }
 
 function invocarCallback(cb) {
    // Invoca/ejecuta el callback `cb`.
    // [NOTA]: no debes reotrnar nada.
    // Tu código:
+   cb();
 }
 
 function operacionMatematica(num1, num2, cb) {
@@ -18,14 +20,20 @@ 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 como parámetros los números.
    // Tu código:
+   return cb(num1, num2);
 }
 
 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.
+   // [NOTA]: no debes retornar nada.
    // Tu código:
+   var suma = 0;
+   for (var i = 0; i < arrayOfNumbers.length; i++) {
+    suma += arrayOfNumbers[i];
+   }
+   cb(suma);
 }
 
 function forEach(array, cb) {
@@ -33,6 +41,9 @@ function forEach(array, cb) {
    // Debes iterar sobre el arreglo, y por cada elemento ejecutar el callback.
    // Debes pasarle el elemento como argumento al callback.
    // Tu código:
+   for (var i = 0; i < array.length; i++) {
+      cb(array[i]);
+   }
 }
 
 function map(array, cb) {
@@ -40,12 +51,24 @@ 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:
+   var newArray = [];
+   for (var i = 0; i < array.length; i++) {
+     newArray.push(cb(array[i]));
+   }
+   return newArray;
 }
 
 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:
+   var newArray = [];
+   for (var i = 0; i < arrayOfStrings.length; i++) {
+     if (arrayOfStrings[i][0] === "a") {
+       newArray.push(arrayOfStrings[i]);
+     }
+   }
+   return newArray;
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/
diff --git a/M09 Ejercicios Extra/Ejercicios Extra.js b/M09 Ejercicios Extra/Ejercicios Extra.js
index 84c1863d6f..d20ee650ca 100644
--- a/M09 Ejercicios Extra/Ejercicios Extra.js	
+++ b/M09 Ejercicios Extra/Ejercicios Extra.js	
@@ -6,6 +6,11 @@ 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:
+   var newArray = [];
+   for (var clave in objeto) {
+     newArray.push([clave, objeto[clave]]);
+   }
+   return newArray;
 }
 
 function numberOfCharacters(string) {
@@ -14,6 +19,22 @@ function numberOfCharacters(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:
+   var charCount = {};
+   for (var i = 0; i < string.length; i++) {
+     var char = string[i];
+     if (charCount[char]) {
+       charCount[char]++;
+     } else {
+       charCount[char] = 1;
+     }
+   }
+   var sortedChars = Object.keys(charCount).sort();
+   var result = {};
+   for (var i = 0; i < sortedChars.length; i++) {
+     var char = sortedChars[i];
+     result[char] = charCount[char];
+   }
+   return result;
 }
 
 function capToFront(string) {
@@ -22,6 +43,16 @@ function capToFront(string) {
    // Retornar el string.
    // [EJEMPLO]: soyHENRY ---> HENRYsoy
    // Tu código:
+   let uppercase = '';
+   let lowercase = '';
+   for (let i = 0; i < string.length; i++) {
+     if (string[i] === string[i].toUpperCase()) {
+       uppercase += string[i];
+     } else {
+       lowercase += string[i];
+     }
+   }
+   return uppercase + lowercase;
 }
 
 function asAmirror(frase) {
@@ -29,18 +60,29 @@ function asAmirror(frase) {
    // 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 words = frase.split(' ');
+   const reversedWords = words.map(word => word.split('').reverse().join(''));
+   return reversedWords.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 numStr = numero.toString();
+   const numReversed = numStr.split('').reverse().join('');
+   if (numStr === numReversed) {
+     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]/gi, '');
 }
 
 function sortArray(arrayOfStrings) {
@@ -49,6 +91,9 @@ function sortArray(arrayOfStrings) {
    // de la longitud de cada string.
    // [EJEMPLO]: ["You", "are", "beautiful", "looking"]  ---> [“You", "are", "looking", "beautiful"]
    // Tu código:
+   return arrayOfStrings.sort(function(a, b) {
+      return a.length - b.length;
+    });
 }
 
 function buscoInterseccion(array1, array2) {
@@ -58,6 +103,13 @@ 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 interseccion = [];
+   for(let i = 0; i < array1.length; i++) {
+     if(array2.includes(array1[i])) {
+       interseccion.push(array1[i]);
+     }
+   }
+   return interseccion;
 }
 
 /*⚠️ NO MODIFIQUES NADA DEBAJO DE ESTO ⚠️*/