Apply changes asked by the reviewer

Author: mohsenzamanist

Sprint-1/fix/median.js

@@ -10,14 +10,15 @@ function calculateMedian(list) {
   const numericList = list
     .filter((l) => typeof l === "number")
     .sort((a, b) => a - b);
-  if (numericList.length <= 1) return null;
+  if (numericList.length < 1) return null;
+  if (numericList.length === 1) return numericList[0];
 
   const middleIndex = Math.floor(numericList.length / 2);
 
   if (numericList.length % 2 === 0) {
     return (numericList[middleIndex] + numericList[middleIndex - 1]) / 2;
   }
-  const median = numericList.splice(middleIndex, 1)[0];
+  const median = numericList[middleIndex];
   return median;
 }
 

Sprint-1/fix/median.test.js

@@ -8,6 +8,11 @@ const calculateMedian = require("./median.js");
 
 describe("calculateMedian", () => {
   [
+    { input: [1.5, 2.5, 3.5], expected: 2.5 },
+    { input: [-2, -4, -6, -10], expected: -5 },
+    { input: [3, 3, 3, 3, 3], expected: 3 },
+    { input: [1, 3], expected: 2 },
+    { input: [1], expected: 1 },
     { input: [1, 2, 3], expected: 2 },
     { input: [1, 2, 3, 4, 5], expected: 3 },
     { input: [1, 2, 3, 4], expected: 2.5 },
@@ -18,6 +23,9 @@ describe("calculateMedian", () => {
   );
 
   [
+    { input: [-5, -1, -3], expected: -3 },
+    { input: [2, 2, 2, 2], expected: 2 },
+    { input: [8, 4], expected: 6 },
     { input: [3, 1, 2], expected: 2 },
     { input: [5, 1, 3, 4, 2], expected: 3 },
     { input: [4, 2, 1, 3], expected: 2.5 },
@@ -49,6 +57,7 @@ describe("calculateMedian", () => {
   );
 
   [
+    { input: ["a", null, 5, undefined], expected: 5 },
     { input: [1, 2, "3", null, undefined, 4], expected: 2 },
     { input: ["apple", 1, 2, 3, "banana", 4], expected: 2.5 },
     { input: [1, "2", 3, "4", 5], expected: 3 },

Sprint-1/implement/dedupe.js

@@ -3,5 +3,3 @@ function dedupe(elements) {
 }
 
 module.exports = dedupe;
-
-console.log(dedupe([4542543, undefined, 4542543, 4542543, null, [], null]));

Sprint-1/implement/dedupe.test.js

@@ -27,8 +27,11 @@ describe("dedupe", () => {
       expected: [4542543, 65756756, 433254],
     },
   ].forEach(({ input, expected }) =>
-    it("returns a copy of original array when passed array with no duplicates ", () =>
-      expect(dedupe(input)).toEqual(expected))
+    it(
+      "returns a copy of original array when passed array with no duplicates ",
+      () => expect(dedupe(input)).toEqual(expected),
+      expect(dedupe(input)).not.toBe(expected)
+    )
   );
 
   [

Sprint-1/implement/max.js

@@ -1,7 +1,11 @@
 function findMax(elements) {
-  const numberElements = elements.filter((el) => typeof el === "number");
+  const numberElements = elements.filter(
+    (el) => typeof el === "number" && !Number.isNaN(el)
+  );
   if (numberElements.length === 0) return -Infinity;
   return Math.max(...numberElements);
 }
 
+// console.log(findMax(findMax([0, null, 1])));
+
 module.exports = findMax;

Sprint-1/implement/max.test.js

@@ -56,7 +56,8 @@ describe("max()", () => {
   );
 
   [
-    { input: [1, 2, "3", null, undefined, 4], expected: 4 },
+    { input: [0, NaN, 1], expected: 1 },
+    { input: [1, 2, "3", null, undefined, NaN, 4], expected: 4 },
     { input: ["apple", 1, 2, 34, "banana", 4], expected: 34 },
     { input: [1, "2", 3, "4", 5], expected: 5 },
     { input: [1, "apple", 2, null, 3, undefined, 4], expected: 4 },

Sprint-1/implement/sum.js

@@ -1,9 +1,8 @@
 function sum(elements) {
   if (!Array.isArray(elements)) return 0;
   return elements.reduce((acc, curr) => {
-    return typeof curr === "number" ? acc + curr : acc;
+    return Number.isFinite(curr) ? acc + curr : acc;
   }, 0);
 }
 
 module.exports = sum;
-console.log(sum([]));

Sprint-1/implement/sum.test.js

@@ -11,15 +11,15 @@ const sum = require("./sum.js");
 // Acceptance Criteria:
 
 describe("sum()", () => {
-  it("returns 0 for empty array", () => expect(sum([])).toBe(0));
+  it("returns 0 for empty array", () => expect(sum([])).toBeCloseTo(0));
 
   [
     { input: [4], expected: 4 },
     { input: [367], expected: 367 },
     { input: [7958463], expected: 7958463 },
   ].forEach(({ input, expected }) => {
     it(`returns the sum for arrays with one number`, () =>
-      expect(sum(input)).toBe(expected));
+      expect(sum(input)).toBeCloseTo(expected));
   });
 
   [
@@ -28,7 +28,7 @@ describe("sum()", () => {
     { input: [-7958463, -100, -202, -6453], expected: -7965218 },
   ].forEach(({ input, expected }) =>
     it("returns the correct sum for array with only negative values", () =>
-      expect(sum(input)).toBe(expected))
+      expect(sum(input)).toBeCloseTo(expected))
   );
 
   [
@@ -37,7 +37,7 @@ describe("sum()", () => {
     { input: [-7958463, -100, -202, -6453, 153, 45621], expected: -7919444 },
   ].forEach(({ input, expected }) =>
     it("returns the correct sum for array containing negative numbers", () =>
-      expect(sum(input)).toBe(expected))
+      expect(sum(input)).toBeCloseTo(expected))
   );
 
   [
@@ -49,17 +49,19 @@ describe("sum()", () => {
     },
   ].forEach(({ input, expected }) =>
     it("returns the correct sum for array containing decimal/float numbers", () =>
-      expect(sum(input)).toBe(expected))
+      expect(sum(input)).toBeCloseTo(expected))
   );
 
   [
-    { input: [-9, 9, 0.1, () => {}], expected: 0.1 },
+    { input: [-9, 9, 0.1, () => {}, undefined], expected: 0.1 },
     {
-      input: [-367, -5, "-234", 70, 2, { fruit: "apple" }, -4.567],
+      input: [-367, -5, "-234", 70, 2, null, { fruit: "apple" }, -4.567],
       expected: -304.567,
     },
+    { input: [Infinity, -Infinity, 1, , NaN, 10, -9], expected: 2 },
     {
       input: [
+        NaN,
         -7958463,
         -100,
         "Iran",
@@ -77,15 +79,15 @@ describe("sum()", () => {
       expected: -7910469.024,
     },
   ].forEach(({ input, expected }) =>
-    it("returns the correct sum for array containing decimal/float numbers", () =>
-      expect(sum(input)).toBe(expected))
+    it("returns the correct sum for array containing finite and infinite values", () =>
+      expect(sum(input)).toBeCloseTo(expected))
   );
 
   [
     ["not an array", null, undefined, {}, []],
     [("apple", null, undefined)],
   ].forEach((item) =>
     it("returns 0 for arrays with only non-number values", () =>
-      expect(sum(item)).toBe(0))
+      expect(sum(item)).toBeCloseTo(0))
   );
 });

Sprint-1/refactor/includes.js

@@ -1,7 +1,8 @@
 // Refactor the implementation of includes to use a for...of loop
 
 function includes(list, target) {
-  return list.includes(target) ? true : false;
+  for (const item of list) if (item === target) return true;
+  return false;
 }
 
 module.exports = includes;

Sprint-1/stretch/aoc-2018-day1/solution.js

@@ -2,6 +2,7 @@ const fs = require("fs");
 
 function calculateFrequecy() {
   const text = fs.readFileSync("input.txt", "utf-8");
-  const ChangesInFrequency = text.trim().split(/\r?\n/).map(Number);
-  return ChangesInFrequency.reduce((acc, curr) => acc + curr, 0);
+  const changesInFrequency = text.trim().split(/\r?\n/).map(Number);
+  return changesInFrequency.reduce((acc, curr) => acc + curr, 0);
 }
+console.log(calculateFrequecy());