Merge branch 'main' into sprint-1

Author: mandipsanger

Sprint-1/fix/median.js

@@ -2,8 +2,8 @@
 // Start by running the tests for this function
 // If you're in the Sprint-1 directory, you can run `npm test -- fix` to run the tests in the fix directory
 
-// Hint: Please consider scenarios when 'list' doesn't have numbers (the function is expected to return null)
-// or 'list' has mixed values (the function is expected to sort only numbers).
+// Hint: Please consider scenarios when 'list' isn't an array, is empty,
+// or contains values that aren't numbers (the function is expected to throw - see the tests).
 
 function calculateMedian(list) {
   // Check that the input is an array

Sprint-1/implement/describe-median.js

@@ -0,0 +1,25 @@
+// Don't change this function.
+function calculateMedian(list) {
+  if (!Array.isArray(list)) {
+    throw new Error("calculateMedian requires an array of numbers");
+  }
+  if (list.length === 0) {
+    throw new Error("calculateMedian requires a non-empty array");
+  }
+  for (const item of list) {
+    if (typeof item !== "number") {
+      throw new Error("calculateMedian requires an array of numbers");
+    }
+  }
+  const middleIndex = Math.floor(list.length / 2);
+  const sorted = [...list].sort((a, b) => a - b);
+  if (sorted.length % 2 === 0) {
+    return (sorted[middleIndex - 1] + sorted[middleIndex]) / 2;
+  }
+  return sorted[middleIndex];
+}
+
+// Implement this function. See describe-median.test.js for the acceptance criteria.
+function describeMedian(list) {}
+
+module.exports = describeMedian;

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

@@ -0,0 +1,32 @@
+/* Describe the median, or explain why there isn't one
+
+calculateMedian is given to you at the top of describe-median.js. It throws
+when it can't calculate a median. Don't change it.
+
+Implement describeMedian, which calls calculateMedian and returns a sentence
+instead of crashing.
+
+E.g. describeMedian([1, 2, 3]), target output: "The median is 2"
+E.g. describeMedian([]), target output: "Could not calculate a median: calculateMedian requires a non-empty array"
+
+You'll need a try/catch block for this. The catch block must use the error's
+message, so the caller can see what went wrong.
+*/
+
+const describeMedian = require("./describe-median.js");
+
+// Acceptance criteria:
+
+// Given an array of numbers
+// 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
+// Then it should return "Could not calculate a median: calculateMedian requires a non-empty array"
+
+// 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"

Sprint-1/implement/mean.js

@@ -0,0 +1,3 @@
+function calculateMean(list) {}
+
+module.exports = calculateMean;

Sprint-1/implement/mean.test.js

@@ -0,0 +1,50 @@
+/* Calculate the mean of an array of numbers
+
+In this kata, you will need to implement a function that calculates the mean of an array of numbers.
+
+E.g. calculateMean([1, 2, 6]), target output: 3
+E.g. calculateMean([]) throws Error("calculateMean requires a non-empty array")
+E.g. calculateMean("banana") throws Error("calculateMean requires an array of numbers")
+
+There is no mean of an empty array, and a string isn't an array of numbers, so
+calculateMean should throw rather than return a value. This is the same problem
+calculateMedian solves in the prep and in the fix directory.
+
+You should implement this function in mean.js, and add tests for it in this file.
+
+We have set things up already so that this file can see your function from the other file.
+*/
+
+const calculateMean = require("./mean.js");
+
+// Acceptance criteria:
+
+// Given an array of numbers
+// 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
+// Then it should return that number
+
+// Given an array containing negative or decimal numbers
+// When passed to calculateMean
+// Then it should return the correct mean
+
+// Given an empty array
+// When passed to calculateMean
+// Then it should throw Error("calculateMean requires a non-empty array")
+
+// Given a value that isn't an array, e.g. "banana", 42, null or {}
+// When passed to calculateMean
+// Then it should throw Error("calculateMean requires an array of numbers")
+
+// Given no argument at all
+// When passed to calculateMean
+// Then it should throw Error("calculateMean requires an array of numbers")
+
+// 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")

Sprint-1/readme.md

@@ -31,6 +31,8 @@ Here is a recommended order:
 1. `max.test.js`
 2. `sum.test.js`
 3. `dedupe.test.js`
+4. `mean.test.js`
+5. `describe-median.test.js`
 
 Again, you can run just the test for the `implement` directory if you're in the `Sprint-1` directory by running `npm test -- implement`.
 

Sprint-2/implement/contains.test.js

@@ -9,6 +9,9 @@ as the object contains a key of 'a'
 
 E.g. contains({a: 1, b: 2}, 'c') // returns false
 as the object doesn't contains a key of 'c'
+
+E.g. contains([1, 2, 3], 'a') throws Error("contains requires an object")
+as an array isn't an object
 */
 
 // Acceptance criteria:
@@ -30,6 +33,8 @@ test.todo("contains on empty object returns false");
 // When passed to contains with a non-existent property name
 // Then it should return false
 
-// Given invalid parameters like an array
+// Given a value that isn't an object - an array, a string, a number,
+// null, or no argument at all
 // When passed to contains
-// Then it should return false or throw an error
+// Then it should throw Error("contains requires an object")
+// (careful: typeof [] and typeof null are both "object")

Sprint-2/implement/tally.test.js

@@ -29,6 +29,6 @@ test.todo("tally on an empty array returns an empty object");
 // When passed to tally
 // Then it should return counts for each unique item
 
-// Given an invalid input like a string
+// Given an invalid input like a string, a number, or no argument at all
 // When passed to tally
-// Then it should throw an error
+// Then it should throw Error("tally requires an array")

Sprint-2/stretch/mode.js

@@ -1,22 +1,35 @@
-// You are given an implementation of calculateMode
+// You are given a working implementation of calculateMode.
+// Run the tests in mode.test.js before you start: they all pass.
 
-// calculateMode's implementation can be broken down into two stages:
+// calculateMode's implementation can be broken down into three stages:
 
-// Stage 1. One part of the code tracks the frequency of each value
-// Stage 2. The other part finds the value with the highest frequency
+// Stage 1. Check the input is a non-empty array of numbers, and throw if not
+// Stage 2. Track the frequency of each value
+// Stage 3. Find the value with the highest frequency
 
-// refactor calculateMode by splitting up the code
-// into smaller functions using the stages above
+// Refactor calculateMode by moving each stage into its own function,
+// then calling those functions from calculateMode.
+
+// 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
+  if (!Array.isArray(list)) {
+    throw new Error("calculateMode requires an array of numbers");
+  }
+  if (list.length === 0) {
+    throw new Error("calculateMode requires a non-empty array");
+  }
+  for (const item of list) {
+    if (typeof item !== "number") {
+      throw new Error("calculateMode requires an array of numbers");
+    }
+  }
+
   // track frequency of each value
   let freqs = new Map();
 
   for (let num of list) {
-    if (typeof num !== "number") {
-      continue;
-    }
-
     freqs.set(num, (freqs.get(num) || 0) + 1);
   }
 
@@ -30,7 +43,7 @@ function calculateMode(list) {
     }
   }
 
-  return maxFreq === 0 ? NaN : mode;
+  return mode;
 }
 
 module.exports = calculateMode;

Sprint-2/stretch/mode.test.js

@@ -1,3 +1,5 @@
+// Don't change this file. The tests check your refactored calculateMode still behaves the same.
+
 const calculateMode = require("./mode.js");
 
 // Acceptance criteria for calculateMode function
@@ -6,10 +8,15 @@ const calculateMode = require("./mode.js");
 // When calculateMode is called on the array
 // Then it should return the number that appears most frequently in the array
 
-// Example:
-// Given [2,4,1,2,3,2,1]
-// When calculateMode is called on [2,4,1,2,3,2,1]
-// Then it should return 2 */
+// E.g. calculateMode([2, 4, 1, 2, 3, 2, 1]) returns 2
+
+// Given an empty array
+// When calculateMode is called on the array
+// Then it should throw Error("calculateMode requires a non-empty array")
+
+// Given something that isn't an array of numbers, e.g. "banana" or [1, "2", 3]
+// When calculateMode is called on it
+// Then it should throw Error("calculateMode requires an array of numbers")
 
 describe("calculateMode()", () => {
   test("returns the most frequent number in an array", () => {
@@ -24,9 +31,27 @@ describe("calculateMode()", () => {
     expect(calculateMode(nums)).toEqual(2);
   });
 
-  test("ignores non-number values", () => {
-    const nums = [1, 3, "2", 2, 3, null];
+  test("throws when the array contains a non-number", () => {
+    expect(() => calculateMode([1, 3, "2", 2, 3, null])).toThrow(
+      new Error("calculateMode requires an array of numbers")
+    );
+  });
+
+  test("throws when given something that isn't an array", () => {
+    expect(() => calculateMode("banana")).toThrow(
+      new Error("calculateMode requires an array of numbers")
+    );
+  });
+
+  test("throws when given no argument", () => {
+    expect(() => calculateMode()).toThrow(
+      new Error("calculateMode requires an array of numbers")
+    );
+  });
 
-    expect(calculateMode(nums)).toEqual(3);
+  test("throws when given an empty array", () => {
+    expect(() => calculateMode([])).toThrow(
+      new Error("calculateMode requires a non-empty array")
+    );
   });
 });