London | ITP-Sep-25 | Gislaine Della Bella | Data Groups | Sprint- 1

Sprint-1/fix/median.js

@@ -5,10 +5,49 @@
 // 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;
+// }
+
+// Ignore this Commit
+// It is not my solution I got help with AI. I confess I need to undestand more those 3 methodos to think
+//and get to this solution
+// I will come back to it later. 
+
 function calculateMedian(list) {
-  const middleIndex = Math.floor(list.length / 2);
-  const median = list.splice(middleIndex, 1)[0];
-  return median;
+  // non-array or empty inputs
+  if (!Array.isArray(list) || list.length === 0) {
+    return null;
+  }
+
+  //Filter non-numeric values and create a new array of only numbers
+
+  const numericList = list.filter(
+    (item) => typeof item === "number" && Number.isFinite(item)
+  );
+
+  // If after filtering, there are no numbers left, return null
+  if (numericList.length === 0) {
+    return null;
+  }
+
+  //Sort the numeric list
+  const sortedList = [...numericList].sort((a, b) => a - b);
+
+  const middleIndex = Math.floor(sortedList.length / 2);
+
+  //Calculate the median based on list length (odd or even)
+  if (sortedList.length % 2 === 1) {
+    // Odd number of elements: return the middle element
+    return sortedList[middleIndex];
+  } else {
+    // Even number of elements: return the average of the two middle elements
+    const mid1 = sortedList[middleIndex - 1];
+    const mid2 = sortedList[middleIndex];
+    return (mid1 + mid2) / 2;
+  }
 }
 
 module.exports = calculateMedian;

Sprint-1/implement/dedupe.js

@@ -1 +1,13 @@
-function dedupe() {}
+function dedupe(arr) {
+  let result = [];
+  for (let item of arr) {
+    if (!result.includes(item)) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+
+console.log(dedupe(["a", "a", "a", "b", "b", "c"]));
+
+module.exports = dedupe;

Sprint-1/implement/dedupe.test.js

@@ -16,12 +16,26 @@ E.g. dedupe([1, 2, 1]) target output: [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("dedupe an empty array returns an empty array", () =>{
+    const inputEmpty = [];
+    const result = dedupe(inputEmpty);
+    expect(result).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", () => {
+  const inputNoDuplicates = ["a", "b", "c" ];
+  const result = dedupe(inputNoDuplicates);
+  expect(result).toEqual(["a", "b", "c"]);
+});
 
 // 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(" Given an array with no duplicates", () => {
+  const inputMix = [1,1,2,2,3,3,4,4,5,5];
+  const result = dedupe(inputMix);
+  expect(result).toEqual([1,2,3,4,5]);
+});

Sprint-1/implement/max.js

@@ -1,4 +1,9 @@
-function findMax(elements) {
+function findMax(numbersList) {
+    let onlyNumbers = numbersList.filter((item) => typeof item === "number");
+ let currentMax = Math.max(...onlyNumbers); ;
+  return currentMax;
 }
 
+console.log(findMax([1, "apple", 5, 0, "banana", 3]));
+
 module.exports = findMax;

Sprint-1/implement/max.test.js

@@ -16,28 +16,65 @@ const findMax = require("./max.js");
 // 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");
+// This one is good to go!
+test("given an empty array, returns -Infinity",() => {
+  const input = [];
+  const result = findMax(input); 
+  expect(result).toEqual(-Infinity); 
+});
 
 // Given an array with one number
 // When passed to the max function
 // Then it should return that number
+test("given an array with 1 number, it returns the number ",() => {;
+  const inputMax1 = [3];
+    const result = findMax(inputMax1);
+expect(result).toEqual(3);
+});
+
 
 // Given an array with both positive and negative numbers
 // When passed to the max function
 // Then it should return the largest number overall
+test("give 2 positive numbers return the largest nunber",() => {
+    const inputMax2= [5,8];
+    const result = findMax(inputMax2);
+    expect(result).toEqual(8);
+});
 
 // Given an array with just negative numbers
 // When passed to the max function
 // Then it should return the closest one to zero
+test ("Given an array with just negative numbers return colest to Zero",() =>{
+const inputMax3= [-5,-3];
+const result = findMax(inputMax3);
+expect (result).toEqual(-3);
+});
 
 // Given an array with decimal numbers
 // When passed to the max function
 // Then it should return the largest decimal number
+test ("Given an array with decimal numbers, should return the largest decimal number",() => {
+const inputMax4= [2.4,3.5];
+const result= findMax(inputMax4);
+expect(result).toEqual(3.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("Given an array with non-number values,it should return the max and ignore non-numeric values ",() => {
+const inputMax5 = [2, "apple", 5, "banana", 8, "watermelon"];
+const result= findMax(inputMax5);
+expect(result).toEqual(8);
+});
 
 // 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 an array with only non-number values,it should return the least surprising value given how it behaves for all other inputs ", () => {
+    const inputMax6= [ "computer", "bike", "car", "ball"];
+const result= findMax(inputMax6);
+expect(result).toEqual(-Infinity);
+});
+

Sprint-1/implement/sum.js

@@ -1,4 +1,24 @@
-function sum(elements) {
+function sum(theArray) {
+
+  let onyNumbers = theArray.filter(item => typeof item === 'number');
+
+
+  const theFinalSum = onyNumbers.reduce((runningTotal, currentNumber) => {
+    return runningTotal + currentNumber;
+  }, 0);
+
+  return theFinalSum;
 }
 
+console.log (sum(["hey", 10, "hi", 60, 10]));
+
 module.exports = sum;
+
+//numbersList.filter((item) => typeof item === "number");
+/* Sum the numbers in an array
+
+In this kata, you will need to implement a function that sums the numerical elements of an array
+
+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)
+*/

Sprint-1/implement/sum.test.js

@@ -13,24 +13,55 @@ const sum = require("./sum.js");
 // 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", () => {
+  const inputNumber = [];
+  const result = sum(inputNumber);
+  expect(result).toEqual(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 1 number, it returns the sam number", () => {
+  const inputNumber = [34];
+  const result = sum(inputNumber);
+  expect(result).toEqual(34);
+});
+
 // Given an array containing negative numbers
 // When passed to the sum function
 // Then it should still return the correct total sum
 
+test("given an array containing negative numbers",() => {
+    const inputNegative = [10, -5, 20, -15];
+    const result= sum(inputNegative )
+    expect (result).toEqual(10);
+});
+
 // Given an array with decimal/float numbers
 // When passed to the sum function
 // Then it should return the correct total sum
+test("Given an array with decimal/float numbers", () => {
+    const inputFloat = [10.2, 10.3];
+    const result = sum(inputFloat);
+    expect (result).toEqual(20.5);
+});
 
 // 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 an array containing non-number values", () => {
+    const inputNonNumbers = [1, "apple", 2, true, 3];
+    const result = sum(inputNonNumbers);
+    expect (result).toEqual(6)
+});
 
 // 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 only non-number values" , () =>{
+    const nonNumbers = ["helo", "hi"];
+    const result = sum(nonNumbers);
+    expect (result).toEqual(0)
+});

Sprint-1/refactor/includes.js

@@ -1,13 +1,23 @@
 // 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];
-    if (element === target) {
-      return true;
-    }
+// function includes(list, target) {
+//   for (let index = 0; index < list.length; index++) {
+//     const element = list[index];
+//     if (element === target) {
+//       return true;
+//     }
+//   }
+//   return false;
+// }
+
+
+function includes(list,target){
+  for (let value of list) {
+   if (value === target) {
+  return true;
   }
-  return false;
 }
+   return false;
+};
 
 module.exports = includes;