London|May-2025|ping wang|Sprint3

Sprint-1/1-key-exercises/1-count.js

@@ -3,4 +3,8 @@ let count = 0;
 count = count + 1;
 
 // Line 1 is a variable declaration, creating the count variable with an initial value of 0
-// Describe what line 3 is doing, in particular focus on what = is doing
+// Describe what line 3 is doing, in particular what=
+Line one shows the initial value is 0 as a variable Declaration,
+Line 3  on the right-hand side count + 1 is evaluated first which means the current value 0 adds 1, giving 1
+The left-hand side count= means: Assign the result of right-hand side 1 back into the variable
+count. So after this runs the output should be 1

Sprint-1/1-key-exercises/2-initials.js

@@ -5,7 +5,7 @@ let lastName = "Johnson";
 // Declare a variable called initials that stores the first character of each string.
 // This should produce the string "CKJ", but you must not write the characters C, K, or J in the code of your solution.
 
-let initials = ``;
+let initials = firstName[0]+middleName[0]+lastName[0]:
 
 // https://www.google.com/search?q=get+first+character+of+string+mdn
 

Sprint-1/1-key-exercises/3-paths.js

@@ -16,8 +16,15 @@ console.log(`The base part of ${filePath} is ${base}`);
 
 // Create a variable to store the dir part of the filePath variable
 // Create a variable to store the ext part of the variable
+// Get everthing before base
+const dir = filePath.slice(0,lastSlashIndex);
+
+//Get everything after the last dot in the base
+const lastDotIndex = base.lastIndexOf(".");
+const ext = base.slice(lastSlashIndex+1);
+
+console.log('The dir part of ${filePath} is ${dir}');
+console.log('The ext part of ${filePath} is ${ext}');
 
-const dir = ;
-const ext = ;
 
 // https://www.google.com/search?q=slice+mdn

Sprint-3/1-key-implement/1-get-angle-type.js

@@ -9,9 +9,13 @@
 
 function getAngleType(angle) {
    if (angle === 90) return "Right angle";
-   // read to the end, complete line 36, then pass your test here
+   if (angle < 90) return "Acute angle";
+  if (angle > 90 && angle < 180) return "Obtuse angle";
+  if (angle === 180) return "Straight angle";
+  if (angle > 180 && angle < 360) return "Reflex angle";
 }
 
+
 // we're going to use this helper function to make our assertions easier to read
 // if the actual output matches the target output, the test will pass
 function assertEquals(actualOutput, targetOutput) {
@@ -43,14 +47,16 @@ assertEquals(acute, "Acute angle");
 // When the angle is greater than 90 degrees and less than 180 degrees,
 // Then the function should return "Obtuse angle"
 const obtuse = getAngleType(120);
-// ====> write your test here, and then add a line to pass the test in the function above
+assertEquals(obtuse,"Obtuse angle");
 
 // Case 4: Identify Straight Angles:
 // When the angle is exactly 180 degrees,
 // Then the function should return "Straight angle"
-// ====> write your test here, and then add a line to pass the test in the function above
+const straight = getAngleType(180);
+assertEquals(straight,"Straight angle");
 
 // Case 5: Identify Reflex Angles:
 // When the angle is greater than 180 degrees and less than 360 degrees,
 // Then the function should return "Reflex angle"
-// ====> write your test here, and then add a line to pass the test in the function above
+const reflex = getAngleType(300);
+assertEquals(reflex,"Reflex angle");

Sprint-3/1-key-implement/2-is-proper-fraction.js

@@ -8,7 +8,8 @@
 // write one test at a time, and make it pass, build your solution up methodically
 
 function isProperFraction(numerator, denominator) {
-    if (numerator < denominator) return true;
+    if (Math.abs(numerator) < Math.abs(denominator)) return true;
+  return false;
 }
 
 // here's our helper again
@@ -40,14 +41,14 @@ assertEquals(improperFraction, false);
 // 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.
 const negativeFraction = isProperFraction(-4, 7);
-// ====> complete with your assertion
+assertEquals(negativeFraction,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.
 const equalFraction = isProperFraction(3, 3);
-// ====> complete with your assertion
+assertEquals(equalFraction, false);
 
 // Stretch:
 // What other scenarios could you test for?

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

@@ -8,7 +8,13 @@
 // write one test at a time, and make it pass, build your solution up methodically
 // just make one change at a time -- don't rush -- programmers are deep and careful thinkers
 function getCardValue(card) {
-    if (rank === "A") return 11;
+    const rank = card.slice(0, -1); // removes suit
+
+  if (rank === "A") return 11;
+  if (!isNaN(rank)) return parseInt(rank); // 2-10
+  if (["J", "Q", "K"].includes(rank)) return 10;
+
+  throw new Error("Invalid card rank");
 }
 
 // You need to write assertions for your function to check it works in different cases
@@ -33,19 +39,38 @@ assertEquals(aceofSpades, 11);
 // 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).
 const fiveofHearts = getCardValue("5♥");
-// ====> write your test here, and then add a line to pass the test in the function above
+assertEquals(fiveofHearts,5);
+// then add a line to pass the test in the function above
 
 // 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.
+const jack = getCardValue("J♦");
+assertEquals(jack, 10);
+
+const queen = getCardValue("Q♣");
+assertEquals(queen, 10);
+
+const king = getCardValue("K♠");
+assertEquals(king, 10);
+
+const ten = getCardValue("10♥");
+assertEquals(ten, 10);
 
 // 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.
+const ace = getCardValue("A♠");
+assertEquals(ace, 11);
 
 // 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."
+try {
+  getCardValue("Z♠");
+} catch (e) {
+  assertEquals(e.message, "Invalid card rank");
+}

Sprint-3/2-mandatory-rewrite/1-get-angle-type.js

@@ -1,7 +1,15 @@
 function getAngleType(angle) {
   if (angle === 90) return "Right angle";
-  // replace with your completed function from key-implement
-
+  if (angle < 90) return "Acute angle";
+  if (angle > 90 && angle < 180) return "Obtuse angle";
+  if (angle === 180) return "Straight angle";
+  if (angle > 180 && angle < 360) return "Reflex angle";
+}
+function assertEquals(actualOutput, targetOutput) {
+  console.assert(
+    actualOutput === targetOutput,
+    `Expected ${actualOutput} to equal ${targetOutput}`
+  );
 }
 
 

Sprint-3/2-mandatory-rewrite/1-get-angle-type.test.js

@@ -10,15 +10,27 @@ test("should identify right angle (90°)", () => {
 // Case 2: Identify Acute Angles:
 // When the angle is less than 90 degrees,
 // Then the function should return "Acute angle"
+test("should identify acute angle (less than 90°)", () => {
+  expect(getAngleType(45)).toEqual("Acute angle");
+});
 
 // Case 3: Identify Obtuse Angles:
 // When the angle is greater than 90 degrees and less than 180 degrees,
 // Then the function should return "Obtuse angle"
+test("should identify obtuse angle (greater than 90° and less than 180°)", () => {
+  expect(getAngleType(120)).toEqual("Obtuse angle");
+});
 
 // Case 4: Identify Straight Angles:
 // When the angle is exactly 180 degrees,
 // Then the function should return "Straight angle"
+test("should identify straight angle (exactly 180°)", () => {
+  expect(getAngleType(180)).toEqual("Straight angle");
+});
 
 // Case 5: Identify Reflex Angles:
 // When the angle is greater than 180 degrees and less than 360 degrees,
 // Then the function should return "Reflex angle"
+test("should identify reflex angle (greater than 180° and less than 360°)", () => {
+  expect(getAngleType(270)).toEqual("Reflex angle");
+});

Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.js

@@ -1,6 +1,13 @@
 function isProperFraction(numerator, denominator) {
-    if (numerator < denominator) return true;
-    // add your completed function from key-implement here
+    if (Math.abs(numerator) < Math.abs(denominator)) return true;
+  return false;
+}
+
+function assertEquals(actualOutput, targetOutput) {
+  console.assert(
+    actualOutput === targetOutput,
+    `Expected ${actualOutput} to equal ${targetOutput}`
+  );
 }
 
 module.exports = isProperFraction;

Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.test.js

@@ -5,7 +5,16 @@ test("should return true for a proper fraction", () => {
 });
 
 // Case 2: Identify Improper Fractions:
+test("should return false for an improper fraction (numerator > denominator)", () => {
+  expect(isProperFraction(5, 2)).toEqual(false);
+});
 
 // Case 3: Identify Negative Fractions:
+test("should return true for a negative proper fraction (-4 < 7)", () => {
+  expect(isProperFraction(-4, 7)).toEqual(true);
+});
 
 // Case 4: Identify Equal Numerator and Denominator:
+test("should return false when numerator equals denominator", () => {
+  expect(isProperFraction(3, 3)).toEqual(false);
+});

Sprint-3/2-mandatory-rewrite/3-get-card-value.js

@@ -1,5 +1,17 @@
 function getCardValue(card) {
-    // replace with your code from key-implement
-    return 11;
+   const rank = card.slice(0, -1); // removes suit
+
+  if (rank === "A") return 11;
+  if (!isNaN(rank)) return parseInt(rank); // 2-10
+  if (["J", "Q", "K"].includes(rank)) return 10;
+
+  throw new Error("Invalid card rank"); 
 }
+function assertEquals(actualOutput, targetOutput) {
+  console.assert(
+    actualOutput === targetOutput,
+    `Expected ${actualOutput} to equal ${targetOutput}`
+  );
+}
+
 module.exports = getCardValue;

Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js

@@ -6,6 +6,37 @@ test("should return 11 for Ace of Spades", () => {
     });
 
 // Case 2: Handle Number Cards (2-10):
+
+test("should return 7 for 7 of Hearts", () => {
+  expect(getCardValue("7♥")).toEqual(7);
+});
+
+test("should return 10 for 10 of Diamonds", () => {
+  expect(getCardValue("10♦")).toEqual(10);
+});
 // Case 3: Handle Face Cards (J, Q, K):
+
+test("should return 10 for Jack of Clubs", () => {
+  expect(getCardValue("J♣")).toEqual(10);
+});
+
+test("should return 10 for Queen of Hearts", () => {
+  expect(getCardValue("Q♥")).toEqual(10);
+});
+
+test("should return 10 for King of Diamonds", () => {
+  expect(getCardValue("K♦")).toEqual(10);
+});
 // Case 4: Handle Ace (A):
+test("should return 11 for Ace, () => { const ace = getCardValue("A")
+    expect(ace).toEqual(11);});
+
+
 // Case 5: Handle Invalid Cards:
+test("should throw error for invalid card rank", () => {
+  expect(() => getCardValue("Z♠")).toThrow("Invalid card rank");
+});
+
+test("should throw error for empty string", () => {
+  expect(() => getCardValue("")).toThrow("Invalid card rank");
+});

Sprint-3/3-mandatory-practice/implement/count.js

@@ -1,5 +1,12 @@
-function countChar(stringOfCharacters, findCharacter) {
-    return 5
+function countChar(stringOfCharacters, findCharacter) {let count = 0;
+    let position = 0;
+
+    while ((position = stringOfCharacters.indexOf(findCharacter, position)) !== -1) {
+        count++;  
+        position++; 
+    }
+
+    return count;
 }
 
 module.exports = countChar;

Sprint-3/3-mandatory-practice/implement/count.test.js

@@ -22,3 +22,10 @@ test("should count multiple occurrences of a character", () => {
 // And a character char that does not exist within the case-sensitive str,
 // When the function is called with these inputs,
 // Then it should return 0, indicating that no occurrences of the char were found in the case-sensitive str.
+
+test("should return 0 when the character does not occur in the string", () => {
+  const str = "hello world";
+  const char = "z"; 
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});

Sprint-3/3-mandatory-practice/implement/get-ordinal-number.js

@@ -1,5 +1,20 @@
-function getOrdinalNumber(num) {
- return "1st";
+function getOrdinalNumber(num) {const lastDigit = num % 10;
+  const lastTwoDigits = num % 100;
+
+  if (lastTwoDigits >= 11 && lastTwoDigits <= 13) {
+    return `${num}th`;
+  }
+
+  switch (lastDigit) {
+    case 1:
+      return `${num}st`;
+    case 2:
+      return `${num}nd`;
+    case 3:
+      return `${num}rd`;
+    default:
+      return `${num}th`;
+  }
 }
 
 module.exports = getOrdinalNumber;

Sprint-3/3-mandatory-practice/implement/get-ordinal-number.test.js

@@ -11,3 +11,31 @@ const getOrdinalNumber = require("./get-ordinal-number");
 test("should return '1st' for 1", () => {
     expect(getOrdinalNumber(1)).toEqual("1st");
     });
+
+test("should return '2nd' for 2", () => {
+  expect(getOrdinalNumber(2)).toEqual("2nd");
+});
+
+test("should return '3rd' for 3", () => {
+  expect(getOrdinalNumber(3)).toEqual("3rd");
+});
+
+test("should return '4th' for 4", () => {
+  expect(getOrdinalNumber(4)).toEqual("4th");
+});
+
+test("should return '11th' for 11", () => {
+  expect(getOrdinalNumber(11)).toEqual("11th");
+});
+
+test("should return '12th' for 12", () => {
+  expect(getOrdinalNumber(12)).toEqual("12th");
+});
+
+test("should return '13th' for 13", () => {
+  expect(getOrdinalNumber(13)).toEqual("13th");
+});
+
+test("should return '21st' for 21", () => {
+  expect(getOrdinalNumber(21)).toEqual("21st");
+});

Sprint-3/3-mandatory-practice/implement/repeat.js

@@ -1,5 +1,9 @@
-function repeat() {
-    return "hellohellohello";
-}
 
+function repeat(str, count) {
+    if (typeof count !== "number" || count < 0) {
+        throw new Error("Count must be a non-negative number");
+    }
+
+    return str.repeat(count);
+}
 module.exports = repeat;