leetcode 643 answer

Author: Kondareddy1209

Leetcode/Leetcode_643.py

@@ -4,123 +4,157 @@
 Given an integer array nums and an integer k,
 find the maximum average value of a subarray of length k.
 
-Example:
+Example
+-------
 nums = [1,12,-5,-6,50,3]
 k = 4
 
-Subarrays of length 4:
-[1,12,-5,-6]  -> average = 0.5
-[12,-5,-6,50] -> average = 12.75
-[-5,-6,50,3]  -> average = 10.5
+Subarrays of size 4:
+
+[1,12,-5,-6]  -> avg = 0.5
+[12,-5,-6,50] -> avg = 12.75
+[-5,-6,50,3]  -> avg = 10.5
 
 Maximum average = 12.75
 
-Concept Used:
+
+Concept Used
+------------
 Sliding Window Technique
 
-Instead of recalculating the sum of every subarray,
-we maintain a moving window of size k.
+Instead of recalculating the sum for every subarray,
+we maintain a window of size k.
 
 Steps:
 1. Add the next element to the window
-2. Calculate average when window size reaches k
+2. When window size == k → calculate result
 3. Remove the leftmost element
 4. Slide the window forward
 
-Time Complexity: O(n)
-Space Complexity: O(1)
+Time Complexity  : O(n)
+Space Complexity : O(1)
+
+
+Sliding Window Visualization
+----------------------------
+
+nums = [1,12,-5,-6,50,3]
+k = 4
+
+Step 1
+
+[1,12,-5,-6] 50 3
+avg = 0.5
+
+
+Step 2
+
+1 [12,-5,-6,50] 3
+avg = 12.75
+
+
+Step 3
+
+1 12 [-5,-6,50,3]
+avg = 10.5
+
+
+Maximum = 12.75
 """
 
 
 class Solution:
 
-    # ------------------------------------------------------------
-    # Approach 1: Sliding Window using FOR loop
-    # ------------------------------------------------------------
+    # ---------------------------------------------------------
+    # APPROACH 1 : Sliding Window using FOR loop
+    # ---------------------------------------------------------
     def findMaxAverage_for_loop(self, nums, k):
         """
-        This method uses a for loop with two pointers.
-        r -> right pointer (expands window)
-        l -> left pointer (shrinks window)
+        Uses a for loop with two pointers.
+
+        l -> left pointer
+        r -> right pointer
+
+        r expands the window
+        l shrinks the window
         """
 
-        l = 0                      # left pointer
-        window_sum = 0             # stores current window sum
-        max_avg = float('-inf')    # stores maximum average found
+        l = 0
+        window_sum = 0
+        max_avg = float('-inf')
 
-        # r represents the right pointer of the sliding window
+        # r moves through the array
         for r in range(len(nums)):
 
-            # Step 1: Add the new element to the window
+            # Add new element entering the window
             window_sum += nums[r]
 
-            # Step 2: Check if window size becomes k
-            if (r - l + 1) == k:
+            # Check if window size reached k
+            if r - l + 1 == k:
 
-                # Step 3: Compute average of current window
+                # Calculate average
                 current_avg = window_sum / k
 
                 # Update maximum average
                 max_avg = max(max_avg, current_avg)
 
-                # Step 4: Remove the leftmost element
+                # Remove element leaving the window
                 window_sum -= nums[l]
 
-                # Step 5: Move the left pointer forward
+                # Move left pointer forward
                 l += 1
 
         return max_avg
 
-    # ------------------------------------------------------------
-    # Approach 2: Sliding Window using WHILE loop
-    # ------------------------------------------------------------
+    # ---------------------------------------------------------
+    # APPROACH 2 : Sliding Window using WHILE loop
+    # ---------------------------------------------------------
     def findMaxAverage_while_loop(self, nums, k):
         """
-        This method uses a while loop instead of a for loop.
-        The logic remains exactly the same.
+        Same sliding window logic but implemented with a while loop.
         """
 
-        l = 0                       # left pointer
-        r = 0                       # right pointer
-        window_sum = 0              # sum of elements inside window
-        max_avg = float('-inf')     # track maximum average
+        l = 0
+        r = 0
+        window_sum = 0
+        max_avg = float('-inf')
 
-        # Continue until right pointer reaches the end
+        # Continue until r reaches end of array
         while r < len(nums):
 
-            # Step 1: Add element at right pointer
+            # Add element at right pointer
             window_sum += nums[r]
 
-            # Step 2: Check if window size becomes k
-            if (r - l + 1) == k:
+            # If window size becomes k
+            if r - l + 1 == k:
 
-                # Calculate current average
+                # Calculate average
                 current_avg = window_sum / k
 
-                # Update maximum average
+                # Update max average
                 max_avg = max(max_avg, current_avg)
 
-                # Step 3: Remove the leftmost element
+                # Remove element leaving window
                 window_sum -= nums[l]
 
-                # Step 4: Move left pointer forward
+                # Move left pointer
                 l += 1
 
-            # Step 5: Move right pointer forward
+            # Move right pointer
             r += 1
 
         return max_avg
 
 
-# ------------------------------------------------------------
-# Example Test (for understanding / local testing)
-# ------------------------------------------------------------
+# ---------------------------------------------------------
+# Example Test (for learning and debugging)
+# ---------------------------------------------------------
 if __name__ == "__main__":
 
     nums = [1, 12, -5, -6, 50, 3]
     k = 4
 
     sol = Solution()
 
-    print("Using FOR loop:", sol.findMaxAverage_for_loop(nums, k))
-    print("Using WHILE loop:", sol.findMaxAverage_while_loop(nums, k))
+    print("FOR LOOP RESULT  :", sol.findMaxAverage_for_loop(nums, k))
+    print("WHILE LOOP RESULT:", sol.findMaxAverage_while_loop(nums, k))