Restore original questions alongside answers in Sprint-2 files; fix capitalise to use new const instead of reassigning parameter

Author: KhotKeys

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

@@ -1,9 +1,23 @@
-// Predict: SyntaxError or ReferenceError because `str` is re-declared with `let` inside the function
-// where it already exists as a parameter.
-// Explanation: You cannot use `let` to re-declare a variable that already exists in the same scope.
-// Fix: remove the `let` keyword — just reassign str.
+// Predict and explain first...
+// Prediction: SyntaxError because `str` is re-declared with `let` inside the function
+// where it already exists as a parameter. You cannot use `let` to re-declare a variable
+// that already exists in the same scope.
+
+// call the function capitalise with a string input
+// interpret the error message and figure out why an error is occurring
+
+// Original broken code:
+// function capitalise(str) {
+//   let str = `${str[0].toUpperCase()}${str.slice(1)}`;
+//   return str;
+// }
+
+// Explanation: The parameter `str` already exists in the function scope.
+// Using `let str` tries to re-declare it, which is a SyntaxError.
+// Instead of reassigning `str` (which represents the original input),
+// we use a new const `capitalisedStr` to make it clear this is a different value.
 
 function capitalise(str) {
-  str = `${str[0].toUpperCase()}${str.slice(1)}`;
-  return str;
+  const capitalisedStr = `${str[0].toUpperCase()}${str.slice(1)}`;
+  return capitalisedStr;
 }

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

@@ -1,10 +1,24 @@
+// Predict and explain first...
+
+// Why will an error occur when this program runs?
 // Prediction: Two errors — (1) re-declaring decimalNumber with const inside the function
-// when it is already a parameter shadows and causes a SyntaxError.
+// when it is already a parameter causes a SyntaxError.
 // (2) console.log(decimalNumber) outside the function will throw ReferenceError because
 // decimalNumber is not defined in the outer scope.
-// Explanation: The parameter decimalNumber already exists; const re-declaration is illegal.
-// Also, decimalNumber is not accessible outside the function.
-// Fix: remove the const re-declaration inside the function, and pass a value to the function.
+
+// Try playing computer with the example to work out what is going on
+
+// Original broken code:
+// function convertToPercentage(decimalNumber) {
+//   const decimalNumber = 0.5;
+//   const percentage = `${decimalNumber * 100}%`;
+//   return percentage;
+// }
+// console.log(decimalNumber);
+
+// Explanation: The parameter decimalNumber already exists in the function scope;
+// const re-declaration is illegal. Also, decimalNumber is not accessible outside the function.
+// Fix: remove the const re-declaration inside the function, and pass a value when calling it.
 
 function convertToPercentage(decimalNumber) {
   const percentage = `${decimalNumber * 100}%`;

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

@@ -1,7 +1,17 @@
+// Predict and explain first BEFORE you run any code...
 
-// Prediction: SyntaxError — a function parameter must be a valid identifier, not a literal number.
-// Error: SyntaxError: Unexpected number
+// this function should square any number but instead we're going to get an error
+
+// Prediction: SyntaxError — a function parameter must be a valid identifier, not a number literal.
+
+// Original broken code:
+// function square(3) {
+//     return num * num;
+// }
+
+// Error message: SyntaxError: Unexpected number
 // Explanation: `3` is a number literal and cannot be used as a parameter name.
+// Parameters must be valid identifiers (variable names).
 // Fix: use a named parameter like `num`.
 
 function square(num) {

Sprint-2/2-mandatory-debug/0.js

@@ -1,7 +1,15 @@
+// Predict and explain first...
 // Prediction: The template literal will print "undefined" for the function result because
 // multiply uses console.log internally but does not return a value (returns undefined).
+
+// Original broken code:
+// function multiply(a, b) {
+//   console.log(a * b);
+// }
+// console.log(`The result of multiplying 10 and 32 is ${multiply(10, 32)}`);
+
 // Explanation: Functions without a return statement return undefined.
-//              The outer console.log then interpolates undefined into the string.
+// The outer console.log then interpolates undefined into the string.
 // Fix: replace console.log inside multiply with a return statement.
 
 function multiply(a, b) {

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

@@ -1,7 +1,16 @@
+// Predict and explain first...
 // Prediction: The sum will print "undefined" because return; exits the function
 // immediately without a value, so a + b is never evaluated.
-// Explanation: return; with no expression returns undefined. The a + b on the next
-// line is unreachable dead code.
+
+// Original broken code:
+// function sum(a, b) {
+//   return;
+//   a + b;
+// }
+// console.log(`The sum of 10 and 32 is ${sum(10, 32)}`);
+
+// Explanation: return; with no expression returns undefined.
+// The a + b on the next line is unreachable dead code and is never executed.
 // Fix: put a + b on the same line as return.
 
 function sum(a, b) {

Sprint-2/2-mandatory-debug/2.js

@@ -1,12 +1,24 @@
+// Predict and explain first...
+
+// Predict the output of the following code:
 // Prediction: All three logs will print "3" (the last digit of the module-level const num = 103)
 // because getLastDigit ignores its parameter and always uses the outer num.
-// Output:
+// Expected output:
 //   The last digit of 42 is 3
 //   The last digit of 105 is 3
 //   The last digit of 806 is 3
+
+// Original broken code:
+// const num = 103;
+// function getLastDigit() {
+//   return num.toString().slice(-1);
+// }
+
+// Actual output matched prediction — all printed "3".
+
 // Explanation: The function has no parameter, so any argument passed in is discarded.
-//              It always reads the outer `num` variable which is 103.
-// Fix: add a parameter to getLastDigit and use it.
+// It always reads the outer `num` variable which is 103.
+// Fix: add a parameter to getLastDigit and use it instead of the outer variable.
 
 function getLastDigit(num) {
   return num.toString().slice(-1);

Sprint-2/4-mandatory-interpret/time-format.js

@@ -15,20 +15,25 @@ function formatTimeDisplay(seconds) {
   return `${pad(totalHours)}:${pad(remainingMinutes)}:${pad(remainingSeconds)}`;
 }
 
-// a) pad is called 3 times per call to formatTimeDisplay (once for hours, minutes, seconds).
+// You will need to play computer with this example - use the Python Visualiser https://pythontutor.com/visualize.html#mode=edit
+// to help you answer these questions
 
-// Call formatTimeDisplay(61):
-//   remainingSeconds = 61 % 60 = 1
-//   totalMinutes = (61 - 1) / 60 = 1
-//   remainingMinutes = 1 % 60 = 1
-//   totalHours = (1 - 1) / 60 = 0
-//   pad is called with: totalHours=0, remainingMinutes=1, remainingSeconds=1
+// Questions
 
-// b) num = 0 (totalHours) when pad is called for the first time.
+// a) When formatTimeDisplay is called how many times will pad be called?
+// =============> pad is called 3 times per call to formatTimeDisplay (once for totalHours, once for remainingMinutes, once for remainingSeconds).
 
-// c) pad(0): "0".length < 2, so prepend "0" -> "00". Return value: "00"
+// Call formatTimeDisplay with an input of 61, now answer the following:
+// (remainingSeconds = 1, totalMinutes = 1, remainingMinutes = 1, totalHours = 0)
 
-// d) num = 1 (remainingSeconds) when pad is called for the last time.
-//    It is the last argument passed in the template literal.
+// b) What is the value assigned to num when pad is called for the first time?
+// =============> num = 0 (totalHours), because totalHours is the first argument in the template literal.
 
-// e) pad(1): "1".length < 2, so prepend "0" -> "01". Return value: "01"
+// c) What is the return value of pad when it is called for the first time?
+// =============> "00" — "0".length < 2, so "0" is prepended, giving "00".
+
+// d) What is the value assigned to num when pad is called for the last time in this program?  Explain your answer
+// =============> num = 1 (remainingSeconds). It is the last argument passed in the template literal, so pad is called with it last.
+
+// e) What is the return value of pad when it is called for the last time in this program?  Explain your answer
+// =============> "01" — "1".length < 2, so "0" is prepended, giving "01".