Added Leetcode easy problems

Author: das-jishu

Leetcode/easy/min-stack.py

@@ -0,0 +1,59 @@
+""" 
+# MIN STACK
+
+Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+
+push(x) -- Push element x onto stack.
+pop() -- Removes the element on top of the stack.
+top() -- Get the top element.
+getMin() -- Retrieve the minimum element in the stack.
+ 
+
+Example 1:
+
+Input
+["MinStack","push","push","push","getMin","pop","top","getMin"]
+[[],[-2],[0],[-3],[],[],[],[]]
+
+Output
+[null,null,null,null,-3,null,0,-2]
+
+Explanation
+MinStack minStack = new MinStack();
+minStack.push(-2);
+minStack.push(0);
+minStack.push(-3);
+minStack.getMin(); // return -3
+minStack.pop();
+minStack.top();    // return 0
+minStack.getMin(); // return -2
+ 
+
+Constraints:
+
+Methods pop, top and getMin operations will always be called on non-empty stacks. 
+"""
+
+class MinStack:
+
+    def __init__(self):
+        """
+        initialize your data structure here.
+        """
+        self.stk=[]
+        self.min=[float('inf')]
+
+    def push(self, x: int) -> None:
+        self.stk.append(x)
+        if x <= self.min[-1]: self.min.append(x)
+        
+    def pop(self) -> None:
+        x=self.stk.pop()
+        if x == self.min[-1]: self.min.pop()
+        return self.stk
+
+    def top(self) -> int:
+        return self.stk[-1]
+
+    def getMin(self) -> int:
+        return self.min[-1]

Leetcode/easy/path-sum.py

@@ -0,0 +1,40 @@
+""" 
+# PATH SUM
+
+Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
+
+Note: A leaf is a node with no children.
+
+Example:
+
+Given the below binary tree and sum = 22,
+
+      5
+     - -
+    4   8
+   -   - -
+  11  13  4
+ -  -      -
+7    2      1
+return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22. 
+"""
+
+# 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 hasPathSum(self, root: TreeNode, sum: int) -> bool:
+        if not root:
+            return False
+        
+        if not root.left and not root.right:
+            if sum - root.val == 0:
+                return True
+            else:
+                return False
+            
+        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)

Leetcode/easy/single-number.py

@@ -0,0 +1,36 @@
+""" 
+# SINGLE NUMBER
+
+Given a non-empty array of integers nums, every element appears twice except for one. Find that single one.
+
+Follow up: Could you implement a solution with a linear runtime complexity and without using extra memory?
+
+ 
+Example 1:
+
+Input: nums = [2,2,1]
+Output: 1
+
+Example 2:
+
+Input: nums = [4,1,2,1,2]
+Output: 4
+
+Example 3:
+
+Input: nums = [1]
+Output: 1
+
+Constraints:
+
+1 <= nums.length <= 3 * 104
+-3 * 104 <= nums[i] <= 3 * 104
+Each element in the array appears twice except for one element which appears only once. 
+"""
+
+class Solution:
+    def singleNumber(self, nums) -> int:
+        res = 0
+        for x in nums:
+            res = res ^ x
+        return res