strech tasks are done

Author: shaghayeghfar

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

@@ -1,5 +1,13 @@
-function repeat() {
-  return "hellohellohello";
+function repeat(str, count) {
+  if (count < 0) {
+    throw new Error("Count must be a non-negative integer");
+  }
+
+  let result = "";
+  for (let i = 0; i < count; i++) {
+    result += str;
+  }
+  return result;
 }
 
 module.exports = repeat;

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

@@ -1,4 +1,3 @@
-// Implement a function repeat
 const repeat = require("./repeat");
 // Given a target string str and a positive integer count,
 // When the repeat function is called with these inputs,
@@ -21,12 +20,34 @@ test("should repeat the string count times", () => {
 // When the repeat function is called with these inputs,
 // Then it should return the original str without repetition, ensuring that a count of 1 results in no repetition.
 
+test("should return the original string when count is 1", () => {
+  const str = "hi";
+  const count = 1;
+  const repeatedStr = repeat(str, count);
+  expect(repeatedStr).toEqual("hi");
+});
+
 // case: Handle Count of 0:
 // Given a target string str and a count equal to 0,
 // When the repeat function is called with these inputs,
 // Then it should return an empty string, ensuring that a count of 0 results in an empty output.
 
+test("should return an empty string when count is 0", () => {
+  const str = "hi";
+  const count = 0;
+  const repeatedStr = repeat(str, count);
+  expect(repeatedStr).toEqual("");
+});
+
 // case: Negative Count:
 // Given a target string str and a negative integer count,
 // When the repeat function is called with these inputs,
 // Then it should throw an error or return an appropriate error message, as negative counts are not valid.
+
+test("should throw an error when count is negative", () => {
+  const str = "hi";
+  const count = -2;
+  expect(() => repeat(str, count)).toThrow(
+    "Count must be a non-negative integer"
+  );
+});

Sprint-3/3-stretch/card-validator.js

@@ -0,0 +1,42 @@
+// Function to validate a credit card number
+function isValidCreditCard(cardNumber) {
+  // Convert the input to a string to handle numbers safely
+  const cardStr = String(cardNumber);
+
+  // Rule 1: Must be 16 digits, all numbers
+  if (!/^\d{16}$/.test(cardStr)) {
+    return false;
+  }
+
+  // Rule 2: Must contain at least two different digits
+  const uniqueDigits = new Set(cardStr);
+  if (uniqueDigits.size < 2) {
+    return false;
+  }
+
+  // Rule 3: Final digit must be even
+  const lastDigit = Number(cardStr[cardStr.length - 1]);
+  if (lastDigit % 2 !== 0) {
+    return false;
+  }
+
+  // Rule 4: Sum of all digits must be greater than 16
+  const sum = cardStr.split("").reduce((acc, digit) => acc + Number(digit), 0);
+  if (sum <= 16) {
+    return false;
+  }
+
+  // If all checks pass, the card number is valid
+  return true;
+}
+
+// Example test cases
+console.log(isValidCreditCard("9999777788880000")); // true
+console.log(isValidCreditCard("6666666666661666")); // true
+console.log(isValidCreditCard("a92332119c011112")); // false
+console.log(isValidCreditCard("4444444444444444")); // false
+console.log(isValidCreditCard("1111111111111110")); // false
+console.log(isValidCreditCard("6666666666666661")); // false
+
+// Export function for testing in other files
+module.exports = isValidCreditCard;

Sprint-3/3-stretch/find.js

@@ -1,25 +1,30 @@
+// Function to find the first occurrence of a character in a string
 function find(str, char) {
+  // Start searching from index 0
   let index = 0;
 
+  // Loop through the string until the end
   while (index < str.length) {
+    // Check if the current character matches the target
     if (str[index] === char) {
-      return index;
+      return index; // Return the index if found
     }
-    index++;
+    index++; // Move to the next character
   }
+
+  // Return -1 if character is not found
   return -1;
 }
 
-console.log(find("code your future", "u"));
-console.log(find("code your future", "z"));
-
-// The while loop statement allows us to do iteration - the repetition of a certain number of tasks according to some condition
-// See the docs https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/while
+// Example calls
+console.log(find("code your future", "u")); // 5 (first 'u')
+console.log(find("code your future", "z")); // -1 (not found)
 
-// Use the Python Visualiser to help you play computer with this example and observe how this code is executed
-// Pay particular attention to the following:
+/* 
+Explanations:
 
-// a) How the index variable updates during the call to find
-// b) What is the if statement used to check
-// c) Why is index++ being used?
-// d) What is the condition index < str.length used for?
+a) How the index variable updates during the call to find? index variable: Tracks the current position in the string during the search.
+b) What is the if statement used to check? if statement: Checks if the current character matches the one we're looking for.
+c) Why is index++ being used? index++: Increments index by 1 to move to the next character in each iteration.
+d) What is the condition index? condition index < str.length: Ensures the loop stops when we reach the end of the string to prevent errors.
+*/

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

@@ -1,6 +1,29 @@
-function passwordValidator(password) {
-    return password.length < 5 ? false : true
-}
+// Array of previous passwords (example)
+const previousPasswords = ["Password1!", "Hello123#", "Test*2024"];
+
+// Function to check if a password is valid
+function isValidPassword(password) {
+  // Rule 1: At least 5 characters
+  if (password.length < 5) return false;
+
+  // Rule 2: At least one uppercase letter
+  if (!/[A-Z]/.test(password)) return false;
+
+  // Rule 3: At least one lowercase letter
+  if (!/[a-z]/.test(password)) return false;
 
+  // Rule 4: At least one number
+  if (!/[0-9]/.test(password)) return false;
+
+  // Rule 5: At least one non-alphanumeric symbol
+  if (!/[!#$%.*&]/.test(password)) return false;
+
+  // Rule 6: Must not be in previous passwords array
+  if (previousPasswords.includes(password)) return false;
+
+  // All checks passed
+  return true;
+}
 
-module.exports = passwordValidator;
+// Export function for Jest testing
+module.exports = isValidPassword;

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

@@ -1,26 +1,44 @@
-/* 
-Password Validation
+const isValidPassword = require("./password-validator");
 
-Write a program that should check if a password is valid
-and returns a boolean
+// Test 1: Password has at least 5 characters and is valid
+test("password has at least 5 characters", () => {
+  const password = "Abc1!";
+  const result = isValidPassword(password);
+  expect(result).toEqual(true);
+});
 
-To be valid, a password must:
-- Have at least 5 characters.
-- Have at least one English uppercase letter (A-Z)
-- Have at least one English lowercase letter (a-z)
-- Have at least one number (0-9)
-- Have at least one of the following non-alphanumeric symbols: ("!", "#", "$", "%", ".", "*", "&")
-- Must not be any previous password in the passwords array. 
+// Test 2: Password too short
+test("password shorter than 5 characters is invalid", () => {
+  const password = "A1!a";
+  expect(isValidPassword(password)).toEqual(false);
+});
 
-You must breakdown this problem in order to solve it. Find one test case first and get that working
-*/
-const isValidPassword = require("./password-validator");
-test("password has at least 5 characters", () => {
-    // Arrange
-    const password = "12345";
-    // Act
-    const result = isValidPassword(password);
-    // Assert
-    expect(result).toEqual(true);
-}
-);
+// Test 3: Missing uppercase
+test("password without uppercase letter is invalid", () => {
+  const password = "abc1!";
+  expect(isValidPassword(password)).toEqual(false);
+});
+
+// Test 4: Missing lowercase
+test("password without lowercase letter is invalid", () => {
+  const password = "ABC1!";
+  expect(isValidPassword(password)).toEqual(false);
+});
+
+// Test 5: Missing number
+test("password without number is invalid", () => {
+  const password = "Abcde!";
+  expect(isValidPassword(password)).toEqual(false);
+});
+
+// Test 6: Missing special character
+test("password without special character is invalid", () => {
+  const password = "Abcde1";
+  expect(isValidPassword(password)).toEqual(false);
+});
+
+// Test 7: Password already used
+test("password that is already used is invalid", () => {
+  const password = "Password1!";
+  expect(isValidPassword(password)).toEqual(false);
+});