Cape Town | 26-ITP-May | Enice Mutanda | Sprint 1 |Data groups

Sprint-1/fix/median.js

@@ -6,8 +6,23 @@
 // 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];
+  if (!Array.isArray(list)){
+    return null;
+  }
+  const numbersOnly= list.filter(item => typeof item === "number");
+  if(numbersOnly.length === 0){
+    return null ;
+  }
+  numbersOnly.sort((a,b)=> a-b);
+  const middleIndex = Math.floor(numbersOnly.length / 2); // finding the middle index of numbers only
+  if (numbersOnly.length %2 === 0){
+    return (numbersOnly[middleIndex-1] + numbersOnly[middleIndex])/2 ;
+    // finding mdeian for even numbers
+
+  } else { 
+    return numbersOnly[middleIndex];
+  }
+  const median = numbersOnly.splice(middleIndex, 1)[0]; //
   return median;
 }
 

Sprint-1/implement/dedupe.js

@@ -1 +1,8 @@
-function dedupe() {}
+function dedupe(arr) {
+return arr.filter((item ,index ) => arr.indexOf(item)=== index);
+
+
+
+}
+
+module.exports = dedupe;

Sprint-1/implement/dedupe.test.js

@@ -16,13 +16,28 @@ E.g. dedupe([1, 2, 1]) returns [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, 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("returns a copy of the array when there are no duplicates", () => {
+  const original = [1, 2, 3];
+  const result = dedupe(original);
+
+  expect(result).toEqual([1, 2, 3]); // same values
+  expect(result).not.toBe(original); // but a different array in memory
+});
 
 // Given an array of strings or numbers
 // When passed to the dedupe function
 // Then it should return a new array with duplicates removed while preserving the 
 // first occurrence of each element from the original array.
+
+test("return duplicate array of strings or numbers", () => {
+expect(dedupe([5,1,1,2,3,2,5,8])).toEqual([5,1,2,3,8]);
+
+});

Sprint-1/implement/max.js

@@ -1,4 +1,15 @@
-function findMax(elements) {
+function findMax(arr) {
+  const numbers = arr.filter((x) => typeof x === "number" && !Number.isNaN(x));
+
+  if (numbers.length === 0) return -Infinity;
+
+  let max = numbers[0];
+  for (let i = 1; i < numbers.length; i++) {
+    if (numbers[i] > max) {
+      max = numbers[i];
+    }
+  }
+  return max;
 }
 
-module.exports = findMax;
+module.exports = findMax;

Sprint-1/implement/max.test.js

@@ -15,29 +15,51 @@ 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");
+// Delete this test.todo and replace it with a test
+test("given an empty array, returns -Infinity", () => {
+  expect(findMax([])).toEqual(-Infinity);
+});
 
 // Given an array with one number
 // When passed to the max function
 // Then it should return that number
-
+test("given one number, when passed by max function, return that number", () => {
+  expect(findMax([1])).toEqual(1);
+});
 // Given an array with both positive and negative numbers
 // When passed to the max function
 // Then it should return the largest number overall
+test("array with positive and negative numbers returns largest number", () => {
+  expect(findMax([-2, 4, -3, 5, -6, 7])).toEqual(7);
+});
 
 // Given an array with just negative numbers
 // When passed to the max function
 // Then it should return the closest one to zero
+test("array with negative numbers , returns one closest to zero",() =>{
+expect(findMax([ -2,-3,-5])).toEqual(-2)
+});
 
 // Given an array with decimal numbers
 // When passed to the max function
 // Then it should return the largest decimal number
+test("array with decimal number,return largest decimal number",()=>{
+expect(findMax([1.2,2.2,3.1,5.5])).toEqual(5.5)
+});
 
 // 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("array with non-number values ,return max number and ignore non-numeric values",()=>{
+    const input = ["hi", 6, 2, 1, 7, "we", "put"];
+  const result = findMax(input);
+  expect(result).toEqual(7);
+});
 // 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("array with only non-number values, return the least surprising value", () => {
+  const input = ["no", "hat", "dot", "cape"];
+  const result = findMax(input);
+  expect(result).toEqual(-Infinity);
+});

Sprint-1/implement/sum.js

@@ -1,4 +1,8 @@
-function sum(elements) {
+function sum(arr) {
+  const list = Array.isArray(arr) ? arr : [arr];
+  return list
+    .filter(item => typeof item === 'number' && !isNaN(item))
+    .reduce((total, num) => total + num, 0);
 }
 
 module.exports = sum;

Sprint-1/implement/sum.test.js

@@ -5,32 +5,46 @@ In this kata, you will need to implement a function that sums the numerical elem
 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");
+const sum = require('./sum');
 
 // 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,return that number",() => {
+    expect(sum(2)).toBe(2);
+});
 
 // 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, sums correctly", () => {
+  expect(sum([-5, 10, -3])).toBe(2);
+});
 
 // Given an array with decimal/float numbers
 // When passed to the sum function
 // Then it should return the correct total sum
-
+test("given floats, sums correctly", () => {
+  expect(sum([1.5, 2.5, -1])).toBe(3);
+});
 // 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 types, ignores non-numeric values", () => {
+  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 non-number values, return the least surprising value", () =>{
+    expect(sum(["up","to","top"])).toBe(0);
+});

Sprint-1/refactor/includes.js

@@ -1,8 +1,6 @@
 // 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;
     }

Sprint-1/refactor/includes.test.js

@@ -1,6 +1,6 @@
 // Refactored version of includes should still pass the tests below:
 
-const includes = require("./includes.js");
+const includes = require("./includes");
 
 test("returns true when target is in array", () => {
   const currentOutput = includes(["a", "b", "c", "d"], "c");