reported problems solved

Author: HX-ABengoechea

M01 Instalación de herramientas/homework.md renamed to C1 Instalación de herramientas/homework.md

@@ -0,0 +1,8 @@
+function sumarHastaNConBreak(n) {
+   // 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.
+   // Tu código:
+}
+
+module.exports = sumarHastaNConBreak;

M02 Terminal, Git y Github/homework.md renamed to C2 Terminal, Git y Github/homework.md

@@ -0,0 +1,11 @@
+function combine(str1, str2, str3) {
+   // Esta función debe combinar de forma alternada cada caracter de cada string.
+   // La función recibe 3 argumentos. Solo debe contabilizar aquellos que NO esten vacíos.
+   // Los strings pueden tener cualquier tamaño.
+   // EJEMPLOS
+   // combine("abc", "", "123") == "a1b2c3"
+   // combine("abc", "12345", "") == "a1b2c345"
+   // combine("abc", "12345", "67") == "a16b27c345"
+}
+
+module.exports = combine;

M03 HTML/homework.md renamed to C3 HTML/homework.md

@@ -0,0 +1,7 @@
+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:
+}
+
+module.exports = invertirTexto;

M04 CSS/homework.md renamed to C4 CSS/homework.md

@@ -0,0 +1,10 @@
+function esPalindromo(string) {
+   // La función recibe un argumento "string".
+   // Verifica si este string es palíndromo o no.
+   // Retorna true si lo es, caso contrario, retorna false.
+   // IMPORTANTE: Un palíndromo es una palabra o frase
+   // que se lee igual hacia adelante que hacia atrás.
+   // Tu código:
+}
+
+module.exports = esPalindromo;

M05 Fundamentos Javascript/ejercicios/01.js renamed to C5 Fundamentos Javascript/ejercicios/01.js

@@ -0,0 +1,25 @@
+const sumarHastaNConBreak = require('../ejercicios/20.js');
+
+test('sumarHastaNConBreak of 5 should return 15', () => {
+   expect(sumarHastaNConBreak(5)).toBe(15);
+});
+
+test('sumarHastaNConBreak of 7 should return 28', () => {
+   expect(sumarHastaNConBreak(7)).toBe(28);
+});
+
+test('sumarHastaNConBreak of 10 should return 55', () => {
+   expect(sumarHastaNConBreak(10)).toBe(55);
+});
+
+test('sumarHastaNConBreak of 15 should return 105', () => {
+   expect(sumarHastaNConBreak(15)).toBe(105);
+});
+
+test('sumarHastaNConBreak of 20 should return 105', () => {
+   expect(sumarHastaNConBreak(20)).toBe(105);
+});
+
+test('sumarHastaNConBreak of 50 should return 105', () => {
+   expect(sumarHastaNConBreak(50)).toBe(105);
+});

M05 Fundamentos Javascript/ejercicios/02.js renamed to C5 Fundamentos Javascript/ejercicios/02.js

@@ -0,0 +1,49 @@
+const combine = require('../ejercicios/22');
+
+// describe('diasEnMes', () => {
+//   it('should return 31 for January', () => {
+//     expect(diasEnMes(1)).toBe(31);
+//   });
+
+//   it('should return 28 for February', () => {
+//     expect(diasEnMes(2)).toBe(28);
+//   });
+
+//   it('should return 30 for April', () => {
+//     expect(diasEnMes(4)).toBe(30);
+//   });
+
+//   it('should return 0 for month outside of range', () => {
+//     expect(diasEnMes(13)).toBe(0);
+//   });
+
+//   it('should return 0 for month outside of range', () => {
+//     expect(diasEnMes(-1)).toBe(0);
+//   });
+// });
+
+describe('combine', () => {
+   test('Debe combinar los caracteres de forma alternada si hay un string vacío', () => {
+      expect(combine('abc', '', '123')).toBe('a1b2c3');
+      expect(combine('abc', '12345', '')).toBe('a1b2c345');
+   });
+
+   test('Debe combinar correctamente los resultas si los strings tienen diferente tamaño', () => {
+      expect(combine('abc', '12345', '')).toBe('a1b2c345');
+      expect(combine('a', '12', 'xyz')).toBe('a1x2yz');
+   });
+
+   test('Debe retornar un string vacío si todos los strings están vacíos', () => {
+      expect(combine('', '', '')).toBe('');
+   });
+
+   test('De procesar strings de tamaño 1 correctamente', () => {
+      expect(combine('a', 'b', 'c')).toBe('abc');
+   });
+
+   test('Debe retornar el resultado correcto si cualquier string está vacío', () => {
+      expect(combine('abc', '', '')).toBe('abc');
+      expect(combine('', '123', '')).toBe('123');
+      expect(combine('', '', 'xyz')).toBe('xyz');
+   });
+});

M05 Fundamentos Javascript/ejercicios/03.js renamed to C5 Fundamentos Javascript/ejercicios/03.js

@@ -0,0 +1,21 @@
+const esPalindromo = require('../ejercicios/25');
+
+test("esPalindromo devuelve true para 'ana'", () => {
+   expect(esPalindromo('ana')).toBe(true);
+});
+
+test("esPalindromo devuelve true para 'reconocer'", () => {
+   expect(esPalindromo('reconocer')).toBe(true);
+});
+
+test("esPalindromo devuelve false para 'hola'", () => {
+   expect(esPalindromo('hola')).toBe(false);
+});
+
+test("esPalindromo devuelve false para 'javascript'", () => {
+   expect(esPalindromo('javascript')).toBe(false);
+});
+
+test("esPalindromo devuelve false para 'No subas, abusón'", () => {
+   expect(esPalindromo('No subas, abusón')).toBe(false);
+});

M05 Fundamentos Javascript/ejercicios/04.js renamed to C5 Fundamentos Javascript/ejercicios/04.js

@@ -0,0 +1,8 @@
+function encontrarElemento(num, array) {
+   // 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.
+   // Tu código:
+}
+
+module.exports = encontrarElemento;

M05 Fundamentos Javascript/ejercicios/05.js renamed to C5 Fundamentos Javascript/ejercicios/05.js

@@ -0,0 +1,7 @@
+function obtenerElementoAleatorio(array) {
+   // Devuelve un elemento aleatorio del arreglo array.
+   // PISTA: Usa el método Math.random().
+   // Tu código:
+}
+
+module.exports = obtenerElementoAleatorio;

M05 Fundamentos Javascript/ejercicios/06.js renamed to C5 Fundamentos Javascript/ejercicios/06.js

@@ -0,0 +1,6 @@
+const devolverPrimerElemento = require('../ejercicios/01');
+
+test('Debe retornar el primer elemento del arreglo', function () {
+   expect(devolverPrimerElemento([10, 10, 16, 12])).toBe(10);
+   expect(devolverPrimerElemento([97, 100, 80, 55, 72, 94])).toBe(97);
+});

M05 Fundamentos Javascript/ejercicios/07.js renamed to C5 Fundamentos Javascript/ejercicios/07.js

@@ -0,0 +1,30 @@
+const obtenerPrimerStringLargo = require('../ejercicios/10');
+
+describe('obtenerPrimerStringLargo', () => {
+   it('should return the first string with more than 5 characters', () => {
+      expect(
+         obtenerPrimerStringLargo(['hello', 'world', 'this', 'is', 'a', 'test'])
+      ).toBe('hello');
+      expect(
+         obtenerPrimerStringLargo([
+            'this',
+            'is',
+            'a',
+            'test',
+            'with',
+            'a',
+            'long',
+            'string',
+         ])
+      ).toBe('string');
+   });
+
+   it('should return undefined if no string with more than 5 characters is found', () => {
+      expect(
+         obtenerPrimerStringLargo(['hi', 'there', 'how', 'are', 'you'])
+      ).toBeUndefined();
+      expect(
+         obtenerPrimerStringLargo(['this', 'is', 'a', 'test'])
+      ).toBeUndefined();
+   });
+});

M05 Fundamentos Javascript/ejercicios/08.js renamed to C5 Fundamentos Javascript/ejercicios/08.js

@@ -0,0 +1,13 @@
+const duplicarElementos = require('../ejercicios/11.js');
+
+describe('duplicarElementos', () => {
+   it('should return an array with each element multiplied by 2', () => {
+      expect(duplicarElementos([1, 2, 3])).toEqual([2, 4, 6]);
+      expect(duplicarElementos([0, 4, 8])).toEqual([0, 8, 16]);
+      expect(duplicarElementos([-1, -2, -3])).toEqual([-2, -4, -6]);
+   });
+
+   it('should return an empty array if the input array is empty', () => {
+      expect(duplicarElementos([])).toEqual([]);
+   });
+});

M05 Fundamentos Javascript/ejercicios/09.js renamed to C5 Fundamentos Javascript/ejercicios/09.js

@@ -0,0 +1,25 @@
+const convertirStringAMayusculas = require('../ejercicios/12.js');
+
+test('convertirStringAMayusculas function exists', () => {
+   expect(convertirStringAMayusculas).toBeDefined();
+});
+
+test('convertirStringAMayusculas returns an array', () => {
+   const result = convertirStringAMayusculas(['hello', 'world']);
+   expect(Array.isArray(result)).toBeTruthy();
+});
+
+test('convertirStringAMayusculas converts strings to uppercase', () => {
+   const result = convertirStringAMayusculas(['hello', 'world']);
+   expect(result).toEqual(['HELLO', 'WORLD']);
+});
+
+test('convertirStringAMayusculas handles empty array', () => {
+   const result = convertirStringAMayusculas([]);
+   expect(result).toEqual([]);
+});
+
+test('convertirStringAMayusculas handles array with one element', () => {
+   const result = convertirStringAMayusculas(['hello']);
+   expect(result).toEqual(['HELLO']);
+});

M05 Fundamentos Javascript/ejercicios/10.js renamed to C5 Fundamentos Javascript/ejercicios/10.js

@@ -0,0 +1,19 @@
+const filtrarNumerosPares = require('../ejercicios/13');
+
+describe('filtrarNumerosPares', () => {
+   test('returns an empty array when given an empty array', () => {
+      expect(filtrarNumerosPares([])).toEqual([]);
+   });
+
+   test('returns an empty array when given an array of only odd numbers', () => {
+      expect(filtrarNumerosPares([1, 3, 5])).toEqual([]);
+   });
+
+   test('returns an array of only even numbers when given an array of only even numbers', () => {
+      expect(filtrarNumerosPares([2, 4, 6])).toEqual([2, 4, 6]);
+   });
+
+   test('returns an array of only even numbers when given an array of mixed numbers', () => {
+      expect(filtrarNumerosPares([1, 2, 3, 4, 5, 6])).toEqual([2, 4, 6]);
+   });
+});

M05 Fundamentos Javascript/ejercicios/11.js renamed to C5 Fundamentos Javascript/ejercicios/11.js

@@ -0,0 +1,12 @@
+const contarElementosMayoresA10 = require('../ejercicios/14');
+
+test('contarElementosMayoresA10 devuelve la cantidad correcta de elementos mayores a 10', () => {
+   expect(contarElementosMayoresA10([1, 2, 3, 4, 5])).toBe(0);
+   expect(contarElementosMayoresA10([10, 20, 30, 40, 50])).toBe(4);
+   expect(contarElementosMayoresA10([11, 12, 13, 14, 15])).toBe(5);
+   expect(contarElementosMayoresA10([-1, 0, 1, 2, 3])).toBe(0);
+});
+
+test('contarElementosMayoresA10 devuelve 0 para un array vacío', () => {
+   expect(contarElementosMayoresA10([])).toBe(0);
+});

M05 Fundamentos Javascript/ejercicios/12.js renamed to C5 Fundamentos Javascript/ejercicios/12.js

@@ -0,0 +1,18 @@
+const encontrarIndiceMayor = require('../ejercicios/15');
+
+test('encuentra el índice del número más grande en un array', () => {
+   expect(encontrarIndiceMayor([1, 2, 3, 4, 5])).toBe(4);
+   expect(encontrarIndiceMayor([5, 4, 3, 2, 1])).toBe(0);
+   expect(encontrarIndiceMayor([1, 3, 2, 5, 4])).toBe(3);
+   expect(encontrarIndiceMayor([-1, -2, -3, -4, -5])).toBe(0);
+   expect(encontrarIndiceMayor([-5, -4, -3, -2, -1])).toBe(4);
+   expect(encontrarIndiceMayor([-1, -3, -2, -5, -4])).toBe(0);
+});
+
+test('devuelve 0 para un array vacío', () => {
+   expect(encontrarIndiceMayor([])).toBe(0);
+});
+
+test('devuelve 0 para un array con un solo elemento', () => {
+   expect(encontrarIndiceMayor([42])).toBe(0);
+});