revert to start of sprint 2

Author: sheetalkharab

Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js

@@ -9,24 +9,24 @@
  *   "product": 30 // 2 * 3 * 5
  * }
  *
- * Time Complexity:O(2n) originall have this as using 2 separate loops
- * Space Complexity:O(1) no extra space used that rows with input
- * Optimal Time Complexity:O(n) must at least visit each number once
+ * Time Complexity:
+ * Space Complexity:
+ * Optimal Time Complexity:
  *
  * @param {Array<number>} numbers - Numbers to process
  * @returns {Object} Object containing running total and product
  */
-
-// here we are using 2 loops one for sum and other for product
-//  but we can do it only in one loop so code will be more simple and faster
-
 export function calculateSumAndProduct(numbers) {
   let sum = 0;
-  let product = 1;
   for (const num of numbers) {
     sum += num;
+  }
+
+  let product = 1;
+  for (const num of numbers) {
     product *= num;
   }
+
   return {
     sum: sum,
     product: product,

Sprint-1/JavaScript/findCommonItems/findCommonItems.js

@@ -1,25 +1,14 @@
 /**
  * Finds common items between two arrays.
  *
- * Time Complexity:O(n+m) it build set and loop through arrays once
- * Space Complexity: store second array in set
- * Optimal Time Complexity:O(m+n)
+ * Time Complexity:
+ * Space Complexity:
+ * Optimal Time Complexity:
  *
  * @param {Array} firstArray - First array to compare
  * @param {Array} secondArray - Second array to compare
  * @returns {Array} Array containing unique common items
  */
-// export const findCommonItems = (firstArray, secondArray) => [
-//   ...new Set(firstArray.filter((item) => secondArray.includes(item))),
-// ];
-// Refactored to use a Set for faster lookups, making the code more efficient
-export const findCommonItems = (firstArray, secondArray) => {
-  const secondArraySet = new Set(secondArray);
-  const resultSet = new Set();
-  for (const element of firstArray) {
-    if (secondArraySet.has(element)) {
-      resultSet.add(element);
-    }
-  }
-  return [...resultSet];
-};
+export const findCommonItems = (firstArray, secondArray) => [
+  ...new Set(firstArray.filter((item) => secondArray.includes(item))),
+];

Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js

@@ -1,35 +1,21 @@
 /**
  * Find if there is a pair of numbers that sum to a given target value.
  *
- * Time Complexity: o(n2) the function use 2 nested loop
- * Space Complexity:o(1)no additional significant memory used
- * Optimal Time Complexity:  O(n) — in the refactored version using a Set for lookups
+ * Time Complexity:
+ * Space Complexity:
+ * Optimal Time Complexity:
  *
  * @param {Array<number>} numbers - Array of numbers to search through
  * @param {number} target - Target sum to find
  * @returns {boolean} True if pair exists, false otherwise
  */
-// export function hasPairWithSum(numbers, target) {
-//   for (let i = 0; i < numbers.length; i++) {
-//     for (let j = i + 1; j < numbers.length; j++) {
-//       if (numbers[i] + numbers[j] === target) {
-//         return true;
-//       }
-//     }
-//   }
-//   return false;
-// }
-
 export function hasPairWithSum(numbers, target) {
-  const numbersNeeded = new Set(); // stores numbers we've already seen
-
-  for (const num of numbers) {
-    const requiredNumber = target - num;
-    if (numbersNeeded.has(requiredNumber)) {
-      return true; // found a pair!
+  for (let i = 0; i < numbers.length; i++) {
+    for (let j = i + 1; j < numbers.length; j++) {
+      if (numbers[i] + numbers[j] === target) {
+        return true;
+      }
     }
-    numbersNeeded.add(num); // remember current number
   }
-
-  return false; // no pair found
+  return false;
 }

Sprint-1/Python/remove_duplicates/remove_duplicates.py

@@ -3,32 +3,23 @@
 ItemType = TypeVar("ItemType")
 
 
-# def remove_duplicates(values: Sequence[ItemType]) -> List[ItemType]:
-#     """
-#     Remove duplicate values from a sequence, preserving the order of the first occurrence of each value.
-
-#     Time complexity:O(n²) Quadratic The outer loop runs n times, and for each value, the inner loop also runs up to n times.
-#     Space complexity:O(n) store n elements in worst possible case
-#     Optimal time complexity: O(n) can be improved useing set
-#     """
-#     unique_items = []
-
-#     for value in values:
-#         is_duplicate = False
-#         for existing in unique_items:
-#             if value == existing:
-#                 is_duplicate = True
-#                 break
-#         if not is_duplicate:
-#             unique_items.append(value)
+def remove_duplicates(values: Sequence[ItemType]) -> List[ItemType]:
+    """
+    Remove duplicate values from a sequence, preserving the order of the first occurrence of each value.
 
-#     return unique_items
+    Time complexity:
+    Space complexity:
+    Optimal time complexity:
+    """
+    unique_items = []
 
-def remove_duplicates(values: Sequence[ItemType]) -> List[ItemType]:
-    unique_element= set() # for unique element
-    order_element =[] # to order maintain
     for value in values:
-        if value not in unique_element:
-            unique_element.add(value)
-            order_element.append(value)
-    return order_element        
+        is_duplicate = False
+        for existing in unique_items:
+            if value == existing:
+                is_duplicate = True
+                break
+        if not is_duplicate:
+            unique_items.append(value)
+
+    return unique_items