update

Author: KaidiGuo

Array/303. Range Sum Query - Immutable.py

@@ -0,0 +1,17 @@
+'''
+pre calculate all the accumulated sum, thus when changing the i and j, we don't need to use a for loop to do sum again,
+we just need to use the j sum substract i sum
+'''
+
+lass NumArray:
+
+    def __init__(self, nums: List[int]):
+        self.presum = nums  # pass by pointer!
+        for i in range(len(nums)-1):
+            self.presum[i+1] += self.presum[i]
+      
+        
+
+    def sumRange(self, left: int, right: int) -> int:
+        if left == 0: return self.presum[right]
+        return self.presum[right] - self.presum[left-1]

Linked List/21. Merge Two Sorted Lists.py

@@ -30,4 +30,8 @@ def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
                 l2 = l2.next
             cur = cur.next
         cur.next = l1 or l2
-        return dummy.next
+        return dummy.next
+    
+    
+    
+    

Linked List/86. Partition List.py

@@ -0,0 +1,54 @@
+# Definition for singly-linked list.
+# class ListNode:
+#     def __init__(self, val=0, next=None):
+#         self.val = val
+#         self.next = next
+
+# Solution 1, split the notes by value into two lists, use append to keep order of the nodes, 
+# re-connect the nodes in the two lists in the end
+# This solution is not inplace
+class Solution:
+    def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
+        small=[]
+        big=[]
+        result = ListNode()
+        marker=result
+        while head:
+            if head.val<x:
+                small.append(head)
+                print(f"small {head.val}")
+            else:
+                big.append(head)
+                print(f"big {head.val}")
+            head = head.next
+
+        for item in small:
+            item.next=None
+            marker.next=item
+            marker = marker.next
+        for item in big:
+            item.next=None
+            marker.next=item
+            marker = marker.next
+        return result.next
+
+#Solution 2
+class Solution:
+    def partition(self, head: Optional[ListNode], x: int) -> Optional[ListNode]:
+        small = ListNode()
+        big= ListNode()
+        ps = small
+        pb = big
+        while head:
+            print(f"head value {head.val}")
+            if head.val <x:
+                ps.next = head
+                ps = head
+            else:
+                pb.next= head
+                pb = head
+            head = head.next
+        pb.next=None
+        
+        ps.next = big.next
+        return small.next

Sliding window/3. Longest Substring Without Repeating Characters.py

@@ -0,0 +1,34 @@
+'''
+move right pointer while adding visited to a map; compare max maxlen on the way with len(map)
+when reaching a visited one, find the initial index
+move and pop the left pointer to the initial index+1
+add the new duplicate and nex index to the visited map
+
+'''
+
+class Solution:
+    def lengthOfLongestSubstring(self, s: str) -> int:
+        maxlen=0
+        left,right=0,0
+        dict ={}
+        for right in range(len(s)):
+            c = s[right]
+            if c not in dict:
+                dict[c] = right
+                maxlen = max(maxlen,len(dict))
+            else:
+                mark = dict[c]+1
+                                
+                for i in range(left,mark):
+                    dict.pop(s[i])
+                dict[c] = right
+                left = mark
+        
+        return maxlen
+
+
+
+
+
+
+        

Sliding window/438. Find All Anagrams in a String.py

@@ -10,7 +10,31 @@
 The following two parts are the same. just one use counter, one use dictionary
 """
 
+class Solution:
+    def findAnagrams(self, s: str, p: str) -> List[int]:
+        if len(p) >len(s):
+            return 
+        l = len(p)
+        dictp = defaultdict(int)
+        window = defaultdict(int)
+        for i in range(len(p)):
+            dictp[ p[i] ] +=1
+            window[ s[i] ] +=1
+        result=[]
 
+       
+        for j in range(len(s)-len(p)+1):
+            if window == dictp:
+                result.append(j)
+            if j +len(p) >= len(s):
+                pass
+            else:
+                window[s[j+len(p)]]+=1
+            window[s[j]] -=1
+            if window[s[j]] ==0:
+                window.pop(s[j])
+        return result
+    
 class Solution:
     def findAnagrams(self, s: str, p: str) -> List[int]:
         l = len(p)

Sliding window/567. Permutation in String.py

@@ -0,0 +1,30 @@
+'''
+Very same to 438.
+Maintain a window dict that is the same length of the target substring
+shifting the window 
++1 to value of existed char on j+l position
+-1 to value of existed char on j position
+'''
+class Solution:
+    def checkInclusion(self, s1: str, s2: str) -> bool:
+        if len(s1)>len(s2):
+            return
+        target = defaultdict(int)
+        window = defaultdict(int)
+        l = len(s1)
+        for index,char in enumerate(s1):
+            target[char] +=1
+            window[s2[index]] +=1
+        
+        for i in range(len(s2)-l+1):
+            if target == window:
+                return True
+
+            if i+l >= len(s2):
+                pass
+            else: 
+                window[s2[i+l]] +=1
+                window[s2[i]] -=1
+                if window[s2[i]] ==0:
+                    window.pop(s2[i])
+        return False 

resource ocupation/1094. Car Pooling.py

@@ -14,3 +14,19 @@ def carPooling(self, trips: List[List[int]], capacity: int) -> bool:
 
         return True
 
+        maxlen=0
+        sub=[]
+        dic={}
+        st=0
+        ed=0
+        for i,char in enumerate(s) :
+            if char not in dic:
+                dic[char] = i
+                maxlen = max(len(dic),maxlen)
+            else:
+                ed=dic[char]+1
+                for p in range(st,ed):
+                    dic.pop(s[p])
+                dic[char]=i
+                st=ed
+        return maxlen