From a284d254aa9aa432da6779c181ced2cf17619020 Mon Sep 17 00:00:00 2001
From: MatiasBirba <mbirba@supaqpel.com.ar>
Date: Thu, 27 Mar 2025 10:55:01 -0300
Subject: [PATCH 1/4] Ejercicios de Fundamentos de  JS resueltos

---
 C5 Fundamentos Javascript/ejercicios/01.js   |  6 ++++--
 C5 Fundamentos Javascript/ejercicios/02.js   |  2 +-
 C5 Fundamentos Javascript/ejercicios/03.js   |  2 +-
 C5 Fundamentos Javascript/ejercicios/04.js   |  6 ++++--
 C5 Fundamentos Javascript/ejercicios/05.js   |  6 ++++--
 C5 Fundamentos Javascript/ejercicios/06.js   |  2 +-
 C5 Fundamentos Javascript/ejercicios/07.js   | 18 ++++++++++++++++--
 C5 Fundamentos Javascript/ejercicios/08.js   | 12 ++++++++++--
 C5 Fundamentos Javascript/ejercicios/09.js   | 10 ++++++++--
 C5 Fundamentos Javascript/ejercicios/10.js   |  7 +++++--
 C5 Fundamentos Javascript/ejercicios/11.js   |  4 +++-
 C5 Fundamentos Javascript/ejercicios/12.js   |  4 +++-
 C5 Fundamentos Javascript/ejercicios/13.js   |  4 +++-
 C5 Fundamentos Javascript/ejercicios/15.js   |  4 ++++
 C5 Fundamentos Javascript/ejercicios/16.js   |  5 ++++-
 C5 Fundamentos Javascript/ejercicios/17.js   | 17 +++++++++++++++--
 C5 Fundamentos Javascript/ejercicios/18.js   | 18 ++++++++++++++++--
 C5 Fundamentos Javascript/ejercicios/19.js   |  3 +++
 C5 Fundamentos Javascript/ejercicios/20.js   |  6 +++++-
 C5 Fundamentos Javascript/ejercicios/21.js   |  5 ++++-
 C5 Fundamentos Javascript/ejercicios/22.js   |  5 ++++-
 C5 Fundamentos Javascript/ejercicios/23.js   |  5 ++++-
 C5 Fundamentos Javascript/ejercicios/24.js   |  2 ++
 C5 Fundamentos Javascript/ejercicios/25.js   |  4 ++++
 C5 Fundamentos Javascript/ejercicios/26.js   |  4 +++-
 C5 Fundamentos Javascript/ejercicios/27.js   |  4 ++++
 C5 Fundamentos Javascript/ejercicios/28.js   |  2 ++
 C5 Fundamentos Javascript/ejercicios/29.js   |  3 +++
 C5 Fundamentos Javascript/ejercicios/30.js   |  3 +++
 C5 Fundamentos Javascript/ejercicios/31.js   |  3 +++
 C5 Fundamentos Javascript/ejercicios/32.js   |  3 +++
 C5 Fundamentos Javascript/ejercicios/34.js   |  3 +++
 C5 Fundamentos Javascript/ejercicios/35.js   |  4 +++-
 C5 Fundamentos Javascript/ejercicios/36.js   |  3 +++
 C5 Fundamentos Javascript/tests/M5T1.test.js |  6 +++++-
 C5 Fundamentos Javascript/tests/M5T4.test.js |  1 +
 C5 Fundamentos Javascript/tests/M5T5.test.js |  3 ++-
 C5 Fundamentos Javascript/tests/M5T7.test.js |  2 +-
 38 files changed, 167 insertions(+), 34 deletions(-)

diff --git a/C5 Fundamentos Javascript/ejercicios/01.js b/C5 Fundamentos Javascript/ejercicios/01.js
index 62feaaf6f6..d1eb0fe4cf 100644
--- a/C5 Fundamentos Javascript/ejercicios/01.js	
+++ b/C5 Fundamentos Javascript/ejercicios/01.js	
@@ -1,6 +1,8 @@
 // Crea una variable de tipo string.
 // Reemplaza el valor de null por el correspondiente.
 
-const nuevoString = null;
+const nuevoString = "String";
 
-module.exports = nuevoString;
\ No newline at end of file
+module.exports = nuevoString;
+
+console.log (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..41434b3966 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 = "number";
 
 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..115174d126 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 = 'boolean';
 
 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..748d08e099 100644
--- a/C5 Fundamentos Javascript/ejercicios/04.js	
+++ b/C5 Fundamentos Javascript/ejercicios/04.js	
@@ -1,6 +1,8 @@
 // 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
+module.exports = nuevaResta;
+
+console.log (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..c170d01bb5 100644
--- a/C5 Fundamentos Javascript/ejercicios/05.js	
+++ b/C5 Fundamentos Javascript/ejercicios/05.js	
@@ -1,6 +1,8 @@
 // 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
+module.exports = nuevaMultiplicacion;
+
+console.log (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..9e4da4f5d4 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 === 4.2;
 
 module.exports = nuevoModulo;
diff --git a/C5 Fundamentos Javascript/ejercicios/07.js b/C5 Fundamentos Javascript/ejercicios/07.js
index 8eecae1d84..7dbad8e9ec 100644
--- a/C5 Fundamentos Javascript/ejercicios/07.js	
+++ b/C5 Fundamentos Javascript/ejercicios/07.js	
@@ -1,8 +1,22 @@
-function esTipoDato(valor) {
+/*function esTipoDato(valor) {
   // La función recibe un argumento llamado valor.
   // Retorna el tipo de dato de este valor.
   // Por ejemplo: "string", "number", "boolean", "object", etc.
   // Tu código:
+};*/
+
+/*test('El tipo de dato ( typeof ) de "hello" debe retornar "string"'); */
+
+const valor = "Hellow Mundo";
+
+function esTipoDato(valor) {
+  return typeof valor;
 }
 
-module.exports = esTipoDato;
\ No newline at end of file
+console.log (esTipoDato(valor));
+
+/*function () {
+  expect(esTipoDato('hello')).toBe('string');
+};
+
+  module.exports = esTipoDato;*/
diff --git a/C5 Fundamentos Javascript/ejercicios/08.js b/C5 Fundamentos Javascript/ejercicios/08.js
index b6594f3466..c97ea42f5f 100644
--- a/C5 Fundamentos Javascript/ejercicios/08.js	
+++ b/C5 Fundamentos Javascript/ejercicios/08.js	
@@ -1,4 +1,10 @@
-function esNumeroEntero(numero) {
+
+const numero = 2.5;
+
+function esNumeroEntero (numero) {
+
+  return Number.isInteger (numero);
+
   // La función recibe un argumento llamado numero.
   // Verifica si este es un número entero o no.
   // Retorna true si lo es, de lo contrario, retorna false.
@@ -9,4 +15,6 @@ function esNumeroEntero(numero) {
   // Tu código:
 }
 
-module.exports = esNumeroEntero;
\ No newline at end of file
+module.exports = esNumeroEntero;
+
+console.log (esNumeroEntero(numero));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/09.js b/C5 Fundamentos Javascript/ejercicios/09.js
index 665d437709..b3b2c7c9a7 100644
--- a/C5 Fundamentos Javascript/ejercicios/09.js	
+++ b/C5 Fundamentos Javascript/ejercicios/09.js	
@@ -1,5 +1,10 @@
 function esNuloOIndefinido(valor) {
-  // La función recibe un argumento llamado valor.
+  
+  if (valor == undefined) return true;
+  else if (valor == null) return true;
+  else return false;
+
+ // La función recibe un argumento llamado valor.
   // Si este valor es null o undefined, retorna true.
   // De lo contrario, retorna false.
   // Por ejemplo: 
@@ -10,4 +15,5 @@ function esNuloOIndefinido(valor) {
   // Tu código:
 }
 
-module.exports = esNuloOIndefinido;
\ No newline at end of file
+module.exports = esNuloOIndefinido;
+console.log (esNuloOIndefinido ("a"));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/10.js b/C5 Fundamentos Javascript/ejercicios/10.js
index a2f730da93..303007a679 100644
--- a/C5 Fundamentos Javascript/ejercicios/10.js	
+++ b/C5 Fundamentos Javascript/ejercicios/10.js	
@@ -1,4 +1,6 @@
-function devolverString(string) {
+function devolverString(str) {
+return str;
+ /*return (string);*/
   // La función recibe un argumento llamado string.
   // Debe retornar dicho string.
   // Por ejemplo: 
@@ -8,4 +10,5 @@ function devolverString(string) {
   // Tu código:
 }
 
-module.exports = devolverString;
\ No newline at end of file
+module.exports = devolverString;
+devolverString (console.log ("chau"));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/11.js b/C5 Fundamentos Javascript/ejercicios/11.js
index 2a4d40a899..3c5b45d064 100644
--- a/C5 Fundamentos Javascript/ejercicios/11.js	
+++ b/C5 Fundamentos Javascript/ejercicios/11.js	
@@ -1,4 +1,5 @@
 function sonIguales(x, y) {
+  return x === y;
   // La función recibe dos argumentos llamados "x" e "y".
   // Retorna true si "x" e "y" son iguales.
   // De lo contrario, retorna false.
@@ -8,4 +9,5 @@ function sonIguales(x, y) {
   // Tu código:
 }
 
-module.exports = sonIguales;
\ No newline at end of file
+module.exports = sonIguales;
+console.log (sonIguales(1,1));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/12.js b/C5 Fundamentos Javascript/ejercicios/12.js
index bce832204b..102f8ab5f5 100644
--- a/C5 Fundamentos Javascript/ejercicios/12.js	
+++ b/C5 Fundamentos Javascript/ejercicios/12.js	
@@ -6,6 +6,8 @@ function tienenMismaLongitud(str1, str2) {
   // "SoyHenry", "HenrySoy" ---> true 
   // "hi", "there" ---> false 
   // Tu código:
+return str1.length === str2.length;
 }
 
-module.exports = tienenMismaLongitud;
\ No newline at end of file
+module.exports = tienenMismaLongitud;
+console.log (tienenMismaLongitud ("hola","chau"));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/13.js b/C5 Fundamentos Javascript/ejercicios/13.js
index 5e4d000dd4..5bbd18248a 100644
--- a/C5 Fundamentos Javascript/ejercicios/13.js	
+++ b/C5 Fundamentos Javascript/ejercicios/13.js	
@@ -1,4 +1,5 @@
 function menosQueNoventa(num) {
+  return num < 90;
   // La función recibe un argumento llamado num.
   // Retorna true si el argumento "num" es menor que noventa.
   // De lo contrario, retorna false.
@@ -8,4 +9,5 @@ function menosQueNoventa(num) {
   // Tu código:
 }
 
-module.exports = menosQueNoventa;
\ No newline at end of file
+module.exports = menosQueNoventa;
+console.log (menosQueNoventa(90));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/15.js b/C5 Fundamentos Javascript/ejercicios/15.js
index 98648a7167..e8dbb610e6 100644
--- a/C5 Fundamentos Javascript/ejercicios/15.js	
+++ b/C5 Fundamentos Javascript/ejercicios/15.js	
@@ -1,4 +1,6 @@
 function esPar(num) {
+
+  return num % 2 === 0; /*Devuelve el resto de la division*/
   // La función recibe un argumento llamado num.
   // Retorna true si el argumento "num" es par.
   // De lo contrario, retorna false.
@@ -9,3 +11,5 @@ function esPar(num) {
 }
 
 module.exports = esPar;
+
+console.log (esPar(3));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/16.js b/C5 Fundamentos Javascript/ejercicios/16.js
index 7721e84f50..741e4ea349 100644
--- a/C5 Fundamentos Javascript/ejercicios/16.js	
+++ b/C5 Fundamentos Javascript/ejercicios/16.js	
@@ -1,4 +1,6 @@
 function esImpar(num) {
+
+  return num % 2 !== 0;
   // La función recibe un argumento llamado num.
   // Retorna true si el argumento "num" es impar.
   // De lo contrario, retorna false.
@@ -8,4 +10,5 @@ function esImpar(num) {
   // Tu código:
 }
 
-module.exports = esImpar;
\ No newline at end of file
+module.exports = esImpar;
+console.log (esImpar(3));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/17.js b/C5 Fundamentos Javascript/ejercicios/17.js
index dc0f6d6a95..553b9cfa9c 100644
--- a/C5 Fundamentos Javascript/ejercicios/17.js	
+++ b/C5 Fundamentos Javascript/ejercicios/17.js	
@@ -1,4 +1,16 @@
 function esPositivo(num) {
+  if (num > 0) {
+      return ("Es positivo");
+    }
+  if (num<0) {
+    return ("Es negativo");
+  }
+  else{
+    return false;
+  }
+
+  }
+
   // La función recibe un argumento llamado num el cual es un numero entero.
   // Retorna como resultado un string que indica si el número es positivo o negativo.
   // Por ejemplo: 
@@ -6,6 +18,7 @@ function esPositivo(num) {
   // Si el número es negativo ---> "Es negativo".
   // Si el número es 0, devuelve false.
   // Tu código:
-}
 
-module.exports = esPositivo;
\ No newline at end of file
+
+module.exports = esPositivo;
+console.log (esPositivo(0));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/18.js b/C5 Fundamentos Javascript/ejercicios/18.js
index 180f3bff3d..5e36b3af2e 100644
--- a/C5 Fundamentos Javascript/ejercicios/18.js	
+++ b/C5 Fundamentos Javascript/ejercicios/18.js	
@@ -1,4 +1,17 @@
-function esVocal(letra) {
+
+  function esVocal(letra) {
+    if (letra.length === 1) {
+       letra = letra.toLowerCase();
+      if (letra === 'a' || letra === 'e' || letra === 'i' || letra === 'o' || letra === 'u') {
+        return "Es vocal";
+      } else {
+        return "Dato incorrecto";
+      }
+    } else {
+      return "Dato incorrecto";
+    }
+  }
+
   // La función recibe un argumento llamado letra el cual es un string.
   // Retorna como resultado un string que indica si el argumento letra es una vocal.
   // de lo contrario retorna el string "Dato incorrecto"
@@ -8,6 +21,7 @@ function esVocal(letra) {
   // "n" ---> "Dato incorrecto"
   // "texto largo" ---> "Dato incorrecto"
   // Tu código:
-}
+
 
 module.exports = esVocal;
+console.log (esVocal("AA"));
diff --git a/C5 Fundamentos Javascript/ejercicios/19.js b/C5 Fundamentos Javascript/ejercicios/19.js
index eadd4aa24e..fbd45f629c 100644
--- a/C5 Fundamentos Javascript/ejercicios/19.js	
+++ b/C5 Fundamentos Javascript/ejercicios/19.js	
@@ -1,4 +1,6 @@
 function suma(x, y) {
+  var sumar = (x+y);
+  return (sumar);
   // La función recibe dos argumentos llamados "x" e "y" que son números.
   // Retorna el resultado de la suma de estos argumentos.
   // Por ejemplo: 
@@ -6,5 +8,6 @@ function suma(x, y) {
   // -5, 5 ---> 0
   // Tu código:
 }
+console.log (suma(-4, 3));
 
 module.exports = suma; 
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/20.js b/C5 Fundamentos Javascript/ejercicios/20.js
index 85e2de4890..9677eca4d9 100644
--- a/C5 Fundamentos Javascript/ejercicios/20.js	
+++ b/C5 Fundamentos Javascript/ejercicios/20.js	
@@ -1,4 +1,7 @@
 function resta(x, y) {
+
+  var restar = (x-y);
+  return restar;
   // La función recibe dos argumentos llamados "x" e "y" que son números.
   // Retorna el resultado de la resta de estos argumentos.
   // Por ejemplo: 
@@ -7,4 +10,5 @@ function resta(x, y) {
   // Tu código:
 }
 
-module.exports = resta;
\ No newline at end of file
+module.exports = resta;
+console.log (resta(4, 5));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/21.js b/C5 Fundamentos Javascript/ejercicios/21.js
index 747fe977f9..f007195661 100644
--- a/C5 Fundamentos Javascript/ejercicios/21.js	
+++ b/C5 Fundamentos Javascript/ejercicios/21.js	
@@ -1,4 +1,6 @@
 function multiplica(x, y) {
+  var multiplicar = x*y;
+  return multiplicar;
   // La función recibe dos argumentos llamados "x" e "y" que son números.
   // Retorna el resultado de la multiplicacion de estos argumentos.
   // Por ejemplo: 
@@ -7,4 +9,5 @@ function multiplica(x, y) {
   // Tu código:
 }
 
-module.exports = multiplica;
\ No newline at end of file
+module.exports = multiplica;
+console.log (multiplica(2,2));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/22.js b/C5 Fundamentos Javascript/ejercicios/22.js
index 57e0e9c6e7..26b276d37e 100644
--- a/C5 Fundamentos Javascript/ejercicios/22.js	
+++ b/C5 Fundamentos Javascript/ejercicios/22.js	
@@ -1,4 +1,6 @@
 function divide(x, y) {
+  var dividir = x/y;
+  return dividir;
   // La función recibe dos argumentos llamados "x" e "y" que son números.
   // Retorna el resultado de la division de estos argumentos.
   // Por ejemplo: 
@@ -7,4 +9,5 @@ function divide(x, y) {
   // Tu código:
 }
 
-module.exports = divide;
\ No newline at end of file
+module.exports = divide;
+console.log (divide(2,2));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/23.js b/C5 Fundamentos Javascript/ejercicios/23.js
index 05b43b2135..c75356e54c 100644
--- a/C5 Fundamentos Javascript/ejercicios/23.js	
+++ b/C5 Fundamentos Javascript/ejercicios/23.js	
@@ -1,4 +1,6 @@
 function obtenerResto(x, y) {
+  var resto = x%y;
+  return resto;
   // La función recibe dos argumentos llamados "x" e "y" que son números.
   // Retorna el resultado del resto de la division de estos argumentos.
   // Por ejemplo: 
@@ -7,4 +9,5 @@ function obtenerResto(x, y) {
   // Tu código:
 }
 
-module.exports = obtenerResto;
\ No newline at end of file
+module.exports = obtenerResto;
+console.log (obtenerResto (5,5));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/24.js b/C5 Fundamentos Javascript/ejercicios/24.js
index 0c25f1a616..faa6f2227f 100644
--- a/C5 Fundamentos Javascript/ejercicios/24.js	
+++ b/C5 Fundamentos Javascript/ejercicios/24.js	
@@ -1,4 +1,5 @@
 function agregarSimboloExclamacion(str) {
+  return (str+"!");
   // La función recibe un argumento llamado str el cual es un string.
   // Agrega un símbolo de exclamación al final del string str y retórnalo.
   // Por ejemplo: 
@@ -7,3 +8,4 @@ function agregarSimboloExclamacion(str) {
 }
 
 module.exports = agregarSimboloExclamacion;
+console.log (agregarSimboloExclamacion("Matias"));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/25.js b/C5 Fundamentos Javascript/ejercicios/25.js
index 6e2e9ed067..68e1387c78 100644
--- a/C5 Fundamentos Javascript/ejercicios/25.js	
+++ b/C5 Fundamentos Javascript/ejercicios/25.js	
@@ -1,4 +1,6 @@
 function combinarNombres(nombre, apellido) {
+
+  return (sumastr = nombre+" "+apellido);
   // La función recibe dos argumentos llamados "nombre" y "apellido" los cuales son string.
   // Retorna "nombre" y "apellido" combinados en un mismo string pero separados por un espacio.
   // Por ejemplo: 
@@ -7,3 +9,5 @@ function combinarNombres(nombre, apellido) {
 }
 
 module.exports = combinarNombres;
+console.log( (combinarNombres ("Matias", "Birba")));
+
diff --git a/C5 Fundamentos Javascript/ejercicios/26.js b/C5 Fundamentos Javascript/ejercicios/26.js
index 2a0f6ceafc..a76e6b47e7 100644
--- a/C5 Fundamentos Javascript/ejercicios/26.js	
+++ b/C5 Fundamentos Javascript/ejercicios/26.js	
@@ -1,4 +1,5 @@
 function obtenerSaludo(nombre) {
+  return (AgregaStr = "Hola "+ nombre +"!");
   // La función recibe un argumento llamado nombre el cual es un string. 
   // Toma el string "nombre" y concatena otros string en la cadena para que tome la siguiente forma:
   // Ejemplo: "Martin" ---> "Hola Martin!"
@@ -6,4 +7,5 @@ function obtenerSaludo(nombre) {
   // Tu código:
 }
 
-module.exports = obtenerSaludo;
\ No newline at end of file
+module.exports = obtenerSaludo;
+console.log( (obtenerSaludo("Matias")));
diff --git a/C5 Fundamentos Javascript/ejercicios/27.js b/C5 Fundamentos Javascript/ejercicios/27.js
index e786d71a11..09695122f5 100644
--- a/C5 Fundamentos Javascript/ejercicios/27.js	
+++ b/C5 Fundamentos Javascript/ejercicios/27.js	
@@ -1,4 +1,6 @@
 function obtenerAreaRectangulo(alto, ancho) {
+
+  return  (area = alto*ancho);
   // La función recibe dos argumentos llamados "alto" y "ancho" los cuales son numeros.
   // Retornar el área de un rectángulo teniendo su alto y ancho.
   // Por ejemplo: 
@@ -8,3 +10,5 @@ function obtenerAreaRectangulo(alto, ancho) {
 }
 
 module.exports = obtenerAreaRectangulo;
+console.log(obtenerAreaRectangulo(2,3));
+
diff --git a/C5 Fundamentos Javascript/ejercicios/28.js b/C5 Fundamentos Javascript/ejercicios/28.js
index c86f27e883..c6655dd246 100644
--- a/C5 Fundamentos Javascript/ejercicios/28.js	
+++ b/C5 Fundamentos Javascript/ejercicios/28.js	
@@ -1,4 +1,5 @@
 function retornarPerimetro(lado) {
+   return (perimetro = 4*lado);
    // La función recibe un argumento llamado lado el cual es un numero.
    // Retornar el perimetro de un cuadrado.
    // Por ejemplo: 
@@ -8,3 +9,4 @@ function retornarPerimetro(lado) {
 }
 
 module.exports = retornarPerimetro;
+console.log (retornarPerimetro (4));
diff --git a/C5 Fundamentos Javascript/ejercicios/29.js b/C5 Fundamentos Javascript/ejercicios/29.js
index 8e7d52ff15..ec0262b4aa 100644
--- a/C5 Fundamentos Javascript/ejercicios/29.js	
+++ b/C5 Fundamentos Javascript/ejercicios/29.js	
@@ -1,4 +1,6 @@
 function areaDelTriangulo(base, altura) {
+
+  return (tria = base*altura/2);
   // La función recibe dos argumentos llamados "base" y "altura" los cuales son numeros.
   // Retornar el área de un triangulo teniendo su base y altura.
   // Por ejemplo: 
@@ -8,3 +10,4 @@ function areaDelTriangulo(base, altura) {
 }
 
 module.exports = areaDelTriangulo;
+console.log (areaDelTriangulo(2,3));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/30.js b/C5 Fundamentos Javascript/ejercicios/30.js
index 6f0882f77d..2bf302b083 100644
--- a/C5 Fundamentos Javascript/ejercicios/30.js	
+++ b/C5 Fundamentos Javascript/ejercicios/30.js	
@@ -1,4 +1,6 @@
 function deEuroAdolar(euro) {
+
+  return (cambio = 1.2*euro);
   // La función recibe un argumento llamado euro el cual es un numero.
   // Debes calcular el valor recibido como argumento pasándolo a dólares.
   // Suponiendo que 1 euro equivale a 1.20 dólares.
@@ -10,3 +12,4 @@ function deEuroAdolar(euro) {
 }
 
 module.exports = deEuroAdolar;
+console.log (deEuroAdolar(2));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/31.js b/C5 Fundamentos Javascript/ejercicios/31.js
index 823f0fb17b..316f39ea8a 100644
--- a/C5 Fundamentos Javascript/ejercicios/31.js	
+++ b/C5 Fundamentos Javascript/ejercicios/31.js	
@@ -1,6 +1,8 @@
 // ⛔️ Recuerda que debes utilizar el objeto global "Math".
 
 function elevarAlCuadrado(num) {
+
+  return (potencia = Math.pow (num, 2));
   // La función recibe un argumento llamado num el cual es un numero.
   // Debes Retorna el valor de "num" elevado al cuadrado.
   // Por ejemplo: 
@@ -10,3 +12,4 @@ function elevarAlCuadrado(num) {
 }
 
 module.exports = elevarAlCuadrado;
+console.log (elevarAlCuadrado(4,2));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/32.js b/C5 Fundamentos Javascript/ejercicios/32.js
index 7150676698..cac4fdde66 100644
--- a/C5 Fundamentos Javascript/ejercicios/32.js	
+++ b/C5 Fundamentos Javascript/ejercicios/32.js	
@@ -1,6 +1,8 @@
 // ⛔️ Recuerda que debes utilizar el objeto global "Math".
 
 function elevarAlCubo(num) {
+
+  console.log (pot = Math.pow (num, 3));
   // La función recibe un argumento llamado num el cual es un numero.
   // Debes Retorna el valor de "num" elevado al cubo.
   // Por ejemplo: 
@@ -10,3 +12,4 @@ function elevarAlCubo(num) {
 }
 
 module.exports = elevarAlCubo;
+elevarAlCubo (3);
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/34.js b/C5 Fundamentos Javascript/ejercicios/34.js
index 2fff9db0e4..2e35ef8938 100644
--- a/C5 Fundamentos Javascript/ejercicios/34.js	
+++ b/C5 Fundamentos Javascript/ejercicios/34.js	
@@ -1,6 +1,8 @@
 // ⛔️ Recuerda que debes utilizar el objeto global "Math".
 
 function redondearNumero(num) {
+   console.log (Math.round (num));
+   Math.round (num);
    // La función recibe un argumento llamado num el cual es un numero.
    // Debes redondear "num" al entero más próximo y retornarlo.
    // Por ejemplo: 
@@ -10,3 +12,4 @@ function redondearNumero(num) {
 }
 
 module.exports = redondearNumero;
+redondearNumero (3,4);
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/35.js b/C5 Fundamentos Javascript/ejercicios/35.js
index 1987c119d4..a128839556 100644
--- a/C5 Fundamentos Javascript/ejercicios/35.js	
+++ b/C5 Fundamentos Javascript/ejercicios/35.js	
@@ -1,6 +1,7 @@
 // ⛔️ Recuerda que debes utilizar el objeto global "Math".
 
 function redondearHaciaArriba(num) {
+  return (Math.ceil (num));
   // La función recibe un argumento llamado num el cual es un numero.
   // Debes redondear "num" hacia arriba y retórnalo.
   // Por ejemplo: 
@@ -9,4 +10,5 @@ function redondearHaciaArriba(num) {
   // Tu código:
 }
 
-module.exports = redondearHaciaArriba;
\ No newline at end of file
+module.exports = redondearHaciaArriba;
+console.log (redondearHaciaArriba (3.1));
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/ejercicios/36.js b/C5 Fundamentos Javascript/ejercicios/36.js
index d0288d803f..6f95a39523 100644
--- a/C5 Fundamentos Javascript/ejercicios/36.js	
+++ b/C5 Fundamentos Javascript/ejercicios/36.js	
@@ -1,8 +1,11 @@
 // ⛔️ Recuerda que debes utilizar el objeto global "Math".
 
 function numeroRandom() {
+
+  return Math.random ();
   // La función numeroRandom debe generar un número al azar entre 0 y 1 y retornarlo.
   // Tu código:
 }
 
 module.exports = numeroRandom;
+console.log (numeroRandom());
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/tests/M5T1.test.js b/C5 Fundamentos Javascript/tests/M5T1.test.js
index 3af5fc32b1..da9aed0bac 100644
--- a/C5 Fundamentos Javascript/tests/M5T1.test.js	
+++ b/C5 Fundamentos Javascript/tests/M5T1.test.js	
@@ -1,5 +1,9 @@
 const nuevoString = require('../ejercicios/01');
 
 test('Debe ser un string', function () {
-  expect(typeof nuevoString).toBe('string');
+ expect(typeof nuevoString).toBe('string');
 });
+console.log (nuevoString);
+//const esString = ('Hola Mundo');
+//return  (esString);
+//return (nuevoString);
diff --git a/C5 Fundamentos Javascript/tests/M5T4.test.js b/C5 Fundamentos Javascript/tests/M5T4.test.js
index f411bb1feb..25ada6d9e8 100644
--- a/C5 Fundamentos Javascript/tests/M5T4.test.js	
+++ b/C5 Fundamentos Javascript/tests/M5T4.test.js	
@@ -2,4 +2,5 @@ const nuevaResta = require("../ejercicios/04");
 
 test('Debe ser la resta correcta', function () {
   expect(nuevaResta).toBe(true);
+  return nuevaResta;
 });
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/tests/M5T5.test.js b/C5 Fundamentos Javascript/tests/M5T5.test.js
index e164e58d43..a58a4b0e6e 100644
--- a/C5 Fundamentos Javascript/tests/M5T5.test.js	
+++ b/C5 Fundamentos Javascript/tests/M5T5.test.js	
@@ -2,4 +2,5 @@ const nuevaMultiplicacion = require("../ejercicios/05");
 
 test('Debe ser la multiplicación correcta', function () {
   expect(nuevaMultiplicacion).toBe(true);
-});
\ No newline at end of file
+});
+return nuevaMultiplicacion;
\ No newline at end of file
diff --git a/C5 Fundamentos Javascript/tests/M5T7.test.js b/C5 Fundamentos Javascript/tests/M5T7.test.js
index d8938e583a..9bcacc61cd 100644
--- a/C5 Fundamentos Javascript/tests/M5T7.test.js	
+++ b/C5 Fundamentos Javascript/tests/M5T7.test.js	
@@ -1,4 +1,4 @@
-const esTipoDato = require('../ejercicios/07');
+const esTipoDato = require ('../ejercicios/07');
 
 test('El tipo de dato ( typeof ) de "1" debe retornar "number"', () => {
   expect(esTipoDato(1)).toBe('number');

From da41078c162ae14f05d676ad7be66a89e44f60ff Mon Sep 17 00:00:00 2001
From: MatiasBirba <mbirba@supaqpel.com.ar>
Date: Mon, 31 Mar 2025 22:05:33 -0300
Subject: [PATCH 2/4] Ejercicios de bucles resueltos

---
 .vscode/settings.json      |  2 ++
 C6 Bucles/ejercicios/01.js |  9 +++++++++
 C6 Bucles/ejercicios/02.js |  4 ++++
 C6 Bucles/ejercicios/03.js |  8 ++++++++
 C6 Bucles/ejercicios/04.js |  5 +++++
 C6 Bucles/ejercicios/05.js |  5 +++++
 C6 Bucles/ejercicios/06.js |  5 +++++
 C6 Bucles/ejercicios/07.js |  7 ++++++-
 C6 Bucles/ejercicios/08.js |  5 +++++
 C6 Bucles/ejercicios/09.js |  6 ++++++
 C6 Bucles/ejercicios/10.js |  4 ++++
 C6 Bucles/ejercicios/12.js | 12 +++++++++++-
 C6 Bucles/ejercicios/13.js |  5 +++++
 C6 Bucles/ejercicios/14.js | 12 ++++++++++++
 C6 Bucles/ejercicios/15.js | 19 +++++++++++++++++--
 C6 Bucles/ejercicios/16.js |  7 +++++++
 C6 Bucles/ejercicios/17.js |  9 +++++++++
 C6 Bucles/ejercicios/18.js | 14 +++++++++++++-
 C6 Bucles/ejercicios/19.js | 18 +++++++++++++++++-
 C6 Bucles/ejercicios/20.js | 13 +++++++++++++
 C6 Bucles/ejercicios/21.js |  7 +++++++
 C6 Bucles/ejercicios/22.js | 12 +++++++++++-
 C6 Bucles/ejercicios/23.js | 13 +++++++++++++
 23 files changed, 194 insertions(+), 7 deletions(-)
 create mode 100644 .vscode/settings.json

diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000000..7a73a41bfd
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,2 @@
+{
+}
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/01.js b/C6 Bucles/ejercicios/01.js
index 95f2825332..7757bdabc7 100644
--- a/C6 Bucles/ejercicios/01.js	
+++ b/C6 Bucles/ejercicios/01.js	
@@ -1,8 +1,17 @@
 function esIgualYNegativo(a, b) {
+
   // La función recibe dos argumentos "a" y "b" que son números.
   // 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) 
+
+  return true 
+  else return false
+
+
 }
 
 module.exports = esIgualYNegativo;
+console.log(esIgualYNegativo(5,-5));
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/02.js b/C6 Bucles/ejercicios/02.js
index a98deee96a..918f9741c2 100644
--- a/C6 Bucles/ejercicios/02.js	
+++ b/C6 Bucles/ejercicios/02.js	
@@ -2,6 +2,10 @@ 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;
+console.log (esVerdaderoYFalso(true, true));
diff --git a/C6 Bucles/ejercicios/03.js b/C6 Bucles/ejercicios/03.js
index 95d1b1f4c3..6e77d2ace4 100644
--- a/C6 Bucles/ejercicios/03.js	
+++ b/C6 Bucles/ejercicios/03.js	
@@ -1,8 +1,16 @@
 function obtenerMayor(x, y) {
+  
+  
+  if (Number.isInteger(x) && Number.isInteger(y))
+    if (x>y) 
+      return (x)
+    else return (y)
+    else return ("Los numeros deben ser enteros")
   // "x" e "y" son números enteros.
   // Retorna el número más grande.
   // Si son iguales, retornar cualquiera de los dos.
   // Tu código:
 }
+console.log (obtenerMayor(.1,3));
 
 module.exports = obtenerMayor;
diff --git a/C6 Bucles/ejercicios/04.js b/C6 Bucles/ejercicios/04.js
index 7ef7a58d03..db3d0dc0f3 100644
--- a/C6 Bucles/ejercicios/04.js	
+++ b/C6 Bucles/ejercicios/04.js	
@@ -1,4 +1,8 @@
 function mayoriaDeEdad(edad) {
+
+  if (edad >= 18) 
+    return ("Allowed") 
+  else return ("Not Allowed")
   // Determinar si la persona puede ingresar al evento según su edad.
   // Si tiene 18 años o más, retorna el string: "Allowed".
   // Caso contrario: "Not allowed".
@@ -6,3 +10,4 @@ function mayoriaDeEdad(edad) {
 }
 
 module.exports = mayoriaDeEdad;
+console.log (mayoriaDeEdad(17));
diff --git a/C6 Bucles/ejercicios/05.js b/C6 Bucles/ejercicios/05.js
index ee7e89c431..aeaaf4929b 100644
--- a/C6 Bucles/ejercicios/05.js	
+++ b/C6 Bucles/ejercicios/05.js	
@@ -1,7 +1,12 @@
 function esVerdadero(valor) {
+
+  if (valor == true)
+    return "Soy Verdadero"
+  else return "Soy Falso"
   // Si "valor" es verdadero, retorna "Soy verdadero".
   // Caso contrario, retorna "Soy falso".
   // Tu código:
 }
 
 module.exports = esVerdadero;
+console.log (esVerdadero(false));
diff --git a/C6 Bucles/ejercicios/06.js b/C6 Bucles/ejercicios/06.js
index b7c047365b..9ca76e8f93 100644
--- a/C6 Bucles/ejercicios/06.js	
+++ b/C6 Bucles/ejercicios/06.js	
@@ -1,7 +1,12 @@
 function tieneTresDigitos(num) {
+  var a = num.toString ();
+  if (a.length  === 3)
+    return true
+  else return false
   // Si el número recibido tiene tres dígitos, retorna true.
   // Caso contrario, retorna false.
   // Tu código:
 }
 
 module.exports = tieneTresDigitos;
+console.log (tieneTresDigitos (4));
diff --git a/C6 Bucles/ejercicios/07.js b/C6 Bucles/ejercicios/07.js
index 5191b315af..ecada55dc4 100644
--- a/C6 Bucles/ejercicios/07.js	
+++ b/C6 Bucles/ejercicios/07.js	
@@ -1,8 +1,13 @@
 function esParYDivisiblePorTres(a) {
+
+  if (a%2 == 0 && a%3 == 0)
+    return true
+  else return false
   // La función recibe un número "a" por argumento.
   // Retorna true si este es par y divisible por tres a la vez.
   // Retorna false si no lo es.
   // Tu código:
 }
 
-module.exports = esParYDivisiblePorTres;
\ No newline at end of file
+module.exports = esParYDivisiblePorTres;
+console.log (esParYDivisiblePorTres (12));
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/08.js b/C6 Bucles/ejercicios/08.js
index bb5f11d4c0..2a46d25295 100644
--- a/C6 Bucles/ejercicios/08.js	
+++ b/C6 Bucles/ejercicios/08.js	
@@ -1,4 +1,8 @@
 function esPositivoOInferiorA10(a) {
+
+   if (a>0 && a<10) 
+      return true
+   else return false
    // La función recibe un número "a" por parámetro.
    // Retorna true si es positivo y menor que 10.
    // Retorna false en caso contrario.
@@ -6,3 +10,4 @@ function esPositivoOInferiorA10(a) {
 }
 
 module.exports = esPositivoOInferiorA10;
+console.log (esPositivoOInferiorA10(8));
diff --git a/C6 Bucles/ejercicios/09.js b/C6 Bucles/ejercicios/09.js
index f3898b19c7..64b427a821 100644
--- a/C6 Bucles/ejercicios/09.js	
+++ b/C6 Bucles/ejercicios/09.js	
@@ -1,4 +1,9 @@
 function conection(status) {
+  if (status === 1)
+    return "Online"
+  else if (status === 2)
+    return "Away"
+  else return "Offline"
   // El argumento "status" representa el estado de conexión de un usuario.
   // Si el estado es igual a 1, el usuario está "Online".
   // Si el estado es igual a 2, el usuario está "Away".
@@ -8,3 +13,4 @@ function conection(status) {
 }
 
 module.exports = conection;
+console.log (conection(0));
diff --git a/C6 Bucles/ejercicios/10.js b/C6 Bucles/ejercicios/10.js
index 2620c50f93..a6215f4228 100644
--- a/C6 Bucles/ejercicios/10.js	
+++ b/C6 Bucles/ejercicios/10.js	
@@ -1,7 +1,11 @@
 function esDiezOCinco(num) {
+  if (num === 10 || num == 5)
+    return true
+  else return false
   // Retornar true si "num" es 10 o 5.
   // De lo contrario, retornar false.
   // Tu código:
 }
 
 module.exports = esDiezOCinco;
+console.log (esDiezOCinco(1));
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/12.js b/C6 Bucles/ejercicios/12.js
index b61a3aec43..668e38e16f 100644
--- a/C6 Bucles/ejercicios/12.js	
+++ b/C6 Bucles/ejercicios/12.js	
@@ -4,6 +4,16 @@ 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
+
+  }
 
 module.exports = fizzBuzz;
+console.log (fizzBuzz(2));
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/13.js b/C6 Bucles/ejercicios/13.js
index 76e254264a..74222567e7 100644
--- a/C6 Bucles/ejercicios/13.js	
+++ b/C6 Bucles/ejercicios/13.js	
@@ -1,4 +1,8 @@
 function esEntero(num) {
+
+  if (Number.isInteger (num))
+    return true
+  else return false
   // Retorna true si "num" es un entero, ya sea positivo, negativo o cero.
   // Ejemplo: 0.8   ---> false
   // Ejemplo: 1     ---> true
@@ -8,3 +12,4 @@ function esEntero(num) {
 }
 
 module.exports = esEntero;
+console.log (esEntero(0.8));
diff --git a/C6 Bucles/ejercicios/14.js b/C6 Bucles/ejercicios/14.js
index 285d4fdfe2..e85411528d 100644
--- a/C6 Bucles/ejercicios/14.js	
+++ b/C6 Bucles/ejercicios/14.js	
@@ -1,4 +1,15 @@
 function operadoresLogicos(num1, num2, num3) {
+
+  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===num2===num3===0)
+      return "Error"
+    else return false
+
   // La función recibe tres números distintos.
   // Si num1 es mayor a num2 y a num3, y además es positivo, retorna ---> "Numero 1 es mayor y positivo".
   // Si alguno de los tres números es negativo, retorna ---> "Hay negativos".
@@ -9,3 +20,4 @@ function operadoresLogicos(num1, num2, num3) {
 }
 
 module.exports = operadoresLogicos;
+console.log (operadoresLogicos(2,-13,1));
diff --git a/C6 Bucles/ejercicios/15.js b/C6 Bucles/ejercicios/15.js
index 906f514225..0315a590be 100644
--- a/C6 Bucles/ejercicios/15.js	
+++ b/C6 Bucles/ejercicios/15.js	
@@ -1,4 +1,19 @@
 function obtenerDiaSemana(numero) {
+  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";
+   default: return "Numero invalido";
+  }
+}  
+  
+  
+  
+  
   // La función recibe un "numero" entre 1 y 7 por argumento.
   // Devuelve el día de la semana correspondiente a este número,
   // por ejemplo, 1 para "Lunes", 2 para "Martes", etc.
@@ -6,6 +21,6 @@ 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:
-}
 
-module.exports = obtenerDiaSemana;
\ No newline at end of file
+module.exports = obtenerDiaSemana;
+console.log (obtenerDiaSemana(1));
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/16.js b/C6 Bucles/ejercicios/16.js
index 01a50c9f01..4d8a3ada07 100644
--- a/C6 Bucles/ejercicios/16.js	
+++ b/C6 Bucles/ejercicios/16.js	
@@ -1,4 +1,10 @@
 function saludo(idioma) {
+ switch (idioma){
+  case "aleman": return "Guten Tag";
+  case "mandarin": return "Ni Hao";
+  case "ingles": return "hello";
+  default: return "Hola";
+ }
   // Retornar un saludo en tres diferentes lenguajes:
   // Si "idioma" es "aleman", devuelve "Guten Tag!".
   // Si "idioma" es "mandarin", devuelve "Ni Hao!".
@@ -8,3 +14,4 @@ function saludo(idioma) {
 }
 
 module.exports = saludo;
+console.log (saludo("portugues"));
diff --git a/C6 Bucles/ejercicios/17.js b/C6 Bucles/ejercicios/17.js
index 3dcc148517..82f2ee943d 100644
--- a/C6 Bucles/ejercicios/17.js	
+++ b/C6 Bucles/ejercicios/17.js	
@@ -1,4 +1,12 @@
 function colors(color) {
+  switch (color) {
+    case "blue": return "This is "+color;
+    case "red": return "This is "+color;
+    case "green": return "This is "+color;
+    case "orange": return "This is "+color;
+    default: return "Color not found";
+
+  }
   // La función recibe un color. Retorna el string correspondiente:
   // En caso que el color recibido sea "blue"   --> "This is blue".
   // En caso que el color recibido sea "red"    --> "This is red".
@@ -10,3 +18,4 @@ function colors(color) {
 }
 
 module.exports = colors;
+console.log  (colors("green"));
diff --git a/C6 Bucles/ejercicios/18.js b/C6 Bucles/ejercicios/18.js
index e7183ff019..51b0078de5 100644
--- a/C6 Bucles/ejercicios/18.js	
+++ b/C6 Bucles/ejercicios/18.js	
@@ -1,7 +1,19 @@
 function productoEntreNúmeros(a, b) {
+
+ var producto = 1;
+  if (b>a)
+    for (var i = a; i<=b; i++)
+      producto = producto*i;
+    else if (a>b)
+    for (var i = b; i<=a; i++)
+      producto = producto*i;
+    else producto = a*b;
+return (producto);    
+
   // Dados dos argumentos "a" y "b", devuelve el producto de todos
   // los números entre a y b (inclusive).
   // Tu código:
 }
 
-module.exports = productoEntreNúmeros;
\ No newline at end of file
+module.exports = productoEntreNúmeros;
+console.log (productoEntreNúmeros (2,10));
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/19.js b/C6 Bucles/ejercicios/19.js
index 41c47d54eb..803840beda 100644
--- a/C6 Bucles/ejercicios/19.js	
+++ b/C6 Bucles/ejercicios/19.js	
@@ -1,7 +1,23 @@
+
 function sumarHastaN(n) {
-  // La función recibe un número "n" por argumento.
+
+  // for (var i=0; i<=n; i++)
+
+  //   suma = suma + i;
+var i=1;
+var suma =0;
+
+  do {
+    suma = suma+i;
+    i = i+1;
+  } while (i<=n);
+
+    return suma;
+
+    // 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:
 }
 
 module.exports = sumarHastaN;
+console.log (sumarHastaN(5));
diff --git a/C6 Bucles/ejercicios/20.js b/C6 Bucles/ejercicios/20.js
index 4c835a54d4..e66035e7c8 100644
--- a/C6 Bucles/ejercicios/20.js	
+++ b/C6 Bucles/ejercicios/20.js	
@@ -1,4 +1,16 @@
 function sumarHastaNConBreak(n) {
+
+   var suma = 0;
+   // var i =0;
+   
+   for (var i=0; i<=n; i++)
+   {
+      suma = suma +i;
+      if (suma > 100)
+      break
+   }
+   return suma;
+
    // La función recibe un numero n por argumento.
    // Devuelve la suma de todos los números desde 1 hasta n.
    // Si la suma supera a 100, detén el bucle usando break.
@@ -6,3 +18,4 @@ function sumarHastaNConBreak(n) {
 }
 
 module.exports = sumarHastaNConBreak;
+console.log (sumarHastaNConBreak(20));
diff --git a/C6 Bucles/ejercicios/21.js b/C6 Bucles/ejercicios/21.js
index 1107bf2a11..a055f98b22 100644
--- a/C6 Bucles/ejercicios/21.js	
+++ b/C6 Bucles/ejercicios/21.js	
@@ -1,9 +1,16 @@
 function esPotenciaDeDos(numero) {
+
+while (numero % 2 === 0){
+    numero = numero / 2;
+  }
   // La función recibe un "numero" por argumento.
   // Determina si es una potencia de 2.
   // Devuelve true si lo es, sino devuelve false.
   // PISTA: Utiliza un bucle while.
   // Tu código:
+if (numero===1) return "Potencia de 2" 
+else return "No es potencia de 2"
 }
 
 module.exports = esPotenciaDeDos;
+console.log (esPotenciaDeDos(129));
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/22.js b/C6 Bucles/ejercicios/22.js
index 308536602f..85d4b9ea34 100644
--- a/C6 Bucles/ejercicios/22.js	
+++ b/C6 Bucles/ejercicios/22.js	
@@ -1,8 +1,18 @@
 function doWhile(num) {
+
+  var i = 0;
+  do {
+  num = num+5; 
+  i = i+1;
+  }
+  while (i<8)
+  
   // Aumenta el valor de "num" recibido en 5 hasta un límite de 8 veces.
   // Retorna el valor final.
   // PISTA: Utiliza el bucle do-while.
   // Tu código:
+  return num;
 }
 
-module.exports = doWhile;
\ No newline at end of file
+module.exports = doWhile;
+console.log (doWhile(2));
\ No newline at end of file
diff --git a/C6 Bucles/ejercicios/23.js b/C6 Bucles/ejercicios/23.js
index ebe222a114..edf2a654f3 100644
--- a/C6 Bucles/ejercicios/23.js	
+++ b/C6 Bucles/ejercicios/23.js	
@@ -1,4 +1,13 @@
 function esNumeroPrimo(numero) {
+
+  // si numero % i === 0 es divisible
+  if (numero<=1) return "El numero no es primo"
+
+  for (var i=2; i<numero; i++){
+    if (numero % i === 0 && i != numero)
+      return "El numero no es primo"
+    
+
   // La función recibe un argumento "numero".
   // Determina si este corresponde a un número primo.
   // De ser así, retorna true.
@@ -7,5 +16,9 @@ function esNumeroPrimo(numero) {
   // solo es divisible por sí mismo y por 1.
   // Tu código:
 }
+return "Numero primo"
+}
 
 module.exports = esNumeroPrimo;
+console.log (esNumeroPrimo(15));
+console.log (Math.sqrt (21));
\ No newline at end of file

From 32d112f5462e6929c6379a21102b363abab254cd Mon Sep 17 00:00:00 2001
From: MatiasBirba <mbirba@supaqpel.com.ar>
Date: Thu, 3 Apr 2025 14:45:53 -0300
Subject: [PATCH 3/4] Ejercicios de Arreglos

---
 C6 Bucles/ejercicios/01.js                    |  8 +++--
 C6 Bucles/ejercicios/02.js                    |  9 ++++-
 C7 Arrays/ejercicios/01.js                    |  6 ----
 .../ejercicios/01RetornaElementoArray.js      | 17 +++++++++
 C7 Arrays/ejercicios/02.js                    |  6 ----
 C7 Arrays/ejercicios/02RetornaultimoEle..js   | 14 ++++++++
 .../{03.js => 03Retornalongituddelarregko.js} |  4 +++
 C7 Arrays/ejercicios/04.js                    |  7 ----
 .../04AgregaEleAlFinalSinPushear.js           | 20 +++++++++++
 .../{05.js => 05.AgregaEleconUnshiftjs}       |  6 ++++
 C7 Arrays/ejercicios/06.InvierteArreglojs     | 20 +++++++++++
 C7 Arrays/ejercicios/06.js                    |  6 ----
 C7 Arrays/ejercicios/07.js                    |  8 +++++
 C7 Arrays/ejercicios/08.js                    | 12 +++++++
 C7 Arrays/ejercicios/09.js                    | 12 +++++++
 C7 Arrays/ejercicios/10.js                    |  7 ++++
 C7 Arrays/ejercicios/11.js                    | 16 +++++++++
 C7 Arrays/ejercicios/12.js                    | 11 ++++++
 C7 Arrays/ejercicios/13.js                    |  8 +++++
 C7 Arrays/ejercicios/14.js                    | 11 ++++++
 C7 Arrays/ejercicios/15.js                    | 10 +++++-
 C7 Arrays/ejercicios/16.js                    | 10 ++++++
 C7 Arrays/ejercicios/17.js                    |  9 +++++
 C7 Arrays/ejercicios/18.js                    | 15 ++++++++
 C7 Arrays/ejercicios/19.js                    | 13 +++++++
 C7 Arrays/ejercicios/20.js                    | 11 ++++++
 C7 Arrays/ejercicios/21.js                    | 18 ++++++++--
 C7 Arrays/ejercicios/22.js                    | 14 ++++++++
 C7 Arrays/ejercicios/23.js                    | 36 ++++++++++++++++---
 C7 Arrays/ejercicios/24.js                    | 16 +++++++++
 C7 Arrays/ejercicios/25.js                    | 16 +++++++++
 C7 Arrays/ejercicios/26.js                    | 14 +++++++-
 .../ejercicios/{27.js => 27ArrAString.js}     |  7 ++++
 .../{28.js => 28.PRUEBASIVARESARREGLOjs}      | 10 +++++-
 C7 Arrays/ejercicios/29.js                    |  9 -----
 C7 Arrays/ejercicios/29NumNoConsecutivos.js   | 25 +++++++++++++
 36 files changed, 394 insertions(+), 47 deletions(-)
 delete mode 100644 C7 Arrays/ejercicios/01.js
 create mode 100644 C7 Arrays/ejercicios/01RetornaElementoArray.js
 delete mode 100644 C7 Arrays/ejercicios/02.js
 create mode 100644 C7 Arrays/ejercicios/02RetornaultimoEle..js
 rename C7 Arrays/ejercicios/{03.js => 03Retornalongituddelarregko.js} (65%)
 delete mode 100644 C7 Arrays/ejercicios/04.js
 create mode 100644 C7 Arrays/ejercicios/04AgregaEleAlFinalSinPushear.js
 rename C7 Arrays/ejercicios/{05.js => 05.AgregaEleconUnshiftjs} (59%)
 create mode 100644 C7 Arrays/ejercicios/06.InvierteArreglojs
 delete mode 100644 C7 Arrays/ejercicios/06.js
 rename C7 Arrays/ejercicios/{27.js => 27ArrAString.js} (63%)
 rename C7 Arrays/ejercicios/{28.js => 28.PRUEBASIVARESARREGLOjs} (55%)
 delete mode 100644 C7 Arrays/ejercicios/29.js
 create mode 100644 C7 Arrays/ejercicios/29NumNoConsecutivos.js

diff --git a/C6 Bucles/ejercicios/01.js b/C6 Bucles/ejercicios/01.js
index 7757bdabc7..72f4d6ab4e 100644
--- a/C6 Bucles/ejercicios/01.js	
+++ b/C6 Bucles/ejercicios/01.js	
@@ -7,11 +7,13 @@ function esIgualYNegativo(a, b) {
 
 if (a==b && a<0) 
 
-  return true 
-  else return false
+  return true
+  else  false
 
 
 }
 
 module.exports = esIgualYNegativo;
-console.log(esIgualYNegativo(5,-5));
\ No newline at end of file
+console.log(esIgualYNegativo(-5,-5));
+console.log ("hola mundo");
+
diff --git a/C6 Bucles/ejercicios/02.js b/C6 Bucles/ejercicios/02.js
index 918f9741c2..3dc628d0f2 100644
--- a/C6 Bucles/ejercicios/02.js	
+++ b/C6 Bucles/ejercicios/02.js	
@@ -2,10 +2,17 @@ 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
+
+  if (booleano1===booleano2) return true 
+  else return false
+
+
 }
 
 module.exports = esVerdaderoYFalso;
-console.log (esVerdaderoYFalso(true, true));
+console.log (esVerdaderoYFalso(false, true));
diff --git a/C7 Arrays/ejercicios/01.js b/C7 Arrays/ejercicios/01.js
deleted file mode 100644
index 508c5fd8a1..0000000000
--- a/C7 Arrays/ejercicios/01.js	
+++ /dev/null
@@ -1,6 +0,0 @@
-function devolverPrimerElemento(array) {
-  // Retornar el primer elemento del arreglo recibido.
-  // Tu código:
-}
-
-module.exports = devolverPrimerElemento;
diff --git a/C7 Arrays/ejercicios/01RetornaElementoArray.js b/C7 Arrays/ejercicios/01RetornaElementoArray.js
new file mode 100644
index 0000000000..94c1be51f2
--- /dev/null
+++ b/C7 Arrays/ejercicios/01RetornaElementoArray.js	
@@ -0,0 +1,17 @@
+
+// var array = ["acqua", true, 1.8, "Hola"]
+var array2 = ["Hola",2,3,4,5,6,7,8]
+console.log (array2);
+// var array3 = ["1", "2","3"]
+// console.log (array.length);
+
+function devolverPrimerElemento(array) {
+
+return array [0];
+
+  }
+  // Retornar el primer elemento del arreglo recibido.
+  // Tu código:
+
+module.exports = devolverPrimerElemento;
+console.log (devolverPrimerElemento(array2));
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/02.js b/C7 Arrays/ejercicios/02.js
deleted file mode 100644
index 3c40692116..0000000000
--- a/C7 Arrays/ejercicios/02.js	
+++ /dev/null
@@ -1,6 +0,0 @@
-function devolverUltimoElemento(array) {
-  // Retornar el último elemento del arreglo recibido.
-  // Tu código:
-}
-
-module.exports = devolverUltimoElemento;
diff --git a/C7 Arrays/ejercicios/02RetornaultimoEle..js b/C7 Arrays/ejercicios/02RetornaultimoEle..js
new file mode 100644
index 0000000000..58ae0362be
--- /dev/null
+++ b/C7 Arrays/ejercicios/02RetornaultimoEle..js	
@@ -0,0 +1,14 @@
+var array = [1.2,3.4,5.6]
+
+ultnum = array.length-1;
+console.log (array.length);
+function devolverUltimoElemento(array) {
+
+  // return array[ultnum];
+  return array [array.length-1];
+  // Retornar el último elemento del arreglo recibido.
+  // Tu código:
+}
+
+module.exports = devolverUltimoElemento;
+console.log (devolverUltimoElemento(array));
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/03.js b/C7 Arrays/ejercicios/03Retornalongituddelarregko.js
similarity index 65%
rename from C7 Arrays/ejercicios/03.js
rename to C7 Arrays/ejercicios/03Retornalongituddelarregko.js
index 1170d0a120..7ada8e22fd 100644
--- a/C7 Arrays/ejercicios/03.js	
+++ b/C7 Arrays/ejercicios/03Retornalongituddelarregko.js	
@@ -1,6 +1,10 @@
+
 function obtenerLargoDelArray(array) {
+
+  return array.length
   // Retornar la longitud del arreglo recibido.
   // Tu código:
 }
 
 module.exports = obtenerLargoDelArray;
+console.log (obtenerLargoDelArray([1,2,3,4,5,6,7]));
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/04.js b/C7 Arrays/ejercicios/04.js
deleted file mode 100644
index f8433b6134..0000000000
--- a/C7 Arrays/ejercicios/04.js	
+++ /dev/null
@@ -1,7 +0,0 @@
-function agregarItemAlFinalDelArray(array, elemento) {
-  // Agrega el "elemento" al final del arreglo recibido.
-  // Retorna el arreglo.
-  // Tu código:
-}
-
-module.exports = agregarItemAlFinalDelArray;
diff --git a/C7 Arrays/ejercicios/04AgregaEleAlFinalSinPushear.js b/C7 Arrays/ejercicios/04AgregaEleAlFinalSinPushear.js
new file mode 100644
index 0000000000..1bba16ccac
--- /dev/null
+++ b/C7 Arrays/ejercicios/04AgregaEleAlFinalSinPushear.js	
@@ -0,0 +1,20 @@
+
+array = [1,2,3,4,5]
+function agregarItemAlFinalDelArray(array, elemento) {
+
+array [array.length] = elemento
+
+  // Agregar el elemento al final del array usando array.length
+  // array[array.length] = elemento;
+
+  // Retornar el array actualizado
+  // return array;
+
+  // array.push (elemento);
+  return array;
+
+}
+
+
+module.exports = agregarItemAlFinalDelArray;
+console.log (agregarItemAlFinalDelArray(array, 6))
diff --git a/C7 Arrays/ejercicios/05.js b/C7 Arrays/ejercicios/05.AgregaEleconUnshiftjs
similarity index 59%
rename from C7 Arrays/ejercicios/05.js
rename to C7 Arrays/ejercicios/05.AgregaEleconUnshiftjs
index 9d17508d9d..506b8f8441 100644
--- a/C7 Arrays/ejercicios/05.js	
+++ b/C7 Arrays/ejercicios/05.AgregaEleconUnshiftjs	
@@ -1,7 +1,13 @@
+array = [1,2,3,"4"];
 function agregarItemAlComienzoDelArray(array, elemento) {
+for (i=0; i<=3;i++){
+  array.unshift (elemento);
+}
+  return array;
   // Agrega el "elemento" al comienzo del arreglo recibido.
   // Retorna el arreglo.
   // Tu código:
 }
 
 module.exports = agregarItemAlComienzoDelArray;
+console.log (agregarItemAlComienzoDelArray(array, "chau"))
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/06.InvierteArreglojs b/C7 Arrays/ejercicios/06.InvierteArreglojs
new file mode 100644
index 0000000000..ad47bc8670
--- /dev/null
+++ b/C7 Arrays/ejercicios/06.InvierteArreglojs	
@@ -0,0 +1,20 @@
+array = ["A","B","C","c"];
+console.log (array[1]);
+
+function invertirArray(array) {
+ let arrayinverso =[];
+
+  for (let i=0; i<array.length; i++){
+      // arrayinverso.unshift (array[i]);
+    
+      arrayinverso[i] = array[array.length-i-1]
+
+    }
+
+return arrayinverso;
+  // Invierte el arreglo array recibido por argumento.
+  // Tu código:
+}
+
+module.exports = invertirArray;
+console.log (invertirArray(array));
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/06.js b/C7 Arrays/ejercicios/06.js
deleted file mode 100644
index 0d093fec57..0000000000
--- a/C7 Arrays/ejercicios/06.js	
+++ /dev/null
@@ -1,6 +0,0 @@
-function invertirArray(array) {
-  // Invierte el arreglo array recibido por argumento.
-  // Tu código:
-}
-
-module.exports = invertirArray;
diff --git a/C7 Arrays/ejercicios/07.js b/C7 Arrays/ejercicios/07.js
index ef9535455e..053a6ecbe5 100644
--- a/C7 Arrays/ejercicios/07.js	
+++ b/C7 Arrays/ejercicios/07.js	
@@ -1,7 +1,15 @@
+
+let pepearray = [1,2,1,3,4,2,5,6,2,4,7,8,9];
+console.log (pepearray, pepearray.length);
 function ordenarArray(array) {
+
+array.sort (function(a,b){ return a-b})
+
   // Ordena los elementos del areglo array de menor a mayor.
   // Devuelve el arreglo resultante.
   // Tu código:
+return array;
 }
 
 module.exports = ordenarArray;
+console.log (ordenarArray(pepearray), pepearray.length);
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/08.js b/C7 Arrays/ejercicios/08.js
index 46dcf9a08f..b5b9edb20f 100644
--- a/C7 Arrays/ejercicios/08.js	
+++ b/C7 Arrays/ejercicios/08.js	
@@ -1,4 +1,15 @@
+
+let array = [1,2,3,4,3,5,2,6,7,4,5,6,7,8,9]
+console.log(array, array.length);
+
 function encontrarElemento(num, array) {
+
+   for (var i=0;i<array.length;i++){
+
+      if (array[i] === num) return i
+    
+   }
+   return -1
    // Busca el número pasado por argumento dentro del array.
    // Si lo encuentras debes retornar el INDICE en el que se encuentra dentro del array.
    // Si no se encuentra, retorna -1.
@@ -6,3 +17,4 @@ function encontrarElemento(num, array) {
 }
 
 module.exports = encontrarElemento;
+console.log (encontrarElemento (4, array));
diff --git a/C7 Arrays/ejercicios/09.js b/C7 Arrays/ejercicios/09.js
index 5f9b6248d8..ac2724a397 100644
--- a/C7 Arrays/ejercicios/09.js	
+++ b/C7 Arrays/ejercicios/09.js	
@@ -1,7 +1,19 @@
+
+let array = [1,2,3,4,3,5,6,2,7,6,5,4,5,6,7,8,9,6,4,3,0];
+console.log (Math.random(), array.length-1);
+// let largoarreglo = array.length;
+var posicion = Math.trunc (Math.random()*(array.length-1));
+console.log (posicion);
+
 function obtenerElementoAleatorio(array) {
+
+  return array [posicion];
+   
+
    // Devuelve un elemento aleatorio del arreglo array.
    // PISTA: Usa el método Math.random().
    // Tu código:
 }
 
 module.exports = obtenerElementoAleatorio;
+console.log (obtenerElementoAleatorio(array));
diff --git a/C7 Arrays/ejercicios/10.js b/C7 Arrays/ejercicios/10.js
index dea50da555..5246c096c3 100644
--- a/C7 Arrays/ejercicios/10.js	
+++ b/C7 Arrays/ejercicios/10.js	
@@ -1,6 +1,13 @@
+let array = ["hola","chau","2","24153645"]
 function obtenerPrimerStringLargo(array) {
+
+  var string5 = array.find (function (elemento) {
+    return (elemento.length > 5);
+  });
+  return string5;
   // Devuelve el primer string con más de 5 caracteres en el array.
   // Tu código:
 }
 
 module.exports = obtenerPrimerStringLargo;
+console.log (obtenerPrimerStringLargo (array));
diff --git a/C7 Arrays/ejercicios/11.js b/C7 Arrays/ejercicios/11.js
index 3194c62196..79790f92cd 100644
--- a/C7 Arrays/ejercicios/11.js	
+++ b/C7 Arrays/ejercicios/11.js	
@@ -1,7 +1,23 @@
+let array = [1,2,3,4,5,6,1,2,3,4,5,6,7,8,3,5,6]
+console.log (array.length);
 function duplicarElementos(array) {
+
+  let nuevoarray = []
+  let arrayx2 = []
+  let arrayduplica = []
+  for (i=0; i<array.length;i++){
+    // nuevoarray.push (array[i]);
+    // arrayx2.push (array [i]*2);
+    arrayduplica.push (String(array[i]));
+    arrayduplica.push (array[i]);
+    
+  }
+  return arrayduplica;
+    
   // Duplica (multiplica x2) cada elemento del array de números.
   // Devuelve un array con los duplicados.
   // Tu código:
 }
 
 module.exports = duplicarElementos;
+console.log (duplicarElementos(array), duplicarElementos(array).length);
diff --git a/C7 Arrays/ejercicios/12.js b/C7 Arrays/ejercicios/12.js
index 2df8d8eb7d..a026299d9b 100644
--- a/C7 Arrays/ejercicios/12.js	
+++ b/C7 Arrays/ejercicios/12.js	
@@ -1,7 +1,18 @@
+
+let array = ["1341343","Qrqd","Qfwrtyh","Qewrgrhteh"]
+
 function convertirStringAMayusculas(array) {
+
+  let arrayuppercase = []
+  arrayuppercase = array.map (function (elemento) {
+    return elemento.toUpperCase ()
+  })
+
+  return arrayuppercase
   // Convierte a mayúsculas todos los strings del array.
   // Retorna el arreglo resultante.
   // Tu código:
 }
 
 module.exports = convertirStringAMayusculas;
+console.log (convertirStringAMayusculas(array));
diff --git a/C7 Arrays/ejercicios/13.js b/C7 Arrays/ejercicios/13.js
index 037a01b1b9..887c9f6fad 100644
--- a/C7 Arrays/ejercicios/13.js	
+++ b/C7 Arrays/ejercicios/13.js	
@@ -1,6 +1,14 @@
+array = [1,2,3,356,7,89,123,987,65,34,67,9,987,6]
+
+
 function filtrarNumerosPares(array) {
+  return array.filter (function (elemento){
+    return elemento % 2 === 0;
+  })
+
   // Devuelve un arreglo solo con los números pares presentes en el array.
   // Tu código:
 }
 
 module.exports = filtrarNumerosPares;
+console.log (filtrarNumerosPares(array));
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/14.js b/C7 Arrays/ejercicios/14.js
index 28cc42c259..28f20f058b 100644
--- a/C7 Arrays/ejercicios/14.js	
+++ b/C7 Arrays/ejercicios/14.js	
@@ -1,6 +1,17 @@
+
+arraynumeros = [123,123,32,4,5,6,7,88,6,2,4,1,87,101,10,10,10,10]
+// console.log (arraynumeros);
+// console.log (arraynumeros.length);
 function contarElementosMayoresA10(array) {
+
+  return array.filter (function (cb){
+    return cb>10;
+  })
   // Cuenta y devuelve la cantidad de elementos mayores a 10 en el array de números.
   // Tu código:
 }
 
 module.exports = contarElementosMayoresA10;
+nuevoarray = contarElementosMayoresA10(arraynumeros);
+console.log (nuevoarray, nuevoarray.length);
+console.log (contarElementosMayoresA10(arraynumeros), arraynumeros.length);
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/15.js b/C7 Arrays/ejercicios/15.js
index cf07316133..5ac7b264ea 100644
--- a/C7 Arrays/ejercicios/15.js	
+++ b/C7 Arrays/ejercicios/15.js	
@@ -1,7 +1,15 @@
+array = [123,23,23,1,2,3,5,75,43,6,78,4333,67,4,7,8,54,34]
+
 function encontrarIndiceMayor(array) {
+
+valormax = Math.max (...array); //spread operator. convierte los elementos del arreglo en argumentos individuales para pasar por el math.max
+return indicevalormax  = array.indexOf (valormax);
+  
   // Encuentra el índice del número más grande en el array de números.
   // Devuelve el valor de este índice.
   // Tu código:
 }
 
-module.exports = encontrarIndiceMayor;
+
+console.log (encontrarIndiceMayor(array));
+console.log (encontrarIndiceMayor)
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/16.js b/C7 Arrays/ejercicios/16.js
index 6e6019e704..e08a538aeb 100644
--- a/C7 Arrays/ejercicios/16.js	
+++ b/C7 Arrays/ejercicios/16.js	
@@ -1,7 +1,17 @@
+let array = [1,2,3,4,5,4,5,6,7,8,9]
+
 function multiplicarElementosPorIndice(array) {
+  let arraymultiplicaporindice = [];
+  for (i=0;i<array.length;i++){
+  arraymultiplicaporindice.push (array[i]*i)
+}
+return arraymultiplicaporindice;
   // Multiplica cada elemento del array por su índice.
   // Devuelve el nuevo arreglo con los resultados.
   // Tu código:
 }
 
 module.exports = multiplicarElementosPorIndice;
+console.log (array.length, typeof(array));
+console.log (multiplicarElementosPorIndice(array));
+console.log (multiplicarElementosPorIndice(array).length, typeof (multiplicarElementosPorIndice(array)));
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/17.js b/C7 Arrays/ejercicios/17.js
index edf8ab42f2..93a926bcf5 100644
--- a/C7 Arrays/ejercicios/17.js	
+++ b/C7 Arrays/ejercicios/17.js	
@@ -1,6 +1,15 @@
+array = [1,2,3,4,5,6,7,3,5,6,"hola"]
+
 function agregarNumeros(arrayOfNums) {
+
+  let suma=0;
+  for (var i=0;i<arrayOfNums.length;i++){
+      suma += arrayOfNums[i]
+  }
+  return suma
   // Suma todos los elementos de arrayOfNums y retorna el resultado.
   // Tu código:
 }
 
 module.exports = agregarNumeros;
+console.log (agregarNumeros(array));
diff --git a/C7 Arrays/ejercicios/18.js b/C7 Arrays/ejercicios/18.js
index 580e26c583..fc9f65b759 100644
--- a/C7 Arrays/ejercicios/18.js	
+++ b/C7 Arrays/ejercicios/18.js	
@@ -1,6 +1,21 @@
+let array = [10,10,10,8,8,8,10,8,10,5]
+console.log (array.length)
 function promedioResultadosTest(resultadosTest) {
+  // let promedio = 0;
+  // let suma = 0;
+  // for (i=0;i<resultadosTest.length;i++){
+    // suma +=  resultadosTest[i]
+  // }
+  // promedio = suma/resultadosTest.length
+  // return promedio
+
+suma = resultadosTest.reduce ((pepacumulador, pepvaloractual) => {
+return pepacumulador+pepvaloractual
+},0);
+return suma/resultadosTest.length
   // Itera sobre los elementos del arreglo resultadosTest y devuelve el promedio de las notas.
   // Tu código:
 }
 
 module.exports = promedioResultadosTest;
+console.log (promedioResultadosTest(array));
diff --git a/C7 Arrays/ejercicios/19.js b/C7 Arrays/ejercicios/19.js
index 4aed7fecae..44ebd34bd1 100644
--- a/C7 Arrays/ejercicios/19.js	
+++ b/C7 Arrays/ejercicios/19.js	
@@ -1,4 +1,16 @@
+let arreglo = [1,2,3,5,6]
+console.log (arreglo);
+
 function multiplicarArgumentos() {
+
+ if (arguments.length ===0) return 0
+
+ let producto = 1
+ 
+ for (var i=0;i<arguments.length;i++){
+  producto *= arguments [i]
+ }
+ return producto
   // Usa la palabra clave `arguments` para multiplicar todos los argumentos y devolver el producto.
   // Si no se pasan argumentos retorna 0. Si se pasa un argumento, simplemente retórnalo.
   // [PISTA]: "arguments" es un arreglo.
@@ -6,3 +18,4 @@ function multiplicarArgumentos() {
 }
 
 module.exports = multiplicarArgumentos;
+console.log (multiplicarArgumentos(...arreglo));
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/20.js b/C7 Arrays/ejercicios/20.js
index bcce3a3dbc..5ff2c825cb 100644
--- a/C7 Arrays/ejercicios/20.js	
+++ b/C7 Arrays/ejercicios/20.js	
@@ -1,7 +1,18 @@
+let array = [2,2,1,2,2]
+
 function todosIguales(array) {
+ele0 = array[0];
+
+//  return array.every (function(elemento){
+  // return ele0 === elemento
+// })
+
+return array.every ((ele)=> ele0 === ele)
+
   // Si todos los elementos del arreglo son iguales, retornar true.
   // Caso contrario, retornar false.
   // Tu código:
 }
 
 module.exports = todosIguales;
+console.log (todosIguales(array));
diff --git a/C7 Arrays/ejercicios/21.js b/C7 Arrays/ejercicios/21.js
index 2dcba2d8e7..2079bd9bfb 100644
--- a/C7 Arrays/ejercicios/21.js	
+++ b/C7 Arrays/ejercicios/21.js	
@@ -1,8 +1,22 @@
+let array = ["Enero", "Febrero", "Diciembre", "Julio", "Noviembre"]
+
 function mesesDelAño(array) {
-  // El array contiene algunos meses del año desordenados. Debes recorrerlo, buscar los meses "Enero",
+let nuevoarray = []
+  if (array.includes ("Enero") && array.includes ("Marzo") &&  array.includes ("Noviembre")){
+    nuevoarray.push ("Enero", "Marzo", "Noviembre")
+    return nuevoarray
+  }
+    else return "No se encontraron los meses pedidos"
+  
+  } 
+   // El array contiene algunos meses del año desordenados. Debes recorrerlo, buscar los meses "Enero",
   // "Marzo" y "Noviembre", guardarlos en un nuevo arreglo y retornarlo.
   // Si alguno de los meses no está, retornar el string: "No se encontraron los meses pedidos".
   // Tu código:
-}
 
 module.exports = mesesDelAño;
+console.log (mesesDelAño(array));
+
+
+
+
diff --git a/C7 Arrays/ejercicios/22.js b/C7 Arrays/ejercicios/22.js
index 00e9aae5e9..a7a111b120 100644
--- a/C7 Arrays/ejercicios/22.js	
+++ b/C7 Arrays/ejercicios/22.js	
@@ -1,7 +1,21 @@
+
+
 function tablaDelSeis() {
+
+arrayT6 = []
+
+for (i=0;i<=9;i++){
+
+  arrayT6[i] = (i+1)*6
+
+}
+
+return (arrayT6)
   // Devuelve un arreglo con los resultados de la tabla de multiplicar del 6 en orden creciente.
   // Desde 0 al 60.
   // Tu código:
 }
 
+console.log (tablaDelSeis())
+
 module.exports = tablaDelSeis;
diff --git a/C7 Arrays/ejercicios/23.js b/C7 Arrays/ejercicios/23.js
index 408aebb292..ba861bff51 100644
--- a/C7 Arrays/ejercicios/23.js	
+++ b/C7 Arrays/ejercicios/23.js	
@@ -1,8 +1,36 @@
+
+
 function breakStatement(num) {
-  // Iterar en un bucle aumentando en 2 el número num recibido hasta un límite de 10 veces.
-  // 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 nuevonum = num;  // Empezamos con el número dado
+  var nuevoarray = [];
+  
+  for (var i = 0; i < 10; i++) {
+    nuevonum += 2;  // Sumamos 2 al número en cada iteración
+    nuevoarray[i] = nuevonum;  // Guardamos el valor en el arreglo
+    
+    // Comprobamos si el valor de nuevonum es igual a la cantidad de iteraciones
+    if (i === nuevonum) {
+      return "Se interrumpió la ejecución";  // Interrumpimos y retornamos el mensaje
+    }
+  }
+  
+  return nuevoarray;  // Si no se interrumpió, retornamos el arreglo completo
 }
 
 module.exports = breakStatement;
+console.log(breakStatement(0));  // Prueba con el número -20
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/C7 Arrays/ejercicios/24.js b/C7 Arrays/ejercicios/24.js
index 522c2d5e4d..ecb9e0e443 100644
--- a/C7 Arrays/ejercicios/24.js	
+++ b/C7 Arrays/ejercicios/24.js	
@@ -1,4 +1,19 @@
+
+
 function continueStatement(num) {
+
+  var nuevonum = num
+    var nuevoarray = []
+
+  for (i=0;i<=9;i++){
+    if (i===5) continue
+      nuevonum += 2
+      nuevoarray[i]=nuevonum
+  
+    }
+
+return nuevoarray
+
   // Iterar en un bucle aumentando en 2 el número num recibido hasta un límite de 10 veces.
   // Guardar cada nuevo valor en un array y retornarlo.
   // Cuando el número de iteraciones alcance el valor 5, no se suma ese caso y
@@ -8,3 +23,4 @@ function continueStatement(num) {
 }
 
 module.exports = continueStatement;
+console.log (continueStatement(2));
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/25.js b/C7 Arrays/ejercicios/25.js
index 2d145505bb..7223a33f6e 100644
--- a/C7 Arrays/ejercicios/25.js	
+++ b/C7 Arrays/ejercicios/25.js	
@@ -1,4 +1,19 @@
+
+var arreglo = [1,2,3,4,5,6,7,8,9,1,2,3,4,3,4,5,6,7,8]
+
 function contarParesConContinue(numeros) {
+  
+  var nuevoarray = []
+  
+  for (i=0;i<numeros.length;i++){
+
+    if (numeros [i] % 2 === 0)
+
+      nuevoarray.push (numeros[i])
+       else continue
+  }
+  return nuevoarray
+  
   // La función recibe un array de numeros por argumento.
   // Devuelve la cantidad de números pares que hay en el array.
   // Evita los impares utilizando continue.
@@ -6,3 +21,4 @@ function contarParesConContinue(numeros) {
 }
 
 module.exports = contarParesConContinue;
+console.log (contarParesConContinue (arreglo), "Largo arreglo: "+arreglo.length, "Largo NuevoArrPar: "+contarParesConContinue(arreglo).length)
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/26.js b/C7 Arrays/ejercicios/26.js
index 4d5a5d9aa4..c840ef8746 100644
--- a/C7 Arrays/ejercicios/26.js	
+++ b/C7 Arrays/ejercicios/26.js	
@@ -1,8 +1,20 @@
+
+secuencia = [1,2,3,4,5,6,7,8,9,10,22,3,4,5,6,77,6,5,443,33,24]
+
 function encontrarPrimerMultiploDeN(n, secuencia) {
+
+  for (i=0;i<secuencia.length;i++){
+    
+      if (secuencia[i] % n === 0) break
+      if (i===secuencia.length-1) return "No hay multiplo"
+    }
+  return secuencia[i]
   // La función recibe un numero "n" y un array de números "secuencia" como argumentos.
   // 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:
+
 }
 
-module.exports = encontrarPrimerMultiploDeN;
\ No newline at end of file
+module.exports = encontrarPrimerMultiploDeN;
+console.log (encontrarPrimerMultiploDeN(12, secuencia))
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/27.js b/C7 Arrays/ejercicios/27ArrAString.js
similarity index 63%
rename from C7 Arrays/ejercicios/27.js
rename to C7 Arrays/ejercicios/27ArrAString.js
index b5d8565c5f..40cb1c2f5e 100644
--- a/C7 Arrays/ejercicios/27.js	
+++ b/C7 Arrays/ejercicios/27ArrAString.js	
@@ -1,4 +1,10 @@
+var palabra = ["Hola","como estas", "todo bien"]
+
 function dePalabrasAFrase(palabras) {
+
+  var palstr = palabras.join (' ')
+  // var pal = palabras.toString ()
+  return palstr
   // El argumento "palabras" es un arreglo de strings.
   // Retorna un string donde todas las palabras estén concatenadas,
   // con un espacio entre cada palabra.
@@ -7,3 +13,4 @@ function dePalabrasAFrase(palabras) {
 }
 
 module.exports = dePalabrasAFrase;
+console.log (dePalabrasAFrase(palabra))
diff --git a/C7 Arrays/ejercicios/28.js b/C7 Arrays/ejercicios/28.PRUEBASIVARESARREGLOjs
similarity index 55%
rename from C7 Arrays/ejercicios/28.js
rename to C7 Arrays/ejercicios/28.PRUEBASIVARESARREGLOjs
index a1a65816b6..37133dc30e 100644
--- a/C7 Arrays/ejercicios/28.js	
+++ b/C7 Arrays/ejercicios/28.PRUEBASIVARESARREGLOjs	
@@ -1,8 +1,16 @@
+
+var array = [1,"hola",2,3,4,"Chau"]
+
 function esArrayNoVacio(arr) {
+
+  if (Array.isArray (arr) && arr.length !==0)
+    return true
+  else return false
   // La función recibe un argumento "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:
 }
 
-module.exports = esArrayNoVacio;
\ No newline at end of file
+module.exports = esArrayNoVacio;
+console.log(esArrayNoVacio(array))
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/29.js b/C7 Arrays/ejercicios/29.js
deleted file mode 100644
index de8a058efa..0000000000
--- a/C7 Arrays/ejercicios/29.js	
+++ /dev/null
@@ -1,9 +0,0 @@
-function encontrarNumeroFaltante(numeros) {
-  // La función recibe un argumento "numeros" correspondiente a un array de números.
-  // Encuentra el número faltante en una secuencia de números enteros consecutivos
-  // y retórnalo.
-  // Devuelve null si el array es vacío o si no hay números faltantes.
-  // Tu código:
-}
-
-module.exports = encontrarNumeroFaltante;
\ No newline at end of file
diff --git a/C7 Arrays/ejercicios/29NumNoConsecutivos.js b/C7 Arrays/ejercicios/29NumNoConsecutivos.js
new file mode 100644
index 0000000000..c4ac98673b
--- /dev/null
+++ b/C7 Arrays/ejercicios/29NumNoConsecutivos.js	
@@ -0,0 +1,25 @@
+
+var num = [1, 2, 3, 4, 5, 6, 7, 8, 9];  // Ejemplo de secuencia completa
+var num1 = [];  // Ejemplo de arreglo vacío
+
+function encontrarNumeroFaltante(numeros) {
+  // Si el arreglo está vacío, devolvemos null
+  if (numeros.length === 0) return null;
+
+  // Recorremos el arreglo buscando el número faltante
+  for (let i = 0; i < numeros.length - 1; i++) {
+    // Si la diferencia entre el número actual y el siguiente no es 1, encontramos el número faltante
+    if (numeros[i + 1] !== numeros[i] + 1) {
+      return numeros[i] + 1;
+    }
+  }
+  
+  // Si no se encontró ningún número faltante, devolvemos null
+  return null;
+}
+
+module.exports = encontrarNumeroFaltante;
+console.log(encontrarNumeroFaltante(num));  // Debería retornar null, ya que no falta ningún número
+
+
+

From 8b5b0fed88a9abc169e3c9ad5a210dd2e3d06a0a Mon Sep 17 00:00:00 2001
From: MatiasBirba <mbirba@supaqpel.com.ar>
Date: Fri, 4 Apr 2025 11:53:26 -0300
Subject: [PATCH 4/4] Ejercicios de Objetos resueltos

---
 ...30.js => 30.jNumRepetidosIdemAnteriors.js} |  0
 .../{31.js => 31.InvierteString.js}           | 11 ++++++
 .../callbacks/ejercicios/02.js                | 16 ++++++++
 .../{03.js => 03.OperacionMatConCallbackjs}   |  9 +++++
 .../callbacks/ejercicios/04.js                |  9 -----
 .../ejercicios/04sumaNumArreConCallback.js    | 27 ++++++++++++++
 .../ejercicios/05.CallbackBucleadojs          | 25 +++++++++++++
 .../callbacks/ejercicios/05.js                |  7 ----
 .../ejercicios/06.ArrayFamiliaCallback.js     | 21 +++++++++++
 .../callbacks/ejercicios/06.js                |  8 ----
 .../ejercicios/{07.js => 07FilerCallback.js}  |  7 ++++
 .../callbacks/ejercicios/08.js                |  8 ----
 .../callbacks/ejercicios/08FindCallback.js    | 37 +++++++++++++++++++
 .../objects/ejercicios/01.FindOwnPropertyjs   | 23 ++++++++++++
 .../objects/ejercicios/01.js                  | 10 -----
 .../{02.js => 02.ActualizarValorPropiedad.js} | 17 ++++++++-
 .../{03.js => 03AgregaPropiedad.js}           | 10 +++++
 .../{04.js => 04VerificarPropiedad.js}        | 10 +++++
 ...js => 05.ListarPropiedades.Object,Keys.js} | 10 +++++
 .../objects/ejercicios/06.js                  |  7 ----
 .../objects/ejercicios/06ForIn.js             | 21 +++++++++++
 .../ejercicios/07.SortArregloDeObjetos.js     | 32 ++++++++++++++++
 .../objects/ejercicios/07.js                  | 12 ------
 .../08.CreaObjetoYagregaPropConFunction.js    | 35 ++++++++++++++++++
 .../objects/ejercicios/08.js                  | 10 -----
 .../{09.js => 09CreaObjetoConDatosUsuario.js} |  9 +++++
 .../{10.js => 10.AgregaPropVariable.js}       | 13 ++++++-
 .../11.jInvocaFuncionDeclaEnUnObjetos         | 31 ++++++++++++++++
 .../objects/ejercicios/11.js                  |  8 ----
 .../{12.js => 12.ObjetoMisterioso.js}         | 10 +++++
 .../{13.js => 13.DeletePropiedadObjeto.js}    |  9 +++++
 31 files changed, 380 insertions(+), 82 deletions(-)
 rename C7 Arrays/ejercicios/{30.js => 30.jNumRepetidosIdemAnteriors.js} (100%)
 rename C7 Arrays/ejercicios/{31.js => 31.InvierteString.js} (57%)
 rename C8 Objects + Callbacks/callbacks/ejercicios/{03.js => 03.OperacionMatConCallbackjs} (71%)
 delete mode 100644 C8 Objects + Callbacks/callbacks/ejercicios/04.js
 create mode 100644 C8 Objects + Callbacks/callbacks/ejercicios/04sumaNumArreConCallback.js
 create mode 100644 C8 Objects + Callbacks/callbacks/ejercicios/05.CallbackBucleadojs
 delete mode 100644 C8 Objects + Callbacks/callbacks/ejercicios/05.js
 create mode 100644 C8 Objects + Callbacks/callbacks/ejercicios/06.ArrayFamiliaCallback.js
 delete mode 100644 C8 Objects + Callbacks/callbacks/ejercicios/06.js
 rename C8 Objects + Callbacks/callbacks/ejercicios/{07.js => 07FilerCallback.js} (60%)
 delete mode 100644 C8 Objects + Callbacks/callbacks/ejercicios/08.js
 create mode 100644 C8 Objects + Callbacks/callbacks/ejercicios/08FindCallback.js
 create mode 100644 C8 Objects + Callbacks/objects/ejercicios/01.FindOwnPropertyjs
 delete mode 100644 C8 Objects + Callbacks/objects/ejercicios/01.js
 rename C8 Objects + Callbacks/objects/ejercicios/{02.js => 02.ActualizarValorPropiedad.js} (64%)
 rename C8 Objects + Callbacks/objects/ejercicios/{03.js => 03AgregaPropiedad.js} (54%)
 rename C8 Objects + Callbacks/objects/ejercicios/{04.js => 04VerificarPropiedad.js} (60%)
 rename C8 Objects + Callbacks/objects/ejercicios/{05.js => 05.ListarPropiedades.Object,Keys.js} (63%)
 delete mode 100644 C8 Objects + Callbacks/objects/ejercicios/06.js
 create mode 100644 C8 Objects + Callbacks/objects/ejercicios/06ForIn.js
 create mode 100644 C8 Objects + Callbacks/objects/ejercicios/07.SortArregloDeObjetos.js
 delete mode 100644 C8 Objects + Callbacks/objects/ejercicios/07.js
 create mode 100644 C8 Objects + Callbacks/objects/ejercicios/08.CreaObjetoYagregaPropConFunction.js
 delete mode 100644 C8 Objects + Callbacks/objects/ejercicios/08.js
 rename C8 Objects + Callbacks/objects/ejercicios/{09.js => 09CreaObjetoConDatosUsuario.js} (62%)
 rename C8 Objects + Callbacks/objects/ejercicios/{10.js => 10.AgregaPropVariable.js} (66%)
 create mode 100644 C8 Objects + Callbacks/objects/ejercicios/11.jInvocaFuncionDeclaEnUnObjetos
 delete mode 100644 C8 Objects + Callbacks/objects/ejercicios/11.js
 rename C8 Objects + Callbacks/objects/ejercicios/{12.js => 12.ObjetoMisterioso.js} (52%)
 rename C8 Objects + Callbacks/objects/ejercicios/{13.js => 13.DeletePropiedadObjeto.js} (61%)

diff --git a/C7 Arrays/ejercicios/30.js b/C7 Arrays/ejercicios/30.jNumRepetidosIdemAnteriors.js
similarity index 100%
rename from C7 Arrays/ejercicios/30.js
rename to C7 Arrays/ejercicios/30.jNumRepetidosIdemAnteriors.js
diff --git a/C7 Arrays/ejercicios/31.js b/C7 Arrays/ejercicios/31.InvierteString.js
similarity index 57%
rename from C7 Arrays/ejercicios/31.js
rename to C7 Arrays/ejercicios/31.InvierteString.js
index e75dcb7773..426cac21d6 100644
--- a/C7 Arrays/ejercicios/31.js	
+++ b/C7 Arrays/ejercicios/31.InvierteString.js	
@@ -1,4 +1,15 @@
+
+
+console.log(("hola").split())
+var arr = ("hola").split ('')
+
+arr.reverse ()
+var nuevostr = arr.reverse().join('')
+console.log (arr)
+console.log (nuevostr)
 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:
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/02.js b/C8 Objects + Callbacks/callbacks/ejercicios/02.js
index df7a401ef8..c58d232eca 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/02.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/02.js	
@@ -1,8 +1,24 @@
+function callback (string){
+   return (string + "Mundo")
+   }
+   
 function cambiarCadena(string, callback) {
+
+    // Si se recibe un callback, lo aplicamos al string. Si no, retornamos el string original.
+  if (typeof callback === 'function') {
+   return callback(string);
+ } else {
+   return string;
+ }
+
    // Aplica la función de callback al string y devuelve el resultado.
    // 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:
 }
 
+
+console.log (typeof callback())
+
 module.exports = cambiarCadena;
+console.log (cambiarCadena("Hola", callback))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/03.js b/C8 Objects + Callbacks/callbacks/ejercicios/03.OperacionMatConCallbackjs
similarity index 71%
rename from C8 Objects + Callbacks/callbacks/ejercicios/03.js
rename to C8 Objects + Callbacks/callbacks/ejercicios/03.OperacionMatConCallbackjs
index 767f0a1808..7fd6f86dd9 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/03.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/03.OperacionMatConCallbackjs	
@@ -1,8 +1,17 @@
 function operacionMatematica(num1, num2, cb) {
+
+
+return cb(num1, num2);
+
   // En este ejercicio recibirás dos números y un callback.
   // El callback realiza una operación matemática, por lo que necesita de los dos números.
   // Retorna el resultado del callback pasándole por valores los números num1 y num2.
   // Tu código:
 }
+function Multiplicacion (num1, num2) {
+
+  return num1*num2/3
+}
 
 module.exports = operacionMatematica;
+console.log (operacionMatematica(5,7,Multiplicacion))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/04.js b/C8 Objects + Callbacks/callbacks/ejercicios/04.js
deleted file mode 100644
index 04f18b1ec5..0000000000
--- a/C8 Objects + Callbacks/callbacks/ejercicios/04.js	
+++ /dev/null
@@ -1,9 +0,0 @@
-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 retornar nada.
-   // Tu código:
-}
-
-module.exports = sumarArray;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/04sumaNumArreConCallback.js b/C8 Objects + Callbacks/callbacks/ejercicios/04sumaNumArreConCallback.js
new file mode 100644
index 0000000000..fa3a663b2a
--- /dev/null
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/04sumaNumArreConCallback.js	
@@ -0,0 +1,27 @@
+var arreglodenumeros = [1,2,3,4,5,6,7,8,9]
+
+function sumarArray(arrayOfNumbers, cb) {
+
+return cb (arrayOfNumbers)
+   // 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 retornar nada.
+   // Tu código:
+}
+
+
+function sumaarreglos (arreglosparasumar) {
+
+   var sumatotal = 0
+ for (i=0; i<arreglosparasumar.length; i++){
+
+   sumatotal += arreglosparasumar[i]
+
+}
+return sumatotal
+}
+
+module.exports = sumarArray;
+
+console.log (sumarArray(arreglodenumeros, sumaarreglos))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/05.CallbackBucleadojs b/C8 Objects + Callbacks/callbacks/ejercicios/05.CallbackBucleadojs
new file mode 100644
index 0000000000..a38cd1a9bb
--- /dev/null
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/05.CallbackBucleadojs	
@@ -0,0 +1,25 @@
+
+arreglo = [1,2,3,4,5,6,7,8,9]
+
+function forEach(array, cb) {
+
+  var arreglofinal = []
+for (i=0; i<array.length; i++){
+    cb (array, arreglofinal)
+}
+return arreglofinal
+
+  // Recibes un arreglo y un callback.
+  // Itera sobre el arreglo y por cada elemento iterado, ejecuta el callback con este valor.
+  // Tu código:
+}
+
+
+function cbforeach (ele, arr){
+
+  return arr.push (ele)
+}
+
+console.log (forEach (arreglo, cbforeach))
+
+module.exports = forEach;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/05.js b/C8 Objects + Callbacks/callbacks/ejercicios/05.js
deleted file mode 100644
index cecc94504d..0000000000
--- a/C8 Objects + Callbacks/callbacks/ejercicios/05.js	
+++ /dev/null
@@ -1,7 +0,0 @@
-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:
-}
-
-module.exports = forEach;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/06.ArrayFamiliaCallback.js b/C8 Objects + Callbacks/callbacks/ejercicios/06.ArrayFamiliaCallback.js
new file mode 100644
index 0000000000..78af2c884e
--- /dev/null
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/06.ArrayFamiliaCallback.js	
@@ -0,0 +1,21 @@
+
+var arreglo = ["Mati","Mery","Feli","Manu"]
+
+
+function map(array, cb) {
+var nuevoarreglo = []
+for (i=0; i< array.length; i++){
+ nuevoarreglo.push (cb (array[i]))
+}
+return nuevoarreglo
+  // Itera sobre el arreglo y por cada elemento, pasárselo como argumento al callback.
+  // Tiene que guardar el resultado devuelto por el callback en cada elemento dentro de un nuevo arreglo.
+  // Retorna el nuevo arreglo.
+  // Tu código:
+}
+
+module.exports = map;
+function mapeayguardanuevosvaloresennuevoarreglo (ele){
+  return "Hola " + ele
+}
+console.log (map (arreglo,mapeayguardanuevosvaloresennuevoarreglo))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/06.js b/C8 Objects + Callbacks/callbacks/ejercicios/06.js
deleted file mode 100644
index e09a7bf8c4..0000000000
--- a/C8 Objects + Callbacks/callbacks/ejercicios/06.js	
+++ /dev/null
@@ -1,8 +0,0 @@
-function map(array, cb) {
-  // Itera sobre el arreglo y por cada elemento, pasárselo como argumento al callback.
-  // Tiene que guardar el resultado devuelto por el callback en cada elemento dentro de un nuevo arreglo.
-  // Retorna el nuevo arreglo.
-  // Tu código:
-}
-
-module.exports = map;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/07.js b/C8 Objects + Callbacks/callbacks/ejercicios/07FilerCallback.js
similarity index 60%
rename from C8 Objects + Callbacks/callbacks/ejercicios/07.js
rename to C8 Objects + Callbacks/callbacks/ejercicios/07FilerCallback.js
index d9983d4528..e04b93867f 100644
--- a/C8 Objects + Callbacks/callbacks/ejercicios/07.js	
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/07FilerCallback.js	
@@ -1,4 +1,11 @@
+
+var arreglo = ["Hola", "Chau", "Arbol", "piso", "Jabon", "alerta"]
+
+
 function filter(arrayOfStrings) {
+
+   return arrayOfStrings.filter((str) => str[0].toLowerCase() === "a");
+
    // Debes identificar todos los elementos el arreglo que comiencen con la letra "a".
    // Luego retorna un nuevo arreglo con estos elementos.
    // Tu código:
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/08.js b/C8 Objects + Callbacks/callbacks/ejercicios/08.js
deleted file mode 100644
index b4c2cad28a..0000000000
--- a/C8 Objects + Callbacks/callbacks/ejercicios/08.js	
+++ /dev/null
@@ -1,8 +0,0 @@
-const buscarElemento = (array, callback) => {
-  // Busca un elemento en el array y retornalo.
-  // 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:
-};
-
-module.exports = buscarElemento;
diff --git a/C8 Objects + Callbacks/callbacks/ejercicios/08FindCallback.js b/C8 Objects + Callbacks/callbacks/ejercicios/08FindCallback.js
new file mode 100644
index 0000000000..b68765b0f6
--- /dev/null
+++ b/C8 Objects + Callbacks/callbacks/ejercicios/08FindCallback.js	
@@ -0,0 +1,37 @@
+
+var find = ["hola", "chau", "location", "curso", "henry"]
+
+const buscarElemento = function (array, callback, elemento) {
+
+return callback (array, elemento)
+
+} 
+
+function callback (arr, ele) {
+
+  resultado = arr.find ((item) => item === ele)
+
+  if (resultado)
+    return resultado 
+  return "Elemento no encontrado"
+}
+
+console.log (buscarElemento (find, callback, "cualquiercosa"))
+  
+  // Busca un elemento en el array y retornalo.
+  // 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:
+
+// function callback (arr, ele){
+// 
+// const resultado = arr.find ((elemento)=> elemento === ele)
+// 
+// if (resultado) return resultado
+// 
+// else return "Elemnto no encontrado"
+// 
+// }
+// 
+// console.log (buscarElemento (find, callback, "location"))
+module.exports = buscarElemento;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/01.FindOwnPropertyjs b/C8 Objects + Callbacks/objects/ejercicios/01.FindOwnPropertyjs
new file mode 100644
index 0000000000..d706cae8f1
--- /dev/null
+++ b/C8 Objects + Callbacks/objects/ejercicios/01.FindOwnPropertyjs	
@@ -0,0 +1,23 @@
+var primerobjeto = {
+
+   prop1: "Hola",
+   prop2: "chau",
+   propiedadprueba: "Encontrado",
+
+}
+
+const obtenerValorPropiedad = (objeto, propiedad) => {
+   
+   // Recibe un objeto y el nombre de una propiedad.
+   // Devuelve el valor de esta propiedad.
+   // Tu código:
+   
+   a = objeto.hasOwnProperty (propiedad)
+
+   if (a) return objeto[propiedad]
+   else return "propuiedad no encontrada"
+   
+};
+
+console.log (obtenerValorPropiedad (primerobjeto, "propiedadprueba"))
+module.exports = obtenerValorPropiedad;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/01.js b/C8 Objects + Callbacks/objects/ejercicios/01.js
deleted file mode 100644
index 4e28b4c584..0000000000
--- a/C8 Objects + Callbacks/objects/ejercicios/01.js	
+++ /dev/null
@@ -1,10 +0,0 @@
-const obtenerValorPropiedad = (objeto, propiedad) => {
-   // Recibe un objeto y el nombre de una propiedad.
-   // Devuelve el valor de esta propiedad.
-   // Tu código:
-   const a = objeto[propiedad];
-
-   return a;
-};
-
-module.exports = obtenerValorPropiedad;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/02.js b/C8 Objects + Callbacks/objects/ejercicios/02.ActualizarValorPropiedad.js
similarity index 64%
rename from C8 Objects + Callbacks/objects/ejercicios/02.js
rename to C8 Objects + Callbacks/objects/ejercicios/02.ActualizarValorPropiedad.js
index fd81338de0..d77cd1bea2 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/02.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/02.ActualizarValorPropiedad.js	
@@ -1,9 +1,22 @@
+
+var objeto = {
+
+   porp1: "valor1",
+   prop2: "valor2",
+   prop3: "valor3",
+}
+
 function actualizarValorPropiedad(objeto, propiedad, valor) {
+   
+   objeto[propiedad] = valor;
+   return objeto;
+
+   
    // Actualiza el valor de la propiedad del objeto recibidos en la función.
    // Retorna el objeto actualizado.
    // Tu código:
-   objeto[propiedad] = valor;
-   return objeto;
 }
 
 module.exports = actualizarValorPropiedad;
+
+console.log (actualizarValorPropiedad (objeto, "prop3", "Nuevo Valor"))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/objects/ejercicios/03.js b/C8 Objects + Callbacks/objects/ejercicios/03AgregaPropiedad.js
similarity index 54%
rename from C8 Objects + Callbacks/objects/ejercicios/03.js
rename to C8 Objects + Callbacks/objects/ejercicios/03AgregaPropiedad.js
index 9705c17350..dd2653aac7 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/03.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/03AgregaPropiedad.js	
@@ -1,6 +1,16 @@
+
+var objeto = {
+  prop1: "valor1",
+  prop2: "valor2"
+}
 const agregarNuevaPropiedad = (objeto, propiedad, valor) => {
+
+  objeto [propiedad] = valor
+
+  return objeto
   // Añade una nueva propiedad al objeto con su respectivo valor pasado por la función.
   // Tu código:
 };
 
 module.exports = agregarNuevaPropiedad;
+console.log (agregarNuevaPropiedad (objeto, "PropiedadNueva", "NuevoValor"))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/04.js b/C8 Objects + Callbacks/objects/ejercicios/04VerificarPropiedad.js
similarity index 60%
rename from C8 Objects + Callbacks/objects/ejercicios/04.js
rename to C8 Objects + Callbacks/objects/ejercicios/04VerificarPropiedad.js
index 8dbc773948..2053687d34 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/04.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/04VerificarPropiedad.js	
@@ -1,4 +1,13 @@
+var objeto = {
+   prop1: "Valor1"
+}
+
 function verificarPropiedad(objeto, propiedad) {
+
+   var a = objeto.hasOwnProperty (propiedad)
+
+   if (a) return true
+   else return false
    // Verifica si el objeto posee la propiedad recibida.
    // Retorna true si la tiene, sino retorna false.
    // PISTA: puedes usar el método hasOwnProperty().
@@ -6,3 +15,4 @@ function verificarPropiedad(objeto, propiedad) {
 }
 
 module.exports = verificarPropiedad;
+console.log (verificarPropiedad (objeto, "prop1"))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/objects/ejercicios/05.js b/C8 Objects + Callbacks/objects/ejercicios/05.ListarPropiedades.Object,Keys.js
similarity index 63%
rename from C8 Objects + Callbacks/objects/ejercicios/05.js
rename to C8 Objects + Callbacks/objects/ejercicios/05.ListarPropiedades.Object,Keys.js
index 57485922a9..e19b863892 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/05.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/05.ListarPropiedades.Object,Keys.js	
@@ -1,7 +1,17 @@
+var objeto = {
+  prop1: "Valor1",
+  prop2: "valor2",
+}
+
 const listarPropiedades = (objeto) => {
+
+  a = Object.keys (objeto)
+
+  return a
   // 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:
 };
 
 module.exports = listarPropiedades;
+console.log (listarPropiedades (objeto))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/objects/ejercicios/06.js b/C8 Objects + Callbacks/objects/ejercicios/06.js
deleted file mode 100644
index da96759653..0000000000
--- a/C8 Objects + Callbacks/objects/ejercicios/06.js	
+++ /dev/null
@@ -1,7 +0,0 @@
-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:
-};
-
-module.exports = contarPropiedades;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/06ForIn.js b/C8 Objects + Callbacks/objects/ejercicios/06ForIn.js
new file mode 100644
index 0000000000..6b04e648fb
--- /dev/null
+++ b/C8 Objects + Callbacks/objects/ejercicios/06ForIn.js	
@@ -0,0 +1,21 @@
+var objeto = {
+  prop1: "valor1",
+  prop2: "valor2"
+}
+
+const contarPropiedades = (objeto) => {
+  
+  // var a = Object.keys (objeto).length
+  let contador = 0
+  for (let propiedad in objeto){
+    if (objeto.hasOwnProperty (propiedad))
+      contador++
+  }
+  return contador
+  // Cuenta y retorna el total de propiedades que tiene el objeto.
+  // PISTA: Puedes iterarlo usando el bucle for-in.
+  // Tu código:
+};
+
+module.exports = contarPropiedades;
+console.log (contarPropiedades (objeto))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/objects/ejercicios/07.SortArregloDeObjetos.js b/C8 Objects + Callbacks/objects/ejercicios/07.SortArregloDeObjetos.js
new file mode 100644
index 0000000000..bae50a888f
--- /dev/null
+++ b/C8 Objects + Callbacks/objects/ejercicios/07.SortArregloDeObjetos.js	
@@ -0,0 +1,32 @@
+var sortby = "a";
+var list = [
+   {a: 1, b: 2},
+   {a: 2, b: 2},
+   {a: 2, b: 40}
+];
+
+function sort(sortBy, list) {
+   // Ordenar el arreglo de objetos de manera descendente según el valor de sortBy
+   return list.sort((obj1, obj2) => {
+      if (obj1[sortBy] > obj2[sortBy]) {
+         return -1; // El primer objeto es mayor, lo ponemos antes (descendente)
+      } else if (obj1[sortBy] < obj2[sortBy]) {
+         return 1; // comola condicion es falsa ponemos -1 moviendo el obj2 al obj1 (descendente)
+      } else {
+         return 0; // Son iguales, no cambiamos el orden
+      }
+   });
+}
+
+   // La función sort recibe dos parámetros:
+   // sortBy: una letra (string).
+   // list: un arreglo de objetos.
+   // La función deberá devolver la lista de objetos ordenada de forma DESCENDIENTE
+   // a partir de la letra recibida. Por ejemplo:
+   // 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:
+
+
+module.exports = sort;
+console.log (sort(sortby, list))
diff --git a/C8 Objects + Callbacks/objects/ejercicios/07.js b/C8 Objects + Callbacks/objects/ejercicios/07.js
deleted file mode 100644
index 38b33c7db6..0000000000
--- a/C8 Objects + Callbacks/objects/ejercicios/07.js	
+++ /dev/null
@@ -1,12 +0,0 @@
-function sort(sortBy, list) {
-   // La función sort recibe dos parámetros:
-   // sortBy: una letra (string).
-   // list: un arreglo de objetos.
-   // La función deberá devolver la lista de objetos ordenada de forma DESCENDIENTE
-   // a partir de la letra recibida. Por ejemplo:
-   // 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:
-}
-
-module.exports = sort;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/08.CreaObjetoYagregaPropConFunction.js b/C8 Objects + Callbacks/objects/ejercicios/08.CreaObjetoYagregaPropConFunction.js
new file mode 100644
index 0000000000..cfd86531fc
--- /dev/null
+++ b/C8 Objects + Callbacks/objects/ejercicios/08.CreaObjetoYagregaPropConFunction.js	
@@ -0,0 +1,35 @@
+
+
+function crearGato(nombre, edad) {
+  var objeto = { 
+    nombre: nombre, 
+    edad: edad,
+    meow: "Meow!"  // En lugar de la función, directamente el valor que debería retornar
+  };
+  
+  return objeto;
+}
+
+const gato = crearGato("Michu", "10 Anos");
+
+console.log(gato);  // Muestra el objeto con las propiedades "nombre", "edad" y "meow" con su valor
+
+// 
+// function crearGato(nombre, edad) {
+
+  // Creamos el objeto con las propiedades "nombre" y "edad"
+  // var objeto = {
+    // nombre: nombre,
+    // edad: edad,
+    // Agregamos la propiedad "meow" como una función
+    // meow: function() {
+      // return meow["Meow!"];
+    // }
+  // };
+
+  // Retornamos el objeto
+  // return objeto;
+// }
+console.log (crearGato ("Michu", "10 Anos"))
+
+module.exports = crearGato;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/08.js b/C8 Objects + Callbacks/objects/ejercicios/08.js
deleted file mode 100644
index b6915259c4..0000000000
--- a/C8 Objects + Callbacks/objects/ejercicios/08.js	
+++ /dev/null
@@ -1,10 +0,0 @@
-function crearGato(nombre, edad) {
-  // Debes crear un nuevo objeto con las propiedades "nombre" y "edad".
-  // Ambas propiedades deben tener el valor correspondiente recibido por parámetro.
-  // Además, agregar una propiedad con el nombre "meow".
-  // La propiedad "meow" será una función que retorne el string: "Meow!".
-  // Retornar el objeto.
-  // Tu código:
-}
-
-module.exports = crearGato;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/09.js b/C8 Objects + Callbacks/objects/ejercicios/09CreaObjetoConDatosUsuario.js
similarity index 62%
rename from C8 Objects + Callbacks/objects/ejercicios/09.js
rename to C8 Objects + Callbacks/objects/ejercicios/09CreaObjetoConDatosUsuario.js
index ff0b379077..d3017b7e59 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/09.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/09CreaObjetoConDatosUsuario.js	
@@ -1,4 +1,12 @@
 function nuevoUsuario(nombre, email, password) {
+
+var objeto = {
+  nombre: nombre,
+  email: email,
+  password: password
+}
+
+return objeto
   // Debes crear un nuevo objeto.
   // Este debe tener las propiedades: "nombre", "email" y "password" con sus respectivos valores.
   // Retorna el objeto creado.
@@ -6,3 +14,4 @@ function nuevoUsuario(nombre, email, password) {
 }
 
 module.exports = nuevoUsuario;
+console.log (nuevoUsuario ("Matias", "mbirba@supapel.com.ar", 1234))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/objects/ejercicios/10.js b/C8 Objects + Callbacks/objects/ejercicios/10.AgregaPropVariable.js
similarity index 66%
rename from C8 Objects + Callbacks/objects/ejercicios/10.js
rename to C8 Objects + Callbacks/objects/ejercicios/10.AgregaPropVariable.js
index b307e660e3..78d729cdce 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/10.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/10.AgregaPropVariable.js	
@@ -1,9 +1,20 @@
+
+var objeto = {
+  Pro1: "Valor1",
+  Prop2: "Valor2"
+}
+
 function agregarPropiedad(objeto, propiedad) {
+
+objeto [propiedad] = null
+
+return objeto
+
   // Recibirás un objeto por parámetro.
   // Debes agregarle una propiedad con el nombre recibido por parámetro.
   // Esta propiedad será igual al valor `null`.
   // Retornar el objeto.
   // Tu código:
 }
-
+console.log (agregarPropiedad(objeto, "propiedad"))
 module.exports = agregarPropiedad;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/11.jInvocaFuncionDeclaEnUnObjetos b/C8 Objects + Callbacks/objects/ejercicios/11.jInvocaFuncionDeclaEnUnObjetos
new file mode 100644
index 0000000000..b8ff7ff6eb
--- /dev/null
+++ b/C8 Objects + Callbacks/objects/ejercicios/11.jInvocaFuncionDeclaEnUnObjetos	
@@ -0,0 +1,31 @@
+
+var objeto = {
+  prop1: "valor1",
+  prop2: "valor2",
+  prop3: function (){    
+  console.log ("Metodo invocado")
+  },
+}
+
+function invocarMetodo(objeto, metodo) {
+  // Verificamos si el objeto tiene la propiedad que corresponde al nombre del método
+  if (objeto[metodo] && typeof objeto[metodo] === "function") {
+    objeto[metodo](); // Invocamos el método
+  } else {
+    console.log("El método no existe en el objeto");
+  }
+}
+
+invocarMetodo(objeto, "prop3");  // Debería imprimir "¡Método invocado!" en la consola
+invocarMetodo(objeto, "prop4");  // Debería imprimir "El método no existe en el objeto" en la consola
+
+// function invocarMetodo(objeto, metodo) {
+
+
+  // El parámetro "metodo" es un string que coincide con el nombre de una propiedad del objeto recibido.
+  // Esta propiedad contiene una función en su interior. Debes invocarla/ejecutarla.
+  // NOTA: no necesitas retornar nada.
+  // Tu código:
+// }
+
+module.exports = invocarMetodo;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/11.js b/C8 Objects + Callbacks/objects/ejercicios/11.js
deleted file mode 100644
index 85579d0d92..0000000000
--- a/C8 Objects + Callbacks/objects/ejercicios/11.js	
+++ /dev/null
@@ -1,8 +0,0 @@
-function invocarMetodo(objeto, metodo) {
-  // El parámetro "metodo" es un string que coincide con el nombre de una propiedad del objeto recibido.
-  // Esta propiedad contiene una función en su interior. Debes invocarla/ejecutarla.
-  // NOTA: no necesitas retornar nada.
-  // Tu código:
-}
-
-module.exports = invocarMetodo;
diff --git a/C8 Objects + Callbacks/objects/ejercicios/12.js b/C8 Objects + Callbacks/objects/ejercicios/12.ObjetoMisterioso.js
similarity index 52%
rename from C8 Objects + Callbacks/objects/ejercicios/12.js
rename to C8 Objects + Callbacks/objects/ejercicios/12.ObjetoMisterioso.js
index 976cd317d3..255dfcfcab 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/12.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/12.ObjetoMisterioso.js	
@@ -1,7 +1,17 @@
+var objetoMisterioso = {
+  numeroMisterioso: 2
+}
+
 function multiplicarNumeroDesconocidoPorCinco(objetoMisterioso) {
+  
+  var a = objetoMisterioso.hasOwnProperty ("numeroMisterioso")
+  if (a)
+  return objetoMisterioso["numeroMisterioso"]*5
+  return "Objeto no encontrado"
   // 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:
 }
 
 module.exports = multiplicarNumeroDesconocidoPorCinco;
+console.log (multiplicarNumeroDesconocidoPorCinco(objetoMisterioso))
\ No newline at end of file
diff --git a/C8 Objects + Callbacks/objects/ejercicios/13.js b/C8 Objects + Callbacks/objects/ejercicios/13.DeletePropiedadObjeto.js
similarity index 61%
rename from C8 Objects + Callbacks/objects/ejercicios/13.js
rename to C8 Objects + Callbacks/objects/ejercicios/13.DeletePropiedadObjeto.js
index 26b71ad81e..b237b035cf 100644
--- a/C8 Objects + Callbacks/objects/ejercicios/13.js	
+++ b/C8 Objects + Callbacks/objects/ejercicios/13.DeletePropiedadObjeto.js	
@@ -1,7 +1,16 @@
+var objeto = {
+  prop1: "valor1",
+  prop2: "valor2"
+}
+
 function eliminarPropiedad(objeto, propiedad) {
+
+  delete objeto[propiedad]
+  return objeto
   // El parámetro "propiedad" es una propiedad del objeto que recibes.
   // Debes eliminarla del objeto y retornarlo finalmente.
   // Tu código:
 }
 
 module.exports = eliminarPropiedad;
+console.log (eliminarPropiedad(objeto, "prop1"))
\ No newline at end of file