NW-6 | AREEB-SATTAR | JS1| [TECH ED] Complete week 4 exercises | WEEK-4

package.json

@@ -0,0 +1,10 @@
+{
+    "name": "week-4-exercises",
+    "description": "Created this package for the JS1 week 4 exercises",
+    "scripts": {
+        "test":"jest"
+    },
+    "devDependencies": {
+        "jest": "^29.7.0"
+    }
+}

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

@@ -0,0 +1,48 @@
+// Implement a function getAngleType, and tests for each of the acceptance criteria.
+
+const { default: expect } = require("expect");
+const { get } = require("http");
+
+// Acceptance criteria:
+
+// Identify Right Angles:
+// When the angle is exactly 90 degrees,
+// Then the function should return "Right angle"
+
+// Identify Acute Angles:
+// When the angle is less than 90 degrees,
+// Then the function should return "Acute angle"
+
+// Identify Obtuse Angles:
+// When the angle is greater than 90 degrees and less than 180 degrees,
+// Then the function should return "Obtuse angle"
+
+// Identify Straight Angles:
+// When the angle is exactly 180 degrees,
+// Then the function should return "Straight angle"
+
+// 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(angle) {
+  if (angle === 90) {
+    return "Right Angle";
+  } else if (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";
+  } else return "Angle cannot be greater than 360 or less than 0";
+}
+
+test("This is to check if our function is returning the correct type of triangle based on given angle", function () {
+  expect(getAngleType(90)).toBe("Right Angle");
+  expect(getAngleType(180)).toBe("Straight Angle");
+  expect(getAngleType(45)).toBe("Acute Angle");
+  expect(getAngleType(120)).toBe("Obtuse Angle");
+  expect(getAngleType(190)).toBe("Reflex Angle");
+});

week-3/implement/get-card-value.js → week-3/implement/get-card-value.test.js

@@ -1,5 +1,7 @@
 // This problem involves playing cards: https://en.wikipedia.org/wiki/Standard_52-card_deck
 
+const { default: expect } = require("expect");
+
 // You will need to implement a function getCardValue
 
 // You need to write assertions for your function to check it works in different cases
@@ -29,3 +31,22 @@
 // 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."
+
+function getCardValue(str) {
+  if (str === "A") {
+    return 11;
+  } else if (str === "J" || str === "Q" || str === "K") {
+    return 10;
+  } else if (str > 1 && str < 11) {
+    return +str;
+  } else return "Invalid card rank";
+}
+
+test("Check if function is returning right value for BlackJack game", function () {
+
+  expect(getCardValue("A")).toBe(11);
+  expect(getCardValue("J")).toBe(10);
+  expect(getCardValue("K")).toBe(10);
+  expect(getCardValue("2")).toBe(2);
+  expect(getCardValue("5")).toBe(5);
+});

week-3/implement/is-proper-fraction.js → week-3/implement/is-proper-fraction.test.js

@@ -1,6 +1,9 @@
 // You wil need to implement a function isProperFraction
 // You need to write assertions for your function to check it works in different cases
 
+const { log } = require("console");
+const { default: expect } = require("expect");
+
 // Terms:
 // Fractions: https://www.bbc.co.uk/bitesize/topics/zt9n6g8/articles/zjxpp4j
 // Written here like this: 1/2 == Numerator/Denominator
@@ -33,3 +36,31 @@
 // 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(a, b) {
+  if (b === 0) {
+    return "error";
+  }
+  if (a === b) {
+    return false;
+  }
+  if (a < b) {
+    return true;
+  }
+  if (a > b) {
+    return false;
+  }
+  if (a < 0) {
+    return true;
+  }
+}
+
+test("Check if the fraction is a proper fraction or not ", function () {
+
+    expect(isProperFraction(4, 7)).toBe(true);
+    expect(isProperFraction(7, 7)).toBe(false);
+    expect(isProperFraction(-4, 7)).toBe(true);
+    expect(isProperFraction(4, 0)).toBe("error");
+    expect(isProperFraction(5, 2)).toBe(false);
+});
+

week-3/implement/is-valid-triangle.js → week-3/implement/is-valid-triangle.test.js

@@ -1,5 +1,7 @@
 // Implement a function isValidTriangle
 
+const { default: expect } = require("expect");
+
 // 🗝️ Terms
 // the Triangle Inequality says: the sum of any two sides is always greater than the third side.
 // practical examples:
@@ -38,3 +40,22 @@
 // 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(a,b,c){
+    if (a+b<=c || a+c<=b || b+c<=a){
+        return false;
+    }
+    else if (a<=0 || b<=0 || c<=0){
+        return false;
+    }
+    else if(a+b>c && a+c>b && b+c>a){
+    return true;
+    }
+}
+
+test("Check if the triangle is valid or not", function () {
+
+    expect(isValidTriangle(3, 3, 3)).toBe(true);
+    expect(isValidTriangle(3, -3, 3)).toBe(false);
+    expect(isValidTriangle(1, 2, 5)).toBe(false);
+});

week-4/implement/count.test.js

@@ -1,5 +1,24 @@
 // implement a function countChar that counts the number of times a character occurs in a string
 
+function countChar(str, char) {
+  let index = 0;
+  for (let i = 0; i < str.length; i++) {
+    if (str[i] === char) {
+      index++;
+    }
+    while (str[i + 1] === char) {
+      i++;
+      index++;
+    }
+  }
+  return index;
+}
+test("This will check consecutive occurrences or no occurrences of a given character", function () {
+  expect(countChar("asad", "s")).toBe(1);
+  expect(countChar("assa", "s")).toBe(2);
+  expect(countChar("aaad", "s")).toBe(0);
+  expect(countChar("asssssd", "s")).toBe(5);
+});
 // Given a string str and a single character char to search for,
 // When the countChar function is called with these inputs,
 // Then it should:
@@ -14,4 +33,4 @@
 // Given the input string str,
 // 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.
+// Then it should return 0, indicating that no occurrences of the char were found in the case-sensitive str

week-4/implement/get-ordinal-number.test.js

@@ -1,4 +1,18 @@
 // In this week's prep, we started implementing getOrdinalNumber
+function getOrdinalNumber(num) {
+  if (num % 10 === 1) {
+    if (num === 11) {
+      return "11th";
+    }
+    return `${num}st`;
+  }
+}
+
+test("works for any number ending in 1", function () {
+  expect(getOrdinalNumber(1)).toBe("1st");
+  expect(getOrdinalNumber(11)).toBe("11th");
+  expect(getOrdinalNumber(21)).toBe("21st");
+});
 
 // continue testing and implementing getOrdinalNumber for additional cases
 // Write your tests using Jest - remember to run your tests often for continual feedback

week-4/implement/is-prime.test.js

@@ -1,3 +1,26 @@
 // Given a positive integer num,
 // When the isPrime function is called with num as input,
 // Then it should return a boolean representing whether the num is prime
+
+function isPrime(num) {
+    if (num < 2) {
+        return false;
+    }
+    if (num != Math.round(num)) {
+        return false;
+    }
+    for (var i = 2; i < num; i++){
+        if(num%i===0)
+        return false;
+    }
+    return true;
+}
+
+test("Check if the number is a positive prime number", function () {
+
+    expect(isPrime(3)).toBe(true);
+    expect(isPrime(-7)).toBe(false);
+    expect(isPrime(0)).toBe(false);
+    expect(isPrime(17)).toBe(true);
+    expect(isPrime(3.5)).toBe(false);
+});

week-4/implement/repeat.test.js

@@ -1,5 +1,7 @@
 // Implement a function repeat
 
+const { default: expect } = require("expect");
+
 // Given a target string str and a positive integer count,
 // When the repeat function is called with these inputs,
 // Then it should:
@@ -23,3 +25,24 @@
 // 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.
+
+function repeatString(str, num) {
+  if (num < 0) {
+    return "negative count is not valid";
+  }
+  let repeatedString = str.repeat(num);
+  if (num === 0) {
+    return "";
+  }
+  if (num === 1) {
+    return str;
+  } else return repeatedString;
+}
+
+test("Check if the string is being repeated correctly", function () {
+  expect(repeatString("Ali", 2)).toBe("AliAli");
+  expect(repeatString("Ali", 5)).toBe("AliAliAliAliAli");
+  expect(repeatString("Ali", 0)).toBe("");
+  expect(repeatString("Ali", 1)).toBe("Ali");
+  expect(repeatString("Ali", -2)).toBe("negative count is not valid");
+});

week-4/investigate/find.js

@@ -20,6 +20,10 @@ console.log(find("code your future", "z"));
 // Pay particular attention to the following:
 
 // a) How the index variable updates during the call to find
+//Ans. It adds 1 everytime the loop runs as index keep adding up until the input character has been reached
 // b) What is the if statement used to check
+//Ans. it's checking the value of certain index or string against the input character
 // c) Why is index++ being used?
+// Ans. It is being used to just add 1 to the value of index each time it has not reached the input character
 // d) What is the condition index < str.length used for?
+//Ans. As long as number of index is less than the length of the string.