SlidingWidnowPractice

Author: Milan-Pro

LinkedList_AddTwonumbers.py

@@ -0,0 +1,45 @@
+class ListNode:
+    def _init_(self,value,next= None):
+        self.value = value
+        self.next = next
+#Approach 1
+class Solution2:
+    def addTwoNumbers2(self, l1: ListNode, l2: ListNode,c = 0) -> ListNode:
+        
+        val = l1.val + l2.val + c
+        c = val // 10
+        ret = ListNode(val % 10 ) 
+        
+        if (l1.next != None or l2.next != None or c != 0):
+            if l1.next == None:
+                l1.next = ListNode(0)
+            if l2.next == None:
+                l2.next = ListNode(0)
+            ret.next = self.addTwoNumbers2(l1.next,l2.next,c)
+        return ret
+
+#Approach 2
+class Solution:
+    def addTwoNumber(self, l1: ListNode, l2: ListNode) -> ListNode :
+        result = ListNode(0)
+        l3 = result
+        carry = 0
+
+        while l1 or l2 or carry:
+            currentSum = 0
+            currentSum += carry
+
+            if l1:
+                currentSum += l1.value
+            if l2:
+                currentSum += l2.value
+            
+            digit = currentSum % 10
+            carry = currentSum // 10
+
+            l3.val = digit
+            if l1 or l2 or carry:
+                l3.next = ListNode(0)
+                l3 = l3.next
+        return result
+

LinnkdList_IntersectionOfTwoLL.py

@@ -0,0 +1,50 @@
+'''
+There are multiple approach to check the inersection of Two linked list
+A) The Brute force
+Iterate trhough LL A with length M and Iterate through LL B with length N.
+ The overall time complexity is O(M*N)
+(B)  ## APPROACH : 2 POINTER ##
+        
+        ## LOGIC ##
+        # 1) Find the length of both lists;
+        # 2) In the biggest list, advance its head N times where N is the length difference between the two lists.
+        # 3) Now both lists have the same length, just iterate them and check for node equality.
+        
+		## TIME COMPLEXITY : O(M+N) ##
+		## SPACE COMPLEXITY : O(1) ##
+'''
+class ListNode:
+    def _init_(self,value, next = None):
+        self.next = next
+        self.value = value
+class Solution:
+    def getIntersection(self, headA:ListNode, headB:ListNode)-> ListNode:
+        la = lb = 0
+        m, n = headA, headB
+
+        #Find the length of both lists
+        while(headA):
+            la += 1
+            headA = headA.next
+        while(headB):
+            lb += 1
+            headB = headB.next
+        
+        # 2) In the biggest list, advance its head N times where N is the length difference between the two lists.
+        if(la > lb):
+            diff = la - lb
+            while(diff):
+                m = m.next
+                diff -= 1
+        else:
+            diff = lb - la
+            while(diff):
+                n= n.next
+                diff -= 1
+        
+        # 3) Now both lists have the same length, just iterate them and check for node equality.
+        while( m and n):
+            if(m == n): return m
+            m = m.next
+            n = n.next
+        return None

SlidingWindow_Fix_Avg_Sum.py renamed to SlidingWindow_AvgOfArray.py

@@ -12,9 +12,10 @@ def find_avg_ofarray(K, arr):
 # Time space is O(n * k)
 
 ##### Optimised Approach ########
-def find_avg_ofarray(K, arr):
+def find_avg_ofarray1(K, arr):
     result = []
-    windowStart = 0, windowSum = 0.0
+    window_start = 0
+    window_Sum = 0.0
     for windowEnd in range(len(arr)):
         windowSum += arr[windowEnd] # add the next element
         # slide the window, we don't need to alide if we have not hit the required window size of 'k'

SlidingWindow_LongestSubstringwithKChar.py

@@ -0,0 +1,45 @@
+'''
+Given a string, find the length of the longest substring in it with no more than K distinct characters
+Input: String="araaci", K=2
+Output: 4
+Explanation: The longest substring with no more than '2' distinct characters is "araa".
+Input: String="araaci", K=1
+Output: 2
+Explanation: The longest substring with no more than '1' distinct characters is "aa".
+Solution:
+->fisrt we will add char in charfreq HashMap
+->then We will expand window by adding element at window_end
+->once we reach greater then k then shrink the window by removing element from start
+'''
+def longest_substring_with_k_dist(str,k):
+    window_start = 0
+    max_length = 0
+    char_freq = {}
+
+    # in the following loop we'll try to expand[window_start,window_end]
+    for window_end in range(len(str)):
+        right_char = str[window_end]
+        if right_char not in char_freq:
+            char_freq[right_char] = 0
+        char_freq[right_char] += 1
+
+        # Shrink the sliding window, untill we are left with 'k' disctinct char in the char_freq
+        while len(char_freq) > k:
+            left_char = str[window_start]
+            char_freq[left_char] -= 1
+            if char_freq[left_char] == 0:
+                del char_freq[left_char]
+            window_start += 1 # shrink the window
+        # remember the maximum length so far
+        max_length = max(max_length, window_end - window_start + 1)
+    return max_length
+
+'''
+Time Complexity #
+The time complexity of the above algorithm will be O(N) where ‘N’ is the number of characters in the input string.
+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 space complexity of the algorithm is O(K)O(K), as we will be storing a maximum of ‘K+1’ characters in the HashMap.
+'''

SlidingWindow_MaximumOfSubArray.py

@@ -0,0 +1,33 @@
+'''
+Input: [2, 1, 5, 1, 3, 2], k=3 
+Output: 9
+Explanation: Subarray with maximum sum is [5, 1, 3].
+#Approach1: 
+Brute Force approach is two loop outer loop will go for the each number and inner loop will do the sum for i+k till we find the sum.
+this will take O(n*k) time
+
+#Approach 2: Fix sliding Window
+Move the sliding window based on our requiremnt 
+1) Subtract the element going out of the sliding window i.e., subtract the first element of the window.
+2) Add the new element getting included in the sliding window i.e., the element coming right after the end of the window.
+
+O(N)
+'''
+def max_sub_aaray_of_size_k(arr,k):
+    max_sum, window_sum = 0,0
+    window_start = 0
+
+
+    for window_end in range(len(arr)):
+        window_sum += arr[window_end] # add the next element
+        #slide the window, we don't need to slide if we have not hit the require window size of 'k'
+        if window_end >= k-1:
+            max_sum = max(max_sum,window_sum)
+            window_sum -= arr[window_start] # subtract the elemnt going out
+            window_start += 1 # move the window towards the next
+    return max_sum
+
+def main():
+    print("Max if sub array of size k"+ str(max_sub_aaray_of_size_k(2,[2,3,4,1,5])))
+
+main()

SlidingWindow_Variable_SmallestSubArray.py

@@ -1,11 +1,18 @@
+'''
+Problem: Given an array of positive numbers and a positive number ‘S’, 
+find the length of the smallest contiguous subarray whose sum is greater than or equal to ‘S’. Return 0, if no such subarray exists.
+Input: [2, 1, 5, 2, 3, 2], S=7 
+Output: 2
+Explanation: The smallest subarray with a sum great than or equal to '7' is [5, 2].
+'''
 import math
 def smallest_Subarray_with_Sum(arr,S):
     # Taking Start of sliding window and initial window sum with min_length
     window_sum = 0
     window_start = 0
     min_length = math.inf
 
-    for window_end in range(0,len(arr)): # taking window end and creating slidin window
+    for window_end in range(len(arr)): # taking window end and creating slidin window
         window_sum += arr[window_end]    # adding eliment of sliding window
 
         while window_sum >= S: #Checking for Sum