Glasgow | Sheetal Kharab | Module-Complexity | Sprint 2 | Implement a linked list in Python

Sprint-1/JavaScript/calculateSumAndProduct/calculateSumAndProduct.js

@@ -9,24 +9,24 @@
  *   "product": 30 // 2 * 3 * 5
  * }
  *
- * Time Complexity:
- * Space Complexity:
- * Optimal Time Complexity:
+ * 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
  *
  * @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;
-  for (const num of numbers) {
-    sum += num;
-  }
-
   let product = 1;
   for (const num of numbers) {
+    sum += num;
     product *= num;
   }
-
   return {
     sum: sum,
     product: product,

Sprint-1/JavaScript/findCommonItems/findCommonItems.js

@@ -1,14 +1,25 @@
 /**
  * Finds common items between two arrays.
  *
- * Time Complexity:
- * Space Complexity:
- * Optimal Time Complexity:
+ * 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)
  *
  * @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))),
-];
+// 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];
+};

Sprint-1/JavaScript/hasPairWithSum/hasPairWithSum.js

@@ -1,21 +1,35 @@
 /**
  * Find if there is a pair of numbers that sum to a given target value.
  *
- * Time Complexity:
- * Space Complexity:
- * Optimal Time Complexity:
+ * 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
  *
  * @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) {
-  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;
-      }
+  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!
     }
+    numbersNeeded.add(num); // remember current number
   }
-  return false;
+
+  return false; // no pair found
 }

Sprint-1/Python/remove_duplicates/remove_duplicates.py

@@ -3,23 +3,32 @@
 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.
+# 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:
-    Space complexity:
-    Optimal time complexity:
-    """
-    unique_items = []
+#     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)
+#     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)
+
+#     return unique_items
 
-    return 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        

Sprint-2/implement_linked_list/linked_list.py

@@ -0,0 +1,51 @@
+class Node:
+    def __init__(self, value):
+        self.value = value
+        self.previous = None
+        self.next = None
+
+class LinkedList:
+    def __init__(self):
+        self.head = None
+        self.tail = None
+
+    def push_head(self, value):
+        new_node = Node(value)  # <-- Node must exist
+        if not self.head:
+            self.head = self.tail = new_node
+        else:
+            new_node.next = self.head
+            self.head.previous = new_node
+            self.head = new_node
+        return new_node
+
+    def pop_tail(self):
+        if not self.tail:
+            return None
+        value = self.tail.value
+        if self.head == self.tail:
+            self.head = self.tail = None
+        else:
+            self.tail = self.tail.previous
+            self.tail.next = None
+        return value
+
+    def remove(self, node):
+        if node is self.head:
+            self.head = node.next
+            if self.head:
+                self.head.previous = None
+
+        if node is self.tail:
+            self.tail = node.previous
+            if self.tail:
+                self.tail.next = None
+
+        if node.previous:
+            node.previous.next = node.next
+
+        if node.next:
+            node.next.previous = node.previous
+
+        node.previous = node.next = None
+