SlidignWindow

Author: Milan-Pro

SlidingWindow_AvgOfArray.py

@@ -16,13 +16,13 @@ def find_avg_ofarray1(K, arr):
     result = []
     window_start = 0
     window_Sum = 0.0
-    for windowEnd in range(len(arr)):
-        windowSum += arr[windowEnd] # add the next element
+    for window_End in range(len(arr)):
+        window_Sum += arr[window_End] # add the next element
         # slide the window, we don't need to alide if we have not hit the required window size of 'k'
-        if windowEnd >= K - 1:
-            result.append(windowSum / K) # Calculate the Average
-            windowSum -= arr[windowStart] # remove element going out
-            windowStart += 1 # slide the windw by 1
+        if window_End >= K - 1:
+            result.append(window_End / K) # Calculate the Average
+            window_Sum -= arr[window_start] # remove element going out
+            window_start += 1 # slide the windw by 1
     return result
 
 # Time Space is O(n)

SlidingWindow_FruitsintoBasket.py

@@ -0,0 +1,61 @@
+'''
+Given an array of characters where each character represents a fruit tree, you are given two baskets and your goal is to put maximum number of fruits in each basket.
+ The only restriction is that each basket can have only one type of fruit.
+You can start with any tree, but once you have started you can’t skip a tree. You will pick one fruit from each tree until you cannot,
+ i.e., you will stop when you have to pick from a third fruit type.
+Write a function to return the maximum number of fruits in both the baskets.
+Example 1:
+Input: Fruit=['A', 'B', 'C', 'A', 'C']
+Output: 3
+Explanation: We can put 2 'C' in one basket and one 'A' in the other from the subarray ['C', 'A', 'C']
+Example 2:
+Input: Fruit=['A', 'B', 'C', 'B', 'B', 'C']
+Output: 5
+Explanation: We can put 3 'B' in one basket and two 'C' in the other basket. 
+This can be done if we start with the second letter: ['B', 'C', 'B', 'B', 'C']
+'''
+
+def fruits_into_baskets(fruits):
+    window_start = 0
+    max_length = 0
+    fruit_freq = {}
+
+    # try to extend the range[window_start, window_end]
+    for window_end in range(len(fruits)):
+        right_fruit = fruits[window_end]
+        if right_fruit not in fruit_freq:
+            fruit_freq[right_fruit] = 0
+        fruit_freq[right_fruit] += 1
+
+        #shrink the sliding window, untill we are left with '2' fruits in the fruit freq dictionary
+        while len(fruit_freq) > 2:
+            left_fruit = fruits[window_start]
+            fruit_freq[left_fruit] -= 1
+            if fruit_freq[left_fruit] == 0:
+                del fruit_freq[left_fruit]
+            window_start += 1 # shrink the window
+        max_length = max(max_length, window_end - window_start + 1)
+    return max_length
+
+def main():
+    print("Max num of Fruits:" + str(fruits_into_baskets(['A','B','C','A','C'])))    
+    print("Max num of Fruits:" + str(fruits_into_baskets(['A','B','C','B','B','C'])))  
+        
+main()
+
+'''
+Time Complexity #
+The time complexity of the above algorithm will be O(N) where ‘N’ is the number of characters in the input array.
+The outer for loop runs for all characters and the inner while loop processes each character only once, 
+therefore the time complexity of the algorithm will be O(N+N) which is asymptotically equivalent to O(N).
+
+Space Complexity #
+The algorithm runs in constant space O(1) as there can be a maximum of three types of fruits stored in the frequency map.
+
+Similar Problems #
+Problem 1: Longest Substring with at most 2 distinct characters
+
+Given a string, find the length of the longest substring in it with at most two distinct characters.
+
+Solution: This problem is exactly similar to our parent problem.
+'''

SlidingWindow_LongestSubstringwithKChar.py

@@ -34,6 +34,11 @@ def longest_substring_with_k_dist(str,k):
         max_length = max(max_length, window_end - window_start + 1)
     return max_length
 
+def main():
+    print("Length of the longest Substring:" + str(longest_substring_with_k_dist("araaci",2)))    
+    print("Length of the longest Substring:" + str(longest_substring_with_k_dist("araaci",1)))   
+    print("Length of the longest Substring:" + str(longest_substring_with_k_dist("cbbebi",3)))     
+main()
 '''
 Time Complexity #
 The time complexity of the above algorithm will be O(N) where ‘N’ is the number of characters in the input string.