London | 25-ITP-Sept | Gislaine Della Bella | Sprint 3 | Quote generator

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;

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-3/quote-generator/index.html

@@ -3,13 +3,15 @@
   <head>
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Title here</title>
+    <link rel="stylesheet" href="style.css">
+    <title>Quote Generator App</title>
     <script defer src="quotes.js"></script>
   </head>
   <body>
-    <h1>hello there</h1>
+
     <p id="quote"></p>
     <p id="author"></p>
-    <button type="button" id="new-quote">New quote</button>
+
+    <button type="button" id="new-quote" onclick="pickFromArray(choices)">New quote</button>
   </body>
 </html>

Sprint-3/quote-generator/quotes.js

@@ -15,11 +15,19 @@
 // ---------------
 // pickFromArray(['a','b','c','d'])     // maybe returns 'c'
 
+let quoteDisplay = document.getElementById("quote");
+let authorDisplay = document.getElementById("author");
+let newQuoteButton = document.getElementById("new-quote");
+
+
 // You don't need to change this function
 function pickFromArray(choices) {
   return choices[Math.floor(Math.random() * choices.length)];
 }
 
+
+
+
 // A list of quotes you can use in your app.
 // DO NOT modify this array, otherwise the tests may break!
 const quotes = [
@@ -490,4 +498,12 @@ const quotes = [
   },
 ];
 
-// call pickFromArray with the quotes array to check you get a random quote
+function displayNewQuote() {
+  const randomQuoteObject = pickFromArray(quotes);
+  quoteDisplay.innerHTML = ' " ' +  randomQuoteObject.quote;
+  authorDisplay.innerHTML = ' - ' + randomQuoteObject.author;
+}
+
+newQuoteButton.addEventListener("click", displayNewQuote);
+
+displayNewQuote();//disply quote when open the page