Add solutions to LC110 and LC58

Author: kate-melnykova

LC110-Balanced-Binary-Tree.py

@@ -0,0 +1,72 @@
+"""
+Given a binary tree, determine if it is height-balanced.
+
+For this problem, a height-balanced binary tree is defined as:
+
+a binary tree in which the left and right subtrees of every
+node differ in height by no more than 1.
+
+Example 1.
+Input: root = [3,9,20,null,null,15,7]
+Output: true
+
+Example 2.
+Input: root = [1,2,2,3,3,null,null,4,4]
+Output: false
+
+Example 3:
+Input: root = []
+Output: true
+
+
+Constraints:
+(*) The number of nodes in the tree is in the range [0, 5000].
+(*)-10^4 <= Node.val <= 10^4
+"""
+from TreeNode import TreeNode
+
+
+class Solution:
+    def isBalanced(self, root: TreeNode) -> bool:
+        """
+        Checking isBalanced using new depth attribute
+        Time complexity: O(n)
+        Space complexity: O(n)
+        """
+        if root is None: return True
+        
+        if root.left is not None:
+            is_left_balanced = self.isBalanced(root.left)
+            left_depth = root.left.depth
+        else:
+            is_left_balanced = True
+            left_depth = 0
+            
+        if root.right is not None:
+            is_right_balanced = self.isBalanced(root.right)
+            right_depth = root.right.depth
+        else:
+            is_right_balanced = True
+            right_depth = 0
+        
+        # determine the depth
+        root.depth = max(right_depth, left_depth) + 1
+        
+        # determine if the node is balanced
+        root.is_balanced = is_left_balanced and is_right_balanced and abs(right_depth - left_depth) <= 1
+        return root.is_balanced
+
+
+if __name__ == '__main__':
+    from run_tests import run_tests
+
+    correct_answers = [
+        [[3, 9, 20, None, None, 15, 7], True],
+        [[1,2,2,3,3,None,None,4,4], False],
+        [[], True]
+    ]
+    correct_answers = [
+        [TreeNode.to_treenode(lst), ans] for lst, ans in correct_answers
+    ]
+    print('Run tests for isBalanced')
+    run_tests(Solution().isBalanced, correct_answers)

LC58-Length-of-Last-Word.py

@@ -0,0 +1,64 @@
+"""
+Given a string s consists of some words separated by spaces,
+return the length of the last word in the string. If the last
+word does not exist, return 0.
+
+A word is a maximal substring consisting of non-space characters only.
+
+Example 1:
+Input: s = "Hello World"
+Output: 5
+
+Example 2:
+Input: s = " "
+Output: 0
+
+
+Constraints:
+(*) 1 <= s.length <= 104
+(*) s consists of only English letters and spaces ' '.
+"""
+
+
+class Solution:
+    def lengthOfLastWord2(self, s: str) -> int:
+        """
+        Time complexity: O(n)
+        Space complexity: O(1)
+        """
+        word_started = False
+        l = 0
+        for i in range(len(s) - 1, -1, -1):
+            if s[i] == ' ' and word_started:
+                return l
+
+            elif s[i] != ' ':
+                word_started = True
+                l += 1
+
+        return l
+
+    def lengthOfLastWord(self, s: str) -> int:
+        """
+        Time complexity: O(n)
+        Space complexity: O(n)
+        """
+        s = s.split()
+        return len(s[-1]) if s else 0
+
+
+if __name__ == '__main__':
+    from run_tests import run_tests
+
+    correct_answers = [
+        ['', 0],
+        [' ', 0],
+        ['  ', 0],
+        ['word', 4],
+        ['Hello World', 5],
+        ['Hello Worlds ', 6]
+    ]
+    methods = ['lengthOfLastWord', 'lengthOfLastWord2', ]
+    for method in methods:
+        print(f'Running tests for {method}')
+        run_tests(getattr(Solution(), method), correct_answers)

TreeNode.py

@@ -0,0 +1,85 @@
+from typing import List
+
+
+class IncorrectTreeNodeTranscription(Exception):
+    pass
+
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+    def to_list(self) -> List[int or str]:
+        level = [self, ]
+        lst = []
+        while level:
+            new_level = list()
+            for node in level:
+                if node is None:
+                    lst.append(None)
+                else:
+                    lst.append(node.val)
+                    new_level.append(node.left)
+                    new_level.append(node.right)
+            level = list(new_level)
+
+        return lst
+
+    @classmethod
+    def to_treenode(cls, arr: List[int or str]) -> 'TreeNode' or None:
+        if not arr or arr[0] is None:
+            return None
+
+        level = [TreeNode(arr.pop(0)), ]
+        root = level[0]
+        while level:
+            new_level = []
+            for node in level:
+                if not arr:
+                    break
+                elif arr[0] is None:
+                    arr.pop(0)
+                else:
+                    node.left = TreeNode(arr.pop(0))
+                    new_level.append(node.left)
+
+                if not arr:
+                    break
+                elif arr[0] is None:
+                    arr.pop(0)
+                else:
+                    node.right = TreeNode(arr.pop(0))
+                    new_level.append(node.right)
+            level = list(new_level)
+        return root
+
+    def __repr__(self):
+        return str(self.to_list())
+
+    def __eq__(self, other):
+        this = self
+        if this is None and other is None:
+            return True
+
+        if this is None or other is None:
+            return False
+
+        if this.val != other.val:
+            return False
+
+        return self.left == other.left and self.right == other.right
+
+
+if __name__ == '__main__':
+    lists = [
+        [1, None, None],
+        [1, 2, None, None, 3, None, None],
+        [1,None,2,None,3, None, None],
+        [1, 4, None, None, 3, None, None],
+        [3,9,20,None,None, 15, 7]
+    ]
+    for lst in lists:
+        lst2 = TreeNode.to_treenode(list(lst)).to_list()
+        assert lst2 == lst + [None, ] * (len(lst2) - len(lst)), str(lst)