London | 26-ITP-May | Zadri Abdule | Sprint 2 | Exercises

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}`);

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);
 }

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);
+}

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;

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);
+});

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;

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

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;

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;

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();
+});

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!)

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");
+});

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;