London | 25-ITP-Sept | Gislaine Della Bella | Sprint 2 | Sprint 2 -Final

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) {
+  const result = [];
+  for (const 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,20 @@
-function sum(elements) {
+function sum(theArray) {
+  const onlyNumbers = theArray.filter((item) => typeof item === "number");
+  const theFinalSum = onlyNumbers.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 sum 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,9 +1,18 @@
 // 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;
+//     }
+//   }
+//   return false;
+// }
+
 function includes(list, target) {
-  for (let index = 0; index < list.length; index++) {
-    const element = list[index];
-    if (element === target) {
+  for (const value of list) {
+    if (value === target) {
       return true;
     }
   }

Sprint-2/implement/contains.js

@@ -1,3 +1,11 @@
-function contains() {}
+function contains(someObject, propertyName) {
+  let whatTheRobotFound = someObject[propertyName];
+  if (someObject[propertyName] === undefined) {
+    return false;
+  } else {
+    return true;
+  }
+}
 
 module.exports = contains;
+

Sprint-2/implement/contains.test.js

@@ -20,16 +20,39 @@ as the object doesn't contains a key of 'c'
 // Given an empty object
 // When passed to contains
 // Then it should return false
-test.todo("contains on empty object returns false");
+test("contains on empty object returns false", () => {
+  const inputEmpty = [];
+  const result = contains(inputEmpty);
+  expect(result).toEqual(false);
+});
 
 // Given an object with properties
 // When passed to contains with an existing property name
 // Then it should return true
+test("Given an object with properties when pass to contains it returns true", () => {
+  const myObject = {
+    name: "Alice",
+    age: 30,
+    city: "London",
+  };
+  const result = contains(myObject, "name");
+  expect(result).toEqual(true);
+});
 
 // Given an object with properties
 // When passed to contains with a non-existent property name
 // Then it should return false
+test("give a object with proprieties when pass contains with non-exist proprity name it should return false", () => {
+  const inputProprieties2 = ["f", "g", "h"];
+  const result = contains(inputProprieties2);
+  expect(result).toEqual(false);
+});
 
 // Given invalid parameters like an array
 // When passed to contains
 // Then it should return false or throw an error
+test("invalid parameters  should return false or throw an error", () => {
+  const invalidParameters = ("f", "g", "h");
+  const result = contains(invalidParameters);
+  expect(result).toEqual(false);
+});

Sprint-2/implement/lookup.js

@@ -1,5 +1,14 @@
-function createLookup() {
-  // implementation here
+function createLookup(countryCurrencyPairs) {
+  const lookup = {};
+
+  for (let i = 0; i < countryCurrencyPairs.length; i++) {
+    const countryCode = countryCurrencyPairs[i][0];
+    const currencyCode = countryCurrencyPairs[i][1];
+
+    lookup[countryCode] = currencyCode;
+  }
+
+  return lookup;
 }
 
 module.exports = createLookup;

Sprint-2/implement/lookup.test.js

@@ -1,7 +1,21 @@
+
 const createLookup = require("./lookup.js");
 
-test.todo("creates a country currency code lookup for multiple codes");
+test("creates a country currency code lookup for multiple codes", () => {
+  const input = [
+    ["US", "USD"],
+    ["CA", "CAD"],
+  ];
+
+  const result = createLookup(input);
+
+  const expected = {
+    US: "USD",
+    CA: "CAD",
+  };
 
+  expect(result).toEqual(expected);
+});
 /*
 
 Create a lookup object of key value pairs from an array of code pairs