feat(work): add LeetCode solutions for 217, 271, and 98

work/1/Easy/Array/217.contains-duplicate.py

@@ -0,0 +1,51 @@
+"""
+217. Contains Duplicate
+Difficulty: Easy
+https://leetcode.com/problems/contains-duplicate/
+
+──────────────────────────────────────────────────
+
+Given an integer array nums, return true if any value appears at
+least twice in the array, and return false if every element is
+distinct.
+
+ 
+
+Example 1:
+
+Input: nums = [1,2,3,1]
+
+Output: true
+
+Explanation:
+
+The element 1 occurs at the indices 0 and 3.
+
+Example 2:
+
+Input: nums = [1,2,3,4]
+
+Output: false
+
+Explanation:
+
+All elements are distinct.
+
+Example 3:
+
+Input: nums = [1,1,1,3,3,4,3,2,4,2]
+
+Output: true
+
+ 
+
+Constraints:
+
+	• 1 <= nums.length <= 10^5
+
+	• -10^9 <= nums[i] <= 10^9
+"""
+
+class Solution:
+    def containsDuplicate(self, nums: List[int]) -> bool:
+        

work/1/Medium/Array/271.encode-and-decode-strings.py

@@ -0,0 +1,92 @@
+"""
+271. Encode and Decode Strings
+Difficulty: Medium
+https://leetcode.com/problems/encode-and-decode-strings/
+
+──────────────────────────────────────────────────
+
+Design an algorithm to encode a list of strings to a string. The
+encoded string is then sent over the network and is decoded back to
+the original list of strings.
+
+Machine 1 (sender) has the function:
+
+string encode(vector<string> strs) {
+  // ... your code
+  return encoded_string;
+}
+Machine 2 (receiver) has the function:
+
+vector<string> decode(string s) {
+  //... your code
+  return strs;
+}
+
+So Machine 1 does:
+
+string encoded_string = encode(strs);
+
+and Machine 2 does:
+
+vector<string> strs2 = decode(encoded_string);
+
+strs2 in Machine 2 should be the same as strs in Machine 1.
+
+Implement the encode and decode methods.
+
+You are not allowed to solve the problem using any serialize methods
+(such as eval).
+
+ 
+
+Example 1:
+
+Input: dummy_input = ["Hello","World"]
+Output: ["Hello","World"]
+Explanation:
+Machine 1:
+Codec encoder = new Codec();
+String msg = encoder.encode(strs);
+Machine 1 ---msg---> Machine 2
+
+Machine 2:
+Codec decoder = new Codec();
+String[] strs = decoder.decode(msg);
+
+Example 2:
+
+Input: dummy_input = [""]
+Output: [""]
+
+ 
+
+Constraints:
+
+	• 1 <= strs.length <= 200
+
+	• 0 <= strs[i].length <= 200
+
+• strs[i] contains any possible characters out of 256 valid ASCII
+characters.
+
+ 
+
+Follow up: Could you write a generalized algorithm to work on any
+possible set of characters?
+"""
+
+class Codec:
+    def encode(self, strs: List[str]) -> str:
+        """Encodes a list of strings to a single string.
+        """
+        
+
+    def decode(self, s: str) -> List[str]:
+        """Decodes a single string to a list of strings.
+        """
+        
+
+
+# Your Codec object will be instantiated and called as such:
+# codec = Codec()
+# codec.decode(codec.encode(strs))

work/1/Medium/Tree/98.validate-binary-search-tree.py

@@ -0,0 +1,62 @@
+"""
+98. Validate Binary Search Tree
+Difficulty: Medium
+https://leetcode.com/problems/validate-binary-search-tree/
+
+──────────────────────────────────────────────────
+
+Given the root of a binary tree, determine if it is a valid binary
+search tree (BST).
+
+A valid BST is defined as follows:
+
+• The left subtree of a node contains only nodes with keys strictly
+less than the node's key.
+
+• The right subtree of a node contains only nodes with keys strictly
+greater than the node's key.
+
+        • Both the left and right subtrees must also be binary search trees.
+
+
+
+Example 1:
+
+Input: root = [2,1,3]
+Output: true
+
+Example 2:
+
+Input: root = [5,1,4,null,null,3,6]
+Output: false
+Explanation: The root node's value is 5 but its right child's value
+is 4.
+
+
+
+Constraints:
+
+        • The number of nodes in the tree is in the range [1, 10^4].
+
+        • -2^31 <= Node.val <= 2^31 - 1
+"""
+
+
+# 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 isValidBST(self, root: Optional[TreeNode]) -> bool:
+        def valid(node, low, high):
+            if not node:
+                return True
+
+            if not (low < node.val < high):
+                return False
+
+            return valid(node.left, low, node.val) and valid(node.right, node.val, high)
+
+        return valid(root, float("-inf"), float("inf"))