Add solutions for mean, describe-median, querystring and mode

Author: abdishakoor-dev

Sprint-1/implement/describe-median.js

@@ -20,6 +20,18 @@ function calculateMedian(list) {
 }
 
 // Implement this function. See describe-median.test.js for the acceptance criteria.
-function describeMedian(list) {}
+
+// Explanation:
+// calculateMedian throws when it can't produce a median. Rather than letting
+// that crash the caller, we try to calculate it and, if an error is thrown,
+// catch it and turn its message into a sentence.
+function describeMedian(list) {
+  try {
+    const median = calculateMedian(list);
+    return `The median is ${median}`;
+  } catch (error) {
+    return `Could not calculate a median: ${error.message}`;
+  }
+}
 
 module.exports = describeMedian;

Sprint-1/implement/describe-median.test.js

@@ -21,7 +21,6 @@ const describeMedian = require("./describe-median.js");
 // When passed to describeMedian
 // Then it should return "The median is " followed by the median
 // Delete this test.todo and replace it with a test.
-test.todo('given [1, 2, 3], returns "The median is 2"');
 
 // Given an empty array
 // When passed to describeMedian
@@ -30,3 +29,23 @@ test.todo('given [1, 2, 3], returns "The median is 2"');
 // Given something that isn't an array of numbers, e.g. "banana"
 // When passed to describeMedian
 // Then it should return "Could not calculate a median: calculateMedian requires an array of numbers"
+
+test('given [1, 2, 3], returns "The median is 2"', () => {
+  expect(describeMedian([1, 2, 3])).toEqual("The median is 2");
+});
+
+test("given an even-length array, describes the average of the middle two", () => {
+  expect(describeMedian([1, 2, 3, 4])).toEqual("The median is 2.5");
+});
+
+test("given an empty array, explains there is no median", () => {
+  expect(describeMedian([])).toEqual(
+    "Could not calculate a median: calculateMedian requires a non-empty array"
+  );
+});
+
+test("given something that isn't an array of numbers, explains why", () => {
+  expect(describeMedian("banana")).toEqual(
+    "Could not calculate a median: calculateMedian requires an array of numbers"
+  );
+});

Sprint-1/implement/mean.js

@@ -1,3 +1,28 @@
-function calculateMean(list) {}
+// Explanation:
+
+// The mean is the sum of the numbers divided by how many there are.
+// We check the input first: it must be an array, it must not be empty (there is
+// no mean of nothing, and dividing by zero would give NaN), and every element
+// must be a number. Each bad input throws a named error rather than guessing.
+
+function calculateMean(list) {
+  if (!Array.isArray(list)) {
+    throw new Error("calculateMean requires an array of numbers");
+  }
+  for (const item of list) {
+    if (typeof item !== "number") {
+      throw new Error("calculateMean requires an array of numbers");
+    }
+  }
+  if (list.length === 0) {
+    throw new Error("calculateMean requires a non-empty array");
+  }
+
+  let total = 0;
+  for (const item of list) {
+    total += item;
+  }
+  return total / list.length;
+}
 
 module.exports = calculateMean;

Sprint-1/implement/mean.test.js

@@ -23,7 +23,6 @@ const calculateMean = require("./mean.js");
 // When passed to calculateMean
 // Then it should return their mean
 // Delete this test.todo and replace it with a test.
-test.todo("given [1, 2, 6], returns 3");
 
 // Given an array with a single number
 // When passed to calculateMean
@@ -48,3 +47,61 @@ test.todo("given [1, 2, 6], returns 3");
 // Given an array containing a non-number value, e.g. [1, "2", 3]
 // When passed to calculateMean
 // Then it should throw Error("calculateMean requires an array of numbers")
+
+test("given [1, 2, 6], returns 3", () => {
+  expect(calculateMean([1, 2, 6])).toEqual(3);
+});
+
+test("given an array with a single number, returns that number", () => {
+  expect(calculateMean([7])).toEqual(7);
+});
+
+test("given negative numbers, returns the correct mean", () => {
+  expect(calculateMean([-4, 2, -1, 3])).toEqual(0);
+});
+
+test("given decimal numbers, returns the correct mean", () => {
+  expect(calculateMean([1.5, 2.5, 3.5])).toEqual(2.5);
+});
+
+test("throws when given an empty array", () => {
+  expect(() => calculateMean([])).toThrow(
+    new Error("calculateMean requires a non-empty array")
+  );
+});
+
+test("throws when given a string", () => {
+  expect(() => calculateMean("banana")).toThrow(
+    new Error("calculateMean requires an array of numbers")
+  );
+});
+
+test("throws when given a number", () => {
+  expect(() => calculateMean(42)).toThrow(
+    new Error("calculateMean requires an array of numbers")
+  );
+});
+
+test("throws when given null", () => {
+  expect(() => calculateMean(null)).toThrow(
+    new Error("calculateMean requires an array of numbers")
+  );
+});
+
+test("throws when given an object", () => {
+  expect(() => calculateMean({})).toThrow(
+    new Error("calculateMean requires an array of numbers")
+  );
+});
+
+test("throws when called with no argument", () => {
+  expect(() => calculateMean()).toThrow(
+    new Error("calculateMean requires an array of numbers")
+  );
+});
+
+test("throws when the array contains a non-number value", () => {
+  expect(() => calculateMean([1, "2", 3])).toThrow(
+    new Error("calculateMean requires an array of numbers")
+  );
+});

Sprint-2/implement/querystring.js

@@ -1,13 +1,45 @@
+// Explanation:
+// Each "&"-separated piece is one key-value pair. Empty pieces (from "&&" or a
+// trailing "&") are skipped. We split on the first "=" only, so a value may
+// itself contain "=", and a piece with no "=" gets an empty string value.
+// decode() turns "+" into a space and decodes percent-encoded characters.
+// If the same key appears more than once, its values are collected into an
+// array instead of overwriting each other.
+
+function decode(text) {
+  return decodeURIComponent(text.replaceAll("+", " "));
+}
+
 function parseQueryString(queryString) {
   const queryParams = {};
   if (queryString.length === 0) {
     return queryParams;
   }
-  const keyValuePairs = queryString.split("&");
 
+  const keyValuePairs = queryString.split("&");
   for (const pair of keyValuePairs) {
-    const [key, value] = pair.split("=");
-    queryParams[key] = value;
+    if (pair === "") {
+      continue;
+    }
+
+    const equalsIndex = pair.indexOf("=");
+    let key;
+    let value;
+    if (equalsIndex === -1) {
+      key = decode(pair);
+      value = "";
+    } else {
+      key = decode(pair.slice(0, equalsIndex));
+      value = decode(pair.slice(equalsIndex + 1));
+    }
+
+    if (!(key in queryParams)) {
+      queryParams[key] = value;
+    } else if (Array.isArray(queryParams[key])) {
+      queryParams[key].push(value);
+    } else {
+      queryParams[key] = [queryParams[key], value];
+    }
   }
 
   return queryParams;

Sprint-2/stretch/mode.js

@@ -12,8 +12,13 @@
 
 // The tests must still pass after your refactor. Run them again to check.
 
-function calculateMode(list) {
-  // check the input is a non-empty array of numbers
+// Explanation:
+// Each stage becomes a function named after what it does. calculateMode then
+// reads as the three steps in order, and each helper can be understood and
+// tested on its own.
+
+// Stage 1
+function checkIsNonEmptyArrayOfNumbers(list) {
   if (!Array.isArray(list)) {
     throw new Error("calculateMode requires an array of numbers");
   }
@@ -25,25 +30,34 @@ function calculateMode(list) {
       throw new Error("calculateMode requires an array of numbers");
     }
   }
+}
 
-  // track frequency of each value
-  let freqs = new Map();
-
-  for (let num of list) {
+// Stage 2
+function countFrequencies(list) {
+  const freqs = new Map();
+  for (const num of list) {
     freqs.set(num, (freqs.get(num) || 0) + 1);
   }
+  return freqs;
+}
 
-  // Find the value with the highest frequency
+// Stage 3
+function findMostFrequent(freqs) {
   let maxFreq = 0;
   let mode;
-  for (let [num, freq] of freqs) {
+  for (const [num, freq] of freqs) {
     if (freq > maxFreq) {
       mode = num;
       maxFreq = freq;
     }
   }
-
   return mode;
 }
 
+function calculateMode(list) {
+  checkIsNonEmptyArrayOfNumbers(list);
+  const freqs = countFrequencies(list);
+  return findMostFrequent(freqs);
+}
+
 module.exports = calculateMode;