diff --git a/src/functions-and-arrays.js b/src/functions-and-arrays.js
index 3a7dbec41..e28084ba3 100644
--- a/src/functions-and-arrays.js
+++ b/src/functions-and-arrays.js
@@ -1,119 +1,230 @@
 // Iteration #1: Find the maximum
-function maxOfTwoNumbers() {}
 
+function maxOfTwoNumbers(num1, num2) {
+  if (num1 > num2) {
+    return num1;
+  } else if (num2 > num1) {
+    return num2;
+  } else {
+    return num1;
+  }
+}
 
+let resultado1 = maxOfTwoNumbers(10, 20);
+console.log(resultado1);
 
-// Iteration #2: Find longest word
-const words = ['mystery', 'brother', 'aviator', 'crocodile', 'pearl', 'orchard', 'crackpot'];
+let resultado2 = maxOfTwoNumbers(20, 10);
+console.log(resultado2);
 
-function findLongestWord() {}
+let resultado3 = maxOfTwoNumbers(20, 20);
+console.log(resultado3);
+
+// Iteration #2: Find longest word
+const words = [
+  "mystery",
+  "brother",
+  "aviator",
+  "crocodile",
+  "pearl",
+  "orchard",
+  "crackpot",
+];
 
+function findLongestWord(words) {
+  // La condición de null tiene que estar fuera del bucle
+  // Esta condición es una medida de seguridad. El array no debería estar vacío, pero a veces puede suceder un fallo en algún lado y que haya un array vacío sin querer. Esta línea es un bloqueo para evitar que haya un error, una forma de prevenir fallos.
+  // (words): longitud del array; (words[i]): longitud de la palabra
+  if (words.length === 0) {
+    return null;
+  }
+  let longestWord = "";
+
+  // Empieza el bucle para ver la longitud de cada palabra de la lista
+  for (let i = 0; i < words.length; i++) {
+    // Si la palabra de esta vuelta (words[i].length) es MÁS LARGA que que la variable longestWord, actualizamos longestWord (i)
+    if (words[i].length > longestWord.length) {
+      longestWord = words[i];
+    }
+  }
+
+  return longestWord;
+}
 
+console.log(findLongestWord(words));
 
 // Iteration #3: Calculate the sum
 const numbers = [6, 12, 1, 18, 13, 16, 2, 1, 8, 10];
+function sumNumbers(numbers) {
+  return numbers.reduce(
+    (accumulator, currentValue) => accumulator + currentValue,
+    0
+  );
+}
 
-function sumNumbers() {}
-
-
-
-// Iteration #3.1 Bonus:
-function sum() {}
-
-
+console.log(sumNumbers(numbers));
 
 // Iteration #4: Calculate the average
 // Level 1: Array of numbers
 const numbersAvg = [2, 6, 9, 10, 7, 4, 1, 9];
 
-function averageNumbers() {}
-
+// 1º: se suman los elementos del array
+function sumNumbers(numbersAvg) {
+  return numbersAvg.reduce(
+    (accumulator, currentValue) => accumulator + currentValue,
+    0
+  );
+}
+console.log(sumNumbers(numbersAvg));
+
+// 2º: se divide la suma entre el número de elementos del array
+function averageNumbers(numbersAvg) {
+  if (numbersAvg.length === 0) {
+    return null;
+  }
+  const sum = sumNumbers(numbersAvg);
+  const average = sum / numbersAvg.length;
+  return average;
+}
+console.log(averageNumbers(numbersAvg));
 
 // Level 2: Array of strings
-const wordsArr = ['seat', 'correspond', 'linen', 'motif', 'hole', 'smell', 'smart', 'chaos', 'fuel', 'palace'];
+const wordsArr = [
+  "seat",
+  "correspond",
+  "linen",
+  "motif",
+  "hole",
+  "smell",
+  "smart",
+  "chaos",
+  "fuel",
+  "palace",
+];
+
+function averageWordLength(wordsArr) {
+  if (wordsArr.length === 0) {
+    return null;
+  }
 
-function averageWordLength() { }
+  // Aquí estamos sumando las longitudes de las palabras
+  const totalLength = wordsArr.reduce(
+    (accumulator, currentValue) => accumulator + currentValue.length,
+    0
+  );
+
+  // Aquí se calcula el average dividiendo la suma total de las longitudes de las palabras (totalLength) entre el nº de palabras (wordsArr.length)
+  return totalLength / wordsArr.length;
+}
 
-// Bonus - Iteration #4.1
-function avg() {}
+console.log(averageWordLength(wordsArr));
 
 // Iteration #5: Unique arrays
 const wordsUnique = [
-  'crab',
-  'poison',
-  'contagious',
-  'simple',
-  'bring',
-  'sharp',
-  'playground',
-  'poison',
-  'communion',
-  'simple',
-  'bring'
+  "crab",
+  "poison",
+  "contagious",
+  "simple",
+  "bring",
+  "sharp",
+  "playground",
+  "poison",
+  "communion",
+  "simple",
+  "bring",
 ];
 
-function uniquifyArray() {}
-
+function uniquifyArray(arr) {
+  if (arr.length === 0) {
+    return null;
+  }
+
+  // Se crea un array vacío para almacenar los valores únicos
+  let uniqueArr = [];
+
+  // Con el bucle, vamos por cada elemento del array (arr). Para cada elemento, se verifica si ya existe en el array de valores únicos (uniqueArr) utilizando includes(). Si no existe, se añade con push()
+  for (let i = 0; i < arr.length; i++) {
+    if (!uniqueArr.includes(arr[i])) {
+      uniqueArr.push(arr[i]);
+    }
+  }
+  return uniqueArr;
+}
+console.log(uniquifyArray(wordsUnique));
 
+//Otra forma: [...new] significa nuevo, crea un nuevo array. Para una copia de algo que ya existe: [Set(arr)], apunta al array que ya existe.
+//return [...new Set(arr)];
+//console.log(uniquifyArray(wordsUnique));
 
 // Iteration #6: Find elements
-const wordsFind = ['machine', 'subset', 'trouble', 'starting', 'matter', 'eating', 'truth', 'disobedience'];
-
-function doesWordExist() {}
+const wordsFind = [
+  "machine",
+  "subset",
+  "trouble",
+  "starting",
+  "matter",
+  "eating",
+  "truth",
+  "disobedience",
+];
 
+// 2 argumentos en la función: el array y la palabra que se busca en el array
+function doesWordExist(arr, word) {
+  if (!word) {
+    return null;
+  }
+  // Miramos si la palabra existe (=está incluida) en el array
+  return arr.includes(word);
+}
 
+console.log(doesWordExist(wordsFind, "matter"));
+console.log(doesWordExist(wordsFind, "flower"));
 
 // Iteration #7: Count repetition
 const wordsCount = [
-  'machine',
-  'matter',
-  'subset',
-  'trouble',
-  'starting',
-  'matter',
-  'eating',
-  'matter',
-  'truth',
-  'disobedience',
-  'matter'
-];
-
-function howManyTimes() {}
-
-
-
-// Iteration #8: Bonus
-const matrix = [
-  [8, 2, 22, 97, 38, 15, 0, 40, 0, 75, 4, 5, 7, 78, 52, 12, 50, 77, 91, 8],
-  [49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48, 4, 56, 62, 0],
-  [81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30, 3, 49, 13, 36, 65],
-  [52, 70, 95, 23, 4, 60, 11, 42, 69, 24, 68, 56, 1, 32, 56, 71, 37, 2, 36, 91],
-  [22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80],
-  [24, 47, 32, 60, 99, 3, 45, 2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50],
-  [32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70],
-  [67, 26, 20, 68, 2, 62, 12, 20, 95, 63, 94, 39, 63, 8, 40, 91, 66, 49, 94, 21],
-  [24, 55, 58, 5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72],
-  [21, 36, 23, 9, 75, 0, 76, 44, 20, 45, 35, 14, 0, 61, 33, 97, 34, 31, 33, 95],
-  [78, 17, 53, 28, 22, 75, 31, 67, 15, 94, 3, 80, 4, 62, 16, 14, 9, 53, 56, 92],
-  [16, 39, 5, 42, 96, 35, 31, 47, 55, 58, 88, 24, 0, 17, 54, 24, 36, 29, 85, 57],
-  [86, 56, 0, 48, 35, 71, 89, 7, 5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58],
-  [19, 80, 81, 68, 5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77, 4, 89, 55, 40],
-  [4, 52, 8, 83, 97, 35, 99, 16, 7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66],
-  [88, 36, 68, 87, 57, 62, 20, 72, 3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69],
-  [4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 8, 46, 29, 32, 40, 62, 76, 36],
-  [20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74, 4, 36, 16],
-  [20, 73, 35, 29, 78, 31, 90, 1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57, 5, 54],
-  [1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52, 1, 89, 19, 67, 48]
+  "machine",
+  "matter",
+  "subset",
+  "trouble",
+  "starting",
+  "matter",
+  "eating",
+  "matter",
+  "truth",
+  "disobedience",
+  "matter",
 ];
 
-function greatestProduct() {}
-
-
+// Devolver 0 si el array está vacío
+function howManyTimes(repeatArr, searchWord) {
+  if (repeatArr.length === 0) {
+    return 0;
+  }
+
+  // Si la palabra coincide con searchWord, el contador sube
+  let count = 0;
+  repeatArr.forEach((word) => {
+    if (word === searchWord) {
+      count++;
+    }
+  });
+
+  if (count === 0) {
+    return 0; // Devuelve 0 si la palabra no está en el array
+  } else if (count === 1) {
+    return 1; // Devuelve 1 si la palabra está solo una vez en el array
+  } else if (count === 5) {
+    return 5; // Devuelve 5 si la palabra está 5 veces en el array
+  }
+
+  return count;
+}
 
+console.log(howManyTimes(wordsCount, "matter"));
+console.log(howManyTimes(wordsCount, "flower"));
 
 // The following is required to make unit tests work.
 /* Environment setup. Do not modify the below code. */
-if (typeof module !== 'undefined') {
+if (typeof module !== "undefined") {
   module.exports = {
     maxOfTwoNumbers,
     findLongestWord,
@@ -125,6 +236,6 @@ if (typeof module !== 'undefined') {
     uniquifyArray,
     doesWordExist,
     howManyTimes,
-    greatestProduct
+    greatestProduct,
   };
 }