London | 26-ITP-January | Ihor Taradaiko | Sprint 1 | Coursework/sprint 1

Sprint-1/fix/median.js

@@ -2,13 +2,26 @@
 // 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).
 
+
 function calculateMedian(list) {
-  const middleIndex = Math.floor(list.length / 2);
-  const median = list.splice(middleIndex, 1)[0];
-  return median;
+
+  if (!Array.isArray(list)) return null;
+
+  const numbers = list.filter(item => typeof item === 'number');
+  if (numbers.length === 0) return null;
+
+  numbers.sort((a, b) => a - b);
+  const middleIndex = Math.floor(numbers.length / 2);
+
+  if (numbers.length % 2 === 1) {
+    return numbers[middleIndex];
+  }
+  return (numbers[middleIndex - 1] + numbers[middleIndex]) / 2;
 }
 
 module.exports = calculateMedian;
+

Sprint-1/implement/dedupe.js

@@ -1 +1,5 @@
-function dedupe() {}
+function dedupe(arr) {
+  return [...new Set(arr)];
+}
+
+module.exports = dedupe;

Sprint-1/implement/dedupe.test.js

@@ -1,4 +1,5 @@
 const dedupe = require("./dedupe.js");
+
 /*
 Dedupe Array
 
@@ -11,17 +12,31 @@ E.g. dedupe([5, 1, 1, 2, 3, 2, 5, 8]) target output: [5, 1, 2, 3, 8]
 E.g. dedupe([1, 2, 1]) target output: [1, 2]
 */
 
+
 // Acceptance Criteria:
 
+
 // 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, it returns a copy of the original array", () => {
+  expect(dedupe([1, 2, 3])).toEqual([1, 2, 3]);
+});
+
 
 // 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("removes duplicate values, preserving first occurrence", () => {
+  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]);
+  expect(dedupe([1, 2, 1])).toEqual([1, 2]);
+});

Sprint-1/implement/max.js

@@ -1,4 +1,6 @@
-function findMax(elements) {
+function findMax(arr) {
+  const numbers = arr.filter(item => typeof item === 'number');
+  return Math.max(...numbers);
 }
 
 module.exports = findMax;

Sprint-1/implement/max.test.js

@@ -1,4 +1,5 @@
-/* Find the maximum element of an array of numbers
+/*
+Find the maximum element of an array of numbers
 
 In this kata, you will need to implement a function that find the largest numerical element of an array.
 
@@ -9,35 +10,59 @@ You should implement this function in max.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 findMax = require("./max.js");
 
 // Given an empty array
 // 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([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 positive and negative numbers, returns the largest", () => {
+  expect(findMax([-10, 5, -3, 20, 1])).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 only negative numbers, returns the closest to zero", () => {
+  expect(findMax([-5, -1, -3, -2])).toBe(-1);
+});
+
 
 // Given an array with decimal numbers
 // When passed to the max function
 // Then it should return the largest decimal number
+test("given decimal numbers, returns the largest decimal", () => {
+  expect(findMax([1.5, 2.7, 0.3, 2.1])).toBe(2.7);
+});
+
 
 // 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 mixed values, ignores non-numbers and returns the max", () => {
+  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 only non-number values, returns -Infinity", () => {
+  expect(findMax(['hey', 'hi', 'hello'])).toBe(-Infinity);
+});

Sprint-1/implement/sum.js

@@ -1,4 +1,7 @@
-function sum(elements) {
+function sum(arr) {
+  return arr
+    .filter(item => typeof item === 'number')
+    .reduce((total, num) => total + num, 0);
 }
 
 module.exports = sum;

Sprint-1/implement/sum.test.js

@@ -6,31 +6,56 @@ E.g. sum([10, 20, 30]), target output: 60
 E.g. sum(['hey', 10, 'hi', 60, 10]), target output: 80 (ignore any non-numerical elements)
 */
 
+
 const sum = require("./sum.js");
 
+
 // Acceptance Criteria:
 
+
 // 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([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 negative numbers, returns the correct total sum", () => {
+  expect(sum([-10, -20, 30])).toBe(0);
+});
+
 
 // Given an array with decimal/float numbers
 // When passed to the sum function
 // Then it should return the correct total sum
+test("given decimal numbers, returns the correct total sum", () => {
+  expect(sum([1.5, 2.5, 3.0])).toBe(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 mixed values, ignores non-numbers and returns the sum", () => {
+  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 only non-number values, returns 0", () => {
+  expect(sum(['hey', 'hi', 'hello'])).toBe(0);
+});

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;
     }
@@ -11,3 +10,4 @@ function includes(list, target) {
 }
 
 module.exports = includes;
+