Emin Akturk| West Midlands| MAY | Coursework/sprint3

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

@@ -4,3 +4,6 @@ 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
+
+// SOLUTION:
+// Line 3 is updating the value of the count by adding 1 to its value.

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

@@ -5,7 +5,9 @@ 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];
+
+console.log(initials);
 
 // https://www.google.com/search?q=get+first+character+of+string+mdn
 

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

@@ -17,7 +17,7 @@ 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
 
-const dir = ;
-const ext = ;
+const dir = filePath.slice(0, lastSlashIndex);
+const ext = filePath.slice(lastSlashIndex + 1);
 
 // https://www.google.com/search?q=slice+mdn

Sprint-1/1-key-exercises/4-random.js

@@ -1,9 +1,20 @@
 const minimum = 1;
 const maximum = 100;
+const num = 2;
 
 const num = Math.floor(Math.random() * (maximum - minimum + 1)) + minimum;
 
 // In this exercise, you will need to work out what num represents?
 // Try breaking down the expression and using documentation to explain what it means
 // It will help to think about the order in which expressions are evaluated
 // Try logging the value of num and running the program several times to build an idea of what the program is doing
+
+
+
+// SOLUTION:
+
+// num represents a random number between the minimum and maximum values.
+
+// program is designed for num to return random numbers between 1-100.
+
+//expressions of math.floor and math.random are there for //generating a random number between the minimum and maximum values and then rounding it down to the nearest whole number...

Sprint-1/2-mandatory-errors/0.js

@@ -1,2 +1,4 @@
 This is just an instruction for the first activity - but it is just for human consumption
-We don't want the computer to run these 2 lines - how can we solve this problem?
+We don't want the computer to run these 2 lines - how can we solve this problem?
+
+// We can use a comment to prevent the computer from running these lines.

Sprint-1/2-mandatory-errors/1.js

@@ -1,4 +1,8 @@
 // trying to create an age variable and then reassign the value by 1
 
-const age = 33;
+let age = 33;
 age = age + 1;
+
+console.log(age);
+
+

Sprint-1/2-mandatory-errors/2.js

@@ -1,5 +1,6 @@
 // Currently trying to print the string "I was born in Bolton" but it isn't working...
 // what's the error ?
-
-console.log(`I was born in ${cityOfBirth}`);
 const cityOfBirth = "Bolton";
+console.log(`I was born in ${cityOfBirth}`);
+
+//Code was correct, I just shifted the const part to the top of the code block.

Sprint-1/2-mandatory-errors/3.js

@@ -1,9 +1,21 @@
 const cardNumber = 4533787178994213;
-const last4Digits = cardNumber.slice(-4);
+const last4Digits = cardNumber.toString().slice(-4);
+
+
+console.log(last4Digits);
 
 // The last4Digits variable should store the last 4 digits of cardNumber
 // However, the code isn't working
 // Before running the code, make and explain a prediction about why the code won't work
 // Then run the code and see what error it gives.
 // Consider: Why does it give this error? Is this what I predicted? If not, what's different?
 // Then try updating the expression last4Digits is assigned to, in order to get the correct value
+
+
+// Prediction; code wont work because slice is for strings, not numbers.
+
+// after running the code, I got an error saying "cardNumber.slice is not a function".
+
+// It's what I predicted.
+
+// to fix the code I need to convert number to string first, then slice it.

Sprint-1/2-mandatory-errors/4.js

@@ -1,2 +1,12 @@
-const 12HourClockTime = "20:53";
-const 24hourClockTime = "08:53";
+//const 12HourClockTime = "20:53";
+//const 24hourClockTime = "08:53";
+
+
+// problem is in javascript we cant start a variable name with a number.
+
+// correct way is:
+
+const.twelveHourClockTime = "20:53";
+const twentyFourHourClockTime = "08:53";
+
+console.log(`The time in 12-hour format is ${twelveHourClockTime} and in 24-hour format is ${twentyFourHourClockTime}`);

Sprint-1/3-mandatory-interpret/1-percentage-change.js

@@ -2,7 +2,7 @@ let carPrice = "10,000";
 let priceAfterOneYear = "8,543";
 
 carPrice = Number(carPrice.replaceAll(",", ""));
-priceAfterOneYear = Number(priceAfterOneYear.replaceAll("," ""));
+priceAfterOneYear = Number(priceAfterOneYear.replaceAll(",", ""));
 
 const priceDifference = carPrice - priceAfterOneYear;
 const percentageChange = (priceDifference / carPrice) * 100;
@@ -20,3 +20,17 @@ console.log(`The percentage change is ${percentageChange}`);
 // d) Identify all the lines that are variable declarations
 
 // e) Describe what the expression Number(carPrice.replaceAll(",","")) is doing - what is the purpose of this expression?
+
+
+// a) There are 3 function calls in this file:
+//  `carPrice.replaceAll(",", "")` on line 5
+//  `priceAfterOneYear.replaceAll(",", "")` on line 6
+//  `Number(...)` on lines 5 and 6
+// b) The error occurs on line 5 there's a missing comma.
+//c) The variable reassignment statements are:
+//  `carPrice = Number(carPrice.replaceAll(",", ""));` on line 5
+//  `priceAfterOneYear = Number(priceAfterOneYear.replaceAll(",", ""));` on line 6
+// d) The variable declarations are:
+// `let carPrice = "10,000";` on line 1
+// `let priceAfterOneYear = "8,543";` on line 2
+// e) The expression `Number(carPrice.replaceAll(",", ""))` is converting carprice, which contains a comma, into a number.  

Sprint-1/3-mandatory-interpret/2-time-format.js

@@ -23,3 +23,30 @@ console.log(result);
 // e) What do you think the variable result represents? Can you think of a better name for this variable?
 
 // f) Try experimenting with different values of movieLength. Will this code work for all values of movieLength? Explain your answer
+
+
+// a) There are 6 variable declarations in this program:
+// which are:
+
+// movieLength
+
+// remainingSeconds
+
+// totalMinutes
+
+// remainingMinutes
+
+// totalHours
+
+// result
+
+// b) There are 2 function calls in this program.
+
+// c) Expression movieLength %60 represents remainder of division by 60.
+
+// d) expression assigned to totalminutes means minutes in the movie by removing the remaining seconds and dividing by 60.
+
+// e) Result variable represents the total time. A better name would be totalTime.
+
+// f) Yes code will work for all the values of movielength. It'll always return the total time with no problems. But It's not working if movielength less than 60 seconds, more than 24 hours or negative values.
+

Sprint-1/3-mandatory-interpret/3-to-pounds.js

@@ -25,3 +25,13 @@ console.log(`£${pounds}.${pence}`);
 
 // To begin, we can start with
 // 1. const penceString = "399p": initialises a string variable with the value "399p"
+
+// 2. const penceStringWithoutTrailingP = penceString.substring(0, penceString.length - 1): This line removes the trailing 'p' from the string.
+
+// 3. const paddedPenceNumberString = penceStringWithoutTrailingP.padStart(3, "0"): This line puts the string into a 3 character string padding with zeros.
+
+// 4. const pounds = paddedPenceNumberString.substring(0, paddedPenceNumberString.length - 2): This line takes out the pounds part of the string.
+
+// 5. const pence = paddedPenceNumberString.substring(paddedPenceNumberString.length - 2).padEnd(2, "0"): This line takes out pence part and pads it to 2 characters.
+
+// 6. console.log(`£${pounds}.${pence}`): This line prints the final results.

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

@@ -8,7 +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";
+  if (angle === 90) return "Right angle";
+  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";
    // read to the end, complete line 36, then pass your test here
 }
 
@@ -44,13 +48,16 @@ assertEquals(acute, "Acute angle");
 // 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
+// ====> write your test here, and then add a line to pass the test in the function above
+const reflex = getAngleType(270);
+assertEquals(reflex, "Reflex angle");

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

@@ -8,14 +8,18 @@
 // 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;
+    } else {
+        return false;
+    }
 }
 
 // here's our helper again
 function assertEquals(actualOutput, targetOutput) {
   console.assert(
     actualOutput === targetOutput,
-    `Expected ${actualOutput} to equal ${targetOutput}`
+    Expected ${actualOutput} to equal ${targetOutput}
   );
 }
 
@@ -40,14 +44,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?
+// What other scenarios could you test for?

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

@@ -8,7 +8,11 @@
 // 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) {
+    const rank = card.slice(0, -1);
     if (rank === "A") return 11;
+    if (rank === "J" || rank === "Q" || rank === "K" || rank === "10") return 10;
+    if (!isNaN(rank)) return Number(rank);
+    throw new Error("Invalid card rank.");
 }
 
 // You need to write assertions for your function to check it works in different cases
@@ -33,12 +37,23 @@ 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);
 
 // 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 jackofClubs = getCardValue("J♣");
+assertEquals(jackofClubs, 10);
+
+const queenofDiamonds = getCardValue("Q♦");
+assertEquals(queenofDiamonds, 10);
+
+const kingofHearts = getCardValue("K♥");
+assertEquals(kingofHearts, 10);
+
+const tenofSpades = getCardValue("10♠");
+assertEquals(tenofSpades, 10);
 
 // Handle Ace (A):
 // Given a card with a rank of "A",
@@ -49,3 +64,9 @@ const fiveofHearts = getCardValue("5♥");
 // 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♠");
+    console.error("Error was expected but not thrown");
+} catch (e) {
+    assertEquals(e.message, "Invalid card rank.");
+}

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

@@ -1,6 +1,10 @@
 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";
+}
 
 }
 

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

@@ -4,21 +4,25 @@ test("should identify right angle (90°)", () => {
   expect(getAngleType(90)).toEqual("Right angle");
 });
 
-// REPLACE the comments with the tests
-// make your test descriptions as clear and readable as possible
-
 // 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 (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 angles (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 (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"
+/

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

@@ -1,6 +1,11 @@
 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;
+    } else {
+        return false;
+    }
 }
 
-module.exports = isProperFraction;
+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", () => {
+  expect(isProperFraction(5, 2)).toEqual(false);
+});
 
 // Case 3: Identify Negative Fractions:
+test("should return true for a negative proper fraction", () => {
+  expect(isProperFraction(-4, 7)).toEqual(true);
+});
 
 // Case 4: Identify Equal Numerator and Denominator:
+test("should return false when numerator and denominator are equal", () => {
+  expect(isProperFraction(3, 3)).toEqual(false);
+});