ngocquan

Author: ngocquanai

1. Two Sum.py

@@ -1,10 +1,53 @@
-class Solution:
-    def twoSum(self, nums, target) :
-        dict_nums = {}
-        for i in range(len(nums)) :
-            dict_nums[nums[i]] = i
-        for i in range(len(nums)):
-            if target - nums[i] in dict_nums :
-                j = dict_nums[target - nums[i]]
-                if i != j :
-                    return [i, j]
+# class Solution:
+#     def twoSum(self, nums, target) :
+#         dict_nums = {}
+#         for i in range(len(nums)) :
+#             dict_nums[nums[i]] = i
+#         for i in range(len(nums)):
+#             if target - nums[i] in dict_nums :
+#                 j = dict_nums[target - nums[i]]
+#                 if i != j :
+#                     return [i, j]
+
+
+
+class Solution(object):
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        set_nums = set(nums)
+
+        first_ind = -1
+
+        second_ind = -1
+
+        for i, num in enumerate(nums) :
+            if target - num in set_nums :
+
+                first_ind = i
+
+                second_num = target - num
+                break
+        print(first_ind)
+        # The first num must be found befor the second num
+        for i, num in enumerate(nums[first_ind+1 :]) :
+            if num == second_num :
+                second_ind = i
+                return [first_ind, second_ind]
+
+            
+
+
+
+
+
+
+
+
+
+
+
+

543. Diameter of Binary Tree.py

@@ -0,0 +1,26 @@
+# 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 __init__(self):
+        self.max_diameter = 0
+
+    def max_depth(self, root):
+        if not root:
+            return 0
+        if root.left == None and root.right == None:
+            return 1
+        left_depth = self.max_depth(root.left)
+        right_depth = self.max_depth(root.right)
+        current_diameter = left_depth + right_depth
+        if current_diameter > self.max_diameter:
+            self.max_diameter = current_diameter
+        return max(left_depth, right_depth) + 1
+
+    def diameterOfBinaryTree(self, root):
+        max_diameter = 0
+        self.max_depth(root)
+        return self.max_diameter

test.py

@@ -1,32 +1,2 @@
-from collections import Counter
-
-
-class Solution:
-    def isIsomorphic(self, s: str, t: str) -> bool:
-        transform = dict()  # Create transform from s to t
-        unique = dict()
-        ans = []
-        if len(s) != len(t):
-            return False
-        n = len(s)  # = len(t) also
-
-        for i in range(n):
-            if s[i] not in transform:
-                transform[s[i]] = t[i]
-                if t[i] in unique:
-                    return False
-                unique[t[i]] = None
-            # If transform[s[i]] exists
-            if t[i] != transform[s[i]]:
-                return False
-
-        for i in range(n):
-            ans.append(transform[s[i]])
-        ans_string = "".join(ans)
-        print(ans_string)
-
-        return ans_string == t
-
-
-obj = Solution()
-print(obj.isIsomorphic("badc", "bada"))
+a = [[0 for i in range(5)] for j in range(3)]
+print(a)

test1.py

@@ -0,0 +1,51 @@
+n = int(input())
+
+keys = [int(i) for i in input().split()]
+
+
+class Node:
+    def __init__(self, key):
+        self.key = key
+        self.left = None
+        self.right = None
+        self.child = 0  # total children
+
+
+def insert(root, key):
+    if root is None:
+        return Node(key)
+
+    if key < root.key:
+        root.left = insert(root.left, key)  # create left child
+    else:
+        root.right = insert(root.right, key)
+
+    root.child += 1
+
+    return root
+
+
+root = None
+for key in keys:
+    root = insert(root, key)
+
+
+def count_balance_node(root):
+    if root is None or (root.left == None and root.right == None):
+        return 0
+
+    if root.left == None:
+        return count_balance_node(root.right)
+    elif root.right == None:
+        return count_balance_node(root.left)
+
+    is_balance = 0
+    if root.left.child == root.right.child:
+        is_balance = 1
+    else:
+        is_balance = 0
+
+    return is_balance + count_balance_node(root.left) + count_balance_node(root.right)
+
+
+print(count_balance_node(root))