Brussels | ITP25 | Beatriz Oliveira | Sprint 3 | Reading List

Sprint-1/fix/median.js

@@ -6,9 +6,28 @@
 // or 'list' has mixed values (the function is expected to sort only numbers).
 
 function calculateMedian(list) {
-  const middleIndex = Math.floor(list.length / 2);
-  const median = list.splice(middleIndex, 1)[0];
-  return median;
+  // check if its array and if has content
+  if (!Array.isArray(list) || list.length === 0) return null;
+
+  // filter for valid numbers
+  const numbers = list.filter(
+    (item) => typeof item === "number" && !isNaN(item)
+  );
+
+  // if there's no numbers returns null
+  if (numbers.length === 0) return null;
+
+  // sort without modifying the original
+  const sorted = [...numbers].sort((a, b) => a - b);
+
+  // calculates median
+  const middle = Math.floor(sorted.length / 2);
+
+  if (sorted.length % 2 === 0) {
+    return (sorted[middle - 1] + sorted[middle]) / 2;
+  } else {
+    return sorted[middle];
+  }
 }
 
 module.exports = calculateMedian;

Sprint-1/fix/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "fix",
+  "version": "1.0.0",
+  "description": "",
+  "main": "median.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "test": "^3.3.0"
+  },
+  "devDependencies": {
+    "jest": "^30.2.0"
+  }
+}

Sprint-1/implement/dedupe.js

@@ -1 +1,27 @@
-function dedupe() {}
+function dedupe(arr) {
+    if (!Array.isArray(arr) || arr.length === 0){
+        return [];
+    }
+    const unique = [...new Set(arr)];
+    return unique;
+}
+
+console.log(dedupe([])); // []
+console.log(dedupe([1, 2, 3])); // [1, 2, 3]
+console.log(dedupe([1, 2, 2, 3, 1])); // [1, 2, 3]
+console.log(dedupe(["apple", "banana", "apple", "orange"])); // ["apple", "banana", "orange"]
+console.log(dedupe(["apple", 3, 5, 5, 9, 7, "banana", "orange", "orange"])); // ["apple", 3, 5, 9, 7, "banana", "orange"]
+
+/*Given an empty array
+When passed to the dedupe function
+Then it should return an empty array*/
+
+/*Given an array with no duplicates
+When passed to the dedupe function
+Then it should return a copy of the original array*/
+
+/*Given an array with strings or numbers
+When passed to the dedupe function
+Then it should remove the duplicate values, preserving the first occurence of each element*/
+
+module.exports = dedupe;

Sprint-1/implement/dedupe.test.js

@@ -1,4 +1,5 @@
 const dedupe = require("./dedupe.js");
+
 /*
 Dedupe Array
 
@@ -16,12 +17,21 @@ E.g. dedupe([1, 2, 1]) target output: [1, 2]
 // Given an empty array
 // When passed to the dedupe function
 // Then it should return an empty array
-test.todo("given an empty array, it returns an empty array");
+
+//test.todo("given an empty array, it returns an empty array");
+test("given an empty array, it returns an empty array", () => {
+    expect(dedupe([])).toEqual([]);
+})
 
 // Given an array with no duplicates
 // When passed to the dedupe function
 // Then it should return a copy of the original array
-
+test("given an array without duplicates, return the copy of original", () => {
+    expect(dedupe([1, 2, 5, 7, 9])).toEqual([1, 2, 5, 7, 9]);
+})
 // Given an array with strings or numbers
 // When passed to the dedupe function
-// Then it should remove the duplicate values, preserving the first occurence of each element
+// Then it should remove the duplicate values, preserving the first occurrence of each element
+test("given an array with strings or numbers, return the original without the repeated values", () => {
+    expect(dedupe(["apple", "apple", "pear", 2, 6, 6, 10, 11, 11, "banana"])).toEqual(["apple", "pear", 2, 6, 10, 11, "banana"]);
+})

Sprint-1/implement/max.js

@@ -1,4 +1,22 @@
 function findMax(elements) {
+    const onlyNumbers = elements.filter(x => typeof x === "number" && !isNaN(x));
+    // empty array
+    if ( onlyNumbers.length === 0){
+        return -Infinity;
+    // array with only one number
+    } if ( onlyNumbers.length === 1) {
+        return onlyNumbers[0];
+    } 
+    return Math.max(...onlyNumbers);
 }
 
+console.log(findMax(["banana", 3, 20, -5, "apple", 3.5]));
+console.log(findMax([10, -5, 20, -3]));        // 20 (mixed positive/negative)
+console.log(findMax([-10, -5, -3, -8]));       // -3 (all negative)
+console.log(findMax([1.5, 2.8, 1.2, 3.1]));    // 3.1 (decimals)
+console.log(findMax([233]));                    // 233 (single number)
+console.log(findMax([]));                       // -Infinity (empty array)
+console.log(findMax(["banana"]));               // -Infinity (no valid numbers)
+
+
 module.exports = findMax;

Sprint-1/implement/max.test.js

@@ -16,28 +16,49 @@ const findMax = require("./max.js");
 // When passed to the max function
 // Then it should return -Infinity
 // Delete this test.todo and replace it with a test.
-test.todo("given an empty array, returns -Infinity");
+// test.todo("given an empty array, returns -Infinity");
+test("given an empty array, returns -Infitiny", () => {
+    expect(findMax([])).toEqual(-Infinity);
+})
 
 // Given an array with one number
 // When passed to the max function
 // Then it should return that number
+test("given an array with one number, returns that number", () => {
+    expect(findMax([1])).toEqual(1);
+})
 
 // Given an array with both positive and negative numbers
 // When passed to the max function
 // Then it should return the largest number overall
+test("given an array with both positive and negative numbers, return the largest number overall", () => {
+    expect(findMax([-10, 3, 6, -1])).toEqual(6);
+})
 
 // Given an array with just negative numbers
 // When passed to the max function
 // Then it should return the closest one to zero
+test("given an array with just negative numbers, return the closest one to zero", () => {
+    expect(findMax([-10, -1, -4, -15])).toEqual(-1);
+})
 
 // Given an array with decimal numbers
 // When passed to the max function
 // Then it should return the largest decimal number
+test("given an array with decimal numbers, return the largest decimal number", () => {
+    expect(findMax([3.2, 4.9, 6.1, 2.9])).toEqual(6.1);
+})
 
 // Given an array with non-number values
 // When passed to the max function
 // Then it should return the max and ignore non-numeric values
+test("given an array with non-number values, return the max and ignore non-numeric values", () => {
+    expect(findMax(["banana", 20, 5, "apple"])).toEqual(20);
+})
 
 // Given an array with only non-number values
 // When passed to the max function
 // Then it should return the least surprising value given how it behaves for all other inputs
+test("given an array with only non-number values, return -Infinity", () => {
+    expect(findMax(["banana", "apple", "orange"])).toEqual(-Infinity);
+})

Sprint-1/implement/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "implement",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dedupe.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "jest": "^30.2.0"
+  }
+}

Sprint-1/implement/sum.js

@@ -1,4 +1,23 @@
 function sum(elements) {
+    // filter out only valid numbers from the input array
+    const onlyNumbers = elements.filter(x => typeof x === "number" && !isNaN(x));
+    // empty array
+    if ( onlyNumbers.length === 0) {
+        return 0;
+    // array with only one number
+    } if ( onlyNumbers.length === 1) {
+        return onlyNumbers[0];
+    } // take first element + sum of the rest untill it's just a number
+    return onlyNumbers[0] + sum(onlyNumbers.slice(1));
 }
 
+console.log(sum([-1, 5, 10, -1]));
+console.log(sum(["banana", -1, 5, 10, -1, "pear"]));
+console.log(sum([-1, -5, -10, -1]));
+console.log(sum([1, 5, 10, 1]));
+console.log(sum([]));
+console.log(sum([10]));
+console.log(sum(["banana"]));
+console.log(sum([-1, 5.9, 10.4, -1.2]));
+
 module.exports = sum;

Sprint-1/implement/sum.test.js

@@ -13,24 +13,40 @@ const sum = require("./sum.js");
 // Given an empty array
 // When passed to the sum function
 // Then it should return 0
-test.todo("given an empty array, returns 0")
-
+//test.todo("given an empty array, returns 0")
+test("given an empty array, return 0", () => {
+    expect(sum([])).toEqual(0);
+})
 // Given an array with just one number
 // When passed to the sum function
 // Then it should return that number
+test("given an array with just one number, return that number", () => {
+    expect(sum([5])).toEqual(5);
+})
 
 // Given an array containing negative numbers
 // When passed to the sum function
 // Then it should still return the correct total sum
-
+test("given an array containing negative numbers, return the correct total sum", () => {
+    expect(sum([5, -10])).toEqual(-5);
+})
 // Given an array with decimal/float numbers
 // When passed to the sum function
 // Then it should return the correct total sum
+test("given an array with decimal/float numbers, return the correct total sum", () => {
+    expect(sum([10.1, 10.2, 6.3])).toEqual(26.6);
+})
 
 // Given an array containing non-number values
 // When passed to the sum function
 // Then it should ignore the non-numerical values and return the sum of the numerical elements
+test("given an array containing non-number values, return the sum of numerical elements", () => {
+    expect(sum(["banana", 5, "apple", 10])).toEqual(15);
+})
 
 // Given an array with only non-number values
 // When passed to the sum function
 // Then it should return the least surprising value given how it behaves for all other inputs
+test("given an array with only non-number values, return lest surprising value, so 0", () => {
+    expect(sum(["banana", "apple"])).toEqual(0);
+})

Sprint-1/refactor/includes.js

@@ -1,13 +1,23 @@
 // Refactor the implementation of includes to use a for...of loop
 
 function includes(list, target) {
-  for (let index = 0; index < list.length; index++) {
-    const element = list[index];
+  for (const element of list) {
     if (element === target) {
       return true;
     }
   }
   return false;
 }
 
+console.log(includes([1, 10, 15, 20], 6));
 module.exports = includes;
+
+/*function includes(list, target) {
+  for (let index = 0; index < list.length; index++) {
+    const element = list[index];
+    if (element === target) {
+      return true;
+    }
+  }
+  return false;
+}*/

Sprint-1/refactor/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "refactor",
+  "version": "1.0.0",
+  "description": "",
+  "main": "includes.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "jest": "^30.2.0"
+  }
+}