From f5a2e689b1dfdf8ec3806aa39bd95417d15c690e Mon Sep 17 00:00:00 2001 From: Anuar Duisenbek Date: Wed, 9 Jul 2025 19:23:12 +0100 Subject: [PATCH 1/6] solved:1-key-impliment --- .gitignore | 1 + Sprint-3/1-key-implement/1-get-angle-type.js | 12 ++++++--- .../1-key-implement/2-is-proper-fraction.js | 13 +++++++++- Sprint-3/1-key-implement/3-get-card-value.js | 26 ++++++++++++++++++- 4 files changed, 47 insertions(+), 5 deletions(-) diff --git a/.gitignore b/.gitignore index bde36e530..8ac30313f 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ node_modules .DS_Store +.idea/ .vscode **/.DS_Store \ No newline at end of file diff --git a/Sprint-3/1-key-implement/1-get-angle-type.js b/Sprint-3/1-key-implement/1-get-angle-type.js index 08d1f0cba..794825b10 100644 --- a/Sprint-3/1-key-implement/1-get-angle-type.js +++ b/Sprint-3/1-key-implement/1-get-angle-type.js @@ -8,8 +8,11 @@ // Then, write the next test! :) Go through this process until all the cases are implemented 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 "Right angle"; + if (angle > 0 && 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 @@ -43,14 +46,17 @@ 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); +assertEquals(obtuse, "Obtuse angle"); // ====> write your test here, and then add a line to pass the test in the function above // 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 \ No newline at end of file +// ====> write your test here, and then add a line to pass the test in the function above diff --git a/Sprint-3/1-key-implement/2-is-proper-fraction.js b/Sprint-3/1-key-implement/2-is-proper-fraction.js index 91583e941..c3a1dbccf 100644 --- a/Sprint-3/1-key-implement/2-is-proper-fraction.js +++ b/Sprint-3/1-key-implement/2-is-proper-fraction.js @@ -8,7 +8,7 @@ // 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 (numerator < denominator) return true; } // here's our helper again @@ -40,6 +40,7 @@ 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); +assertEquals(negativeFraction, true); // ====> complete with your assertion // Equal Numerator and Denominator check: @@ -47,7 +48,17 @@ const negativeFraction = isProperFraction(-4, 7); // 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); +assertEquals(equalFraction, false); // ====> complete with your assertion // Stretch: // What other scenarios could you test for? + +const zeroNumerator = isProperFraction(0, 5); +assertEquals(zeroNumerator, true); // 0/5 is a proper fraction + +const negativeDenominator = isProperFraction(2, -8); +assertEquals(negativeDenominator, true); + +const negativeImproper = isProperFraction(-5, -2); +assertEquals(negativeImproper, false); diff --git a/Sprint-3/1-key-implement/3-get-card-value.js b/Sprint-3/1-key-implement/3-get-card-value.js index aa1cc9f90..f7b2e8a67 100644 --- a/Sprint-3/1-key-implement/3-get-card-value.js +++ b/Sprint-3/1-key-implement/3-get-card-value.js @@ -8,7 +8,12 @@ // 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; + let rank = card.slice(0, -1); + if (rank === "A") return 11; + if (rank === "K" || rank === "Q" || rank === "J" || rank === "10") return 10; + if (Number(rank) >= 2 && Number(rank) <= 9 && rank.length === 1) + return Number(rank); + throw Error("Invalid card rank"); } // You need to write assertions for your function to check it works in different cases @@ -39,13 +44,32 @@ const fiveofHearts = getCardValue("5♥"); // 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 kingOfHearts = getCardValue("K♥"); +assertEquals(kingOfHearts, 10); + +const jackOfSpades = getCardValue("J♠"); +assertEquals(jackOfSpades, 10); + +const queenOfDiamonds = getCardValue("Q♦"); +assertEquals(queenOfDiamonds, 10); + +const tenOfDiamonds = getCardValue("10♦"); +assertEquals(tenOfDiamonds, 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("X♠"); + console.log("Test failed: should have thrown an error"); +} catch (e) { + assertEquals(e.message, "Invalid card rank"); +} From 1d8b2ebd0103b954d03e00917d3431cd0e9abae1 Mon Sep 17 00:00:00 2001 From: Anuar Duisenbek Date: Wed, 9 Jul 2025 19:47:10 +0100 Subject: [PATCH 2/6] solved: manadatory-rewrite --- .../2-mandatory-rewrite/1-get-angle-type.js | 17 ++++------ .../1-get-angle-type.test.js | 12 +++++++ .../2-is-proper-fraction.js | 6 ++-- .../2-is-proper-fraction.test.js | 9 ++++++ .../2-mandatory-rewrite/3-get-card-value.js | 10 ++++-- .../3-get-card-value.test.js | 31 +++++++++++++++++-- 6 files changed, 65 insertions(+), 20 deletions(-) diff --git a/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js b/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js index d61254bd7..c65e98b2d 100644 --- a/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js +++ b/Sprint-3/2-mandatory-rewrite/1-get-angle-type.js @@ -1,18 +1,13 @@ function getAngleType(angle) { if (angle === 90) return "Right angle"; - // replace with your completed function from key-implement - + if (angle > 0 && 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"; } - - - - - - - // Don't get bogged down in this detail // Jest uses CommonJS module syntax by default as it's quite old -// We will upgrade our approach to ES6 modules in the next course module, so for now +// We will upgrade our approach to ES6 modules in the next course module, so for now // we have just written the CommonJS module.exports syntax for you -module.exports = getAngleType; \ No newline at end of file +module.exports = getAngleType; diff --git a/Sprint-3/2-mandatory-rewrite/1-get-angle-type.test.js b/Sprint-3/2-mandatory-rewrite/1-get-angle-type.test.js index b62827b7c..79c2a3d66 100644 --- a/Sprint-3/2-mandatory-rewrite/1-get-angle-type.test.js +++ b/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 angles (<90°)", () => { + expect(getAngleType(89)).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 right angles (between 90° and 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 (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 (between 180° and 360°)", () => { + expect(getAngleType(280)).toEqual("Reflex angle"); +}); diff --git a/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.js b/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.js index 9836fe398..eeb08afdf 100644 --- a/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.js +++ b/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.js @@ -1,6 +1,6 @@ function isProperFraction(numerator, denominator) { - if (numerator < denominator) return true; - // add your completed function from key-implement here + if (numerator < 0 || denominator < 0) return false; + return numerator < denominator; } -module.exports = isProperFraction; \ No newline at end of file +module.exports = isProperFraction; diff --git a/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.test.js b/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.test.js index ff1cc8173..1edd11e6b 100644 --- a/Sprint-3/2-mandatory-rewrite/2-is-proper-fraction.test.js +++ b/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", () => { + expect(isProperFraction(6, 3)).toEqual(false); +}); // Case 3: Identify Negative Fractions: +test("should false for a negative fraction", () => { + expect(isProperFraction(-4, -7)).toEqual(false); +}); // Case 4: Identify Equal Numerator and Denominator: +test("should return false for equal numerator and denominator", () => { + expect(isProperFraction(3, 3)).toEqual(false); +}); diff --git a/Sprint-3/2-mandatory-rewrite/3-get-card-value.js b/Sprint-3/2-mandatory-rewrite/3-get-card-value.js index 0d95d3736..853d8d7a1 100644 --- a/Sprint-3/2-mandatory-rewrite/3-get-card-value.js +++ b/Sprint-3/2-mandatory-rewrite/3-get-card-value.js @@ -1,5 +1,9 @@ function getCardValue(card) { - // replace with your code from key-implement - return 11; + let rank = card.slice(0, -1); + if (rank === "A") return 11; + if (rank === "K" || rank === "Q" || rank === "J" || rank === "10") return 10; + if (Number(rank) >= 2 && Number(rank) <= 9 && rank.length === 1) + return Number(rank); + throw Error("Invalid card rank"); } -module.exports = getCardValue; \ No newline at end of file +module.exports = getCardValue; diff --git a/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js b/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js index 03a8e2f34..350a88a0b 100644 --- a/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js +++ b/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js @@ -1,11 +1,36 @@ const getCardValue = require("./3-get-card-value"); test("should return 11 for Ace of Spades", () => { - const aceofSpades = getCardValue("A♠"); - expect(aceofSpades).toEqual(11); - }); + const aceofSpades = getCardValue("A♠"); + expect(aceofSpades).toEqual(11); +}); // Case 2: Handle Number Cards (2-10): +test("should return 7 for Seven of Hearts", () => { + expect(getCardValue("7♥")).toEqual(7); +}); +test("should return 10 for Ten 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 Diamonds", () => { + expect(getCardValue("Q♦")).toEqual(10); +}); +test("should return 10 for King of Hearts", () => { + expect(getCardValue("K♥")).toEqual(10); +}); + // Case 4: Handle Ace (A): +test("should return 11 for Ace of Hearts", () => { + expect(getCardValue("A♥")).toEqual(11); +}); // Case 5: Handle Invalid Cards: +test("should throw an error for invalid card rank", () => { + expect(() => getCardValue("X♠")).toThrow("Invalid card rank"); +}); +test("should throw an error for empty string", () => { + expect(() => getCardValue("")).toThrow("Invalid card rank"); +}); From ad6956efe79659520910aad5317dd07ab39ef935 Mon Sep 17 00:00:00 2001 From: Anuar Duisenbek Date: Wed, 9 Jul 2025 19:57:42 +0100 Subject: [PATCH 3/6] solved: count.test.js --- .../2-mandatory-rewrite/3-get-card-value.test.js | 1 + Sprint-3/3-mandatory-practice/implement/count.js | 12 +++++++++--- .../3-mandatory-practice/implement/count.test.js | 3 +++ 3 files changed, 13 insertions(+), 3 deletions(-) diff --git a/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js b/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js index 350a88a0b..99d9e9a88 100644 --- a/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js +++ b/Sprint-3/2-mandatory-rewrite/3-get-card-value.test.js @@ -12,6 +12,7 @@ test("should return 7 for Seven of Hearts", () => { test("should return 10 for Ten 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); diff --git a/Sprint-3/3-mandatory-practice/implement/count.js b/Sprint-3/3-mandatory-practice/implement/count.js index fce249650..c377378c9 100644 --- a/Sprint-3/3-mandatory-practice/implement/count.js +++ b/Sprint-3/3-mandatory-practice/implement/count.js @@ -1,5 +1,11 @@ -function countChar(stringOfCharacters, findCharacter) { - return 5 +function countChar(str, char) { + let count = 0; + for (let i = 0; i < str.length; i++) { + if (str[i] === char) { + count++; + } + } + return count; } -module.exports = countChar; \ No newline at end of file +module.exports = countChar; diff --git a/Sprint-3/3-mandatory-practice/implement/count.test.js b/Sprint-3/3-mandatory-practice/implement/count.test.js index 42baf4b4b..b5a5d6b7e 100644 --- a/Sprint-3/3-mandatory-practice/implement/count.test.js +++ b/Sprint-3/3-mandatory-practice/implement/count.test.js @@ -22,3 +22,6 @@ 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 there are no occurrences", () => { + expect(countChar("hello", "z")).toEqual(0); +}); From f8db359047691e746c80b44e4e34fdd7d97578b8 Mon Sep 17 00:00:00 2001 From: Anuar Duisenbek Date: Wed, 9 Jul 2025 20:00:36 +0100 Subject: [PATCH 4/6] solved: get-ordinal-number.test.js --- .../implement/get-ordinal-number.js | 12 ++++++++++-- .../implement/get-ordinal-number.test.js | 16 ++++++++++++++-- 2 files changed, 24 insertions(+), 4 deletions(-) diff --git a/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.js b/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.js index 24f528b0d..a7b46d90f 100644 --- a/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.js +++ b/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.js @@ -1,5 +1,13 @@ function getOrdinalNumber(num) { - return "1st"; + const lastTwoDigits = num % 100; + if (lastTwoDigits >= 11 && lastTwoDigits <= 13) { + return `${num}th`; + } + const lastDigit = num % 10; + if (lastDigit === 1) return `${num}st`; + if (lastDigit === 2) return `${num}nd`; + if (lastDigit === 3) return `${num}rd`; + return `${num}th`; } -module.exports = getOrdinalNumber; \ No newline at end of file +module.exports = getOrdinalNumber; diff --git a/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.test.js b/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.test.js index 6d55dfbb4..0201282d9 100644 --- a/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.test.js +++ b/Sprint-3/3-mandatory-practice/implement/get-ordinal-number.test.js @@ -9,5 +9,17 @@ const getOrdinalNumber = require("./get-ordinal-number"); // Then the function should return "1st" test("should return '1st' for 1", () => { - expect(getOrdinalNumber(1)).toEqual("1st"); - }); + expect(getOrdinalNumber(1)).toEqual("1st"); +}); + +test("should return '2nd' for 2", () => { + expect(getOrdinalNumber(2)).toEqual("2nd"); +}); //currently fails + +test("should return '3rd' for 3", () => { + expect(getOrdinalNumber(3)).toEqual("3rd"); +}); + +test("should return '4th' for 4", () => { + expect(getOrdinalNumber(4)).toEqual("4th"); +}); From 2d2e05700a55b35d994f025e8eef67e4bbf54d91 Mon Sep 17 00:00:00 2001 From: Anuar Duisenbek Date: Wed, 9 Jul 2025 20:09:18 +0100 Subject: [PATCH 5/6] solved repeat-test-js --- .../3-mandatory-practice/implement/repeat.js | 9 ++++++--- .../implement/repeat.test.js | 20 +++++++++++++------ 2 files changed, 20 insertions(+), 9 deletions(-) diff --git a/Sprint-3/3-mandatory-practice/implement/repeat.js b/Sprint-3/3-mandatory-practice/implement/repeat.js index 621f9bd35..82c4a1edf 100644 --- a/Sprint-3/3-mandatory-practice/implement/repeat.js +++ b/Sprint-3/3-mandatory-practice/implement/repeat.js @@ -1,5 +1,8 @@ -function repeat() { - return "hellohellohello"; +function repeat(str, count) { + if (count < 0) { + throw new Error("Count must be non-negative"); + } + return str.repeat(count); } -module.exports = repeat; \ No newline at end of file +module.exports = repeat; diff --git a/Sprint-3/3-mandatory-practice/implement/repeat.test.js b/Sprint-3/3-mandatory-practice/implement/repeat.test.js index 8a4ab42ef..dba68da32 100644 --- a/Sprint-3/3-mandatory-practice/implement/repeat.test.js +++ b/Sprint-3/3-mandatory-practice/implement/repeat.test.js @@ -10,23 +10,31 @@ const repeat = require("./repeat"); // Then it should repeat the str count times and return a new string containing the repeated str values. test("should repeat the string count times", () => { - const str = "hello"; - const count = 3; - const repeatedStr = repeat(str, count); - expect(repeatedStr).toEqual("hellohellohello"); - }); + const str = "hello"; + const count = 3; + const repeatedStr = repeat(str, count); + expect(repeatedStr).toEqual("hellohellohello"); +}); // case: handle Count of 1: // Given a target string str and a count equal to 1, // When the repeat function is called with these inputs, // Then it should return the original str without repetition, ensuring that a count of 1 results in no repetition. - +test("should return the original string if count is 1", () => { + expect(repeat("hello", 1)).toEqual("hello"); +}); // case: Handle Count of 0: // Given a target string str and a count equal to 0, // When the repeat function is called with these inputs, // Then it should return an empty string, ensuring that a count of 0 results in an empty output. +test("should return empty string if count 0", () => { + expect(repeat("hello", 0)).toEqual(""); +}); // case: Negative Count: // Given a target string str and a negative integer count, // When the repeat function is called with these inputs, // Then it should throw an error or return an appropriate error message, as negative counts are not valid. +test("should throw error for negative count", () => { + expect(() => repeat("hello", -2)).toThrow("Count must be non-negative"); +}); From 01b09dbae8dba45da7d624c7f2dd1a027594a1bc Mon Sep 17 00:00:00 2001 From: Anuar Duisenbek Date: Wed, 9 Jul 2025 22:12:36 +0100 Subject: [PATCH 6/6] fixed:isProperFraction --- Sprint-3/1-key-implement/2-is-proper-fraction.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Sprint-3/1-key-implement/2-is-proper-fraction.js b/Sprint-3/1-key-implement/2-is-proper-fraction.js index c3a1dbccf..8dc9cd240 100644 --- a/Sprint-3/1-key-implement/2-is-proper-fraction.js +++ b/Sprint-3/1-key-implement/2-is-proper-fraction.js @@ -8,7 +8,7 @@ // write one test at a time, and make it pass, build your solution up methodically function isProperFraction(numerator, denominator) { - if (numerator < denominator) return true; + return Math.abs(numerator) < Math.abs(denominator); } // here's our helper again