May 2020 leetcode challenge

Author: Shashank Singh

Leetcode/MAY2020challenge/0001_first_unique_character_in_a_string.py

@@ -0,0 +1,37 @@
+"""
+https://leetcode.com/explore/featured/card/may-leetcoding-challenge/534/week-1-may-1st-may-7th/3320/
+Given a string, find the first non-repeating character in it and return it's index. If it doesn't exist, return -1.
+
+Examples:
+
+s = "leetcode"
+return 0.
+
+s = "loveleetcode",
+return 2.
+
+Note: You may assume the string contain only lowercase letters.
+
+"""
+from collections import OrderedDict
+
+
+class Solution(object):
+    def firstUniqChar(self, s: str) -> int:
+        """
+        :type s: str
+        :rtype: int
+        """
+
+        character_frequency = OrderedDict()
+        for index in range(len(s)):
+            c = s[index]
+            character_frequency[c] = ((character_frequency.get(c, (0, -1)))[0] + 1, index)
+        for k, v in character_frequency.items():
+            if v[0] == 1:
+                return v[1]
+        return -1
+
+
+if __name__ == '__main__':
+    print(Solution().firstUniqChar('loveleetcode'))

Leetcode/MAY2020challenge/0002_cousins_in_a_binary_tree.py

@@ -0,0 +1,42 @@
+"""
+https://leetcode.com/explore/featured/card/may-leetcoding-challenge/534/week-1-may-1st-may-7th/3322/
+In a binary tree, the root node is at depth 0, and children of each depth k node are at depth k+1.
+
+Two nodes of a binary tree are cousins if they have the same depth, but have different parents.
+
+We are given the root of a binary tree with unique values, and the values x and y of two different nodes in the tree.
+
+Return true if and only if the nodes corresponding to the values x and y are cousins.
+"""
+
+
+# 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 isCousins(self, root: TreeNode, x: int, y: int) -> bool:
+
+        global_var = {}
+
+        def traversal(node, depth, parent_val):
+            if node is None:
+                return
+            if node.val in [x, y]:
+                global_var[node.val] = {
+                    'parent': parent_val,
+                    'depth': depth
+                }
+            traversal(node.left, depth + 1, node.val)
+            traversal(node.right, depth + 1, node.val)
+
+        traversal(root, 0, None)
+        if global_var[x]['depth'] == global_var[y]['depth']:
+            if global_var[x]['parent'] != global_var[y]['parent']:
+                return True
+
+        return False