diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
index 9e05a871e2..945fa68e55 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/1-get-angle-type.js
@@ -10,28 +10,30 @@
 
 // Assumption: The parameter is a valid number. (You do not need to handle non-numeric inputs.)
 
-// Acceptance criteria:
-// After you have implemented the function, write tests to cover all the cases, and
-// execute the code to ensure all tests pass.
-
 function getAngleType(angle) {
-  // TODO: Implement this function
+  if (angle > 0 && angle < 90) {
+    return "Acute angle";
+  } else if (angle === 90) {
+    return "Right 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";
+  } else {
+    return "Invalid angle";
+  }
 }
 
 // The line below allows us to load the getAngleType function into tests in other files.
-// This will be useful in the "rewrite tests with jest" step.
 module.exports = getAngleType;
 
 // This helper function is written to make our assertions easier to read.
-// If the actual output matches the target output, the test will pass
 function assertEquals(actualOutput, targetOutput) {
   console.assert(
     actualOutput === targetOutput,
-    `Expected ${actualOutput} to equal ${targetOutput}`
+    `Expected "${actualOutput}" to equal "${targetOutput}"`
   );
 }
 
-// TODO: Write tests to cover all cases, including boundary and invalid cases.
-// Example: Identify Right Angles
-const right = getAngleType(90);
-assertEquals(right, "Right angle");
diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js b/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
index 970cb9b641..905a6907e0 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/2-is-proper-fraction.js
@@ -4,18 +4,18 @@
 
 // Assumption: The parameters are valid numbers (not NaN or Infinity).
 
-// Note: If you are unfamiliar with proper fractions, please look up its mathematical definition.
-
-// Acceptance criteria:
-// After you have implemented the function, write tests to cover all the cases, and
-// execute the code to ensure all tests pass.
-
 function isProperFraction(numerator, denominator) {
-  // TODO: Implement this function
+  // A denominator of 0 is mathematically undefined, so it cannot be a proper fraction.
+  if (denominator === 0) {
+    return false;
+  }
+
+  // A fraction is proper if the absolute value of the numerator 
+  // is strictly less than the absolute value of the denominator.
+  return Math.abs(numerator) < Math.abs(denominator);
 }
 
 // The line below allows us to load the isProperFraction function into tests in other files.
-// This will be useful in the "rewrite tests with jest" step.
 module.exports = isProperFraction;
 
 // Here's our helper again
@@ -26,8 +26,3 @@ function assertEquals(actualOutput, targetOutput) {
   );
 }
 
-// TODO: Write tests to cover all cases.
-// What combinations of numerators and denominators should you test?
-
-// Example: 1/2 is a proper fraction
-assertEquals(isProperFraction(1, 2), true);
diff --git a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
index ff5c532e1d..3b19476101 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/implement/3-get-card-value.js
@@ -1,35 +1,50 @@
-// This problem involves playing cards: https://en.wikipedia.org/wiki/Standard_52-card_deck
-
 // Implement a function getCardValue, when given a string representing a playing card,
 // should return the numerical value of the card.
 
-// A valid card string will contain a rank followed by the suit.
-// The rank can be one of the following strings:
-//   "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"
-// The suit can be one of the following emojis:
-//   "♠", "♥", "♦", "♣"
-// For example: "A♠", "2♥", "10♥", "J♣", "Q♦", "K♦".
+function getCardValue(card) {
+  // Validate that input is a non-empty string and has at least 2 characters (Rank + Suit)
+  if (typeof card !== "string" || card.length < 2) {
+    throw new Error("Invalid card format");
+  }
+
+  // Define valid suits
+  const validSuits = ["♠", "♥", "♦", "♣"];
 
-// When the card is an ace ("A"), the function should return 11.
-// When the card is a face card ("J", "Q", "K"), the function should return 10.
-// When the card is a number card ("2" to "10"), the function should return its numeric value.
+  // The suit is always the last character/emoji of the string.
+  // Using Array.from() or string methods safely extracts it.
+  const suit = card.slice(-1);
+  if (!validSuits.includes(suit)) {
+    throw new Error("Invalid card suit");
+  }
 
-// When the card string is invalid (not following the above format), the function should
-// throw an error.
+  // The rank is everything up to the suit emoji.
+  const rank = card.slice(0, -1);
 
-// Acceptance criteria:
-// After you have implemented the function, write tests to cover all the cases, and
-// execute the code to ensure all tests pass.
+  // Handle value mappings
+  if (rank === "A") {
+    return 11;
+  }
+  
+  if (["J", "Q", "K"].includes(rank)) {
+    return 10;
+  }
 
-function getCardValue(card) {
-  // TODO: Implement this function
+  // Parse numeric ranks ("2" through "10")
+  const numericValue = parseInt(rank, 10);
+  if (!isNaN(numericValue) && numericValue >= 2 && numericValue <= 10 && String(numericValue) === rank) {
+    return numericValue;
+  }
+
+  // If the rank doesn't match any criteria, it's invalid.
+  throw new Error("Invalid card rank");
 }
 
-// The line below allows us to load the getCardValue function into tests in other files.
-// This will be useful in the "rewrite tests with jest" step.
 module.exports = getCardValue;
 
-// Helper functions to make our assertions easier to read.
+// ==========================================
+// ASSERTION HELPERS
+// ==========================================
+
 function assertEquals(actualOutput, targetOutput) {
   console.assert(
     actualOutput === targetOutput,
@@ -37,18 +52,45 @@ function assertEquals(actualOutput, targetOutput) {
   );
 }
 
-// TODO: Write tests to cover all outcomes, including throwing errors for invalid cards.
-// Examples:
-assertEquals(getCardValue("9♠"), 9);
+// A helper to verify that an invalid input throws an error as expected
+function assertThrows(invalidCard) {
+  try {
+    getCardValue(invalidCard);
+    console.error(`❌ Error was NOT thrown for invalid card: "${invalidCard}"`);
+  } catch (e) {
+    // Test passes if an error is thrown
+  }
+}
 
-// Handling invalid cards
-try {
-  getCardValue("invalid");
+// ==========================================
+// TEST SUITE
+// ==========================================
 
-  // This line will not be reached if an error is thrown as expected
-  console.error("Error was not thrown for invalid card 😢");
-} catch (e) {
-  console.log("Error thrown for invalid card 🎉");
-}
+console.log("Running tests...");
+
+// 1. Valid Aces (Value: 11)
+assertEquals(getCardValue("A♠"), 11);
+assertEquals(getCardValue("A♥"), 11);
+
+// 2. Valid Face Cards (Value: 10)
+assertEquals(getCardValue("J♣"), 10);
+assertEquals(getCardValue("Q♦"), 10);
+assertEquals(getCardValue("K♠"), 10);
+
+// 3. Valid Numeric Boundary Cards
+assertEquals(getCardValue("2♥"), 2);
+assertEquals(getCardValue("5♦"), 5);
+assertEquals(getCardValue("9♠"), 9);
+assertEquals(getCardValue("10♣"), 10);
+
+// 4. Invalid Card Scenarios (Should throw errors)
+assertThrows("invalid");   // Completely wrong format
+assertThrows("A");         // Missing suit
+assertThrows("♠");         // Missing rank
+assertThrows("1♠");        // 1 is not a valid rank (should be "A")
+assertThrows("11♥");       // Out-of-bounds number card
+assertThrows("A♣️");       // Suit variations or hidden characters
+assertThrows("Q⭐️");       // Invalid suit emoji
+assertThrows("J ♠");       // Unwanted spacing
 
-// What other invalid card cases can you think of?
+console.log("All tests completed!");
\ No newline at end of file
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
index d777f348d3..60eeb470f9 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/1-get-angle-type.test.js
@@ -2,19 +2,52 @@
 // We will use the same function, but write tests for it using Jest in this file.
 const getAngleType = require("../implement/1-get-angle-type");
 
-// TODO: Write tests in Jest syntax to cover all cases/outcomes,
-// including boundary and invalid cases.
+describe("getAngleType", () => {
+  
+  // Case 1: Acute angles
+  test('should return "Acute angle" when (0 < angle < 90)', () => {
+    expect(getAngleType(1)).toBe("Acute angle");
+    expect(getAngleType(45)).toBe("Acute angle");
+    expect(getAngleType(89.9)).toBe("Acute angle");
+  });
 
-// Case 1: Acute angles
-test(`should return "Acute angle" when (0 < angle < 90)`, () => {
-  // Test various acute angles, including boundary cases
-  expect(getAngleType(1)).toEqual("Acute angle");
-  expect(getAngleType(45)).toEqual("Acute angle");
-  expect(getAngleType(89)).toEqual("Acute angle");
-});
+  // Case 2: Right angle
+  test('should return "Right angle" when angle is exactly 90', () => {
+    expect(getAngleType(90)).toBe("Right angle");
+  });
 
-// Case 2: Right angle
-// Case 3: Obtuse angles
-// Case 4: Straight angle
-// Case 5: Reflex angles
-// Case 6: Invalid angles
+  // Case 3: Obtuse angles
+  test('should return "Obtuse angle" when (90 < angle < 180)', () => {
+    expect(getAngleType(90.1)).toBe("Obtuse angle");
+    expect(getAngleType(135)).toBe("Obtuse angle");
+    expect(getAngleType(179.9)).toBe("Obtuse angle");
+  });
+
+  // Case 4: Straight angle
+  test('should return "Straight angle" when angle is exactly 180', () => {
+    expect(getAngleType(180)).toBe("Straight angle");
+  });
+
+  // Case 5: Reflex angles
+  test('should return "Reflex angle" when (180 < angle < 360)', () => {
+    expect(getAngleType(180.1)).toBe("Reflex angle");
+    expect(getAngleType(270)).toBe("Reflex angle");
+    expect(getAngleType(359.9)).toBe("Reflex angle");
+  });
+
+  // Case 6: Invalid angles
+  test('should return "Invalid angle" for angles outside the 0 to 360 range', () => {
+    // Negative angles
+    expect(getAngleType(-45)).toBe("Invalid angle");
+    
+    // Lower boundary
+    expect(getAngleType(0)).toBe("Invalid angle");
+    
+    // Upper boundary
+    expect(getAngleType(360)).toBe("Invalid angle");
+    
+    // Exceeding upper boundary
+    expect(getAngleType(361)).toBe("Invalid angle");
+  });
+
+});
\ No newline at end of file
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
index 7f087b2ba1..81e52b88b2 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/2-is-proper-fraction.test.js
@@ -2,9 +2,50 @@
 // We will use the same function, but write tests for it using Jest in this file.
 const isProperFraction = require("../implement/2-is-proper-fraction");
 
-// TODO: Write tests in Jest syntax to cover all combinations of positives, negatives, zeros, and other categories.
+describe("isProperFraction", () => {
+  
+  // 1. Positive Proper Fractions
+  test("should return true for positive proper fractions (numerator < denominator)", () => {
+    expect(isProperFraction(1, 2)).toBe(true);
+    expect(isProperFraction(3, 4)).toBe(true);
+    expect(isProperFraction(99, 100)).toBe(true);
+  });
+
+  // 2. Positive Improper Fractions
+  test("should return false for positive improper fractions (numerator >= denominator)", () => {
+    expect(isProperFraction(5, 4)).toBe(false);
+    expect(isProperFraction(10, 2)).toBe(false);
+    expect(isProperFraction(4, 4)).toBe(false); // Exactly 1
+  });
+
+  // 3. Zero Cases
+  test("should return false when denominator is zero", () => {
+    expect(isProperFraction(1, 0)).toBe(false);
+    expect(isProperFraction(0, 0)).toBe(false);
+  });
+
+  test("should return true when numerator is zero and denominator is non-zero", () => {
+    expect(isProperFraction(0, 5)).toBe(true);
+    expect(isProperFraction(0, -5)).toBe(true);
+  });
+
+  // 4. Negative Fractions
+  test("should evaluate proper fractions correctly when negative signs are present", () => {
+    expect(isProperFraction(-1, 3)).toBe(true);   // Negative numerator
+    expect(isProperFraction(1, -3)).toBe(true);   // Negative denominator
+    expect(isProperFraction(-1, -3)).toBe(true);  // Both negative
+  });
+
+  test("should evaluate improper fractions correctly when negative signs are present", () => {
+    expect(isProperFraction(-5, 4)).toBe(false);  // Magnitude > 1
+    expect(isProperFraction(5, -4)).toBe(false);  // Magnitude > 1
+    expect(isProperFraction(-4, -4)).toBe(false); // Magnitude = 1
+  });
+
+  // 5. Decimals / Floating Point Numbers
+  test("should handle decimal inputs using absolute magnitude values", () => {
+    expect(isProperFraction(1.5, 3)).toBe(true);
+    expect(isProperFraction(4.5, 3)).toBe(false);
+  });
 
-// Special case: numerator is zero
-test(`should return false when denominator is zero`, () => {
-  expect(isProperFraction(1, 0)).toEqual(false);
 });
diff --git a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
index cf7f9dae2e..49027d7d9c 100644
--- a/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
+++ b/Sprint-3/1-implement-and-rewrite-tests/rewrite-tests-with-jest/3-get-card-value.test.js
@@ -1,20 +1,72 @@
 // This statement loads the getCardValue function you wrote in the implement directory.
-// We will use the same function, but write tests for it using Jest in this file.
+// We will use the same function, but write tests for it using Jest in this file
 const getCardValue = require("../implement/3-get-card-value");
 
-// TODO: Write tests in Jest syntax to cover all possible outcomes.
+describe("getCardValue", () => {
 
-// Case 1: Ace (A)
-test(`Should return 11 when given an ace card`, () => {
-  expect(getCardValue("A♠")).toEqual(11);
-});
+  // Case 1: Aces
+  test("Should return 11 when given an ace card", () => {
+    expect(getCardValue("A♠")).toBe(11);
+    expect(getCardValue("A♥")).toBe(11);
+    expect(getCardValue("A♦")).toBe(11);
+    expect(getCardValue("A♣")).toBe(11);
+  });
+
+  // Case 2: Number Cards (2-10)
+  describe("Number Cards (2-10)", () => {
+    test("should return the exact numeric value for standard cards", () => {
+      expect(getCardValue("2♥")).toBe(2);
+      expect(getCardValue("5♦")).toBe(5);
+      expect(getCardValue("9♠")).toBe(9);
+    });
+
+    test("should correctly parse the two-digit boundary card 10", () => {
+      expect(getCardValue("10♣")).toBe(10);
+      expect(getCardValue("10♦")).toBe(10);
+    });
+  });
+
+  // Case 3: Face Cards (J, Q, K)
+  describe("Face Cards (J, Q, K)", () => {
+    test("should return 10 for Jacks (J)", () => {
+      expect(getCardValue("J♣")).toBe(10);
+    });
+
+    test("should return 10 for Queens (Q)", () => {
+      expect(getCardValue("Q♦")).toBe(10);
+    });
 
-// Suggestion: Group the remaining test data into these categories:
-//   Number Cards (2-10)
-//   Face Cards (J, Q, K)
-//   Invalid Cards
+    test("should return 10 for Kings (K)", () => {
+      expect(getCardValue("K♠")).toBe(10);
+    });
+  });
 
-// To learn how to test whether a function throws an error as expected in Jest,
-// please refer to the Jest documentation:
-// https://jestjs.io/docs/expect#tothrowerror
+  // Case 4: Invalid Cards (Error Handling)
+  describe("Invalid Cards", () => {
+    // Note: When testing exceptions in Jest, wrap the execution in an anonymous function.
+    test("should throw an error for text strings unrelated to cards", () => {
+      expect(() => getCardValue("invalid")).toThrow();
+    });
 
+    test("should throw an error if missing the rank or the suit", () => {
+      expect(() => getCardValue("A")).toThrow();
+      expect(() => getCardValue("♠")).toThrow();
+    });
+
+    test("should throw an error for numeric values out of boundaries", () => {
+      expect(() => getCardValue("1♠")).toThrow();  // Should be an Ace
+      expect(() => getCardValue("11♥")).toThrow(); // Invalid face range
+      expect(() => getCardValue("0♦")).toThrow();  // Zero baseline invalid
+    });
+
+    test("should throw an error for unsupported suits or symbols", () => {
+      expect(() => getCardValue("Q⭐️")).toThrow();
+      expect(() => getCardValue("10X")).toThrow();
+    });
+
+    test("should throw an error for spacing anomalies", () => {
+      expect(() => getCardValue("J ♠")).toThrow();
+    });
+  });
+
+});
diff --git a/Sprint-3/2-practice-tdd/count.js b/Sprint-3/2-practice-tdd/count.js
index 95b6ebb7d4..dc0d2250cb 100644
--- a/Sprint-3/2-practice-tdd/count.js
+++ b/Sprint-3/2-practice-tdd/count.js
@@ -1,5 +1,17 @@
 function countChar(stringOfCharacters, findCharacter) {
-  return 5
+  let count = 0;
+  for (let i = 0; i < stringOfCharacters.length; i++) {
+    if (stringOfCharacters[i] === findCharacter) {
+      count++;
+    }
+  }
+  return count;
 }
 
 module.exports = countChar;
+
+// for mordern approach, we can use the following code
+// function countChar(stringOfCharacters, findCharacter) {
+//   return stringOfCharacters.split(findCharacter).length - 1;
+// }
+// module.exports = countChar;
diff --git a/Sprint-3/2-practice-tdd/count.test.js b/Sprint-3/2-practice-tdd/count.test.js
index 179ea0ddf7..1b1e18aa38 100644
--- a/Sprint-3/2-practice-tdd/count.test.js
+++ b/Sprint-3/2-practice-tdd/count.test.js
@@ -22,3 +22,23 @@ test("should count multiple occurrences of a character", () => {
 // And a character `char` that does not exist within `str`.
 // When the function is called with these inputs,
 // Then it should return 0, indicating that no occurrences of `char` were found.
+
+test("should return 0 if the character does not exist in the string", () => {
+  const str = "hello";
+  const char = "z";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});
+
+// Scenario: Boundary Case - Empty String
+// Given an empty input string `str`,
+// And any character `char`,
+// When the function is called with these inputs,
+// Then it should safely return 0.
+
+test("should return 0 when checking an empty string", () => {
+  const str = "";
+  const char = "a";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});
\ No newline at end of file
diff --git a/Sprint-3/2-practice-tdd/get-ordinal-number.js b/Sprint-3/2-practice-tdd/get-ordinal-number.js
index f95d71db13..658f517f59 100644
--- a/Sprint-3/2-practice-tdd/get-ordinal-number.js
+++ b/Sprint-3/2-practice-tdd/get-ordinal-number.js
@@ -1,5 +1,28 @@
+//function getOrdinalNumber(num) {
+//return "1st";
+//}
+
+//module.exports = getOrdinalNumber;
 function getOrdinalNumber(num) {
-  return "1st";
+  // Handle the teen exception rule first (11th, 12th, 13th)
+  // Any number ending in 11, 12, or 13 gets a "th" suffix
+  const lastTwoDigits = num % 100;
+  if (lastTwoDigits >= 11 && lastTwoDigits <= 13) {
+    return num + "th";
+  }
+
+  // Otherwise, look closely at the very last digit
+  const lastDigit = num % 10;
+  switch (lastDigit) {
+    case 1:
+      return num + "st";
+    case 2:
+      return num + "nd";
+    case 3:
+      return num + "rd";
+    default:
+      return num + "th";
+  }
 }
 
 module.exports = getOrdinalNumber;
diff --git a/Sprint-3/2-practice-tdd/get-ordinal-number.test.js b/Sprint-3/2-practice-tdd/get-ordinal-number.test.js
index adfa58560f..d047bde5db 100644
--- a/Sprint-3/2-practice-tdd/get-ordinal-number.test.js
+++ b/Sprint-3/2-practice-tdd/get-ordinal-number.test.js
@@ -18,3 +18,46 @@ test("should append 'st' for numbers ending with 1, except those ending with 11"
   expect(getOrdinalNumber(21)).toEqual("21st");
   expect(getOrdinalNumber(131)).toEqual("131st");
 });
+
+// Case 2: Numbers ending with 2 (but not 12)
+// When the number ends with 2, except those ending with 12,
+// Then the function should return a string by appending "nd" to the number.
+test("should append 'nd' for numbers ending with 2, except those ending with 12", () => {
+  expect(getOrdinalNumber(2)).toEqual("2nd");
+  expect(getOrdinalNumber(32)).toEqual("32nd");
+  expect(getOrdinalNumber(242)).toEqual("242nd");
+});
+
+// Case 3: Numbers ending with 3 (but not 13)
+// When the number ends with 3, except those ending with 13,
+// Then the function should return a string by appending "rd" to the number.
+test("should append 'rd' for numbers ending with 3, except those ending with 13", () => {
+  expect(getOrdinalNumber(3)).toEqual("3rd");
+  expect(getOrdinalNumber(43)).toEqual("43rd"); // Note: should be "43rd" based on standard logic, fixing a potential typo
+  expect(getOrdinalNumber(103)).toEqual("103rd");
+});
+
+// Case 4: General numbers ending with 4 through 9, and 0
+// When the number ends with 4, 5, 6, 7, 8, 9, or 0,
+// Then the function should return a string by appending "th" to the number.
+test("should append 'th' for general numbers ending in 4-9 or 0", () => {
+  expect(getOrdinalNumber(4)).toEqual("4th");
+  expect(getOrdinalNumber(7)).toEqual("7th");
+  expect(getOrdinalNumber(20)).toEqual("20th");
+  expect(getOrdinalNumber(56)).toEqual("56th");
+});
+
+// Case 5: The Exception Rule (Numbers ending with 11, 12, or 13)
+// When the number ends specifically with 11, 12, or 13 (the teen boundary),
+// Then the function should always override standard rules and append "th".
+test("should correctly append 'th' for exceptions ending in 11, 12, or 13", () => {
+  // Primary boundaries
+  expect(getOrdinalNumber(11)).toEqual("11th");
+  expect(getOrdinalNumber(12)).toEqual("12th");
+  expect(getOrdinalNumber(13)).toEqual("13th");
+  
+  // Larger representative samples matching the group
+  expect(getOrdinalNumber(111)).toEqual("111th");
+  expect(getOrdinalNumber(212)).toEqual("212th");
+  expect(getOrdinalNumber(1013)).toEqual("1013th");
+});
\ No newline at end of file
diff --git a/Sprint-3/2-practice-tdd/repeat-str.js b/Sprint-3/2-practice-tdd/repeat-str.js
index 2af0a2cea7..9635190b9a 100644
--- a/Sprint-3/2-practice-tdd/repeat-str.js
+++ b/Sprint-3/2-practice-tdd/repeat-str.js
@@ -1,7 +1,17 @@
-function repeatStr() {
-  // Your implementation of this function must *not* call String.prototype.repeat (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/repeat).
-  // The goal is to re-implement that function, not to use it.
-  return "hellohellohello";
+function repeatStr(str, count) {
+  // Guard clause for invalid counts
+  if (count < 0) {
+    throw new RangeError("repeatStr count must be non-negative");
+  }
+
+  let result = "";
+
+  // Append the string to the result string 'count' times
+  for (let i = 0; i < count; i++) {
+    result += str;
+  }
+
+  return result;
 }
 
-module.exports = repeatStr;
+module.exports = repeatStr;
\ No newline at end of file
diff --git a/Sprint-3/2-practice-tdd/repeat-str.test.js b/Sprint-3/2-practice-tdd/repeat-str.test.js
index a3fc1196c4..fb8d5a8b81 100644
--- a/Sprint-3/2-practice-tdd/repeat-str.test.js
+++ b/Sprint-3/2-practice-tdd/repeat-str.test.js
@@ -20,13 +20,34 @@ test("should repeat the string count times", () => {
 // Given a target string `str` and a `count` equal to 1,
 // When the repeatStr function is called with these inputs,
 // Then it should return the original `str` without repetition.
+test("should return the original string when count is 1", () => {
+  const str = "hello";
+  const count = 1;
+  const repeatedStr = repeatStr(str, count);
+  expect(repeatedStr).toEqual("hello");
+});
 
 // Case: Handle count of 0:
 // Given a target string `str` and a `count` equal to 0,
 // When the repeatStr function is called with these inputs,
 // Then it should return an empty string.
+test("should return an empty string when count is 0", () => {
+  const str = "hello";
+  const count = 0;
+  const repeatedStr = repeatStr(str, count);
+  expect(repeatedStr).toEqual("");
+});
 
 // Case: Handle negative count:
 // Given a target string `str` and a negative integer `count`,
 // When the repeatStr function is called with these inputs,
 // Then it should throw an error, as negative counts are not valid.
+test("should throw an error when count is negative", () => {
+  const str = "hello";
+  const count = -1;
+  
+  // In Jest, to test if a function throws an error, you must wrap it in a wrapper function
+  expect(() => {
+    repeatStr(str, count);
+  }).toThrow();
+});
\ No newline at end of file
diff --git a/Sprint-3/3-dead-code/exercise-1.js b/Sprint-3/3-dead-code/exercise-1.js
index 4d09f15fa9..baf94c4476 100644
--- a/Sprint-3/3-dead-code/exercise-1.js
+++ b/Sprint-3/3-dead-code/exercise-1.js
@@ -15,3 +15,31 @@ testName = "Aman";
 const greetingMessage = sayHello(greeting, testName);
 
 console.log(greetingMessage); // 'hello, Aman!'
+
+// this is the correct code after removing unreachable and redundant code
+
+const greeting = "hello";
+let testName = "Aman";
+
+function sayHello(greeting, name) {
+  // Directly returns the cleanly formatted string
+  return `${greeting}, ${name}!`;
+}
+
+const greetingMessage = sayHello(greeting, testName);
+
+console.log(greetingMessage); // Output: 'hello, Aman!'
+
+//reasons for the changes:
+
+// 1. Unreachable Code: The console.log(greetingStr); 
+// inside the function occurs after the return statement. 
+// Once a function hits a return, it immediately exits, 
+// making anything below it completely unreachable.
+
+// 2. Redundant Code: The variable const greetingStr = greeting + ", " + name + "!"; 
+// was created using old string concatenation, but the function actually returns a template literal expression (${greeting}, ${name}!). 
+// Since greetingStr is never used elsewhere, it can be deleted entirely.
+
+// 3. Unused Global Variable: let testName = "Jerry"; is declared but immediately overwritten by testName = "Aman"; 
+// before ever being used, making the initial assignment redundant.
diff --git a/Sprint-3/3-dead-code/exercise-2.js b/Sprint-3/3-dead-code/exercise-2.js
index 56d7887c4c..d75750f93d 100644
--- a/Sprint-3/3-dead-code/exercise-2.js
+++ b/Sprint-3/3-dead-code/exercise-2.js
@@ -2,12 +2,9 @@
 // The countAndCapitalisePets function should continue to work for any reasonable input it's given, and you shouldn't modify the pets variable.
 
 const pets = ["parrot", "hamster", "horse", "dog", "hamster", "cat", "hamster"];
-const capitalisedPets = pets.map((pet) => pet.toUpperCase());
-const petsStartingWithH = pets.filter((pet) => pet[0] === "h");
 
-function logPets(petsArr) {
-  petsArr.forEach((pet) => console.log(pet));
-}
+// Kept because it is explicitly passed into the final calculation function
+const petsStartingWithH = pets.filter((pet) => pet[0] === "h");
 
 function countAndCapitalisePets(petsArr) {
   const petCount = {};
@@ -25,4 +22,4 @@ function countAndCapitalisePets(petsArr) {
 
 const countedPetsStartingWithH = countAndCapitalisePets(petsStartingWithH);
 
-console.log(countedPetsStartingWithH); // { 'HAMSTER': 3, 'HORSE': 1 } <- Final console log
+console.log(countedPetsStartingWithH); // { 'HAMSTER': 3, 'HORSE': 1 }
diff --git a/Sprint-3/4-stretch/card-validator.md b/Sprint-3/4-stretch/card-validator.md
index e39c6ace6e..e2e8290778 100644
--- a/Sprint-3/4-stretch/card-validator.md
+++ b/Sprint-3/4-stretch/card-validator.md
@@ -33,3 +33,39 @@ These are the requirements your project needs to fulfill:
 - Return a boolean from the function to indicate whether the credit card number is valid.
 
 Good luck!
+
+
+function validateCreditCard(cardNumber) {
+  // Requirement Rule 1: Must be exactly 16 characters long and contain only numbers
+  const is16Digits = /^\d{16}$/.test(cardNumber);
+  if (!is16Digits) {
+    return false;
+  }
+
+  // Convert the string into an array of integers for numerical calculations
+  const digits = cardNumber.split("").map(Number);
+
+  // Requirement Rule 2: Must have at least two different digits represented
+  // We use a Set because it automatically filters out duplicate values
+  const uniqueDigits = new Set(digits);
+  if (uniqueDigits.size < 2) {
+    return false;
+  }
+
+  // Requirement Rule 3: The final digit must be even
+  const lastDigit = digits[digits.length - 1];
+  if (lastDigit % 2 !== 0) {
+    return false;
+  }
+
+  // Requirement Rule 4: The sum of all digits must be greater than 16
+  const totalSum = digits.reduce((sum, currentDigit) => sum + currentDigit, 0);
+  if (totalSum <= 16) {
+    return false;
+  }
+
+  // If the number passes every single gatekeeper conditional check above, it's valid!
+  return true;
+}
+
+module.exports = validateCreditCard;
diff --git a/Sprint-3/4-stretch/find.js b/Sprint-3/4-stretch/find.js
index c7e79a2f21..124b5855cd 100644
--- a/Sprint-3/4-stretch/find.js
+++ b/Sprint-3/4-stretch/find.js
@@ -20,6 +20,26 @@ console.log(find("code your future", "z"));
 // Pay particular attention to the following:
 
 // a) How the index variable updates during the call to find
+// The index variable starts at 0. In every iteration of the while loop, 
+// after the if check is performed, index increases by exactly 1 (index++). 
+//  This moves the "pointer" one character to the right through the string str, 
+// ensuring that the function checks every character sequentially from left to right.
+
 // b) What is the if statement used to check
+// The if statement checks equality. Specifically, it asks: 
+// "Does the character currently stored at the index position of the string match the char I am looking for?"
+// If the answer is true, the function immediately returns the current index, which exits the entire function.
+// If the answer is false, the loop simply continues to the next iteration.
+
 // c) Why is index++ being used?
+// index++ (which is shorthand for index = index + 1) is the loop advancement mechanism. 
+// Without it, index would remain 0 forever. 
+// This would cause an "infinite loop" where the program keeps checking the very first character of the string over and over again, 
+// never moving forward to inspect the rest of the string.
+
 // d) What is the condition index < str.length used for?
+// This is the boundary condition (or loop guard). It ensures the code doesn't try to look for a character outside of the string's memory.
+// In JavaScript, if you try to access an index that doesn't exist, it returns undefined.
+// By ensuring index is always less than the length of the string, we guarantee that we only access valid positions. 
+// Once index equals the length of the string, it means we have checked every single character without finding a match, 
+// so the loop terminates, and the function returns -1 (indicating "not found").
diff --git a/Sprint-3/4-stretch/password-validator.js b/Sprint-3/4-stretch/password-validator.js
index b55d527dba..0ba3b2c700 100644
--- a/Sprint-3/4-stretch/password-validator.js
+++ b/Sprint-3/4-stretch/password-validator.js
@@ -1,6 +1,16 @@
 function passwordValidator(password) {
-    return password.length < 5 ? false : true
-}
+    // Rule: Must be at least 8 characters
+    if (password.length < 8) return false;
+
+    // Rule: Must contain at least one number
+    const hasNumber = /\d/.test(password);
+    if (!hasNumber) return false;
 
+    // Rule: Must contain at least one uppercase letter
+    const hasUpperCase = /[A-Z]/.test(password);
+    if (!hasUpperCase) return false;
+
+    return true;
+}
 
 module.exports = passwordValidator;
\ No newline at end of file
diff --git a/Sprint-3/4-stretch/password-validator.test.js b/Sprint-3/4-stretch/password-validator.test.js
index 8fa3089d6b..ac2a60e55e 100644
--- a/Sprint-3/4-stretch/password-validator.test.js
+++ b/Sprint-3/4-stretch/password-validator.test.js
@@ -14,13 +14,30 @@ To be valid, a password must:
 
 You must breakdown this problem in order to solve it. Find one test case first and get that working
 */
-const isValidPassword = require("./password-validator");
-test("password has at least 5 characters", () => {
-    // Arrange
-    const password = "12345";
-    // Act
-    const result = isValidPassword(password);
-    // Assert
-    expect(result).toEqual(true);
+
+const previousPasswords = [];
+
+function isValidPassword(password) {
+  // Check length
+  if (password.length < 5) return false;
+
+  // Check if we already used this password
+  if (previousPasswords.includes(password)) return false;
+
+  // Check for required types using simple helper logic
+  const hasUpper = /[A-Z]/.test(password);
+  const hasLower = /[a-z]/.test(password);
+  const hasNumber = /[0-9]/.test(password);
+  const hasSymbol = /[!#$%&.*]/.test(password);
+
+  // If all conditions are met, save it and return true
+  if (hasUpper && hasLower && hasNumber && hasSymbol) {
+    previousPasswords.push(password);
+    return true;
+  }
+
+  // Otherwise, it's invalid
+  return false;
 }
-);
\ No newline at end of file
+
+module.exports = isValidPassword;
\ No newline at end of file