Karla Grajales | Sprint-3 - Module-Structuring-and-Testing-Data | SPRINT 3

Sprint-2/errors/2.js

@@ -2,9 +2,3 @@
 // Predict and explain first...
 
 // this function should square any number but instead we're going to get an error
-
-function square(3) {
-    return num * num;
-}
-
-

Sprint-3/implement/get-angle-type.test.js

@@ -0,0 +1,113 @@
+// Implement a function getAngleType
+
+// Acceptance criteria:
+
+// Given an angle in degrees,
+// When the function getAngleType is called with this angle,
+// Then it should:
+
+// 1. Identify Right Angles:
+// When the angle is exactly 90 degrees,
+// Then the function should return "Right angle"
+
+// 2. Identify Acute Angles:
+// When the angle is less than 90 degrees",
+// Then the function should return "Acute angle"
+
+// 3. Identify Obtuse Angles:
+// When the angle is greater than 90 degrees and less than 180 degrees,
+// Then the function should return "Obtuse angle"
+
+// 4. Identify Straight Angles:
+// When the angle is exactly 180 degrees,
+// Then the function should return "Straight angle"
+
+// 5. Identify Reflex Angles:
+// When the angle is greater than 180 degrees and less than 360 degrees,
+// Then the function should return "Reflex angle"
+
+
+// ============================= function getAngleType ===============================
+//the use of else if is to compare one of the conditions 
+
+function getAngleType(angle){
+
+    if (angle === 90) {
+      return "Right angle";
+    } else if (angle > 0 && angle < 90) {
+      return "Acute angle";
+    } else if (angle > 90 && angle < 180) {
+      return  "Obtuse Angle";
+    } else if (angle === 180) {
+      return "Straight angle";
+    } else if (angle > 180 && angle < 360) {
+      return "Reflex Angle";
+    }
+    return "Invalid angle";
+} 
+
+
+// console.log(getAngleType(90));  // "Right angle"
+// console.log(getAngleType(45));  // "Acute angle"
+// console.log(getAngleType(135)); // "Obtuse angle"
+// console.log(getAngleType(180)); // "Straight angle"
+// console.log(getAngleType(270)); // "Reflex angle"
+// console.log(getAngleType(-30)); // "Invalid angle"
+
+
+
+// ============== test with console.assert() ==================
+//these test are more simple to write and read and only return the fail message
+//  console.assert(expression, message);
+
+console.assert(getAngleType(99) === "Right angle", "Test case failed for Right Angle"); // fail AssertionError [ERR_ASSERTION]: Test case failed for Right Angle
+console.assert(getAngleType(40) === "Acute angle", "Test case failed for Acute Angle");
+console.assert(getAngleType(135) === "Obtuse Angle", "test case failed for Obtuse Angle");
+console.assert(getAngleType(380) === "Straight angle", "Test failed for Straight angle"); // fail AssertionError [ERR_ASSERTION]: Test failed for Straight angle
+console.assert(getAngleType(270) === "Reflex Angle", "Test case Failed for Reflex Angle");
+console.assert(getAngleType(-10) === "Invalid angle", "Test case Failed for Invalid angle");
+console.assert(getAngleType(400) === "Invalid angle", "Test case Failed for Invalid Angle");
+
+
+
+// ============== test with Jest ==================
+// These tests are more detailed because we can see what was expected and what went wrong
+test('Should return "Right angle" for 90 degrees', () => {
+  const result = getAngleType(90); 
+  expect(result).toBe("Right angle");
+});
+
+test('Should return "Acute angle" for angles between 0 and 90', () => {
+  const result = getAngleType(35); 
+  expect(result).toBe("Acute angle");
+});
+
+test('Should return "Obtuse Angle" for angles between 90 and 180', () => {
+  const result = getAngleType(135);
+  expect(result).toBe("Obtuse Angle");
+});
+
+test('Should return "Straight angle" for 180 degrees', () => {
+  const result = getAngleType(180);
+  expect(result).toBe("Straight angle");
+});
+
+test('Should return "Reflex Angle" for angles between 180 and 360', () => {
+  const result = getAngleType(270);
+  expect(result).toBe("Reflex Angle");
+});
+
+test('Should return "Invalid angle" for angles outside 0-360 degrees', () => {
+  expect(getAngleType(-10)).toBe("Invalid angle");
+  expect(getAngleType(400)).toBe("Invalid angle");
+});
+
+
+
+
+
+//nodemon
+// to run these test and see the changes applied in the same time use      < nodemon -x "npm test" get-angle-type.test.js >
+
+// npm
+//once you are inside of the file you want to run  < npm test --  --watch >

Sprint-3/implement/get-card-value.js

@@ -6,26 +6,115 @@
 
 // Acceptance criteria:
 
-// Given a card string in the format "A♠" (representing a card in blackjack - the last character will always be an emoji for a suit, and all characters before will be a number 2-10, or one letter of J, Q, K, A),
+// 1. Given a card string in the format "A♠" (representing a card in blackjack -
+// the last character will always be an emoji for a suit, and all characters
+// before will be a number 2-10, or one letter of J, Q, K, A),
 // When the function getCardValue is called with this card string as input,
 // Then it should return the numerical card value
 
-// Handle Number Cards (2-10):
+// 2. Handle Number Cards (2-10):
 // Given a card with a rank between "2" and "9",
 // When the function is called with such a card,
-// Then it should return the numeric value corresponding to the rank (e.g., "5" should return 5).
+// Then it should return the numeric value corresponding to the rank
+// (e.g., "5" should return 5).
 
-// Handle Face Cards (J, Q, K):
+// 3. Handle Face Cards (J, Q, K):
 // Given a card with a rank of "10," "J," "Q," or "K",
 // When the function is called with such a card,
-// Then it should return the value 10, as these cards are worth 10 points each in blackjack.
+// Then it should return the value 10, as these cards are worth 10 points each
+//  in blackjack.
 
-// Handle Ace (A):
+// 4. Handle Ace (A):
 // Given a card with a rank of "A",
 // When the function is called with an Ace,
 // Then it should, by default, assume the Ace is worth 11 points, which is a common rule in blackjack.
 
-// Handle Invalid Cards:
+// 5. Handle Invalid Cards:
 // Given a card with an invalid rank (neither a number nor a recognized face card),
 // When the function is called with such a card,
 // Then it should throw an error indicating "Invalid card rank."
+
+// ========================= getCardValue ===========================
+
+function getCardValue(input) {
+  const rank = input.slice(0, -1);
+  const suit = input.slice(-1);
+
+
+  if (input === "10"){
+    return 10;
+  }else if (rank > 1 && rank < 11) {
+    return Number(rank);
+  } 
+  else if (input === "A") 
+    return 11;
+  else if (input.toUpperCase() === "K" || input.toUpperCase() === "Q" || input.toUpperCase() === "J"){
+    return 10;
+  }
+
+    if (suit !== "♠" && suit !== "♥" && suit !== "♣" && suit !== "♦" && input.length > 1) {
+  return "Invalid card rank.";
+  }
+}
+
+
+// ========================   Test cases console.log() =====================
+
+// console.log(getCardValue("10")); // Output: 10
+// console.log(getCardValue("10♠")); // Output: 10
+// console.log(getCardValue("5♥")); // Output: 5
+// console.log(getCardValue("A")); // Output: 11
+// console.log(getCardValue("k$")); // output Invalid card rank.
+// console.log(getCardValue("k")); // output 10
+
+
+// ========================   Test console.assert  =====================
+
+console.assert(getCardValue("10") === 10, "Test case failed for input '10'");
+console.assert(getCardValue("10♠") === 10, "Test case failed for input '10♠'");
+console.assert(getCardValue("5♥") === 5, "Test case failed for input '5♥'");
+console.assert(getCardValue("A") === 11, "Test case failed for input 'A'");
+console.assert(getCardValue("K") === 10, "Test case failed for input 'K'");
+console.assert(getCardValue("3X") === "Invalid card rank.", "Test case failed for input '3X'");
+
+console.log("All tests passed!");
+
+
+// ========================== optimized version =======================
+
+// function getCardValue(input) {
+//   const validSuits = ["♠", "♥", "♣", "♦"];
+//   const rank = input.length > 1 && isNaN(input) ? input.slice(0, -1) : input;
+//   const suit = input.length > 1 ? input.slice(-1) : null;
+
+//   // Validate suit if present
+//   if (suit && !validSuits.includes(suit)) {
+//     return "Invalid card suit.";
+//   }
+
+//   // Handle numeric cards
+//   if (rank >= 2 && rank <= 10) {
+//     return Number(rank);
+//   }
+
+//   // Handle face cards
+//   if (["K", "Q", "J"].includes(rank.toUpperCase())) {
+//     return 10;
+//   }
+
+//   // Handle Ace
+//   if (rank.toUpperCase() === "A") {
+//     return 11;
+//   }
+
+//   return "Invalid card rank.";
+// }
+
+// // Test cases
+// console.log(getCardValue("10"));    // Output: 10
+// console.log(getCardValue("10♠"));   // Output: 10
+// console.log(getCardValue("5♥"));    // Output: 5
+// console.log(getCardValue("A"));     // Output: 11
+// console.log(getCardValue("K$"));    // Output: "Invalid card suit."
+// console.log(getCardValue("K"));     // Output: 10
+// console.log(getCardValue("11♥"));   // Output: "Invalid card rank."

Sprint-3/implement/is-proper-fraction.js

@@ -25,10 +25,32 @@
 // Negative Fraction check:
 // Input: numerator = -4, denominator = 7
 // target output: true
-// Explanation: The fraction -4/7 is a proper fraction because the absolute value of the numerator (4) is less than the denominator (7). The function should return true.
+// Explanation: The fraction -4/7 is a proper fraction because 
+// the absolute value of the numerator (4) is less than the denominator (7). The function should return true.
 
 // Equal Numerator and Denominator check:
 // Input: numerator = 3, denominator = 3
 // target output: false
 // Explanation: The fraction 3/3 is not a proper fraction because the numerator is equal to the denominator. The function should return false.
 // These acceptance criteria cover a range of scenarios to ensure that the isProperFraction function handles both proper and improper fractions correctly and handles potential errors such as a zero denominator.
+
+function isProperFraction(numerator, denominator) {
+  // Check for denominator being zero
+  if (denominator === 0) {
+    throw new Error("Denominator cannot be zero");
+  }
+
+  // If numerator is equal to denominator, it's not a proper fraction
+  if (numerator === denominator) {
+    return false;
+  }
+
+  // Proper fraction if the absolute value of the numerator is less than the denominator
+  return Math.abs(numerator) < denominator;
+}
+
+
+console.log(isProperFraction(3, 6)); 
+console.log(isProperFraction(-3, 6));
+console.log(isProperFraction(9, 0)); 
+console.log(isProperFraction(5, 5)); 

Sprint-3/implement/is-valid-triangle.js

@@ -33,3 +33,49 @@
 // Then it should return true because the input forms a valid triangle.
 
 // This specification outlines the behavior of the isValidTriangle function for different input scenarios, ensuring it properly checks for invalid side lengths and whether they form a valid triangle according to the Triangle Inequality Theorem.
+
+
+function isValidTriangle(side1, side2, side3){
+
+    if(side1 === 0 || side2 === 0 || side3 === 0){
+        return false;
+    }
+
+    else if(side1 + side2 > side3){
+        return true;
+    }
+    else if(side2 + side3 > side1){
+        return true;
+    }
+    else if(side1 + side3 > side2){
+        return true;
+    }
+    return false
+
+
+}
+
+console.log(isValidTriangle(3, 20, 20));
+console.log(isValidTriangle(3, 6, 10));
+console.log(isValidTriangle(9, 0, 1));
+console.log(isValidTriangle(5, 0, 1)); 
+
+
+// ========================== optimized version =======================
+
+// function isValidTriangle(side1, side2, side3) {
+//     // Check for non-positive side lengths
+//     if (side1 <= 0 || side2 <= 0 || side3 <= 0) {
+//         return false;
+//     }
+//     // Validate triangle inequality
+//     if (side1 + side2 > side3 && side2 + side3 > side1 && side1 + side3 > side2) {
+//         return true;
+//     }
+//     return false;
+// }
+
+// console.log(isValidTriangle(3, 20, 20));  // false
+// console.log(isValidTriangle(3, 6, 10));   // true
+// console.log(isValidTriangle(9, 0, 1));    // false
+// console.log(isValidTriangle(5, 0, 1));    // false