commit 2-time-format.js and 3-to-pounds.js

Author: carlosyabreu

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

@@ -12,14 +12,79 @@ console.log(result);
 // For the piece of code above, read the code and then answer the following questions
 
 // a) How many variable declarations are there in this program?
+// Each const introduces a new variable.
+// 
+// movieLength
+// remainingSeconds
+// totalMinutes
+// remainingMinutes
+// totalHours
+// result
+// Total variable declarations: 6
 
 // b) How many function calls are there?
 
+// The only function call is:
+
+// Total function calls: 1
+// console.log(result);
+
 // c) Using documentation, explain what the expression movieLength % 60 represents
 // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators
 
+// According to the MDN documentation on the remainder (%) operator
+// The remainder operator returns the remainder left over when one operand is divided by a second operand.
+// So:
+// movieLength % 60
+// means “the remainder when movieLength is divided by 60.”
+// Interpretation:
+// It gives you the remaining seconds that don’t make up a full minute.
+// For example, if the movie length were 125 seconds:
+// 125 % 60 = 5, so there are 5 seconds left over after 2 full minutes.
+// Purpose: Extract the leftover seconds after converting total seconds into minutes.
+
 // d) Interpret line 4, what does the expression assigned to totalMinutes mean?
 
+// const totalMinutes = (movieLength - remainingSeconds) / 60;
+// This line:
+// Subtracts the leftover seconds (that couldn’t form a full minute).
+
+// Divides the remaining seconds by 60.
+// Meaning:
+// Converts the total movie length into minutes, ignoring any incomplete minute.
+// So it gives the total number of full minutes in the movie.
+
 // e) What do you think the variable result represents? Can you think of a better name for this variable?
 
+// const result = `${totalHours}:${remainingMinutes}:${remainingSeconds}`;
+
+// This combines hours, minutes, and seconds into a single string formatted like H:M:S.
+// Example output: "2:26:24"
+// Meaning: It represents the formatted time duration of the movie.
+// Better variable names:
+// formattedDuration
+// timeString
+// movieTime
+// durationInHMS
+
 // f) Try experimenting with different values of movieLength. Will this code work for all values of movieLength? Explain your answer
+
+// It will work correctly for most positive integers, since it’s just converting seconds into hours, minutes, and seconds using division and remainders.
+// However, there are some edge cases:
+// If movieLength = 0:
+// Output: 0:0:0 ✅ Works fine.
+// If movieLength < 60 (less than a minute):
+// Works fine (e.g., 45 → 0:0:45).
+// If movieLength is not an integer (e.g., 87.5):
+// Still works, but decimals might appear in remainingSeconds.
+// If movieLength is negative:
+// The logic breaks — you’d get negative time components ❌.
+// Formatting issue:
+
+// The output isn’t padded.
+// Example: 2 hours, 5 minutes, 9 seconds → "2:5:9" instead of "02:05:09".
+// (Can fix that with .padStart(2, '0') on each component.)
+
+// Summary:
+// It works for positive whole numbers, but for negative or non-integer inputs, or if you need formatted time, adjustments are needed.
+

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

@@ -1,17 +1,17 @@
-const penceString = "399p";
+let penceString = "399p";
 
-const penceStringWithoutTrailingP = penceString.substring(
+let penceStringWithoutTrailingP = penceString.substring(
   0,
   penceString.length - 1
 );
 
-const paddedPenceNumberString = penceStringWithoutTrailingP.padStart(3, "0");
-const pounds = paddedPenceNumberString.substring(
+let paddedPenceNumberString = penceStringWithoutTrailingP.padStart(3, "0");
+let pounds = paddedPenceNumberString.substring(
   0,
   paddedPenceNumberString.length - 2
 );
 
-const pence = paddedPenceNumberString
+let pence = paddedPenceNumberString
   .substring(paddedPenceNumberString.length - 2)
   .padEnd(2, "0");
 
@@ -25,3 +25,94 @@ console.log(`£${pounds}.${pence}`);
 
 // To begin, we can start with
 // 1. const penceString = "399p": initialises a string variable with the value "399p"
+
+// const penceString = "399p";
+// Initialises a string variable with the value "399p".
+// Example value now: "399p"
+
+// const penceStringWithoutTrailingP = penceString.substring(
+//  0,
+//  penceString.length - 1
+// );
+
+
+// What it does: takes a substring of penceString from index 0 up to (but not including) penceString.length - 1.
+// Why: removes the last character (the trailing "p") so we are left with just the numeric part.
+// Example: "399p".substring(0, 4 - 1) → "399".
+// Result stored: penceStringWithoutTrailingP === "399"
+
+// const paddedPenceNumberString = penceStringWithoutTrailingP.padStart(3, "0");
+
+
+// What it does: ensures the numeric string has at least 3 characters by adding leading "0" characters if necessary.
+// Why: the subsequent logic expects at least three digits so we can safely slice off "pounds" (all but the last two digits) and "pence" (last two digits). Padding handles small values like "5p" → ensures correct indexing.
+// Example: "399".padStart(3, "0") → "399" (no change). If input had been "5", .padStart(3,"0") → "005".
+// Result stored: paddedPenceNumberString === "399"
+
+// const pounds = paddedPenceNumberString.substring(
+//  0,
+//  paddedPenceNumberString.length - 2
+// );
+
+
+// What it does: takes the substring from index 0 up to (but not including) the last two characters. Those leading characters represent whole pounds.
+// Why: British currency: last two digits are pence, the digits before them are pounds. This extracts the pounds portion.
+// Example: "399".substring(0, 3 - 2) → "3". So pounds === "3", meaning £3.
+// Note: Because of padStart(3, "0"), this always returns at least one character (for values < 100 it returns "0" or more).
+
+// const pence = paddedPenceNumberString
+//  .substring(paddedPenceNumberString.length - 2)
+//  .padEnd(2, "0");
+
+
+// What it does (first part): .substring(length - 2) returns the final two characters (the pence digits).
+// What it does (second part): .padEnd(2, "0") ensures the result has at least two characters by adding trailing zeros if needed.
+// Why: extracting the two pence digits is necessary to format £x.yy. The padEnd is defensive: if the substring somehow produced a single character (it shouldn't after the earlier padStart, but this makes the code more robust), it will ensure two digits (e.g., "5" → "50").
+// Example: "399".substring(1) → "99". .padEnd(2,"0") → still "99". So pence === "99".
+
+// console.log(`£${pounds}.${pence}`);
+
+
+// What it does: prints a formatted pounds-and-pence string to the console, using template interpolation.
+// Why: final user-facing representation of the price.
+// Example output: £3.99
+
+// Quick summary of the data flow (with the example "399p")
+
+// penceString → "399p"
+
+// remove trailing p → "399" (penceStringWithoutTrailingP)
+
+// pad to at least 3 chars → "399" (paddedPenceNumberString)
+
+// pounds = all but last two chars → "3"
+
+// pence = last two chars → "99"
+
+// printed string → £3.99
+
+// Why some steps (like padStart / padEnd) are needed
+
+// padStart(3, "0") ensures inputs shorter than 3 digits (e.g. "5p" or "45p") still produce correct pound/pence splitting:
+
+// "5p" → "5" → pad → "005" → pounds = "0", pence = "05" → £0.05
+
+// "45p" → "45" → pad → "045" → pounds = "0", pence = "45" → £0.45
+
+// padEnd(2, "0") is defensive to guarantee two pence digits (useful if some earlier step produced one digit).
+
+// Edge cases & small improvements
+
+// If the input lacks the trailing "p" or contains non-digits ("£3.99", "abc") the code will produce incorrect results or unexpected output. Consider validating the string first (e.g., /^\d+p$/).
+
+// For clarity and robustness you could parse the number then compute pounds/pence numerically:
+
+let numericPence = parseInt(penceString.replace(/\D/g, ""), 10);
+pounds = Math.floor(numericPence / 100);
+pence = String(numericPence % 100).padStart(2, "0");
+
+
+// This avoids fiddly substring indices and better expresses intent.
+
+// padEnd(2, "0") after slicing the last two characters is usually unnecessary if padStart(3,"0") is present — but leaving it is harmless and defensive.
+