added 056 merge interval & 100 same tree

Author: mahesh-3pillar

README.md

@@ -4,15 +4,43 @@
 https://sebinsua.com/algorithmic-bathwater
 https://sebinsua.com/assets/posts/algorithmic-bathwater/algorithmic-bathwater-1.svg
 
+
+
+
+# 2405: Optimal Partition of String
+
+Intuition: map to store the string char, if char already exists in map means with hit a non unique char, increase the count and reset the map
+
+Approach:
+1. Map to track the unique char, count to track the count, set it to 1
+2. for each char
+   1. if char in map, count increment ans reset the map 
+   2. for all, set char in map with True or index
+
+
+# 056 Merge Interval
+Intuition: Sort the intervals on first element. For each interval, if last's[1] is less then curr[0] merge the intervals
+
+Approach:
+
+1. Sort the intervals on first element
+2. for each interval
+   1. if no merge interval in result so far or last interval in result is out of current interval
+      1. add into result
+   2. else merge interval // edge case  - current interval might be within boundary of first interval
+3. return the result  
+
+----
+
 # 763 Partition Labels 
 Intuition: store last occurrence index of the char in map and two pointer to find the break points to get the partitions
 
 Approach:
 1. map to store the last occurrence of the each index in pam
-2. Two variables break point, count and result array
-3. for loop till len of string
-   1. get the index of char from map
-   2. store the max of index and break point //this will help us to find the appropriate break point
+2. Variables break point, count and result array
+3. for loop till the len of the string
+   1. get the last index of char from map
+   2. store the max of index and break point in break point //this will help us to find the appropriate break point
    3. count++ for current partition
    4. if index is equal to break point
       1. store count value in result array

leetcode-py/056-merge-interval.py

@@ -0,0 +1,13 @@
+class Solution:
+    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
+        res = []
+
+        intervals.sort(key=lambda x:x[0])
+
+        for interval in intervals:
+            if not res or res[-1][1]<interval[0]:
+                res.append(interval)
+            else:
+                res[-1][1] = max(res[-1][1], interval[1])
+        
+        return res

leetcode-py/100-same-tree.py

@@ -0,0 +1,18 @@
+# Definition for a binary tree node.
+# class TreeNode:
+#     def __init__(self, val=0, left=None, right=None):
+#         self.val = val
+#         self.left = left
+#         self.right = right
+class Solution:
+    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
+        if not p and not q:
+            return True
+
+        if not p or not q:
+            return False
+
+        if p.val == q.val:
+            return self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
+        else:
+            return False 

leetcode-py/README.md

@@ -10,3 +10,46 @@
  output `{'w': [], 'r': [], 't': [], 'f': [], 'e': []}`
 
  ----
+
+Loop over list and get the index and value both
+`for i, interval in enumerate(intervals):`
+
+
+Loop over list from non zero starting point
+`for j in range(i+1, len(intervals)):`
+
+----
+Sorting 
+- `sorted()` return the new sorted list without modifying existing 
+-  `my_list.sort()` modify existing list
+-  Reverse sorting pass `reverse=True`
+-  custom sorting pass `key=lambda x:x[0]` 
+```
+my_list = [(1, 'apple'), (3, 'banana'), (2, 'orange')]
+
+# Sort based on the second element of each tuple (the fruit name)
+sorted_list = sorted(my_list, key=lambda x: x[1])
+print(sorted_list)
+# Output: [(1, 'apple'), (3, 'banana'), (2, 'orange')]
+
+# Sort based on the first element of each tuple (the number)
+my_list.sort(key=lambda x: x[0])
+print(my_list)
+# Output: [(1, 'apple'), (2, 'orange'), (3, 'banana')]
+```
+
+-----
+maps
+
+- How to check keys in maps
+`key in map`
+
+- How to check values in map
+`value in map.values()`
+
+----
+List
+
+- How to define an array of 26 size with all the element `0`
+`unique = [0] * 26`
+