add oop

dsa/d1/exercise_1.py

@@ -5,17 +5,16 @@ def main():
     print(two_sum(nums, target))
 
 def two_sum(nums, target):
-    map = {}
+    seen = set()
     #num, index
-    pairs=[]
-    for i in range(len(nums)):
-        required_num = target - nums[i]
-        if required_num in map:
-            pairs.append((nums[i], required_num))
-            #pairs[nums[i]] = required_num
+    pairs=set()
+    for num in nums:
+        required_num = target - num
+        if required_num in seen:
+            pairs.add((min(num, required_num), max(num, required_num)))
 
-        map[nums[i]] = i
-    return sorted(pairs, key=lambda v: v[0])
+        seen.add(num)
+    return sorted(pairs)
 
 if __name__ == "__main__":
     main()

dsa/d1/exercise_2.py

@@ -0,0 +1,21 @@
+def main():
+    nums = [2, 7, 11, 15, 3, 4, 8, 1]
+    target = 11
+
+    print(two_sum(nums, target))
+
+def two_sum(nums, target):
+    seen = set()
+    pairs = set()
+    for num in nums:
+        required_num = target - num
+        if required_num in seen:
+            if required_num > num:
+                pairs.add((num, required_num))
+            else:
+                pairs.add((required_num, num))
+        seen.add(num)
+    return sorted(pairs)
+
+if __name__ == "__main__":
+    main()

dsa/d1/exercise_3.py

@@ -0,0 +1,20 @@
+def main():
+    nums = [2, 7, 11, 15, 3, 4, 8, 1]
+    target = 11
+
+    print(two_sum(nums, target))
+
+def two_sum(nums, target):
+    seen = set()
+    pairs=set()
+    for num in nums:
+        required_num = target - num
+        if required_num in seen:
+            if required_num > num:
+                pairs.add((num, required_num))
+            else:
+                pairs.add((required_num, num))
+        seen.add(num)
+    return sorted(pairs)
+if __name__ == "__main__":
+    main()

dsa/d2/exercise_1.py

@@ -1,5 +1,5 @@
 def main():
-    # s = "abcabcbb"  # → "abc"
+    #s = "abcabcbb"  # → "abc"
     # # s = "pwwkew"  # → "wke"
     # # s = ""  # → ""
     # print(longest_substring(s))
@@ -8,16 +8,19 @@ def main():
     print(longest_substring(s))
 
 def longest_substring(s):
-    maxLength = 0
+    max_length = 0
     seen = set()
     left = 0
+    best_start = 0
     for right in range(len(s)):
         while s[right] in seen:
             seen.remove(s[left])
             left+=1
         seen.add(s[right])
-        maxLength = max(maxLength,right - left +1)
-    return s[left:right+1]
+        if right - left + 1 > max_length:
+            max_length = right-left+1
+            best_start = left
+    return s[best_start:best_start+max_length]
 
 if __name__ == "__main__":
     main()

dsa/d2/exercise_2.py

@@ -0,0 +1,22 @@
+def main():
+    s = "abcabcbb"
+    print(longest_substring(s))
+
+def longest_substring(s):
+    seen = set()
+    max_length = 0
+    left = 0
+    best_start = 0
+
+    for right in range(len(s)):
+        while s[right] in seen:
+            seen.remove(s[left])
+            left+=1
+        seen.add(s[right])
+        if right - left + 1 > max_length:
+            max_length = right - left + 1
+            best_start = left
+    return s[best_start:best_start+max_length]
+
+if __name__ == "__main__":
+    main()

dsa/d2/exercise_3.py

@@ -0,0 +1,22 @@
+def main():
+    s = "xyzxy"
+    print(longest_substring(s))
+
+def longest_substring(s):
+
+    left = 0
+    seen = set()
+    max_length =0
+    best_start = 0
+    for right in range(len(s)):
+        while s[right] in seen:
+            seen.remove(s[left])
+            left+=1
+
+        if max_length < right - left + 1:
+            max_length = right - left + 1
+            best_start = left
+        seen.add(s[right])
+    return s[best_start:best_start+max_length]
+if __name__ == "__main__":
+    main()

dsa/d3/exercise_1.py

@@ -5,7 +5,7 @@ def main():
 def palindrome(s):
     clean_s = ""
     for i in range(len(s)):
-        if s[i].isalpha():
+        if s[i].isalpha() or s[i].isdigit():
            clean_s += s[i].lower()
     print(clean_s)
 

dsa/d3/exercise_2.py

@@ -0,0 +1,25 @@
+def main():
+    s = "race a car"
+    print(palindrome(s))
+
+def palindrome(string):
+    #clean_s = ""
+    clean_list = []
+    for i in string:
+       if i.isalpha() or i.isdigit():
+           #clean_s += i.lower()
+            clean_list.append(i)
+    clean_string = "".join(clean_list)
+    left = 0
+    right = len(clean_string)-1
+    print(clean_string)
+    while left < right:
+
+        if clean_string[left] != clean_string[right]:
+            return False
+        left+=1
+        right-=1
+    return True
+
+if __name__ == "__main__":
+    main()

dsa/d4/exercise_3.py

@@ -0,0 +1,26 @@
+def main():
+    nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]  # → [4, -1, 2, 1]
+    print(kadane_algorithm(nums))
+
+def kadane_algorithm(nums):
+    current_sum = nums[0]
+    max_sum = nums[0]
+    temp_start = 0
+    best_start = 0
+    best_end = 0
+    for i in range(1, len(nums)):
+        if current_sum + nums[i] > nums[i]:
+            current_sum = current_sum + nums[i]
+        else:
+            current_sum = nums[i]
+            temp_start = i
+        if current_sum > max_sum:
+            max_sum = current_sum
+            best_start = temp_start
+            best_end = i
+    return nums[best_start:best_end+1]
+
+
+
+if __name__ == "__main__":
+    main()

dsa/d4/exercise_4.py

@@ -0,0 +1,26 @@
+def main():
+    nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]  # → [4, -1, 2, 1]
+    print(kadane_algorithm(nums))
+
+def kadane_algorithm(nums):
+    current_sum = nums[0]
+    max_sum = nums[0]
+    temp_start = 0
+    best_start = 0
+    best_end =0
+    for i in range(1, len(nums)):
+        if current_sum +nums[i] > nums[i]:
+            current_sum = current_sum + nums[i]
+        else:
+            current_sum = nums[i]
+            temp_start = i
+        if current_sum > max_sum:
+            max_sum = current_sum
+            best_start = temp_start
+            best_end = i
+    return nums[best_start:best_end + 1]
+
+if __name__ == "__main__":
+    main()
+
+

dsa/d5/exercise_2.py

@@ -0,0 +1,18 @@
+from collections import defaultdict
+
+def main():
+    words = ["eat", "tea", "tan", "ate", "nat", "bat"]
+    print(algorithm(words))
+
+def algorithm(words):
+    word_list = defaultdict(list)
+
+    for word in words:
+        key = "".join(sorted(word))
+
+        word_list[key].append(word)
+
+    return dict(word_list)
+
+if __name__ == "__main__":
+    main()

dsa/d5/exercise_3.py

@@ -0,0 +1,16 @@
+from collections import defaultdict
+
+def main():
+    words = ["eat", "tea", "tan", "ate", "nat", "bat"]
+    print(algorithm(words))
+
+def algorithm(words):
+    anagram_words = defaultdict(list)
+    for word in words:
+        key = "".join(sorted(word))
+        anagram_words[key].append(word)
+
+    return dict(anagram_words)
+
+if __name__ == "__main__":
+    main()

exercise/dunder_methods/Employee.py

@@ -12,6 +12,15 @@ def __init__(self,name):
         self.name = name
         Employee.count += 1
 
+    def __eq__(self, other):
+        if isinstance(other, Employee):
+            if self.name == other.name:
+                return True
+        return False
+
+    def __hash__(self):
+        return hash((self.name))
+
     @staticmethod
     def is_valid_name(name):
         return len(name) > 0  # doesn't need self or the class

hashing/task4/exercise_6.py

@@ -0,0 +1,18 @@
+def main():
+
+    nums = [1, 2, 1]
+    k = 2
+    print(is_contains_nearby_duplicate(nums, k))
+
+def is_contains_nearby_duplicate(nums, k):
+    #hash_map -> value, index
+    hash_map = {}
+
+    for i in range(0, len(nums)):
+        if nums[i] in hash_map and i - hash_map[nums[i]] == k:
+            return True
+        hash_map[nums[i]] = i
+    return False
+
+if __name__ == "__main__":
+    main()

hashing/task5/exercise_5.py

@@ -0,0 +1,18 @@
+def main():
+    s = "rat"
+    t = "tar"
+    print(is_anagram(s,t))
+
+def is_anagram(s,t):
+    hash_map = {}
+    for i in range(len(s)):
+        hash_map[s[i]] = hash_map.get(s[i],0)+1
+
+    for j in range(len(t)):
+        if t[j] not in hash_map or hash_map[t[j]] == 0:
+            return False
+        hash_map[t[j]] = hash_map.get(t[j],0)-1
+
+    return True
+if __name__ == "__main__":
+    main()

kadanes_algorithm/task1/exercise_4.py

@@ -0,0 +1,26 @@
+def main():
+    nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+    print(f"Largest sum in the array -> {max_subarray_sum(nums)}")
+
+def max_subarray_sum(nums):
+    current_sum = nums[0]
+    max_sum = nums[0]
+    temp_start=0
+    best_start=0
+    best_end=0
+
+    for i in range(1, len(nums)):
+        if current_sum + nums[i] > nums[i]:
+            current_sum = current_sum + nums[i]
+        else:
+            current_sum = nums[i]
+            temp_start=i
+
+        if current_sum > max_sum:
+            max_sum = current_sum
+            best_start = temp_start
+            best_end = i
+    #return nums[best_start:best_end+1]
+    return max_sum
+if __name__ == "__main__":
+    main()