Complete Sprint 3 practice TDD tasks

Author: MouawiaElkhalifa

Sprint-3/2-practice-tdd/count.js

@@ -1,5 +1,9 @@
 function countChar(stringOfCharacters, findCharacter) {
-  return 5
+  let count =0;
+  for(let i=0; i<stringOfCharacters.length; i++){
+  if(stringOfCharacters[i] === findCharacter){
+    count=count+1;}}
+    return count;
 }
-
+console.log(countChar("banana","a"))//3
 module.exports = countChar;

Sprint-3/2-practice-tdd/count.test.js

@@ -1,5 +1,6 @@
 // implement a function countChar that counts the number of times a character occurs in a string
 const countChar = require("./count");
+
 // Given a string `str` and a single character `char` to search for,
 // When the countChar function is called with these inputs,
 // Then it should:
@@ -22,3 +23,32 @@ test("should count multiple occurrences of a character", () => {
 // And a character `char` that does not exist within `str`.
 // When the function is called with these inputs,
 // Then it should return 0, indicating that no occurrences of `char` were found.
+
+test("should return 0 when character does not exist in string", () => {
+  const str = "welcome";
+  const char = "z";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});
+
+// Scenario: Single Occurrence
+// Given a string where the character appears exactly once,
+// Then it should return 1.
+
+test("should return 1 when character appears once", () => {
+  const str = "apple";
+  const char = "a";
+  const count = countChar(str, char);
+  expect(count).toEqual(1);
+});
+
+// Scenario: Empty String
+// Given an empty string,
+// Then it should return 0 for any character.
+
+test("should return 0 for empty string", () => {
+  const str = "";
+  const char = "a";
+  const count = countChar(str, char);
+  expect(count).toEqual(0);
+});

Sprint-3/2-practice-tdd/get-ordinal-number.js

@@ -1,5 +1,18 @@
+
 function getOrdinalNumber(num) {
-  return "1st";
+  const lastTwoDigits = num % 100;
+
+  if (lastTwoDigits >= 11 && lastTwoDigits <= 13) {
+    return num + "th";
+  }
+
+  const lastDigit = num % 10;
+
+  if (lastDigit === 1) return num + "st";
+  if (lastDigit === 2) return num + "nd";
+  if (lastDigit === 3) return num + "rd";
+
+  return num + "th";
 }
 
 module.exports = getOrdinalNumber;

Sprint-3/2-practice-tdd/get-ordinal-number.test.js

@@ -18,3 +18,44 @@ test("should append 'st' for numbers ending with 1, except those ending with 11"
   expect(getOrdinalNumber(21)).toEqual("21st");
   expect(getOrdinalNumber(131)).toEqual("131st");
 });
+
+// Case 2: Numbers ending with 2 (but not 12)
+// When the number ends with 2, except those ending with 12,
+// Then the function should return a string by appending "nd" to the number.
+test("should append 'nd' for numbers ending with 2, except those ending with 12", () => {
+  expect(getOrdinalNumber(2)).toEqual("2nd");
+  expect(getOrdinalNumber(22)).toEqual("22nd");
+  expect(getOrdinalNumber(102)).toEqual("102nd");
+});
+
+// Case 3: Numbers ending with 3 (but not 13)
+// When the number ends with 3, except those ending with 13,
+// Then the function should return a string by appending "rd" to the number.
+test("should append 'rd' for numbers ending with 3, except those ending with 13", () => {
+  expect(getOrdinalNumber(3)).toEqual("3rd");
+  expect(getOrdinalNumber(23)).toEqual("23rd");
+  expect(getOrdinalNumber(203)).toEqual("203rd");
+});
+
+// Case 4: Numbers ending with 11, 12, 13
+// When the number ends with 11, 12, or 13,
+// Then the function should return a string by appending "th" to the number.
+test("should append 'th' for numbers ending with 11, 12, or 13", () => {
+  expect(getOrdinalNumber(11)).toEqual("11th");
+  expect(getOrdinalNumber(12)).toEqual("12th");
+  expect(getOrdinalNumber(13)).toEqual("13th");
+  expect(getOrdinalNumber(111)).toEqual("111th");
+  expect(getOrdinalNumber(112)).toEqual("112th");
+  expect(getOrdinalNumber(113)).toEqual("113th");
+});
+
+// Case 5: All other numbers
+// When the number does not end with 1, 2, 3 (or ends with 11, 12, 13),
+// Then the function should return a string by appending "th" to the number.
+test("should append 'th' for all other numbers", () => {
+  expect(getOrdinalNumber(4)).toEqual("4th");
+  expect(getOrdinalNumber(10)).toEqual("10th");
+  expect(getOrdinalNumber(14)).toEqual("14th");
+  expect(getOrdinalNumber(20)).toEqual("20th");
+  expect(getOrdinalNumber(100)).toEqual("100th");
+});

Sprint-3/2-practice-tdd/repeat-str.js

@@ -1,5 +1,8 @@
-function repeatStr() {
-  return "hellohellohello";
-}
+function repeatStr(str, count) {
+  if (count < 0) {
+    throw new Error("Count cannot be negative");
+  }
 
+  return str.repeat(count);
+}
 module.exports = repeatStr;

Sprint-3/2-practice-tdd/repeat-str.test.js

@@ -1,5 +1,6 @@
 // Implement a function repeatStr
 const repeatStr = require("./repeat-str");
+
 // Given a target string `str` and a positive integer `count`,
 // When the repeatStr function is called with these inputs,
 // Then it should:
@@ -8,7 +9,6 @@ const repeatStr = require("./repeat-str");
 // Given a target string `str` and a positive integer `count` greater than 1,
 // When the repeatStr function is called with these inputs,
 // Then it should return a string that contains the original `str` repeated `count` times.
-
 test("should repeat the string count times", () => {
   const str = "hello";
   const count = 3;
@@ -20,13 +20,31 @@ test("should repeat the string count times", () => {
 // Given a target string `str` and a `count` equal to 1,
 // When the repeatStr function is called with these inputs,
 // Then it should return the original `str` without repetition.
+test("should return original string when count is 1", () => {
+  const str = "hello";
+  const count = 1;
+  const repeatedStr = repeatStr(str, count);
+  expect(repeatedStr).toEqual("hello");
+});
 
 // Case: Handle count of 0:
 // Given a target string `str` and a `count` equal to 0,
 // When the repeatStr function is called with these inputs,
 // Then it should return an empty string.
+test("should return empty string when count is 0", () => {
+  const str = "hello";
+  const count = 0;
+  const repeatedStr = repeatStr(str, count);
+  expect(repeatedStr).toEqual("");
+});
 
 // Case: Handle negative count:
 // Given a target string `str` and a negative integer `count`,
 // When the repeatStr function is called with these inputs,
 // Then it should throw an error, as negative counts are not valid.
+test("should throw error when count is negative", () => {
+  const str = "hello";
+  const count = -2;
+
+  expect(() => repeatStr(str, count)).toThrow();
+});

Sprint-3/3-dead-code/exercise-1.js

@@ -1,17 +1,23 @@
 // Find the instances of unreachable and redundant code - remove them!
-// The sayHello function should continue to work for any reasonable input it's given.
+// The sayHello function should continue to work for any reasonable input it's given
 
-let testName = "Jerry";
+let testName = "Jerry"; //  Redundant assignment: This value is overwritten before being used.
 const greeting = "hello";
 
 function sayHello(greeting, name) {
-  const greetingStr = greeting + ", " + name + "!";
-  return `${greeting}, ${name}!`;
-  console.log(greetingStr);
+  const greetingStr = greeting + ", " + name + "!"; 
+  // ⚠ Not redundant by itself, but becomes redundant because it is only used in unreachable code below.
+
+  return `${greeting}, ${name}!`; 
+  
+
+  console.log(greetingStr); 
+  //  Unreachable code: This will never execute because it is after the return statement.
 }
 
-testName = "Aman";
+testName = "Aman"; 
+// This overwrites "Jerry", so the original assignment is redundant.
 
 const greetingMessage = sayHello(greeting, testName);
 
-console.log(greetingMessage); // 'hello, Aman!'
+console.log(greetingMessage); // 'hello, Aman!'

Sprint-3/3-dead-code/exercise-2.js

@@ -2,12 +2,8 @@
 // The countAndCapitalisePets function should continue to work for any reasonable input it's given, and you shouldn't modify the pets variable.
 
 const pets = ["parrot", "hamster", "horse", "dog", "hamster", "cat", "hamster"];
-const capitalisedPets = pets.map((pet) => pet.toUpperCase());
-const petsStartingWithH = pets.filter((pet) => pet[0] === "h");
 
-function logPets(petsArr) {
-  petsArr.forEach((pet) => console.log(pet));
-}
+const petsStartingWithH = pets.filter((pet) => pet[0] === "h");
 
 function countAndCapitalisePets(petsArr) {
   const petCount = {};
@@ -20,9 +16,10 @@ function countAndCapitalisePets(petsArr) {
       petCount[capitalisedPet] = 1;
     }
   });
+
   return petCount;
 }
 
 const countedPetsStartingWithH = countAndCapitalisePets(petsStartingWithH);
 
-console.log(countedPetsStartingWithH); // { 'HAMSTER': 3, 'HORSE': 1 } <- Final console log
+console.log(countedPetsStartingWithH); // { 'HAMSTER': 3, 'HORSE': 1 }

Sprint-3/4-stretch/find.js

@@ -20,6 +20,28 @@ console.log(find("code your future", "z"));
 // Pay particular attention to the following:
 
 // a) How the index variable updates during the call to find
+// The variable `index` starts at 0.
+// Each time the loop runs, `index++` increases its value by 1.
+// So index becomes 0, then 1, then 2, then 3, and so on,
+// until it reaches the length of the string.
+// This allows the function to check each character one by one.
+
+
 // b) What is the if statement used to check
+// The if statement checks whether the current character in the string
+// (`str[index]`) is equal to the character we are searching for (`char`).
+// If they are equal, the function returns the index immediately.
+// This means the function finds the first occurrence of the character.
+
+
 // c) Why is index++ being used?
+// `index++` moves the search to the next position in the string.
+// Without `index++`, the value of index would never change,
+// and the loop would run forever (infinite loop).
+
+
 // d) What is the condition index < str.length used for?
+// The condition `index < str.length` makes sure the loop stops
+// when we reach the end of the string.
+// It prevents accessing characters outside the string.
+// If no match is found, the function returns -1.

Sprint-3/4-stretch/password-validator.js

@@ -1,5 +1,7 @@
 function passwordValidator(password) {
     return password.length < 5 ? false : true
+
+    
 }