From 53fa90f23e51a0aecf94e5be7db577997e87a7b6 Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Sat, 7 Mar 2026 14:25:25 +0200
Subject: [PATCH 01/18] implement correct median calculation

---
 Sprint-1/fix/median.js | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/Sprint-1/fix/median.js b/Sprint-1/fix/median.js
index b22590bc6..f7d2fd653 100644
--- a/Sprint-1/fix/median.js
+++ b/Sprint-1/fix/median.js
@@ -6,9 +6,21 @@
 // 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;
+  // Filter out non-numeric values and sort the remaining numbers
+  const numbers = list
+    .filter((x) => typeof x === "number" && !isNaN(x))
+    .sort((a, b) => a - b);
+
+  if (numbers.length === 0) {
+    return null;
+  }
+
+  const mid = Math.floor(numbers.length / 2);
+  if (numbers.length % 2 === 0) {
+    return (numbers[mid - 1] + numbers[mid]) / 2;
+  } else {
+    return numbers[mid];
+  }
 }
 
 module.exports = calculateMedian;

From 86132f97ce780c0dd5392eba06e3a94fdab469af Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Thu, 26 Mar 2026 10:58:09 +0200
Subject: [PATCH 02/18] Co-authored-by: Isaac Abodunrin
 <bytesandroses@users.noreply.github.com>fix: correct calculateMedian
 implementation and handle non-array inputs

---
 Sprint-1/fix/median.js     | 6 +++++-
 Sprint-1/package-lock.json | 2 ++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/Sprint-1/fix/median.js b/Sprint-1/fix/median.js
index f7d2fd653..e2c4d80c0 100644
--- a/Sprint-1/fix/median.js
+++ b/Sprint-1/fix/median.js
@@ -6,7 +6,10 @@
 // or 'list' has mixed values (the function is expected to sort only numbers).
 
 function calculateMedian(list) {
-  // Filter out non-numeric values and sort the remaining numbers
+  if (!Array.isArray(list)) {
+    return null;
+  }
+
   const numbers = list
     .filter((x) => typeof x === "number" && !isNaN(x))
     .sort((a, b) => a - b);
@@ -16,6 +19,7 @@ function calculateMedian(list) {
   }
 
   const mid = Math.floor(numbers.length / 2);
+
   if (numbers.length % 2 === 0) {
     return (numbers[mid - 1] + numbers[mid]) / 2;
   } else {
diff --git a/Sprint-1/package-lock.json b/Sprint-1/package-lock.json
index 83e427d0b..b52480af5 100644
--- a/Sprint-1/package-lock.json
+++ b/Sprint-1/package-lock.json
@@ -56,6 +56,7 @@
       "integrity": "sha512-Oixnb+DzmRT30qu9d3tJSQkxuygWm32DFykT4bRoORPa9hZ/L4KhVB/XiRm6KG+roIEM7DBQlmg27kw2HZkdZg==",
       "dev": true,
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "@ampproject/remapping": "^2.2.0",
         "@babel/code-frame": "^7.25.7",
@@ -1368,6 +1369,7 @@
         }
       ],
       "license": "MIT",
+      "peer": true,
       "dependencies": {
         "caniuse-lite": "^1.0.30001663",
         "electron-to-chromium": "^1.5.28",

From 33ec99a65907feeeba7fdd9c0df0ca902a5a633e Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Thu, 26 Mar 2026 11:09:20 +0200
Subject: [PATCH 03/18] implement dedupe function to remove duplicates from
 array

---
 Sprint-1/implement/dedupe.js | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/Sprint-1/implement/dedupe.js b/Sprint-1/implement/dedupe.js
index 781e8718a..311c23877 100644
--- a/Sprint-1/implement/dedupe.js
+++ b/Sprint-1/implement/dedupe.js
@@ -1 +1,6 @@
-function dedupe() {}
+function dedupe(list) {
+  if (!Array.isArray(list)) {
+    return null;
+  }
+  return list.filter((value, index, self) => self.indexOf(value) === index);
+}

From 4bf67023217b796bd49cde708f618605dc27a519 Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Thu, 26 Mar 2026 11:29:26 +0200
Subject: [PATCH 04/18] git commit -m implement dedupe function and add
 comprehensive tests"

---
 Sprint-1/implement/dedupe.test.js | 20 +++++++++++++++++++-
 1 file changed, 19 insertions(+), 1 deletion(-)

diff --git a/Sprint-1/implement/dedupe.test.js b/Sprint-1/implement/dedupe.test.js
index 23e0f8638..5b80ef48d 100644
--- a/Sprint-1/implement/dedupe.test.js
+++ b/Sprint-1/implement/dedupe.test.js
@@ -16,12 +16,30 @@ 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, when passed to the dedupe function, then it should return an empty array", () => {
+  expect(dedupe([])).toEqual([]);
+});
+
+// Given a non-array value
+// When passed to the dedupe function
+// Then it should return null
+test("Given a non-array value, when passed to the dedupe function, then it should return null", () => {
+  expect(dedupe("not an array")).toBeNull();
+  expect(dedupe(123)).toBeNull();
+  expect(dedupe({})).toBeNull();
+});
 
 // 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, when passed to the dedupe function, then it should return a copy of the original array", () => {
+  expect(dedupe(["a", "b", "c"])).toEqual(["a", "b", "c"]);
+});
 
 // 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 strings or numbers, when passed to the dedupe function, then it should remove the duplicate values, preserving the first occurrence of each element", () => {
+  expect(dedupe(["a", "a", "b", "c", "c"])).toEqual(["a", "b", "c"]);
+  expect(dedupe([1, 2, 2, 3, 4, 4])).toEqual([1, 2, 3, 4]);
+});

From 5db3aac68705cf1d442e8bf2419d3954901c1554 Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Thu, 26 Mar 2026 13:04:36 +0200
Subject: [PATCH 05/18] git commit -m  implement max, sum, and dedupe functions
 with passing tests"

---
 Sprint-1/implement/dedupe.js |  1 +
 Sprint-1/implement/max.js    | 13 +++++++++++++
 2 files changed, 14 insertions(+)

diff --git a/Sprint-1/implement/dedupe.js b/Sprint-1/implement/dedupe.js
index 311c23877..0e45e5c8e 100644
--- a/Sprint-1/implement/dedupe.js
+++ b/Sprint-1/implement/dedupe.js
@@ -4,3 +4,4 @@ function dedupe(list) {
   }
   return list.filter((value, index, self) => self.indexOf(value) === index);
 }
+module.exports = dedupe;
diff --git a/Sprint-1/implement/max.js b/Sprint-1/implement/max.js
index 6dd76378e..1772e7b40 100644
--- a/Sprint-1/implement/max.js
+++ b/Sprint-1/implement/max.js
@@ -1,4 +1,17 @@
 function findMax(elements) {
+  if (!Array.isArray(elements) || elements.length === 0) {
+    return null;
+  }
+
+  let max = elements[0];
+
+  for (let i = 1; i < elements.length; i++) {
+    if (elements[i] > max) {
+      max = elements[i];
+    }
+  }
+
+  return max;
 }
 
 module.exports = findMax;

From fc16e68811baf5f49f41a7e68d62c3d6cc74cfc6 Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Thu, 26 Mar 2026 13:15:31 +0200
Subject: [PATCH 06/18] git commit -m implement findMax with support for mixed
 data and edge cases

---
 Sprint-1/implement/max.js      | 14 +++++++++-----
 Sprint-1/implement/max.test.js | 22 +++++++++++++++++++++-
 2 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/Sprint-1/implement/max.js b/Sprint-1/implement/max.js
index 1772e7b40..57dee4357 100644
--- a/Sprint-1/implement/max.js
+++ b/Sprint-1/implement/max.js
@@ -3,14 +3,18 @@ function findMax(elements) {
     return null;
   }
 
-  let max = elements[0];
+  let max = -Infinity;
 
-  for (let i = 1; i < elements.length; i++) {
-    if (elements[i] > max) {
-      max = elements[i];
+  for (let i = 0; i < elements.length; i++) {
+    if (typeof elements[i] === "number" && !isNaN(elements[i])) {
+      if (elements[i] > max) {
+        max = elements[i];
+      }
     }
   }
-
+  if (max === -Infinity) {
+    return null;
+  }
   return max;
 }
 
diff --git a/Sprint-1/implement/max.test.js b/Sprint-1/implement/max.test.js
index 82f18fd88..8f06e962f 100644
--- a/Sprint-1/implement/max.test.js
+++ b/Sprint-1/implement/max.test.js
@@ -16,28 +16,48 @@ 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, when passed to the max function, then it should return null", () => {
+  expect(findMax([])).toBeNull();
+});
 
 // 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, when passed to the max function, then it should return that number", () => {
+  expect(findMax([42])).toBe(42);
+});
 
 // 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, when passed to the max function, then it should return the largest number overall", () => {
+  expect(findMax([-10, -5, 0, 5, 10])).toBe(10);
+});
 
 // 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, when passed to the max function, then it should return the closest one to zero", () => {
+  expect(findMax([-10, -5, -1])).toBe(-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, when passed to the max function, then it should return the largest decimal number", () => {
+  expect(findMax([1.5, 2.3, 0.8, 3.1])).toBe(3.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, when passed to the max function, then it should return the max and ignore non-numeric values", () => {
+  expect(findMax(["hey", 10, "hi", 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, when passed to the max function, then it should return null", () => {
+  expect(findMax(["hey", "hi", "hello"])).toBeNull();
+});

From 0e7b9da9aaf09b6936964cf2240670bb2962eb49 Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Thu, 26 Mar 2026 13:23:22 +0200
Subject: [PATCH 07/18] implemented sum function with support for mixed data

---
 Sprint-1/implement/sum.js | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/Sprint-1/implement/sum.js b/Sprint-1/implement/sum.js
index 9062aafe3..9c5b95cff 100644
--- a/Sprint-1/implement/sum.js
+++ b/Sprint-1/implement/sum.js
@@ -1,4 +1,14 @@
 function sum(elements) {
+  if (!Array.isArray(elements)) {
+    return null;
+  }
+  let total = 0;
+  for (let i = 0; i < elements.length; i++) {
+    if (typeof elements[i] === "number" && !isNaN(elements[i])) {
+      total += elements[i];
+    }
+  }
+  return total;
 }
 
 module.exports = sum;

From d4e734a18676c7e28fa656dbd90770e3701f4f03 Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Thu, 26 Mar 2026 13:31:10 +0200
Subject: [PATCH 08/18]  resolve precision bug in sum

---
 Sprint-1/implement/sum.js      |  2 +-
 Sprint-1/implement/sum.test.js | 28 +++++++++++++++++++++++++++-
 2 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/Sprint-1/implement/sum.js b/Sprint-1/implement/sum.js
index 9c5b95cff..749413e13 100644
--- a/Sprint-1/implement/sum.js
+++ b/Sprint-1/implement/sum.js
@@ -8,7 +8,7 @@ function sum(elements) {
       total += elements[i];
     }
   }
-  return total;
+  return Number(total.toFixed(10));
 }
 
 module.exports = sum;
diff --git a/Sprint-1/implement/sum.test.js b/Sprint-1/implement/sum.test.js
index dd0a090ca..32215fff3 100644
--- a/Sprint-1/implement/sum.test.js
+++ b/Sprint-1/implement/sum.test.js
@@ -13,24 +13,50 @@ 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, when passed to the sum function, then it should return 0", () => {
+  expect(sum([])).toBe(0);
+});
+
+// Given a non-array value
+// When passed to the sum function
+// Then it should return null
+test("Given a non-array value, when passed to the sum function, then it should return null", () => {
+  expect(sum("not an array")).toBeNull();
+  expect(sum(123)).toBeNull();
+  expect(sum({})).toBeNull();
+});
 
 // 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, when passed to the sum function, then it should return that number", () => {
+  expect(sum([42])).toBe(42);
+});
 
 // 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, when passed to the sum function, then it should still return the correct total sum", () => {
+  expect(sum([-10, -20, -30])).toBe(-60);
+});
 
 // 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, when passed to the sum function, then it should return the correct total sum", () => {
+  expect(sum([1.5, 2.3, 0.8, 3.1])).toBe(7.7);
+});
 
 // 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, when passed to the sum function, then it should ignore the non-numerical values and return the sum of the numerical elements", () => {
+  expect(sum(["hey", 10, "hi", 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, when passed to the sum function, then it should return 0", () => {
+  expect(sum(["hey", "hi", "hello"])).toBe(0);
+});

From 459eb79ed5cd15d78bb92a9f9c0b5012cf1bbf0c Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Thu, 26 Mar 2026 13:35:45 +0200
Subject: [PATCH 09/18] update includes to use for...of loop

---
 Sprint-1/refactor/includes.js | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/Sprint-1/refactor/includes.js b/Sprint-1/refactor/includes.js
index 29dad81f0..8c9ae2e66 100644
--- a/Sprint-1/refactor/includes.js
+++ b/Sprint-1/refactor/includes.js
@@ -1,8 +1,7 @@
 // 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;
     }

From 0a5f5cc9a84a9cb47bc8cc4b31b1fd801918de6f Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Thu, 26 Mar 2026 14:28:36 +0200
Subject: [PATCH 10/18] fixed a wrong spelling

---
 Sprint-1/implement/dedupe.test.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Sprint-1/implement/dedupe.test.js b/Sprint-1/implement/dedupe.test.js
index 5b80ef48d..76ec9d6f1 100644
--- a/Sprint-1/implement/dedupe.test.js
+++ b/Sprint-1/implement/dedupe.test.js
@@ -38,7 +38,7 @@ test("Given an array with no duplicates, when passed to the dedupe function, the
 
 // 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, when passed to the dedupe function, then it should remove the duplicate values, preserving the first occurrence of each element", () => {
   expect(dedupe(["a", "a", "b", "c", "c"])).toEqual(["a", "b", "c"]);
   expect(dedupe([1, 2, 2, 3, 4, 4])).toEqual([1, 2, 3, 4]);

From 5514777eae5e07d630f8b617c4a7f04e3079263b Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Fri, 27 Mar 2026 13:15:36 +0200
Subject: [PATCH 11/18] Co-authored-by: Isaac Abodunrin
 <bytesandroses@users.noreply.github.com>Add reference check to ensure dedupe
 returns a copy of the array

---
 Sprint-1/implement/dedupe.test.js | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/Sprint-1/implement/dedupe.test.js b/Sprint-1/implement/dedupe.test.js
index 7810e62f5..798c1f1cc 100644
--- a/Sprint-1/implement/dedupe.test.js
+++ b/Sprint-1/implement/dedupe.test.js
@@ -33,7 +33,10 @@ test("Given a non-array value, when passed to the dedupe function, then it shoul
 // When passed to the dedupe function
 // Then it should return a copy of the original array
 test("Given an array with no duplicates, when passed to the dedupe function, then it should return a copy of the original array", () => {
-  expect(dedupe(["a", "b", "c"])).toEqual(["a", "b", "c"]);
+  const input = ["a", "b", "c"];
+  const result = dedupe(input);
+  expect(result).toEqual(input);
+  expect(result).not.toBe(input);
 });
 
 // Given an array of strings or numbers
@@ -43,4 +46,3 @@ test("Given an array with strings or numbers, when passed to the dedupe function
   expect(dedupe(["a", "a", "b", "c", "c"])).toEqual(["a", "b", "c"]);
   expect(dedupe([1, 2, 2, 3, 4, 4])).toEqual([1, 2, 3, 4]);
 });
-

From eb1b8f2dd207f680d04b1043ea46b7491120882b Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Fri, 27 Mar 2026 23:24:20 +0200
Subject: [PATCH 12/18] Ensure dedupe returns a new array reference

---
 Sprint-1/implement/dedupe.test.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Sprint-1/implement/dedupe.test.js b/Sprint-1/implement/dedupe.test.js
index 798c1f1cc..0eee99668 100644
--- a/Sprint-1/implement/dedupe.test.js
+++ b/Sprint-1/implement/dedupe.test.js
@@ -35,6 +35,7 @@ test("Given a non-array value, when passed to the dedupe function, then it shoul
 test("Given an array with no duplicates, when passed to the dedupe function, then it should return a copy of the original array", () => {
   const input = ["a", "b", "c"];
   const result = dedupe(input);
+
   expect(result).toEqual(input);
   expect(result).not.toBe(input);
 });

From d0ec9a3d2960bd22772b73553e81eb9a732a76ab Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Fri, 27 Mar 2026 23:32:12 +0200
Subject: [PATCH 13/18] Return -Infinity for empty array to match spec

---
 Sprint-1/implement/max.js | 19 +++++--------------
 1 file changed, 5 insertions(+), 14 deletions(-)

diff --git a/Sprint-1/implement/max.js b/Sprint-1/implement/max.js
index 57dee4357..726aedac6 100644
--- a/Sprint-1/implement/max.js
+++ b/Sprint-1/implement/max.js
@@ -1,21 +1,12 @@
-function findMax(elements) {
-  if (!Array.isArray(elements) || elements.length === 0) {
-    return null;
-  }
-
+function max(numbers) {
   let max = -Infinity;
 
-  for (let i = 0; i < elements.length; i++) {
-    if (typeof elements[i] === "number" && !isNaN(elements[i])) {
-      if (elements[i] > max) {
-        max = elements[i];
-      }
+  for (let num of numbers) {
+    if (num > max) {
+      max = num;
     }
   }
-  if (max === -Infinity) {
-    return null;
-  }
   return max;
 }
 
-module.exports = findMax;
+module.exports = max;

From 90c1ff91c41ba5d6e5ef766f031b27f52d66f70c Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Fri, 27 Mar 2026 23:45:34 +0200
Subject: [PATCH 14/18] Fix expected values and remove duplicate tests

---
 Sprint-1/implement/max.test.js | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/Sprint-1/implement/max.test.js b/Sprint-1/implement/max.test.js
index 8f06e962f..17cea71e3 100644
--- a/Sprint-1/implement/max.test.js
+++ b/Sprint-1/implement/max.test.js
@@ -16,8 +16,8 @@ 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("Given an empty array, when passed to the max function, then it should return null", () => {
-  expect(findMax([])).toBeNull();
+test("Given an empty array, when passed to the max function, then it should return -Infinity", () => {
+  expect(findMax([])).toBe(-Infinity);
 });
 
 // Given an array with one number
@@ -58,6 +58,13 @@ test("Given an array with non-number values, when passed to the max function, th
 // 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, when passed to the max function, then it should return null", () => {
-  expect(findMax(["hey", "hi", "hello"])).toBeNull();
+test("Given an array with only non-number values, when passed to the max function, then it should return -Infinity", () => {
+  expect(findMax(["hey", "hi", "hello"])).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, when passed to the max function, then it should return that number", () => {
+  expect(findMax([42])).toBe(42);
 });

From 6aa82cfe363a26d3588f9b58349526dac89ce156 Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Fri, 27 Mar 2026 23:56:17 +0200
Subject: [PATCH 15/18] Ignore non-number values when calculating maximum

---
 Sprint-1/implement/max.js      | 2 +-
 Sprint-1/implement/max.test.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Sprint-1/implement/max.js b/Sprint-1/implement/max.js
index 726aedac6..f401bcfc2 100644
--- a/Sprint-1/implement/max.js
+++ b/Sprint-1/implement/max.js
@@ -2,7 +2,7 @@ function max(numbers) {
   let max = -Infinity;
 
   for (let num of numbers) {
-    if (num > max) {
+    if (typeof num === "number" && num > max) {
       max = num;
     }
   }
diff --git a/Sprint-1/implement/max.test.js b/Sprint-1/implement/max.test.js
index 17cea71e3..a4566fb55 100644
--- a/Sprint-1/implement/max.test.js
+++ b/Sprint-1/implement/max.test.js
@@ -52,7 +52,7 @@ test("Given an array with decimal numbers, when passed to the max function, then
 // 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, when passed to the max function, then it should return the max and ignore non-numeric values", () => {
-  expect(findMax(["hey", 10, "hi", 60, 10])).toBe(60);
+  expect(findMax(["hey", 10, "300", "hi", 60, 10])).toBe(60);
 });
 
 // Given an array with only non-number values

From afa2fdb635613dc172e88aef36c895be3fdf166d Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Sat, 28 Mar 2026 00:03:09 +0200
Subject: [PATCH 16/18] Remove unnecessary precision reduction

---
 Sprint-1/implement/sum.js      | 2 +-
 Sprint-1/implement/sum.test.js | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Sprint-1/implement/sum.js b/Sprint-1/implement/sum.js
index 749413e13..9c5b95cff 100644
--- a/Sprint-1/implement/sum.js
+++ b/Sprint-1/implement/sum.js
@@ -8,7 +8,7 @@ function sum(elements) {
       total += elements[i];
     }
   }
-  return Number(total.toFixed(10));
+  return total;
 }
 
 module.exports = sum;
diff --git a/Sprint-1/implement/sum.test.js b/Sprint-1/implement/sum.test.js
index 32215fff3..f648c3007 100644
--- a/Sprint-1/implement/sum.test.js
+++ b/Sprint-1/implement/sum.test.js
@@ -44,7 +44,7 @@ test("Given an array containing negative numbers, when passed to the sum functio
 // When passed to the sum function
 // Then it should return the correct total sum
 test("Given an array with decimal/float numbers, when passed to the sum function, then it should return the correct total sum", () => {
-  expect(sum([1.5, 2.3, 0.8, 3.1])).toBe(7.7);
+  expect(sum([1.5, 2.3, 0.8, 3.1])).toBeCloseTo(7.7, 10);
 });
 
 // Given an array containing non-number values

From 43cf84a257af4a04f4e4fa0c9c828766cf18e950 Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Sat, 28 Mar 2026 18:49:14 +0200
Subject: [PATCH 17/18] Improve dedupe tests by adding duplicate cases and
 ensuring correct behavior

---
 Sprint-1/implement/dedupe.test.js | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Sprint-1/implement/dedupe.test.js b/Sprint-1/implement/dedupe.test.js
index 0eee99668..8655e916f 100644
--- a/Sprint-1/implement/dedupe.test.js
+++ b/Sprint-1/implement/dedupe.test.js
@@ -47,3 +47,10 @@ test("Given an array with strings or numbers, when passed to the dedupe function
   expect(dedupe(["a", "a", "b", "c", "c"])).toEqual(["a", "b", "c"]);
   expect(dedupe([1, 2, 2, 3, 4, 4])).toEqual([1, 2, 3, 4]);
 });
+
+test("preserves the original order of first occurrences", () => {
+  const input = ["b", "a", "b", "c"];
+  const result = dedupe(input);
+
+  expect(result).toEqual(["b", "a", "c"]);
+});

From a548d711624926dc176cb9073384e8a8e79a3a05 Mon Sep 17 00:00:00 2001
From: Pretty Taruvinga <pretty548@gmail.com>
Date: Sat, 28 Mar 2026 19:05:13 +0200
Subject: [PATCH 18/18] Strengthen dedupe test by adding length and content
 checks to prevent false positives

---
 Sprint-1/implement/dedupe.test.js | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Sprint-1/implement/dedupe.test.js b/Sprint-1/implement/dedupe.test.js
index 8655e916f..ed941955b 100644
--- a/Sprint-1/implement/dedupe.test.js
+++ b/Sprint-1/implement/dedupe.test.js
@@ -38,6 +38,7 @@ test("Given an array with no duplicates, when passed to the dedupe function, the
 
   expect(result).toEqual(input);
   expect(result).not.toBe(input);
+  expect(result.length).toBe(input.length);
 });
 
 // Given an array of strings or numbers