diff --git a/Sprint-2/debug/address.js b/Sprint-2/debug/address.js
index 940a6af83..5581abff1 100644
--- a/Sprint-2/debug/address.js
+++ b/Sprint-2/debug/address.js
@@ -1,4 +1,5 @@
 // Predict and explain first...
+// that it will throw a undefined error because the address object is not defined in the code snippet. The code snippet is missing the definition of the address object, which is necessary for the console.log statement to work correctly.
 
 // This code should log out the houseNumber from the address object
 // but it isn't working...
@@ -12,4 +13,4 @@ const address = {
   postcode: "XYZ 123",
 };
 
-console.log(`My house number is ${address[0]}`);
+console.log(`My house number is ${address.houseNumber}`);
diff --git a/Sprint-2/debug/author.js b/Sprint-2/debug/author.js
index 8c2125977..8700730d3 100644
--- a/Sprint-2/debug/author.js
+++ b/Sprint-2/debug/author.js
@@ -1,4 +1,5 @@
 // Predict and explain first...
+// will throw a TypeError because Object.values() is not a function. The correct way to get the values of an object is to use Object.values(author) instead of Object.values(author). The code is trying to call Object.values() on the author object, which is not a function, hence the error.
 
 // This program attempts to log out all the property values in the object.
 // But it isn't working. Explain why first and then fix the problem
@@ -11,6 +12,6 @@ const author = {
   alive: true,
 };
 
-for (const value of author) {
+for (const value of Object.values(author)) {
   console.log(value);
 }
diff --git a/Sprint-2/debug/recipe.js b/Sprint-2/debug/recipe.js
index 6cbdd22cd..3303e40e0 100644
--- a/Sprint-2/debug/recipe.js
+++ b/Sprint-2/debug/recipe.js
@@ -1,4 +1,5 @@
 // Predict and explain first...
+// will log out the title and how many it serves, but it will not log out the ingredients on new lines. The ingredients are in an array, and the current code does not iterate over that array to log each ingredient on a new line.
 
 // This program should log out the title, how many it serves and the ingredients.
 // Each ingredient should be logged on a new line
@@ -10,6 +11,7 @@ const recipe = {
   ingredients: ["olive oil", "tomatoes", "salt", "pepper"],
 };
 
-console.log(`${recipe.title} serves ${recipe.serves}
-  ingredients:
-${recipe}`);
+console.log(`${recipe.title} serves ${recipe.serves}`);
+for (const ingredient of recipe.ingredients) {
+  console.log(ingredient);
+}
diff --git a/Sprint-2/implement/contains.js b/Sprint-2/implement/contains.js
index cd779308a..dafc64de7 100644
--- a/Sprint-2/implement/contains.js
+++ b/Sprint-2/implement/contains.js
@@ -1,3 +1,8 @@
-function contains() {}
+function contains(obj, prop) {
+    if (typeof obj !== "object" || obj === null) {
+        return false;
+    }
+    return obj.hasOwnProperty(prop);
+}
 
 module.exports = contains;
diff --git a/Sprint-2/implement/contains.test.js b/Sprint-2/implement/contains.test.js
index 326bdb1f2..917de2fbd 100644
--- a/Sprint-2/implement/contains.test.js
+++ b/Sprint-2/implement/contains.test.js
@@ -16,20 +16,44 @@ as the object doesn't contains a key of 'c'
 // Given a contains function
 // When passed an object and a property name
 // Then it should return true if the object contains the property, false otherwise
+describe("contains", () => {
+  test("should return true if the object contains the property, false otherwise", () => {
+    expect(contains({ a: 1, b: 2 }, 'a')).toBe(true);
+    expect(contains({ a: 1, b: 2 }, 'b')).toBe(true);
+    expect(contains({ a: 1, b: 2 }, 'c')).toBe(false);
+    expect(contains({}, 'a')).toBe(false);
+  });
+});
 
 // Given an empty object
 // When passed to contains
 // Then it should return false
-test.todo("contains on empty object returns false");
+test("contains returns false for empty object", () => {
+  expect(contains({}, 'a')).toBe(false);
+});
+
+
 
 // Given an object with properties
 // When passed to contains with an existing property name
 // Then it should return true
+test("contains returns true for existing keys", () => {
+  expect(contains({ a: 1, b: 2 }, 'a')).toBe(true);
+  expect(contains({ a: 1, b: 2 }, 'b')).toBe(true);
+});
 
 // Given an object with properties
 // When passed to contains with a non-existent property name
 // Then it should return false
+test("contains returns false for non-existent property name", () => {
+  expect(contains({ a: 1, b: 2 }, 'c')).toBe(false);
+});
 
 // Given invalid parameters like an array
 // When passed to contains
 // Then it should return false or throw an error
+test("contains with invalid parameters returns false", () => {
+  expect(contains([], 'a')).toBe(false);
+  expect(contains(null, 'a')).toBe(false);
+  expect(contains(undefined, 'a')).toBe(false);
+});
diff --git a/Sprint-2/implement/lookup.js b/Sprint-2/implement/lookup.js
index a6746e07f..adc25cd72 100644
--- a/Sprint-2/implement/lookup.js
+++ b/Sprint-2/implement/lookup.js
@@ -1,5 +1,17 @@
-function createLookup() {
-  // implementation here
+function createLookup(countryCurrencyPairs) {
+  let lookUp = {};
+  if (!Array.isArray(countryCurrencyPairs)) {
+    throw new Error("Input must be an array of arrays");
+  }
+  countryCurrencyPairs.forEach(pair => {
+    if (Array.isArray(pair) && pair.length === 2) {
+      lookUp[pair[0]] = pair[1];
+    } else {
+      throw new Error("Each element of the input array must be an array of two elements");
+    }
+  });
+
+  return lookUp;
 }
 
 module.exports = createLookup;
diff --git a/Sprint-2/implement/lookup.test.js b/Sprint-2/implement/lookup.test.js
index 547e06c5a..303794298 100644
--- a/Sprint-2/implement/lookup.test.js
+++ b/Sprint-2/implement/lookup.test.js
@@ -1,6 +1,49 @@
 const createLookup = require("./lookup.js");
 
-test.todo("creates a country currency code lookup for multiple codes");
+describe("createLookup", () => {
+  test("creates a country currency code lookup for multiple codes", () => {
+    const countryCurrencyPairs = [['US', 'USD'], ['CA', 'CAD']];
+    const expectedLookup = {
+      'US': 'USD',
+      'CA': 'CAD'
+    };
+    expect(createLookup(countryCurrencyPairs)).toEqual(expectedLookup);
+  });
+});
+
+test("creates a country currency code lookup for a single code", () => {
+  const countryCurrencyPairs = [['GB', 'GBP']];
+  const expectedLookup = {
+    'GB': 'GBP'
+  };
+  expect(createLookup(countryCurrencyPairs)).toEqual(expectedLookup);
+});
+
+test("creates an empty lookup for an empty array", () => {
+  const countryCurrencyPairs = [];
+  const expectedLookup = {};
+  expect(createLookup(countryCurrencyPairs)).toEqual(expectedLookup);
+});
+
+test("creates a country currency code lookup for multiple codes with different currencies", () => {
+  const countryCurrencyPairs = [['JP', 'JPY'], ['AU', 'AUD'], ['IN', 'INR']];
+  const expectedLookup = {
+    'JP': 'JPY',
+    'AU': 'AUD',
+    'IN': 'INR'
+  };
+  expect(createLookup(countryCurrencyPairs)).toEqual(expectedLookup);
+});
+
+test("creates an array of array representing country code and currency code pairs", () => {
+  const countryCurrencyPairs = [['FR', 'EUR'], ['DE', 'EUR'], ['IT', 'EUR']];
+  const expectedLookup = {
+    'FR': 'EUR',
+    'DE': 'EUR',
+    'IT': 'EUR'
+  };
+  expect(createLookup(countryCurrencyPairs)).toEqual(expectedLookup);
+});
 
 /*
 
@@ -11,6 +54,8 @@ Acceptance Criteria:
 Given
  - An array of arrays representing country code and currency code pairs
    e.g. [['US', 'USD'], ['CA', 'CAD']]
+   tes
+   
 
 When
  - createLookup function is called with the country-currency array as an argument
diff --git a/Sprint-2/implement/querystring.js b/Sprint-2/implement/querystring.js
index 45ec4e5f3..11840433c 100644
--- a/Sprint-2/implement/querystring.js
+++ b/Sprint-2/implement/querystring.js
@@ -1,16 +1,30 @@
 function parseQueryString(queryString) {
-  const queryParams = {};
-  if (queryString.length === 0) {
-    return queryParams;
+  const params = {};
+if (!queryString) {
+    return params;
   }
-  const keyValuePairs = queryString.split("&");
 
-  for (const pair of keyValuePairs) {
-    const [key, value] = pair.split("=");
-    queryParams[key] = value;
-  }
+  const pairs = queryString.split("&");
+  for (const pair of pairs) {
+    if (!pair) continue; // Ignore empty key-value pairs
+
+    const [key, ...valueParts] = pair.split("=");
+    const value = valueParts.join("="); // Join back in case value contains '='
 
-  return queryParams;
+    const decodedKey = decodeURIComponent(key.replace(/\+/g, " "));
+    const decodedValue = decodeURIComponent(value.replace(/\+/g, " "));
+
+    if (params.hasOwnProperty(decodedKey)) {
+      if (Array.isArray(params[decodedKey])) {
+        params[decodedKey].push(decodedValue);
+      } else {
+        params[decodedKey] = [params[decodedKey], decodedValue];
+      }
+    } else {
+      params[decodedKey] = decodedValue;
+    }
+  }
+  return params;
 }
 
 module.exports = parseQueryString;
diff --git a/Sprint-2/implement/tally.js b/Sprint-2/implement/tally.js
index f47321812..333265db4 100644
--- a/Sprint-2/implement/tally.js
+++ b/Sprint-2/implement/tally.js
@@ -1,3 +1,16 @@
-function tally() {}
+function tally(items) {
+	if (!Array.isArray(items)) {
+		throw new Error('tally expects an array');
+	}
+
+	const counts = {};
+	for (const item of items) {
+		// Use the item as the key; this will stringify non-string keys
+		const key = String(item);
+		counts[key] = (counts[key] || 0) + 1;
+	}
+
+	return counts;
+}
 
 module.exports = tally;
diff --git a/Sprint-2/implement/tally.test.js b/Sprint-2/implement/tally.test.js
index 2ceffa8dd..a5aceac2c 100644
--- a/Sprint-2/implement/tally.test.js
+++ b/Sprint-2/implement/tally.test.js
@@ -19,16 +19,31 @@ const tally = require("./tally.js");
 // Given a function called tally
 // When passed an array of items
 // Then it should return an object containing the count for each unique item
+test("tally returns an object containing the count for each unique item", () => {
+	const input = ["a"];
+	const expected = { a: 1 };
+	expect(tally(input)).toEqual(expected);
+});
 
 // Given an empty array
 // When passed to tally
 // Then it should return an empty object
-test.todo("tally on an empty array returns an empty object");
+test("tally on an empty array returns an empty object", () => {
+	expect(tally([])).toEqual({});
+});
 
 // Given an array with duplicate items
 // When passed to tally
 // Then it should return counts for each unique item
+test("tally should return counts for each unique item", () => {
+	const input = ["a", "a", "b", "c"];
+	const expected = { a: 2, b: 1, c: 1 };
+	expect(tally(input)).toEqual(expected);
+});
 
 // Given an invalid input like a string
 // When passed to tally
 // Then it should throw an error
+test("tally should throw on invalid input", () => {
+	expect(() => tally("not-an-array")).toThrow();
+});
diff --git a/Sprint-2/interpret/invert.js b/Sprint-2/interpret/invert.js
index bb353fb1f..40f67dd7f 100644
--- a/Sprint-2/interpret/invert.js
+++ b/Sprint-2/interpret/invert.js
@@ -5,25 +5,44 @@
 // Then it should swap the keys and values in the object
 
 // E.g. invert({x : 10, y : 20}), target output: {"10": "x", "20": "y"}
-
 function invert(obj) {
-  const invertedObj = {};
+  const inverted = {};
 
   for (const [key, value] of Object.entries(obj)) {
-    invertedObj.key = value;
+    const v = String(value);
+
+    if (v in inverted) {
+      // If value already exists
+      if (Array.isArray(inverted[v])) {
+        inverted[v].push(key);
+      } else {
+        inverted[v] = [inverted[v], key];
+      }
+    } else {
+      inverted[v] = key;
+    }
   }
 
-  return invertedObj;
+  return inverted;
 }
 
+module.exports = invert;
+
 // a) What is the current return value when invert is called with { a : 1 }
+// {"1":"a"}
 
 // b) What is the current return value when invert is called with { a: 1, b: 2 }
+// {"1":"a", "2":"b"}
 
 // c) What is the target return value when invert is called with {a : 1, b: 2}
+// the intended result is -> {"1":"a","2":"b"} (same as the as the current output)
 
 // c) What does Object.entries return? Why is it needed in this program?
+// makes a list of pairs from the object: [[key1, value2], [key2, value2]]
+// it's needed so that the code can look at the key and value together in each loop and build the swapped object.
 
 // d) Explain why the current return value is different from the target output
+// In the examples shown, it matches the expectation. but: values are turned into strings when used as keys (so 1 becomes "1").
+
 
 // e) Fix the implementation of invert (and write tests to prove it's fixed!)
diff --git a/Sprint-2/interpret/invert.test.js b/Sprint-2/interpret/invert.test.js
new file mode 100644
index 000000000..f102f2010
--- /dev/null
+++ b/Sprint-2/interpret/invert.test.js
@@ -0,0 +1,20 @@
+const invert = require('./invert');
+
+test('inverts a single key/value pair', () => {
+  expect(invert({ a: 1 })).toEqual({ '1': 'a' });
+});
+
+test('inverts multiple pairs', () => {
+  expect(invert({ a: 1, b: 2 })).toEqual({ '1': 'a', '2': 'b' });
+});
+
+test('string values become keys', () => {
+  expect(invert({ a: 'x', b: 'y' })).toEqual({ x: 'a', y: 'b' });
+});
+
+test('collects multiple keys that share the same value', () => {
+  const input = { a: 1, b: 1, c: 2 };
+  const actual = invert(input);
+  expect(actual["1"]).toEqual(expect.arrayContaining(["a", "b"]));
+  expect(actual["2"]).toBe("c");
+});
\ No newline at end of file
diff --git a/Sprint-2/stretch/count-words.js b/Sprint-2/stretch/count-words.js
index 8e85d19d7..4f9d97664 100644
--- a/Sprint-2/stretch/count-words.js
+++ b/Sprint-2/stretch/count-words.js
@@ -26,3 +26,19 @@
 
 3. Order the results to find out which word is the most common in the input
 */
+function countWords(str) {
+  if (typeof str !== 'string') throw new Error('countWords expect a string');
+
+  const cleaned = str.toLowerCase().replace(/[^a-z0-9'\s]+/gi, ' ').trim();
+  if (cleaned === '') return {};
+
+  const counts = {};
+  for (const w of cleaned.split(/\s+/)) {
+    counts[w] = (counts[w] || 0) + 1;
+  }
+  return counts;
+
+
+}
+
+module.exports = countWords;
\ No newline at end of file
diff --git a/Sprint-2/stretch/mode.js b/Sprint-2/stretch/mode.js
index 3f7609d79..eb7275327 100644
--- a/Sprint-2/stretch/mode.js
+++ b/Sprint-2/stretch/mode.js
@@ -8,29 +8,30 @@
 // refactor calculateMode by splitting up the code
 // into smaller functions using the stages above
 
-function calculateMode(list) {
-  // track frequency of each value
-  let freqs = new Map();
-
-  for (let num of list) {
-    if (typeof num !== "number") {
-      continue;
-    }
-
-    freqs.set(num, (freqs.get(num) || 0) + 1);
+function buildFrequency(list) {
+  const freqs = new Map();
+  for (const num of list) {
+    if (typeof num !== 'number') continue;
+    freqs.set(num, (freqs.get(num) ?? 0) + 1);
   }
+  return freqs;
+}
 
-  // Find the value with the highest frequency
+function findMode(freqs) {
   let maxFreq = 0;
   let mode;
-  for (let [num, freq] of freqs) {
+  for (const [num, freq] of freqs) {
     if (freq > maxFreq) {
       mode = num;
       maxFreq = freq;
     }
   }
-
   return maxFreq === 0 ? NaN : mode;
 }
 
+function calculateMode(list) {
+  const freqs = buildFrequency(list);
+  return findMode(freqs);
+}
+
 module.exports = calculateMode;
diff --git a/Sprint-2/stretch/till.js b/Sprint-2/stretch/till.js
index 6a08532e7..1a96c1367 100644
--- a/Sprint-2/stretch/till.js
+++ b/Sprint-2/stretch/till.js
@@ -8,10 +8,15 @@ function totalTill(till) {
   let total = 0;
 
   for (const [coin, quantity] of Object.entries(till)) {
-    total += coin * quantity;
+    // coin is like "1p" or "50p"; strip non-digits and parse to integer pence
+    const pence = parseInt(String(coin).replace(/\D+/g, ''), 10);
+    if (!Number.isFinite(pence)) continue;
+    if (typeof quantity !== 'number') continue;
+
+    total += pence * quantity;
   }
 
-  return `£${total / 100}`;
+  return `£${(total / 100).toFixed(2)}`;
 }
 
 const till = {
@@ -22,10 +27,36 @@ const till = {
 };
 const totalAmount = totalTill(till);
 
+module.exports = totalTill;
+
 // a) What is the target output when totalTill is called with the till object
+//Expected total in pounds: calculate coins in pence -> (1p * 10) + (5p * 6) + (50p * 4) + (20p * 10)
+//1*10 = 10
+//5*6 = 30
+//50*4 = 200
+//20*10 = 200
+//Total pence = 440 -> £4.40
+//So target output string: "£4.40"
 
 // b) Why do we need to use Object.entries inside the for...of loop in this function?
+// It gives [key, value] pairs so the loop can access both coin quantity directly without separate lookups.
 
 // c) What does coin * quantity evaluate to inside the for...of loop?
+// coin * quantity evaluates evaluates to NaN because '1p' cannot be coerced to a number
 
 // d) Write a test for this function to check it works and then fix the implementation of totalTill
+const totalTill = require('./till');
+
+test('calculates total for sample till', () => {
+  const till = { '1p': 10, '5p': 6, '50p': 4, '20p': 10};
+  expect(totalTill(till)).toBe('£4.40');
+});
+
+test('empty till returns £0.00', () => {
+  expect(totalTill({})).toBe('£0.00');
+});
+
+test('ignores invalid coin labels and quantities', () => {
+  const till = { '1p': 5, 'abc': 10, '10p': 'x', '20p': 3};
+  expect(totalTill(till)).toBe('£0.65');
+})
\ No newline at end of file