leetcode answer 1679

Author: Kondareddy1209

Leetcode/Leetcode_1679.py

@@ -3,56 +3,77 @@
 class Solution:
     def maxOperations(self, nums: List[int], k: int) -> int:
         """
-        Problem:
-        Find the maximum number of pairs in the array such that
-        the sum of each pair equals k. Each element can be used only once.
+        Problem
+        -------
+        Given an integer array `nums` and an integer `k`, return the maximum number 
+        of operations where each operation consists of choosing two numbers whose 
+        sum equals `k`. Each number can be used only once.
 
-        Approach (Two Pointer Technique):
-        1. First sort the array so that we can use two pointers.
+        Example
+        -------
+        Input: nums = [1,2,3,4], k = 5
+        Output: 2
+        Explanation:
+        (1,4) -> 5
+        (2,3) -> 5
+
+        --------------------------------------------------
+
+        Approach: Two Pointer Technique
+        --------------------------------
+        1. First sort the array so that numbers are in increasing order.
         2. Use two pointers:
-           - l (left) starting from the beginning.
-           - r (right) starting from the end.
-        3. Check the sum of elements at these pointers.
-        4. If sum == k → we found a valid pair:
-              - increase pair count
-              - move both pointers inward
-        5. If sum < k → move the left pointer right to increase the sum.
-        6. If sum > k → move the right pointer left to decrease the sum.
+           - Left pointer (l) starting from the beginning.
+           - Right pointer (r) starting from the end.
+        3. Calculate the sum of elements at both pointers.
+        4. If the sum equals k:
+              - A valid pair is found.
+              - Increase the pair count.
+              - Move both pointers inward.
+        5. If the sum is less than k:
+              - Move the left pointer forward to increase the sum.
+        6. If the sum is greater than k:
+              - Move the right pointer backward to decrease the sum.
         7. Continue until the pointers meet.
 
-        Why this works:
-        Sorting allows us to efficiently adjust the sum by moving pointers
-        instead of checking all possible pairs (which would be O(n²)).
+        Why This Works
+        ---------------
+        Sorting allows us to efficiently adjust the sum using two pointers 
+        instead of checking every possible pair.
+
+        --------------------------------------------------
+
+        Time Complexity
+        ----------------
+        Sorting: O(n log n)
+        Two-pointer traversal: O(n)
 
-        Time Complexity (TC):
-        Sorting takes O(n log n)
-        Two-pointer traversal takes O(n)
         Overall TC = O(n log n)
 
-        Space Complexity (SC):
-        O(1) → No extra data structures used (in-place operations)
+        Space Complexity
+        -----------------
+        O(1) → No extra space is used (in-place operations).
         """
 
-        pairs = 0                # Count of valid pairs
-        nums.sort()              # Sort the array to apply two-pointer technique
+        pairs = 0
+        nums.sort()              # Sort array to apply two-pointer technique
 
         l = 0                    # Left pointer
         r = len(nums) - 1        # Right pointer
 
-        # Continue until the two pointers meet
+        # Traverse until both pointers meet
         while l < r:
+            current_sum = nums[l] + nums[r]
 
-            n = nums[l] + nums[r]   # Current pair sum
-
-            if k == n:              # If the pair sum equals k
-                pairs += 1          # Found a valid pair
-                l += 1              # Move left pointer forward
-                r -= 1              # Move right pointer backward
+            if current_sum == k:     # Valid pair found
+                pairs += 1
+                l += 1               # Move left pointer forward
+                r -= 1               # Move right pointer backward
 
-            elif n < k:             # If sum is smaller than k
-                l += 1              # Increase sum by moving left pointer
+            elif current_sum < k:    # Sum too small → increase it
+                l += 1
 
-            else:                   # If sum is greater than k
-                r -= 1              # Decrease sum by moving right pointer
+            else:                    # Sum too large → decrease it
+                r -= 1
 
-        return pairs               # Return total number of valid pairs
+        return pairs