London | 25-ITP-Sept | Samuel Tarawally | Sprint 1 | Exercises

.devcontainer/devcontainer.json

@@ -0,0 +1,31 @@
+// Docker rootless development container
+{
+    "name": "Code-Your-Future",
+    "image": "debian:latest",
+    "features": {
+        "ghcr.io/devcontainers/features/common-utils:2": {
+            "installZsh": true,
+            "upgradePackages": true
+        },
+        "ghcr.io/devcontainers/features/node:1": {
+            "version": "lts"
+        },
+        "ghcr.io/devcontainers/features/github-cli:1": {}
+    },
+    "customizations" : {
+        "vscode" : {
+            "settings": {
+                "terminal.integrated.defaultProfile.linux": "zsh"
+            },
+            "extensions": [
+                    "esbenp.prettier-vscode",
+                    "dbaeumer.vscode-eslint",
+                    "streetsidesoftware.code-spell-checker",
+                    "eamodio.gitlens",
+                    "ritwickdey.LiveServer",
+                    "vsliveshare.vsliveshare",
+                    "Orta.vscode-jest"
+            ]
+        }
+    }
+}

Sprint-1/fix/median.js

@@ -6,9 +6,35 @@
 // 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 the input is an array, if not return null
+  if (!Array.isArray(list)) {
+    return null;
+  }
+
+  // Filter the list to keep only numbers.
+  // `filter` creates a new array with only numeric values.
+  const numericList = list.filter((item) => typeof item === "number");
+
+  // If there are no numbers, return null.
+  if (numericList.length === 0) {
+    return null;
+  }
+
+  // Sort the numbers in ascending order.
+  // `sort` ensure numerical sorting, not alphabetical.
+  numericList.sort((a, b) => a - b);
+
+  const length = numericList.length;
+  const middleIndex = Math.floor(length / 2);
+
+  // Check if the list has an odd number of elements.
+  if (length % 2 !== 0) {
+    // If odd, return the middle element.
+    return numericList[middleIndex];
+  } else {
+    // If even, calculate the average of the two middle elements.
+    return (numericList[middleIndex - 1] + numericList[middleIndex]) / 2;
+  }
 }
 
 module.exports = calculateMedian;

Sprint-1/fix/median.test.js

@@ -13,7 +13,8 @@ describe("calculateMedian", () => {
     { input: [1, 2, 3, 4], expected: 2.5 },
     { input: [1, 2, 3, 4, 5, 6], expected: 3.5 },
   ].forEach(({ input, expected }) =>
-    it(`returns the median for [${input}]`, () => expect(calculateMedian(input)).toEqual(expected))
+    it(`returns the median for [${input}]`, () =>
+      expect(calculateMedian(input)).toEqual(expected))
   );
 
   [
@@ -24,7 +25,8 @@ describe("calculateMedian", () => {
     { input: [110, 20, 0], expected: 20 },
     { input: [6, -2, 2, 12, 14], expected: 6 },
   ].forEach(({ input, expected }) =>
-    it(`returns the correct median for unsorted array [${input}]`, () => expect(calculateMedian(input)).toEqual(expected))
+    it(`returns the correct median for unsorted array [${input}]`, () =>
+      expect(calculateMedian(input)).toEqual(expected))
   );
 
   it("doesn't modify the input array [3, 1, 2]", () => {
@@ -33,8 +35,17 @@ describe("calculateMedian", () => {
     expect(list).toEqual([3, 1, 2]);
   });
 
-  [ 'not an array', 123, null, undefined, {}, [], ["apple", null, undefined] ].forEach(val =>
-    it(`returns null for non-numeric array (${val})`, () => expect(calculateMedian(val)).toBe(null))
+  [
+    "not an array",
+    123,
+    null,
+    undefined,
+    {},
+    [],
+    ["apple", null, undefined],
+  ].forEach((val) =>
+    it(`returns null for non-numeric array (${val})`, () =>
+      expect(calculateMedian(val)).toBe(null))
   );
 
   [
@@ -45,6 +56,7 @@ describe("calculateMedian", () => {
     { input: [3, "apple", 1, null, 2, undefined, 4], expected: 2.5 },
     { input: ["banana", 5, 3, "apple", 1, 4, 2], expected: 3 },
   ].forEach(({ input, expected }) =>
-    it(`filters out non-numeric values and calculates the median for [${input}]`, () => expect(calculateMedian(input)).toEqual(expected))
+    it(`filters out non-numeric values and calculates the median for [${input}]`, () =>
+      expect(calculateMedian(input)).toEqual(expected))
   );
 });

Sprint-1/implement/dedupe.js

@@ -1 +1,21 @@
-function dedupe() {}
+function dedupe(arr) {
+  // Check if the input is an array; if not, throw a TypeError.
+  if (!Array.isArray(arr)) {
+    throw new TypeError("Input must be an array");
+  }
+
+  // If the array is empty, return an empty array.
+  if (arr.length === 0) {
+    return [];
+  }
+
+  // Use a Set to keep unique values.
+  // A Set is a collection of unique values, so duplicates are removed automatically.
+  const uniqueSet = new Set(arr);
+
+  // Change the Set back to an array.
+  // `Array.from` makes a new array of unique values, not the original array.
+  return Array.from(uniqueSet);
+}
+
+module.exports = dedupe;

Sprint-1/implement/dedupe.test.js

@@ -16,12 +16,24 @@ 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("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 with no duplicates, returns copy of original array", () => {
+  const input = [1, 2, 3, "d", "e", "f"];
+  const result = dedupe(input);
+  expect(result).toEqual(input);
+  expect(result).not.toBe(input); // Ensure it's a different array (a copy)
+});
 
 // 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
+test("given an array with duplicates, removes them preserving order", () => {
+  expect(dedupe(["a", "a", "a", "b", "b", "c"])).toEqual(["a", "b", "c"]);
+  expect(dedupe([5, 1, 1, 2, 3, 2, 5, 8])).toEqual([5, 1, 2, 3, 8]);
+});

Sprint-1/implement/max.js

@@ -1,4 +1,25 @@
 function findMax(elements) {
+  // Check if the input is an array; if not, throw a TypeError.
+  if (!Array.isArray(elements)) {
+    throw new TypeError("Input must be an array");
+  }
+
+  // If the array is empty, return return -Infinity.
+  if (elements.length === 0) {
+    return -Infinity;
+  }
+
+  // Filter the array to keep only numbers
+  const numbers = elements.filter((item) => typeof item === "number");
+
+  // If there are no numbers in the array, return -Infinity
+  if (numbers.length === 0) {
+    return -Infinity;
+  }
+
+  // Use Math.max with the spread operator to find the maximum number
+  // This is an efficient way to find the largest value in an array
+  return Math.max(...numbers);
 }
 
 module.exports = findMax;

Sprint-1/implement/max.test.js

@@ -16,28 +16,50 @@ 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("given an empty array, returns -Infinity", () => {
+  expect(findMax([])).toBe(-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([10])).toBe(10);
+});
 
 // 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 positive and negative numbers, returns the largest number", () => {
+  expect(findMax([10, -5, 20, -10])).toBe(20);
+});
 
 // 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, returns the closest to zero", () => {
+  expect(findMax([-10, -5, -20])).toBe(-5);
+});
 
 // 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, returns the largest decimal", () => {
+  expect(findMax([10.5, 207.1145, 99.9])).toBe(207.1145);
+});
 
 // 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, ignores them and returns max", () => {
+  expect(findMax(["yo", 10, "sup", 60, 10])).toBe(60);
+});
 
 // 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, returns -Infinity", () => {
+  expect(
+    findMax(["a", "b", "c", "null", "undefined", "true", "false", ""])
+  ).toBe(-Infinity);
+});

Sprint-1/implement/sum.js

@@ -1,4 +1,24 @@
 function sum(elements) {
+  // Check if the input is an array; if not, throw a TypeError.
+  if (!Array.isArray(elements)) {
+    throw new TypeError("Input must be an array");
+  }
+
+  // If the array is empty, return 0.
+  if (elements.length === 0) {
+    return 0;
+  }
+
+  // Filter the array to keep only numbers
+  const numbers = elements.filter((item) => typeof item === "number");
+
+  // Calculate the sum of the numbers using a for loop
+  let total = 0;
+
+  for (const item of numbers) {
+    total += item;
+  }
+  return total;
 }
 
 module.exports = sum;

Sprint-1/implement/sum.test.js

@@ -13,24 +13,41 @@ 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("given an empty array, returns 0", () => {
+  expect(sum([])).toBe(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 one number, returns that number", () => {
+  expect(sum([10])).toBe(10);
+});
 
 // 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, returns correct sum", () => {
+  expect(sum([10, -5, 20])).toBe(25);
+});
 
 // 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 numbers, returns correct sum", () => {
+  expect(sum([10.5, 20.5])).toBe(31);
+});
 
 // 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 with non-number values, ignores them and returns sum", () => {
+  expect(sum(["yo", 10, "sup", 60, 10, ":)"])).toBe(80);
+});
 
 // 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, returns 0", () => {
+  expect(sum(["a", "b", "c","``","//","", null])).toBe(0);
+});

Sprint-1/refactor/includes.js

@@ -1,12 +1,14 @@
 // 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) {
+    // Check if the current element matches the target
     if (element === target) {
       return true;
     }
   }
+
+  // Return false if the target is not found in the list
   return false;
 }