adding questions

Author: sharanbale

.gitignore

@@ -0,0 +1,2 @@
+leet.py
+

1.two-sum.py

@@ -0,0 +1,37 @@
+#
+# [1] Two Sum
+#
+# https://leetcode.com/problems/two-sum/description/
+#
+# algorithms
+# Easy (38.50%)
+# Total Accepted:    979.9K
+# Total Submissions: 2.5M
+# Testcase Example:  '[2,7,11,15]\n9'
+#
+# Given an array of integers, return indices of the two numbers such that they
+# add up to a specific target.
+# 
+# You may assume that each input would have exactly one solution, and you may
+# not use the same element twice.
+# 
+# Example:
+# 
+# 
+# Given nums = [2, 7, 11, 15], target = 9,
+# 
+# Because nums[0] + nums[1] = 2 + 7 = 9,
+# return [0, 1].
+# 
+# 
+# 
+# 
+#
+class Solution(object):
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        

10.regular-expression-matching.py

@@ -0,0 +1,89 @@
+#
+# [10] Regular Expression Matching
+#
+# https://leetcode.com/problems/regular-expression-matching/description/
+#
+# algorithms
+# Hard (24.36%)
+# Total Accepted:    209.9K
+# Total Submissions: 861.8K
+# Testcase Example:  '"aa"\n"a"'
+#
+# Given an input string (s) and a pattern (p), implement regular expression
+# matching with support for '.' and '*'.
+# 
+# 
+# '.' Matches any single character.
+# '*' Matches zero or more of the preceding element.
+# 
+# 
+# The matching should cover the entire input string (not partial).
+# 
+# Note:
+# 
+# 
+# s could be empty and contains only lowercase letters a-z.
+# p could be empty and contains only lowercase letters a-z, and characters like
+# . or *.
+# 
+# 
+# Example 1:
+# 
+# 
+# Input:
+# s = "aa"
+# p = "a"
+# Output: false
+# Explanation: "a" does not match the entire string "aa".
+# 
+# 
+# Example 2:
+# 
+# 
+# Input:
+# s = "aa"
+# p = "a*"
+# Output: true
+# Explanation: '*' means zero or more of the precedeng element, 'a'. Therefore,
+# by repeating 'a' once, it becomes "aa".
+# 
+# 
+# Example 3:
+# 
+# 
+# Input:
+# s = "ab"
+# p = ".*"
+# Output: true
+# Explanation: ".*" means "zero or more (*) of any character (.)".
+# 
+# 
+# Example 4:
+# 
+# 
+# Input:
+# s = "aab"
+# p = "c*a*b"
+# Output: true
+# Explanation: c can be repeated 0 times, a can be repeated 1 time. Therefore
+# it matches "aab".
+# 
+# 
+# Example 5:
+# 
+# 
+# Input:
+# s = "mississippi"
+# p = "mis*is*p*."
+# Output: false
+# 
+# 
+#
+class Solution(object):
+    def isMatch(self, s, p):
+        """
+        :type s: str
+        :type p: str
+        :rtype: bool
+        """
+        

100.same-tree.py

@@ -0,0 +1,69 @@
+#
+# [100] Same Tree
+#
+# https://leetcode.com/problems/same-tree/description/
+#
+# algorithms
+# Easy (48.11%)
+# Total Accepted:    281.3K
+# Total Submissions: 584.7K
+# Testcase Example:  '[1,2,3]\n[1,2,3]'
+#
+# Given two binary trees, write a function to check if they are the same or
+# not.
+# 
+# Two binary trees are considered the same if they are structurally identical
+# and the nodes have the same value.
+# 
+# Example 1:
+# 
+# 
+# Input:     1         1
+# ⁠         / \       / \
+# ⁠        2   3     2   3
+# 
+# ⁠       [1,2,3],   [1,2,3]
+# 
+# Output: true
+# 
+# 
+# Example 2:
+# 
+# 
+# Input:     1         1
+# ⁠         /           \
+# ⁠        2             2
+# 
+# ⁠       [1,2],     [1,null,2]
+# 
+# Output: false
+# 
+# 
+# Example 3:
+# 
+# 
+# Input:     1         1
+# ⁠         / \       / \
+# ⁠        2   1     1   2
+# 
+# ⁠       [1,2,1],   [1,1,2]
+# 
+# Output: false
+# 
+# 
+#
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def isSameTree(self, p, q):
+        """
+        :type p: TreeNode
+        :type q: TreeNode
+        :rtype: bool
+        """
+        

101.symmetric-tree.py

@@ -0,0 +1,54 @@
+#
+# [101] Symmetric Tree
+#
+# https://leetcode.com/problems/symmetric-tree/description/
+#
+# algorithms
+# Easy (40.90%)
+# Total Accepted:    269.8K
+# Total Submissions: 659.5K
+# Testcase Example:  '[1,2,2,3,4,4,3]'
+#
+# Given a binary tree, check whether it is a mirror of itself (ie, symmetric
+# around its center).
+# 
+# 
+# For example, this binary tree [1,2,2,3,4,4,3] is symmetric:
+# 
+# ⁠   1
+# ⁠  / \
+# ⁠ 2   2
+# ⁠/ \ / \
+# 3  4 4  3
+# 
+# 
+# 
+# But the following [1,2,2,null,3,null,3]  is not:
+# 
+# ⁠   1
+# ⁠  / \
+# ⁠ 2   2
+# ⁠  \   \
+# ⁠  3    3
+# 
+# 
+# 
+# 
+# Note:
+# Bonus points if you could solve it both recursively and iteratively.
+# 
+#
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def isSymmetric(self, root):
+        """
+        :type root: TreeNode
+        :rtype: bool
+        """
+        

102.binary-tree-level-order-traversal.py

@@ -0,0 +1,49 @@
+#
+# [102] Binary Tree Level Order Traversal
+#
+# https://leetcode.com/problems/binary-tree-level-order-traversal/description/
+#
+# algorithms
+# Medium (43.61%)
+# Total Accepted:    255.3K
+# Total Submissions: 585.4K
+# Testcase Example:  '[3,9,20,null,null,15,7]'
+#
+# Given a binary tree, return the level order traversal of its nodes' values.
+# (ie, from left to right, level by level).
+# 
+# 
+# For example:
+# Given binary tree [3,9,20,null,null,15,7],
+# 
+# ⁠   3
+# ⁠  / \
+# ⁠ 9  20
+# ⁠   /  \
+# ⁠  15   7
+# 
+# 
+# 
+# return its level order traversal as:
+# 
+# [
+# ⁠ [3],
+# ⁠ [9,20],
+# ⁠ [15,7]
+# ]
+# 
+# 
+#
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def levelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """

103.binary-tree-zigzag-level-order-traversal.py

@@ -0,0 +1,51 @@
+#
+# [103] Binary Tree Zigzag Level Order Traversal
+#
+# https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/description/
+#
+# algorithms
+# Medium (37.56%)
+# Total Accepted:    146.7K
+# Total Submissions: 390.5K
+# Testcase Example:  '[3,9,20,null,null,15,7]'
+#
+# Given a binary tree, return the zigzag level order traversal of its nodes'
+# values. (ie, from left to right, then right to left for the next level and
+# alternate between).
+# 
+# 
+# For example:
+# Given binary tree [3,9,20,null,null,15,7],
+# 
+# ⁠   3
+# ⁠  / \
+# ⁠ 9  20
+# ⁠   /  \
+# ⁠  15   7
+# 
+# 
+# 
+# return its zigzag level order traversal as:
+# 
+# [
+# ⁠ [3],
+# ⁠ [20,9],
+# ⁠ [15,7]
+# ]
+# 
+# 
+#
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def zigzagLevelOrder(self, root):
+        """
+        :type root: TreeNode
+        :rtype: List[List[int]]
+        """
+