Leetcode 2

Author: Kondareddy1209

Leetcode/Leetcode_2.py

@@ -0,0 +1,109 @@
+```python
+# ============================================================
+# LeetCode 2. Add Two Numbers
+# ============================================================
+
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+
+class Solution:
+    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
+
+        # =====================================================
+        # Brute Force Approach (Not Recommended)
+        # -----------------------------------------------------
+        # Idea:
+        # 1. Store linked list digits in two arrays.
+        # 2. Reverse both arrays.
+        # 3. Convert them into integers.
+        # 4. Add the integers.
+        # 5. Convert the sum back into a reversed linked list.
+        #
+        # Note:
+        # This approach may fail for very large inputs because
+        # Python has limits when converting extremely large
+        # strings into integers.
+        # =====================================================
+
+        """
+        n1 = []
+        curr = l1
+        while curr:
+            n1.append(curr.val)
+            curr = curr.next
+
+        n2 = []
+        curr = l2
+        while curr:
+            n2.append(curr.val)
+            curr = curr.next
+
+        num1 = int("".join(map(str, n1[::-1])))
+        num2 = int("".join(map(str, n2[::-1])))
+
+        total = num1 + num2
+
+        digits = list(str(total))[::-1]
+
+        dummy = ListNode(0)
+        curr = dummy
+
+        for digit in digits:
+            curr.next = ListNode(int(digit))
+            curr = curr.next
+
+        return dummy.next
+        """
+
+        # =====================================================
+        # Optimal Approach
+        # -----------------------------------------------------
+        # Idea:
+        # Traverse both linked lists simultaneously.
+        # Add corresponding digits along with carry.
+        # Store (sum % 10) as the current digit.
+        # Update carry as (sum // 10).
+        # Continue until both lists and carry are exhausted.
+        # =====================================================
+
+        dummy = ListNode(0)
+        curr = dummy
+        carry = 0
+
+        while l1 or l2 or carry:
+
+            total = carry
+
+            if l1:
+                total += l1.val
+                l1 = l1.next
+
+            if l2:
+                total += l2.val
+                l2 = l2.next
+
+            carry = total // 10
+            digit = total % 10
+
+            curr.next = ListNode(digit)
+            curr = curr.next
+
+        return dummy.next
+
+
+# ============================================================
+# Time Complexity
+# ============================================================
+
+# Brute Force:
+# Time Complexity  : O(n + m)
+# Space Complexity : O(n + m)
+
+# Optimal:
+# Time Complexity  : O(max(n, m))
+# Space Complexity : O(1)   (excluding the output linked list)
+```