From 27c39ad875d51a2c54c980604c7ab1d505744c1d Mon Sep 17 00:00:00 2001
From: Vaishnvee Shinde <65480790+Vaishnvee-Shinde@users.noreply.github.com>
Date: Sat, 15 Oct 2022 17:24:31 +0530
Subject: [PATCH 1/3] Added Leetcode problem solutions.
---
python/101_Symmetric_Tree.py | 27 ++++
python/python/001_Two_Sum.py | 66 +++++++++
python/python/002_Add_Two_Numbers.py | 57 ++++++++
..._Substring_Without_Repeating_Characters.py | 71 ++++++++++
.../python/004_Median_of_Two_Sorted_Arrays.py | 60 +++++++++
.../005_Longest_Palindromic_Substring.py | 88 ++++++++++++
python/python/006_ZigZag_Conversion.py | 53 ++++++++
python/python/007_Reverse_Integer.py | 39 ++++++
python/python/008_String_to_Integer(atoi).py | 43 ++++++
python/python/009_Palindrome_Number.py | 67 +++++++++
.../python/010_Regular_Expression_Matching.py | 36 +++++
.../python/011_Container_With_Most_Water.py | 14 ++
python/python/012_Integer_to_Roman.py | 47 +++++++
python/python/013_Roman_to_Integer.py | 35 +++++
python/python/014_Longest_Common_Prefix.py | 44 ++++++
python/python/015_3Sum.py | 76 +++++++++++
python/python/016_3Sum_Closest.py | 25 ++++
...7_Letter_Combinations_of_a_Phone_Number.py | 36 +++++
python/python/018_4Sum.py | 61 +++++++++
.../019_Remove_Nth_Node_From_End_of_List.py | 60 +++++++++
python/python/020_Valid_Parentheses.py | 59 ++++++++
python/python/021_Merge_Two_Sorted_Lists.py | 47 +++++++
python/python/022_Generate_Parentheses.py | 33 +++++
python/python/023_Merge_k_Sorted_Lists.py | 89 ++++++++++++
python/python/024_Swap_Nodes_in_Pairs.py | 42 ++++++
python/python/025_Reverse_Nodes_i_ k-Group.py | 46 +++++++
...026_Remove_Duplicates_from_Sorted_Array.py | 33 +++++
python/python/027_Remove_Element.py | 41 ++++++
python/python/028_Implement_strStr().py | 70 ++++++++++
python/python/029_Divide_Two_Integers.py | 45 +++++++
...bstring_with_Concatenation_of_All_Words.py | 51 +++++++
python/python/031_Next_Permutation.py | 54 ++++++++
.../python/032_Longest_Valid_Parentheses.py | 47 +++++++
.../033_Search_in_Rotated_Sorted_Array.py | 27 ++++
python/python/034_Search_for_a_Range.py | 28 ++++
python/python/035_Search_Insert_Position.py | 43 ++++++
python/python/036_Valid Sudoku.py | 68 ++++++++++
python/python/037_Sudoku_Solver.py | 43 ++++++
python/python/038_Count_and_Say.py | 27 ++++
python/python/039_Combination_Sum.py | 52 +++++++
python/python/040_Combination_Sum_II.py | 32 +++++
python/python/041_First_Missing_Positive.py | 21 +++
python/python/042_Trapping_Rain_Water.py | 76 +++++++++++
python/python/043_Multiply_Strings.py | 79 +++++++++++
python/python/044_Wildcard_Matching.py | 79 +++++++++++
python/python/045_Jump_Game_II.py | 20 +++
python/python/046_Permutations.py | 44 ++++++
python/python/047_Permutations_II.py | 67 +++++++++
python/python/048_Rotate_Image.py | 29 ++++
python/python/049_Group_Anagrams.py | 45 +++++++
python/python/050_Pow(x, n).py | 31 +++++
python/python/051_N-Queens.py | 42 ++++++
python/python/052_N-Queens II.py | 78 +++++++++++
python/python/053_Maximum_Subarray.py | 48 +++++++
python/python/054_Spiral_Matrix.py | 47 +++++++
python/python/055_Jump_Game.py | 14 ++
python/python/056_Merge_Intervals.py | 36 +++++
python/python/057_Insert_Interval.py | 48 +++++++
python/python/058_Length_of_Last_Word.py | 14 ++
python/python/059_Spiral_Matrix_II.py | 22 +++
python/python/060_Permutation_Sequence.py | 34 +++++
python/python/061_Rotate_List.py | 38 ++++++
python/python/062_Unique_Paths.py | 21 +++
python/python/063_Unique_Paths_II.py | 43 ++++++
python/python/064_Minimum_Path_Sum.py | 24 ++++
python/python/065_Valid_Number.py | 52 +++++++
python/python/066_Plus_One.py | 35 +++++
python/python/067_Add_Binary.py | 60 +++++++++
python/python/068_Text_Justification.py | 73 ++++++++++
python/python/069_Sqrt(x).py | 35 +++++
python/python/070_Climbing_Stairs.py | 37 +++++
python/python/071_Simplify_Path.py | 20 +++
python/python/072_Edit_Distance.py | 45 +++++++
python/python/073_Set_Matrix_Zeroes.py | 29 ++++
python/python/074_Search_a_2D_Matrix.py | 62 +++++++++
python/python/075_Sort_Colors.py | 34 +++++
python/python/076_Minimum_Window_Substring.py | 127 ++++++++++++++++++
python/python/077_Combinations.py | 43 ++++++
python/python/078_Subsets.py | 58 ++++++++
python/python/079_Word_Search.py | 39 ++++++
..._Remove_Duplicates_from_Sorted_Array_II.py | 29 ++++
.../081_Search_in_Rotated_Sorted_Array_II.py | 35 +++++
.../083_Remove_Duplicates_from_Sorted_List.py | 37 +++++
.../084_Largest_Rectangle_in_Histogram.py | 29 ++++
python/python/085_Maximal_Rectangle.py | 35 +++++
python/python/086_Partition_List.py | 36 +++++
python/python/087_Scramble_String.py | 81 +++++++++++
python/python/088_Merge_Sorted_Array.py | 38 ++++++
python/python/089_Gray_Code.py | 25 ++++
python/python/090_Subsets_II.py | 44 ++++++
python/python/091_Decode_Ways.py | 24 ++++
python/python/092_Reverse_Linked_Lis_ II.py | 40 ++++++
python/python/093_Restore_IP_Addresses.py | 71 ++++++++++
.../094_Binary_Tree_Inorder_Traversal.py | 79 +++++++++++
.../095_Unique_Binary_Search_Trees_II.py | 36 +++++
.../python/096_Unique_Binary_Search_Trees.py | 14 ++
python/python/097_Interleaving_String.py | 32 +++++
.../python/098_Validate_Binary_Search_Tree.py | 40 ++++++
.../python/099_Recover_Binary_Search_Tree.py | 67 +++++++++
python/python/100_Same_Tree.py | 25 ++++
100 files changed, 4548 insertions(+)
create mode 100644 python/101_Symmetric_Tree.py
create mode 100644 python/python/001_Two_Sum.py
create mode 100644 python/python/002_Add_Two_Numbers.py
create mode 100644 python/python/003_Longest_Substring_Without_Repeating_Characters.py
create mode 100644 python/python/004_Median_of_Two_Sorted_Arrays.py
create mode 100644 python/python/005_Longest_Palindromic_Substring.py
create mode 100644 python/python/006_ZigZag_Conversion.py
create mode 100644 python/python/007_Reverse_Integer.py
create mode 100644 python/python/008_String_to_Integer(atoi).py
create mode 100644 python/python/009_Palindrome_Number.py
create mode 100644 python/python/010_Regular_Expression_Matching.py
create mode 100644 python/python/011_Container_With_Most_Water.py
create mode 100644 python/python/012_Integer_to_Roman.py
create mode 100644 python/python/013_Roman_to_Integer.py
create mode 100644 python/python/014_Longest_Common_Prefix.py
create mode 100644 python/python/015_3Sum.py
create mode 100644 python/python/016_3Sum_Closest.py
create mode 100644 python/python/017_Letter_Combinations_of_a_Phone_Number.py
create mode 100644 python/python/018_4Sum.py
create mode 100644 python/python/019_Remove_Nth_Node_From_End_of_List.py
create mode 100644 python/python/020_Valid_Parentheses.py
create mode 100644 python/python/021_Merge_Two_Sorted_Lists.py
create mode 100644 python/python/022_Generate_Parentheses.py
create mode 100644 python/python/023_Merge_k_Sorted_Lists.py
create mode 100644 python/python/024_Swap_Nodes_in_Pairs.py
create mode 100644 python/python/025_Reverse_Nodes_i_ k-Group.py
create mode 100644 python/python/026_Remove_Duplicates_from_Sorted_Array.py
create mode 100644 python/python/027_Remove_Element.py
create mode 100644 python/python/028_Implement_strStr().py
create mode 100644 python/python/029_Divide_Two_Integers.py
create mode 100644 python/python/030_Substring_with_Concatenation_of_All_Words.py
create mode 100644 python/python/031_Next_Permutation.py
create mode 100644 python/python/032_Longest_Valid_Parentheses.py
create mode 100644 python/python/033_Search_in_Rotated_Sorted_Array.py
create mode 100644 python/python/034_Search_for_a_Range.py
create mode 100644 python/python/035_Search_Insert_Position.py
create mode 100644 python/python/036_Valid Sudoku.py
create mode 100644 python/python/037_Sudoku_Solver.py
create mode 100644 python/python/038_Count_and_Say.py
create mode 100644 python/python/039_Combination_Sum.py
create mode 100644 python/python/040_Combination_Sum_II.py
create mode 100644 python/python/041_First_Missing_Positive.py
create mode 100644 python/python/042_Trapping_Rain_Water.py
create mode 100644 python/python/043_Multiply_Strings.py
create mode 100644 python/python/044_Wildcard_Matching.py
create mode 100644 python/python/045_Jump_Game_II.py
create mode 100644 python/python/046_Permutations.py
create mode 100644 python/python/047_Permutations_II.py
create mode 100644 python/python/048_Rotate_Image.py
create mode 100644 python/python/049_Group_Anagrams.py
create mode 100644 python/python/050_Pow(x, n).py
create mode 100644 python/python/051_N-Queens.py
create mode 100644 python/python/052_N-Queens II.py
create mode 100644 python/python/053_Maximum_Subarray.py
create mode 100644 python/python/054_Spiral_Matrix.py
create mode 100644 python/python/055_Jump_Game.py
create mode 100644 python/python/056_Merge_Intervals.py
create mode 100644 python/python/057_Insert_Interval.py
create mode 100644 python/python/058_Length_of_Last_Word.py
create mode 100644 python/python/059_Spiral_Matrix_II.py
create mode 100644 python/python/060_Permutation_Sequence.py
create mode 100644 python/python/061_Rotate_List.py
create mode 100644 python/python/062_Unique_Paths.py
create mode 100644 python/python/063_Unique_Paths_II.py
create mode 100644 python/python/064_Minimum_Path_Sum.py
create mode 100644 python/python/065_Valid_Number.py
create mode 100644 python/python/066_Plus_One.py
create mode 100644 python/python/067_Add_Binary.py
create mode 100644 python/python/068_Text_Justification.py
create mode 100644 python/python/069_Sqrt(x).py
create mode 100644 python/python/070_Climbing_Stairs.py
create mode 100644 python/python/071_Simplify_Path.py
create mode 100644 python/python/072_Edit_Distance.py
create mode 100644 python/python/073_Set_Matrix_Zeroes.py
create mode 100644 python/python/074_Search_a_2D_Matrix.py
create mode 100644 python/python/075_Sort_Colors.py
create mode 100644 python/python/076_Minimum_Window_Substring.py
create mode 100644 python/python/077_Combinations.py
create mode 100644 python/python/078_Subsets.py
create mode 100644 python/python/079_Word_Search.py
create mode 100644 python/python/080_Remove_Duplicates_from_Sorted_Array_II.py
create mode 100644 python/python/081_Search_in_Rotated_Sorted_Array_II.py
create mode 100644 python/python/083_Remove_Duplicates_from_Sorted_List.py
create mode 100644 python/python/084_Largest_Rectangle_in_Histogram.py
create mode 100644 python/python/085_Maximal_Rectangle.py
create mode 100644 python/python/086_Partition_List.py
create mode 100644 python/python/087_Scramble_String.py
create mode 100644 python/python/088_Merge_Sorted_Array.py
create mode 100644 python/python/089_Gray_Code.py
create mode 100644 python/python/090_Subsets_II.py
create mode 100644 python/python/091_Decode_Ways.py
create mode 100644 python/python/092_Reverse_Linked_Lis_ II.py
create mode 100644 python/python/093_Restore_IP_Addresses.py
create mode 100644 python/python/094_Binary_Tree_Inorder_Traversal.py
create mode 100644 python/python/095_Unique_Binary_Search_Trees_II.py
create mode 100644 python/python/096_Unique_Binary_Search_Trees.py
create mode 100644 python/python/097_Interleaving_String.py
create mode 100644 python/python/098_Validate_Binary_Search_Tree.py
create mode 100644 python/python/099_Recover_Binary_Search_Tree.py
create mode 100644 python/python/100_Same_Tree.py
diff --git a/python/101_Symmetric_Tree.py b/python/101_Symmetric_Tree.py
new file mode 100644
index 0000000..8c4b1f4
--- /dev/null
+++ b/python/101_Symmetric_Tree.py
@@ -0,0 +1,27 @@
+# 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
+ """
+ if root is None:
+ return True
+ return self.mirrorVisit(root.left, root.right)
+
+ def mirrorVisit(self, left, right):
+ if left is None and right is None:
+ return True
+ try:
+ if left.val == right.val:
+ if self.mirrorVisit(left.left, right.right) and self.mirrorVisit(left.right, right.left):
+ return True
+ return False
+ except:
+ return False
\ No newline at end of file
diff --git a/python/python/001_Two_Sum.py b/python/python/001_Two_Sum.py
new file mode 100644
index 0000000..e4bd58a
--- /dev/null
+++ b/python/python/001_Two_Sum.py
@@ -0,0 +1,66 @@
+class Solution(object):
+ # def twoSum(self, nums, target):
+ # """
+ # :type nums: List[int]
+ # :type target: int
+ # :rtype: List[int]
+ # """
+ # #n^2
+ # ls = len(nums)
+ # for i in range(ls):
+ # for j in range(i + 1, ls):
+ # if nums[i] + nums[j] == target:
+ # return [i, j]
+
+ # def twoSum(self, nums, target):
+ # # hash 1
+ # hash_nums = {}
+ # for index, num in enumerate(nums):
+ # try:
+ # hash_nums[num].append(index)
+ # except KeyError:
+ # hash_nums[num] = [index]
+ # for index, num in enumerate(nums):
+ # another = target - num
+ # try:
+ # candicate = hash_nums[another]
+ # if another == num:
+ # if len(candicate) > 1:
+ # return candicate
+ # else:
+ # continue
+ # else:
+ # return [index, candicate[0]]
+ # except KeyError:
+ # pass
+
+ # def twoSum(self, nums, target):
+ # # hash 2
+ # hash_nums = {}
+ # for index, num in enumerate(nums):
+ # another = target - num
+ # try:
+ # hash_nums[another]
+ # return [hash_nums[another], index]
+ # except KeyError:
+ # hash_nums[num] = index
+
+ def twoSum(self, nums, target):
+ # two point
+ nums_index = [(v, index) for index, v in enumerate(nums)]
+ nums_index.sort()
+ begin, end = 0, len(nums) - 1
+ while begin < end:
+ curr = nums_index[begin][0] + nums_index[end][0]
+ if curr == target:
+ return [nums_index[begin][1], nums_index[end][1]]
+ elif curr < target:
+ begin += 1
+ else:
+ end -= 1
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.twoSum([3, 2, 4], 6)
diff --git a/python/python/002_Add_Two_Numbers.py b/python/python/002_Add_Two_Numbers.py
new file mode 100644
index 0000000..0e91587
--- /dev/null
+++ b/python/python/002_Add_Two_Numbers.py
@@ -0,0 +1,57 @@
+# Definition for singly-linked list.
+class ListNode(object):
+ def __init__(self, x):
+ self.val = x
+ self.next = None
+
+
+class Solution(object):
+ # def addTwoNumbers(self, l1, l2):
+ # """
+ # :type l1: ListNode
+ # :type l2: ListNode
+ # :rtype: ListNode
+ # """
+ # last = 0
+ # head = prev = None
+ # while True:
+ # if l2 is None and l1 is None and last == 0:
+ # break
+ # val = last
+ # if l2 is not None:
+ # val += l2.val
+ # l2 = l2.next
+ # if l1 is not None:
+ # val += l1.val
+ # l1 = l1.next
+ # if val >= 10:
+ # val = val % 10
+ # last = 1
+ # else:
+ # last = 0
+ # current = ListNode(val)
+ # if prev is None:
+ # head = current
+ # else:
+ # prev.next = current
+ # prev = current
+ # return head
+
+ def addTwoNumbers(self, l1, l2):
+ carry = 0
+ # dummy head
+ head = curr = ListNode(0)
+ while l1 or l2:
+ val = carry
+ if l1:
+ val += l1.val
+ l1 = l1.next
+ if l2:
+ val += l2.val
+ l2 = l2.next
+ curr.next = ListNode(val % 10)
+ curr = curr.next
+ carry = int(val / 10)
+ if carry > 0:
+ curr.next = ListNode(carry)
+ return head.next
diff --git a/python/python/003_Longest_Substring_Without_Repeating_Characters.py b/python/python/003_Longest_Substring_Without_Repeating_Characters.py
new file mode 100644
index 0000000..e6977c5
--- /dev/null
+++ b/python/python/003_Longest_Substring_Without_Repeating_Characters.py
@@ -0,0 +1,71 @@
+class Solution(object):
+ # def lengthOfLongestSubstring(self, s):
+ # """
+ # :type s: str
+ # :rtype: int
+ # """
+ # sls = len(set(s))
+ # ls = len(s)
+ # if ls >= 1:
+ # max_l = 1
+ # else:
+ # return 0
+ # for i in range(ls):
+ # for j in range(i + max_l + 1, i + sls + 1):
+ # curr = s[i:j]
+ # c_ls = len(curr)
+ # if len(set(curr)) != c_ls:
+ # break
+ # else:
+ # if c_ls > max_l:
+ # max_l = c_ls
+ # if max_l == sls:
+ # return sls
+ # return max_l
+
+ # def lengthOfLongestSubstring(self, s):
+ # sls = len(set(s))
+ # ls = len(s)
+ # if ls >= 1:
+ # max_l = 1
+ # else:
+ # return 0
+ # for i in range(ls):
+ # for j in reversed(range(i + max_l + 1, i + sls + 1)):
+ # curr = s[i:j]
+ # c_ls = len(curr)
+ # if len(set(curr)) == c_ls:
+ # if c_ls > max_l:
+ # max_l = c_ls
+ # if max_l == sls:
+ # return sls
+ # break
+ # return max_l
+
+ # def lengthOfLongestSubstring(self, s):
+ # exist = [False] * 256
+ # ls = len(s)
+ # max_len = i = 0
+ # for j in range(ls):
+ # while(exist[ord(s[j])]):
+ # exist[ord(s[i])] = False
+ # i += 1
+ # exist[ord(s[j)] = True
+ # max_len = max(max_len, j - i + 1)
+ # return max_len
+
+ def lengthOfLongestSubstring(self, s):
+ # https://leetcode.com/articles/longest-substring-without-repeating-characters/
+ charMap = {}
+ for i in range(256):
+ charMap[i] = -1
+ ls = len(s)
+ i = max_len = 0
+ for j in range(ls):
+ # Note that when charMap[ord(s[j])] >= i, it means that there are
+ # duplicate character in current i,j. So we need to update i.
+ if charMap[ord(s[j])] >= i:
+ i = charMap[ord(s[j])] + 1
+ charMap[ord(s[j])] = j
+ max_len = max(max_len, j - i + 1)
+ return max_len
diff --git a/python/python/004_Median_of_Two_Sorted_Arrays.py b/python/python/004_Median_of_Two_Sorted_Arrays.py
new file mode 100644
index 0000000..ef7de82
--- /dev/null
+++ b/python/python/004_Median_of_Two_Sorted_Arrays.py
@@ -0,0 +1,60 @@
+class Solution(object):
+ # def findMedianSortedArrays(self, nums1, nums2):
+ # """
+ # :type nums1: List[int]
+ # :type nums2: List[int]
+ # :rtype: float
+ # """
+ # p1 = p2 = 0
+ # ls1 = len(nums1)
+ # ls2 = len(nums2)
+ # all_nums = []
+ # median = 0.0
+ # while p1 < ls1 and p2 < ls2:
+ # if nums1[p1] < nums2[p2]:
+ # all_nums.append(nums1[p1])
+ # p1 += 1
+ # else:
+ # all_nums.append(nums2[p2])
+ # p2 += 1
+ # if p1 < ls1:
+ # while p1 < ls1:
+ # all_nums.append(nums1[p1])
+ # p1 += 1
+ # if p2 < ls2:
+ # while p2 < ls2:
+ # all_nums.append(nums2[p2])
+ # p2 += 1
+ # # print all_nums
+ # if (ls1 + ls2) % 2 == 1:
+ # median = all_nums[(ls1 + ls2) / 2]
+ # else:
+ # median = 1.0 * (all_nums[(ls1 + ls2) / 2] + all_nums[(ls1 + ls2) / 2 - 1]) / 2
+ # return median
+
+ def findMedianSortedArrays(self, nums1, nums2):
+ # https://discuss.leetcode.com/topic/4996/share-my-o-log-min-m-n-solution-with-explanation
+ # https://discuss.leetcode.com/topic/16797/very-concise-o-log-min-m-n-iterative-solution-with-detailed-explanation
+ ls1, ls2 = len(nums1), len(nums2)
+ if ls1 < ls2:
+ return self.findMedianSortedArrays(nums2, nums1)
+ l, r = 0, ls2 * 2
+ while l <= r:
+ mid2 = (l + r) >> 1
+ mid1 = ls1 + ls2 - mid2
+ L1 = -sys.maxint - 1 if mid1 == 0 else nums1[(mid1 - 1) >> 1]
+ L2 = -sys.maxint - 1 if mid2 == 0 else nums2[(mid2 - 1) >> 1]
+ R1 = sys.maxint if mid1 == 2 * ls1 else nums1[mid1 >> 1]
+ R2 = sys.maxint if mid2 == 2 * ls2 else nums2[mid2 >> 1]
+ if L1 > R2:
+ l = mid2 + 1
+ elif L2 > R1:
+ r = mid2 - 1
+ else:
+ return (max(L1, L2) + min(R1, R2)) / 2.0
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.findMedianSortedArrays([1, 1], [1, 2])
diff --git a/python/python/005_Longest_Palindromic_Substring.py b/python/python/005_Longest_Palindromic_Substring.py
new file mode 100644
index 0000000..5086547
--- /dev/null
+++ b/python/python/005_Longest_Palindromic_Substring.py
@@ -0,0 +1,88 @@
+class Solution(object):
+ def longestPalindrome(self, s):
+ """
+ :type s: str
+ :rtype: str
+ """
+ # my solution
+ # expand string according to Manacher algorithm
+ # but extend radius step by step
+ ls = len(s)
+ if ls <= 1 or len(set(s)) == 1:
+ return s
+ # create a new list like this: "abc"->"a#b#c"
+ temp_s = '#'.join('{}'.format(s))
+ # print temp_s
+ tls = len(temp_s)
+ seed = range(1, tls - 1)
+ # this table stores the max length palindrome
+ len_table = [0] * tls
+ for step in range(1, tls / 2 + 1):
+ final = []
+ for pos in seed:
+ if pos - step < 0 or pos + step >= tls:
+ continue
+ if temp_s[pos - step] != temp_s[pos + step]:
+ continue
+ final.append(pos)
+ if temp_s[pos - step] == '#':
+ continue
+ len_table[pos] = step
+ seed = final
+ max_pos, max_step = 0, 0
+ for i, s in enumerate(len_table):
+ if s >= max_step:
+ max_step = s
+ max_pos = i
+ return temp_s[max_pos - max_step:max_pos + max_step + 1].translate(None, '#')
+
+ # def longestPalindrome(self, s):
+ # # example in leetcode book
+ # max_left, max_right = 0, 0
+ # ls = len(s)
+ # for i in range(ls):
+ # len1 = self.expandAroundCenter(s, i, i)
+ # len2 = self.expandAroundCenter(s, i, i + 1)
+ # max_len = max(len1, len2)
+ # if (max_len > max_right - max_left):
+ # max_left = i - (max_len - 1) / 2
+ # max_right = i + max_len / 2
+ # return s[max_left:max_right + 1]
+ #
+ # def expandAroundCenter(self, s, left, right):
+ # ls = len(s)
+ # while (left >= 0 and right < ls and s[left] == s[right]):
+ # left -= 1
+ # right += 1
+ # return right - left - 1
+
+ # def longestPalindrome(self, s):
+ # #Manacher algorithm
+ # #http://en.wikipedia.org/wiki/Longest_palindromic_substring
+ # # Transform S into T.
+ # # For example, S = "abba", T = "^#a#b#b#a#$".
+ # # ^ and $ signs are sentinels appended to each end to avoid bounds checking
+ # T = '#'.join('^{}$'.format(s))
+ # n = len(T)
+ # P = [0] * n
+ # C = R = 0
+ # for i in range (1, n-1):
+ # P[i] = (R > i) and min(R - i, P[2*C - i]) # equals to i' = C - (i-C)
+ # # Attempt to expand palindrome centered at i
+ # while T[i + 1 + P[i]] == T[i - 1 - P[i]]:
+ # P[i] += 1
+ #
+ # # If palindrome centered at i expand past R,
+ # # adjust center based on expanded palindrome.
+ # if i + P[i] > R:
+ # C, R = i, i + P[i]
+ #
+ # # Find the maximum element in P.
+ # maxLen, centerIndex = max((n, i) for i, n in enumerate(P))
+ # return s[(centerIndex - maxLen)//2: (centerIndex + maxLen)//2]
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print(s.longestPalindrome("abcbe"))
diff --git a/python/python/006_ZigZag_Conversion.py b/python/python/006_ZigZag_Conversion.py
new file mode 100644
index 0000000..ae3c418
--- /dev/null
+++ b/python/python/006_ZigZag_Conversion.py
@@ -0,0 +1,53 @@
+class Solution(object):
+ # def convert(self, s, numRows):
+ # """
+ # :type s: str
+ # :type numRows: int
+ # :rtype: str
+ # """
+ # ls = len(s)
+ # if ls <= 1 or numRows == 1:
+ # return s
+ # temp_s = []
+ # for i in range(numRows):
+ # temp_s.append(['']*(ls / 2))
+ # inter = numRows - 1
+ # col, row = 0, 0
+ # for i, ch in enumerate(s):
+ # flag = True
+ # if (i / inter) % 2 == 1:
+ # # print i
+ # flag = False
+ # if flag:
+ # temp_s[row][col] = ch
+ # row += 1
+ # else:
+ # temp_s[row][col] = ch
+ # col += 1
+ # row -= 1
+ # result = ''
+ # for i in range(numRows):
+ # result += ''.join(temp_s[i])
+ # return result
+
+ def convert(self, s, numRows):
+ # https://leetcode.com/discuss/90908/easy-python-o-n-solution-94%25-with-explanations
+ if numRows == 1:
+ return s
+ # calculate period
+ p = 2 * (numRows - 1)
+ result = [""] * numRows
+ for i in xrange(len(s)):
+ floor = i % p
+ if floor >= p//2:
+ floor = p - floor
+ result[floor] += s[i]
+ return "".join(result)
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.convert("PAYPALISHIRING", 3)
+
+
diff --git a/python/python/007_Reverse_Integer.py b/python/python/007_Reverse_Integer.py
new file mode 100644
index 0000000..a125d47
--- /dev/null
+++ b/python/python/007_Reverse_Integer.py
@@ -0,0 +1,39 @@
+class Solution:
+ # @return an integer
+
+ # def reverse(self, x):
+ # max_int = 2147483647
+ # if x == 0:
+ # return 0
+ # isPos = True
+ # if x < 0:
+ # x *= (-1)
+ # isPos = False
+ # ltemp = []
+ # while x != 0:
+ # temp = x % 10
+ # ltemp.append(temp)
+ # x /= 10
+ # result = 0
+ # # the main solution
+ # for t in ltemp:
+ # result = result * 10 + t
+ # if result > max_int:
+ # result = 0
+ # if isPos:
+ # return result
+ # else:
+ # return -1 * result
+
+ def reverse(self, x):
+ # Note that in Python -1 / 10 = -1
+ res, isPos = 0, 1
+ if x < 0:
+ isPos = -1
+ x = -1 * x
+ while x != 0:
+ res = res * 10 + x % 10
+ if res > 2147483647:
+ return 0
+ x /= 10
+ return res * isPos
\ No newline at end of file
diff --git a/python/python/008_String_to_Integer(atoi).py b/python/python/008_String_to_Integer(atoi).py
new file mode 100644
index 0000000..ac167ad
--- /dev/null
+++ b/python/python/008_String_to_Integer(atoi).py
@@ -0,0 +1,43 @@
+class Solution(object):
+ def myAtoi(self, str):
+ """
+ :type str: str
+ :rtype: int
+ """
+ sign = 1
+ max_int, min_int = 2147483647, -2147483648
+ result, pos = 0, 0
+ ls = len(str)
+ while pos < ls and str[pos] == ' ':
+ pos += 1
+ if pos < ls and str[pos] == '-':
+ sign = -1
+ pos += 1
+ elif pos < ls and str[pos] == '+':
+ pos += 1
+ while pos < ls and ord(str[pos]) >= ord('0') and ord(str[pos]) <= ord('9'):
+ num = ord(str[pos]) - ord('0')
+ if result > max_int / 10 or ( result == max_int / 10 and num >= 8):
+ if sign == -1:
+ return min_int
+ return max_int
+ result = result * 10 + num
+ pos += 1
+ return sign * result
+
+ # def myAtoi(self, s):
+ # #https://leetcode.com/discuss/83626/line-python-solution-eafp-instead-lbyl-easier-logic-beats-24%25
+ # try:
+ # s = s.lstrip() + '$' # remove leading spaces and append an end mark
+ # for i, ch in enumerate(s):
+ # if not (ch in '+-' or '0' <= ch <= '9'):
+ # result = int(s[:i])
+ # return -2 ** 31 if result < -2 ** 31 else 2 ** 31 - 1 if result > 2 ** 31 - 1 else result
+ # except:
+ # return 0
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.myAtoi("+-2")
\ No newline at end of file
diff --git a/python/python/009_Palindrome_Number.py b/python/python/009_Palindrome_Number.py
new file mode 100644
index 0000000..8dc7ce5
--- /dev/null
+++ b/python/python/009_Palindrome_Number.py
@@ -0,0 +1,67 @@
+# class Solution(object):
+# def isPalindrome(self, x):
+# """
+# :type x: int
+# :rtype: bool
+# """
+
+class Solution(object):
+ def isPalindrome(self, x: int) -> bool:
+ x = str(x)
+ if (x == x[::-1]):
+ return True
+ return False
+
+
+ # def isPalindrome(self, x):
+ # if x < 0:
+ # return False
+ # ls = len(str(x))
+ # tmp = x
+ # for i in range(int(ls/2)):
+ # right = int(tmp % 10)
+ # left = tmp / (10 ** (ls - 2 * i - 1))
+ # left = int(left % 10)
+ # if left != right:
+ # return False
+ # tmp = tmp // 10
+ # return True
+
+
+ # def isPalindrome(self, x):
+ # #leetcode book
+ # if x < 0:
+ # return False
+ # div = 1
+ # while x / div >= 10:
+ # div *= 10
+ # while x != 0:
+ # left = x / div
+ # right = x % 10
+ # if left != right:
+ # return False
+ # x = (x % div) / 10
+ # div /= 100
+ # return True
+
+
+ # def isPalindrome(self, x):
+ # # reverse number
+ # if x < 0:
+ # return False
+ # rev_x = 0
+ # temp = x
+ # while temp != 0:
+ # curr = temp % 10
+ # rev_x = rev_x * 10 + curr
+ # temp = temp // 10
+ # if rev_x == x:
+ # return True
+ # else:
+ # return False
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.isPalindrome(1001)
diff --git a/python/python/010_Regular_Expression_Matching.py b/python/python/010_Regular_Expression_Matching.py
new file mode 100644
index 0000000..8a708a9
--- /dev/null
+++ b/python/python/010_Regular_Expression_Matching.py
@@ -0,0 +1,36 @@
+class Solution(object):
+ def isMatch(self, s, p):
+ """
+ :type s: str
+ :type p: str
+ :rtype: bool
+ """
+ # bottom up o(m*n)
+ # https://leetcode.com/discuss/93024/easy-dp-java-solution-with-detailed-explanation
+ if s == p:
+ return True
+ m, n = len(s), len(p)
+ dp = [[False] * (n + 1) for _ in range(m + 1)]
+ dp[0][0] = True
+ for j in range(1, n):
+ if p[j] == '*' and dp[0][j - 1]:
+ dp[0][j + 1] = True
+ # print dp
+ for i in range(m):
+ for j in range(n):
+ if p[j] == '.' or p[j] == s[i]:
+ dp[i + 1][j + 1] = dp[i][j]
+ elif p[j] == '*':
+ if p[j - 1] != s[i] and p[j - 1] != '.':
+ dp[i + 1][j + 1] = dp[i + 1][j - 1]
+ else:
+ dp[i + 1][j + 1] = dp[i + 1][j] or dp[i][j + 1] or dp[i + 1][j - 1]
+ return dp[m][n]
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.isMatch("", ".*")
+
+
diff --git a/python/python/011_Container_With_Most_Water.py b/python/python/011_Container_With_Most_Water.py
new file mode 100644
index 0000000..e49e40a
--- /dev/null
+++ b/python/python/011_Container_With_Most_Water.py
@@ -0,0 +1,14 @@
+class Solution:
+ def maxArea(self, height: List[int]) -> int:
+ # Two points
+ left, right = 0, len(height) - 1
+ result = 0
+ while left < right:
+ result = max(min(height[left], height[right]) * (right - left), result)
+ if height[left] > height[right]:
+ # remove right
+ right -= 1
+ else:
+ # remove left
+ left += 1
+ return result
diff --git a/python/python/012_Integer_to_Roman.py b/python/python/012_Integer_to_Roman.py
new file mode 100644
index 0000000..5181c73
--- /dev/null
+++ b/python/python/012_Integer_to_Roman.py
@@ -0,0 +1,47 @@
+# class Solution(object):
+# def intToRoman(self, num: int) -> str:
+# """
+# :type num: int
+# :rtype: str
+# """
+#
+class Solution(object):
+ # def intToRoman(self, num: int) -> str:
+ ## http://www.rapidtables.com/convert/number/how-number-to-roman-numerals.htm
+ # roman_dim = [[1000, 'M'], [900, 'CM'], [500, 'D'], [400, 'CD'],
+ # [100, 'C'], [90, 'XC'], [50, 'L'], [40, 'XL'], [10, 'X'],
+ # [9,'IX'], [5, 'V'], [4, 'IV'], [1, 'I']]
+ # if num == 0:
+ # return ''
+ # roman_str = ''
+ # current, dim = num, 0
+ # while current != 0:
+ # while current // roman_dim[dim][0] == 0:
+ # dim += 1
+ # while current - roman_dim[dim][0] >= 0:
+ # current -= roman_dim[dim][0]
+ # roman_str += roman_dim[dim][1]
+ # return roman_str
+
+ def intToRoman(self, num: int) -> str:
+ values = [1000, 900, 500, 400,
+ 100, 90, 50, 40,
+ 10, 9, 5, 4, 1]
+ symbols = ["M", "CM", "D", "CD",
+ "C", "XC", "L", "XL",
+ "X", "IX", "V", "IV",
+ "I"]
+ roman = ''
+ i = 0
+ while num > 0:
+ k = num // values[i]
+ for j in range(k):
+ roman += symbols[i]
+ num -= values[i]
+ i += 1
+ return roman
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.intToRoman(90)
\ No newline at end of file
diff --git a/python/python/013_Roman_to_Integer.py b/python/python/013_Roman_to_Integer.py
new file mode 100644
index 0000000..f73fc74
--- /dev/null
+++ b/python/python/013_Roman_to_Integer.py
@@ -0,0 +1,35 @@
+class Solution:
+ # def romanToInt(self, s):
+ # """
+ # :type s: str
+ # :rtype: int
+ # """
+ # roman = {'I': 1, 'V': 5, 'X': 10,
+ # 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
+ # result = 0
+ # last = s[-1]
+ # for t in reversed(s):
+ # if t == 'C' and last in ['D', 'M']:
+ # result -= roman[t]
+ # elif t == 'X' and last in ['L', 'C']:
+ # result -= roman[t]
+ # elif t == 'I' and last in ['V', 'X']:
+ # result -= roman[t]
+ # else:
+ # result += roman[t]
+ # last = t
+ # return result
+
+ def romanToInt(self, s):
+ roman = {'I': 1, 'V': 5, 'X': 10,
+ 'L': 50, 'C': 100, 'D': 500, 'M': 1000}
+ prev, total = 0, 0
+ for c in s:
+ curr = roman[c]
+ total += curr
+ # need to subtract
+ if curr > prev:
+ total -= 2 * prev
+ prev = curr
+ return total
+
diff --git a/python/python/014_Longest_Common_Prefix.py b/python/python/014_Longest_Common_Prefix.py
new file mode 100644
index 0000000..600e663
--- /dev/null
+++ b/python/python/014_Longest_Common_Prefix.py
@@ -0,0 +1,44 @@
+# class Solution(object):
+# def longestCommonPrefix(self, strs):
+# """
+# :type strs: List[str]
+# :rtype: str
+# """
+
+class Solution(object):
+ def longestCommonPrefix(self, strs):
+ ls = len(strs)
+ if ls == 1:
+ return strs[0]
+ prefix = ''
+ pos = 0
+ while True:
+ try:
+ current = strs[0][pos]
+ except IndexError:
+ break
+ index = 1
+ while index < ls:
+ try:
+ if strs[index][pos] != current:
+ break
+ except IndexError:
+ break
+ index += 1
+ if index == ls:
+ prefix = prefix + current
+ else:
+ break
+ pos += 1
+ return prefix
+
+ # def longestCommonPrefix(self, strs):
+ # # https://leetcode.com/discuss/89987/one-line-solution-using-itertools-takewhile
+ # return reduce(lambda s1, s2: ''.join(y[0] for y in itertools.takewhile(lambda x: x[0] == x[1], zip(s1, s2))), strs or [''])
+
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.longestCommonPrefix(["aca","cba"])
\ No newline at end of file
diff --git a/python/python/015_3Sum.py b/python/python/015_3Sum.py
new file mode 100644
index 0000000..0d9914a
--- /dev/null
+++ b/python/python/015_3Sum.py
@@ -0,0 +1,76 @@
+
+class Solution(object):
+ # def threeSum(self, nums):
+ # # skip duplicate
+ # # O(n^3)
+ # if len(nums) < 3:
+ # return []
+ # nums.sort()
+ # ls = len(nums)
+ # result = []
+ # for i in range(0, ls - 2):
+ # if nums[i] > 0:
+ # break
+ # if i > 0 and nums[i] == nums[i - 1]:
+ # continue
+ # j = i + 1
+ # k = ls - 1
+ # while(j < k):
+ # temp = [nums[i], nums[j], nums[k]]
+ # s = sum(temp)
+ # jtemp = nums[j]
+ # ktemp = nums[k]
+ # if s <= 0:
+ # j += 1
+ # while(j < k and jtemp == nums[j]):
+ # j += 1
+ # if s == 0:
+ # result.append(temp)
+ # else:
+ # k -= 1
+ # while(j < k and ktemp == nums[k]):
+ # k -= 1
+ # return result
+ # def threeSum(self, nums):
+ # """
+ # :type nums: List[int]
+ # :rtype: List[List[int]]
+ # """
+ # # using multiple 2 sum
+ # nums.sort()
+ # result, visited = set(), {}
+ # for i in xrange(len(nums) - 2):
+ # table, target = {}, -nums[i]
+ # if nums[i] not in visited:
+ # for j in xrange(i + 1, len(nums)):
+ # if nums[j] not in table:
+ # table[target - nums[j]] = j
+ # else:
+ # result.add((nums[i], target - nums[j], nums[j]))
+ # visited[nums[i]] = 1
+ # return list(result)
+
+ def threeSum(self, nums):
+ res = []
+ nums.sort()
+ ls = len(nums)
+ for i in range(ls - 2):
+ if i > 0 and nums[i] == nums[i - 1]:
+ continue
+ j = i + 1
+ k = ls - 1
+ while j < k:
+ curr = nums[i] + nums[j] + nums[k]
+ if curr == 0:
+ res.append([nums[i], nums[j], nums[k]])
+ while j < k and nums[j] == nums[j + 1]:
+ j += 1
+ while j < k and nums[k] == nums[k - 1]:
+ k -= 1
+ j += 1
+ k -= 1
+ elif curr < 0:
+ j += 1
+ else:
+ k -= 1
+ return res
diff --git a/python/python/016_3Sum_Closest.py b/python/python/016_3Sum_Closest.py
new file mode 100644
index 0000000..dcae265
--- /dev/null
+++ b/python/python/016_3Sum_Closest.py
@@ -0,0 +1,25 @@
+# class Solution(object):
+# def threeSumClosest(self, nums, target):
+# """
+# :type nums: List[int]
+# :type target: int
+# :rtype: int
+# """
+class Solution(object):
+ def threeSumClosest(self, nums, target):
+ ls = len(nums)
+ sort_nums = sorted(nums)
+ res = nums[0] + nums[1] + nums[2]
+ for i in range(ls - 2):
+ j, k = i + 1, ls - 1
+ while j < k:
+ temp = sort_nums[i] + sort_nums[j] + sort_nums[k]
+ if abs(target - temp) < abs(target - res):
+ res = temp
+ if temp < target:
+ j += 1
+ else:
+ k -= 1
+ return res
+
+
diff --git a/python/python/017_Letter_Combinations_of_a_Phone_Number.py b/python/python/017_Letter_Combinations_of_a_Phone_Number.py
new file mode 100644
index 0000000..4a43033
--- /dev/null
+++ b/python/python/017_Letter_Combinations_of_a_Phone_Number.py
@@ -0,0 +1,36 @@
+# class Solution(object):
+# def letterCombinations(self, digits):
+# """
+# :type digits: str
+# :rtype: List[str]
+# """
+dmap = {'2': 'abc',
+ '3': 'def',
+ '4': 'ghi',
+ '5': 'jkl',
+ '6': 'mno',
+ '7': 'pqrs',
+ '8': 'tuv',
+ '9': 'wxyz',
+ '0': ' ',
+ None: None}
+
+class Solution(object):
+ def letterCombinations(self, digits):
+ # DFS
+ result = []
+ ls = len(digits)
+ if ls == 0:
+ return result
+ current = digits[0]
+ posfix = self.letterCombinations(digits[1:])
+ for t in dmap[current]:
+ if len(posfix) > 0:
+ for p in posfix:
+ temp = t + p
+ result.append(temp)
+ else:
+ result.append(t)
+ return result
+
+
diff --git a/python/python/018_4Sum.py b/python/python/018_4Sum.py
new file mode 100644
index 0000000..adbd653
--- /dev/null
+++ b/python/python/018_4Sum.py
@@ -0,0 +1,61 @@
+# class Solution(object):
+# def fourSum(self, nums, target):
+# """
+# :type nums: List[int]
+# :type target: int
+# :rtype: List[List[int]]
+# """
+
+
+class Solution(object):
+ def fourSum(self, nums, target):
+ sort_nums = sorted(nums)
+ ls = len(nums)
+ res = {}
+ pairs = {}
+ for i in range(ls - 3):
+ for j in range(i + 1, ls - 2):
+ res_2 = sort_nums[i] + sort_nums[j]
+ try:
+ pairs[target - res_2].append([i, j])
+ except KeyError:
+ pairs[target - res_2] = [[i, j]]
+ for key, temp in pairs.items():
+ for pair in temp:
+ j = pair[1] + 1
+ k = ls - 1
+ while j < k:
+ current = sort_nums[j] + sort_nums[k]
+ if current == key:
+ result = (sort_nums[pair[0]], sort_nums[pair[1]], sort_nums[j], sort_nums[k])
+ res[result] = True
+ j += 1
+ elif current < key:
+ j += 1
+ else:
+ k -= 1
+ return res.keys()
+
+ # def fourSum(self, nums, target):
+ # # https://leetcode.com/discuss/89989/why-is-python-o-n-3-tle
+ # index_pairs = dict()
+ # combos = dict()
+ # n = len(nums)
+ # for i in range(0,n):
+ # for j in range(i+1,n):
+ # sum = nums[i] + nums[j]
+ # if index_pairs.get(target - sum) is not None:
+ # for pair in index_pairs[target - sum]:
+ # if i != pair[0] and i != pair[1] and j != pair[0] and j != pair[1]: # Avoid overuse
+ # combo = sorted((nums[i], nums[j], nums[pair[0]], nums[pair[1]])) # Avoid duplicate
+ # combos[tuple(combo)] = True
+ # if index_pairs.get(sum) is not None:
+ # index_pairs[sum].append((i,j))
+ # else:
+ # index_pairs[sum] = [(i,j)]
+ # return combos.keys()
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.fourSum([0, 0, 0, 0], 0)
\ No newline at end of file
diff --git a/python/python/019_Remove_Nth_Node_From_End_of_List.py b/python/python/019_Remove_Nth_Node_From_End_of_List.py
new file mode 100644
index 0000000..cfd327c
--- /dev/null
+++ b/python/python/019_Remove_Nth_Node_From_End_of_List.py
@@ -0,0 +1,60 @@
+# Given a linked list, remove the n-th node from the end of list and return its head.
+#
+# Example:
+# Given linked list: 1->2->3->4->5, and n = 2.
+# After removing the second node from the end, the linked list becomes 1->2->3->5.
+#
+# Note:
+# Given n will always be valid.
+#
+# Follow up:
+# Could you do this in one pass?
+
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+# class Solution(object):
+# def removeNthFromEnd(self, head, n):
+# """
+# :type head: ListNode
+# :type n: int
+# :rtype: ListNode
+# """
+class Solution(object):
+ # def removeNthFromEnd(self, head, n):
+ # # with O(n) space
+ # index = []
+ # pos = head
+ # while pos is not None:
+ # index.append(pos)
+ # pos = pos.next
+ # ls = len(index)
+ # if n == ls:
+ # if ls > 1:
+ # return index[1]
+ # else:
+ # return None
+ # else:
+ # index_pos = ls - n - 1
+ # index[index_pos].next = index[index_pos + 1].next
+ # return head
+
+ def removeNthFromEnd(self, head, n):
+ # https://leetcode.com/discuss/86721/o-n-solution-in-java
+ if head is None:
+ return None
+ slow = fast = head
+ for i in range(n):
+ fast = fast.next
+ if fast is None:
+ head = head.next
+ return head
+ while fast.next is not None:
+ fast = fast.next
+ slow = slow.next
+ curr = slow.next
+ slow.next = curr.next
+ return head
diff --git a/python/python/020_Valid_Parentheses.py b/python/python/020_Valid_Parentheses.py
new file mode 100644
index 0000000..a9e65bf
--- /dev/null
+++ b/python/python/020_Valid_Parentheses.py
@@ -0,0 +1,59 @@
+# class Solution(object):
+# def isValid(self, s):
+
+#
+class Solution:
+ def isValid(self, s):
+ """
+ :type s: str
+ :rtype: bool
+ """
+ if s is None:
+ return True
+ stack = []
+ for t in s:
+ if t == ')':
+ try:
+ current = stack.pop()
+ if current != '(':
+ return False
+ except:
+ return False
+ elif t == '}':
+ try:
+ current = stack.pop()
+ if current != '{':
+ return False
+ except:
+ return False
+ elif t == ']':
+ try:
+ current = stack.pop()
+ if current != '[':
+ return False
+ except:
+ return False
+ else:
+ stack.append(t)
+ if len(stack) == 0:
+ return True
+ else:
+ return False
+
+
+ # def isValid(self, s):
+ # # python replace
+ # n = len(s)
+ # if n == 0:
+ # return True
+ #
+ # if n % 2 != 0:
+ # return False
+ #
+ # while '()' in s or '{}' in s or '[]' in s:
+ # s = s.replace('{}', '').replace('()', '').replace('[]', '')
+ #
+ # if s == '':
+ # return True
+ # else:
+ # return False
diff --git a/python/python/021_Merge_Two_Sorted_Lists.py b/python/python/021_Merge_Two_Sorted_Lists.py
new file mode 100644
index 0000000..a084914
--- /dev/null
+++ b/python/python/021_Merge_Two_Sorted_Lists.py
@@ -0,0 +1,47 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+# class Solution(object):
+# def mergeTwoLists(self, l1, l2):
+# """
+# :type l1: ListNode
+# :type l2: ListNode
+# :rtype: ListNode
+# """
+class Solution(object):
+ def mergeTwoLists(self, l1, l2):
+ # dummy head
+ pos = dummyHead = ListNode(-1)
+ while l1 is not None and l2 is not None:
+ if l1.val <= l2.val:
+ pos.next = l1
+ l1 = l1.next
+ else:
+ pos.next = l2
+ l2 = l2.next
+ pos = pos.next
+ # merge residual l1
+ if l1 is not None:
+ pos.next = l1
+ # merge residual l2
+ if l2 is not None:
+ pos.next = l2
+ return dummyHead.next
+
+
+ # def mergeTwoLists(self, l1, l2):
+ # # recursive
+ # if l1 is None:
+ # return l2
+ # elif l2 is None:
+ # return l1
+ # if l1.val <= l2.val:
+ # l1.next = self.mergeTwoLists(l1.next, l2)
+ # return l1
+ # else:
+ # l2.next = self.mergeTwoLists(l1, l2.next)
+ # return l2
+
diff --git a/python/python/022_Generate_Parentheses.py b/python/python/022_Generate_Parentheses.py
new file mode 100644
index 0000000..ed907dc
--- /dev/null
+++ b/python/python/022_Generate_Parentheses.py
@@ -0,0 +1,33 @@
+# class Solution(object):
+# def generateParenthesis(self, n):
+# """
+# :type n: int
+# :rtype: List[str]
+# """
+class Solution(object):
+ def generateParenthesis(self, n):
+ if n == 1:
+ return ['()']
+ last_list = self.generateParenthesis(n - 1)
+ res = []
+ for t in last_list:
+ curr = t + ')'
+ for index in range(len(curr)):
+ if curr[index] == ')':
+ res.append(curr[:index] + '(' + curr[index:])
+ return list(set(res))
+
+
+ # def generateParenthesis(self, n):
+ # def generate(leftnum, rightnum, s, result):
+ # if leftnum == 0 and rightnum == 0:
+ # result.append(s)
+ # if leftnum > 0:
+ # generate(leftnum - 1, rightnum, s + '(', result)
+ # if rightnum > 0 and leftnum < rightnum:
+ # generate(leftnum, rightnum - 1, s + ')', result)
+ #
+ # result = []
+ # s = ''
+ # generate(n, n, s, result)
+ # return result
diff --git a/python/python/023_Merge_k_Sorted_Lists.py b/python/python/023_Merge_k_Sorted_Lists.py
new file mode 100644
index 0000000..5d38110
--- /dev/null
+++ b/python/python/023_Merge_k_Sorted_Lists.py
@@ -0,0 +1,89 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+class Solution(object):
+ # def mergeKLists(self, lists):
+ # # Priority queue
+ # from Queue import PriorityQueue
+ # queue = PriorityQueue()
+ # for l in lists:
+ # while l is not None:
+ # queue.put((l.val, l))
+ # l = l.next
+ # p = dummyHead = ListNode(-1)
+ # while queue.qsize() > 0:
+ # p.next = queue.get()[1]
+ # p = p.next
+ # p.next = None
+ # return dummyHead.next
+
+
+ # def mergeKLists(self, lists):
+ # """
+ # :type lists: List[ListNode]
+ # :rtype: ListNode
+ # """
+ # # sort
+ # v_map = {}
+ # # hash
+ # for l in lists:
+ # while l is not None:
+ # try:
+ # v_map[l.val].append(l)
+ # except KeyError:
+ # v_map[l.val] = [l]
+ # l = l.next
+ # head = last = ListNode(-1)
+ # # sort and connect
+ # for k in sorted(v_map.keys()):
+ # for t in v_map[k]:
+ # last.next = t
+ # last = t
+ # last.next = None
+ # return head.next
+
+
+
+
+ def mergeKLists(self, lists):
+ # recursive
+ if lists is None:
+ return None
+ elif len(lists) == 0:
+ return None
+ return self.mergeK(lists, 0, len(lists) - 1)
+
+ def mergeK(self, lists, low, high):
+ if low == high:
+ return lists[low]
+ elif low + 1 == high:
+ return self.mergeTwolists(lists[low], lists[high])
+ mid = (low + high) / 2
+ return self.mergeTwolists(self.mergeK(lists, low, mid), self.mergeK(lists, mid + 1, high))
+
+ def mergeTwolists(self, l1, l2):
+ if l1 is None:
+ return l2
+ if l2 is None:
+ return l1
+ head = curr = ListNode(-1)
+ while l1 is not None and l2 is not None:
+ if l1.val <= l2.val:
+ curr.next = l1
+ l1 = l1.next
+ else:
+ curr.next = l2
+ l2 = l2.next
+ curr = curr.next
+ if l1 is not None:
+ curr.next = l1
+ if l2 is not None:
+ curr.next = l2
+ return head.next
+
+
+
+
diff --git a/python/python/024_Swap_Nodes_in_Pairs.py b/python/python/024_Swap_Nodes_in_Pairs.py
new file mode 100644
index 0000000..cb860ef
--- /dev/null
+++ b/python/python/024_Swap_Nodes_in_Pairs.py
@@ -0,0 +1,42 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+# class Solution(object):
+# def swapPairs(self, head):
+# """
+# :type head: ListNode
+# :rtype: ListNode
+# """
+class Solution(object):
+ # def swapPairs(self, head):
+ # current = last = last2 = head
+ # while current is not None:
+ # nex = current.next
+ # if current == last.next:
+ # last.next = nex
+ # current.next = last
+ # if last == head:
+ # head = current
+ # else:
+ # last2.next = current
+ # last2 = last
+ # last = nex
+ # current = nex
+ # return head
+
+ def swapPairs(self, head):
+ dummyHead = ListNode(-1)
+ dummyHead.next = head
+ prev, p = dummyHead, head
+ while p != None and p.next != None:
+ q, r = p.next, p.next.next
+ prev.next = q
+ q.next = p
+ p.next = r
+ prev = p
+ p = r
+ return dummyHead.next
+
\ No newline at end of file
diff --git a/python/python/025_Reverse_Nodes_i_ k-Group.py b/python/python/025_Reverse_Nodes_i_ k-Group.py
new file mode 100644
index 0000000..f6b511f
--- /dev/null
+++ b/python/python/025_Reverse_Nodes_i_ k-Group.py
@@ -0,0 +1,46 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+# class Solution(object):
+# def reverseKGroup(self, head, k):
+# """
+# :type head: ListNode
+# :type k: int
+# :rtype: ListNode
+# """
+class Solution(object):
+ def reverseKGroup(self, head, k):
+ if head is None:
+ return None
+ index = 0
+ lead, last = 0, 0
+ pos = head
+ temp = ListNode(-1)
+ temp.next = head
+ head = temp
+ start = head
+ while pos is not None:
+ if index % k == k - 1:
+ last = pos.next
+ start = self.reverseList(start, last)
+ pos = start
+ pos = pos.next
+ index += 1
+ return head.next
+
+ def reverseList(self, head, end):
+ pos = head.next
+ last = end
+ next_start = pos
+ while pos != end:
+ head.next = pos
+ last_pos = pos
+ pos = pos.next
+ last_pos.next = last
+ last = last_pos
+ return next_start
+
+
diff --git a/python/python/026_Remove_Duplicates_from_Sorted_Array.py b/python/python/026_Remove_Duplicates_from_Sorted_Array.py
new file mode 100644
index 0000000..6876ac6
--- /dev/null
+++ b/python/python/026_Remove_Duplicates_from_Sorted_Array.py
@@ -0,0 +1,33 @@
+class Solution(object):
+ # def removeDuplicates(self, nums):
+ # """
+ # :type nums: List[int]
+ # :rtype: int
+ # """
+ # ls = len(nums)
+ # if ls <= 1:
+ # return ls
+ # last = nums[0]
+ # pos = 1
+ # for t in nums[1:]:
+ # if t == last:
+ # continue
+ # else:
+ # nums[pos] = t
+ # pos += 1
+ # last = t
+ # return pos
+
+ # https://leetcode.com/articles/remove-duplicates-sorted-array/
+ def removeDuplicates(self, nums):
+ if len(nums) == 0:
+ return 0
+ left = 0
+ for i in range(1, len(nums)):
+ if nums[left] == nums[i]:
+ continue
+ else:
+ left += 1
+ nums[left] = nums[i]
+ return left + 1
+
diff --git a/python/python/027_Remove_Element.py b/python/python/027_Remove_Element.py
new file mode 100644
index 0000000..3266ad3
--- /dev/null
+++ b/python/python/027_Remove_Element.py
@@ -0,0 +1,41 @@
+# class Solution(object):
+# def removeElement(self, nums, val):
+# """
+# :type nums: List[int]
+# :type val: int
+# :rtype: int
+# """
+class Solution(object):
+ # def removeElement(self, nums, val):
+ # ls = len(nums)
+ # if ls == 0:
+ # return ls
+ # pos = 0
+ # for i in range(ls):
+ # if nums[i] == val:
+ # continue
+ # else:
+ # nums[pos] = nums[i]
+ # pos += 1
+ # # del nums[pos:]
+ # return pos
+
+ def removeElement(self, nums, val):
+ ls = len(nums)
+ if ls == 0:
+ return ls
+ count = 0
+ index = 0
+ while index < ls - count:
+ if nums[index] == val:
+ nums[index] = nums[ls - 1 - count]
+ count += 1
+ else:
+ index += 1
+ return ls - count
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.removeElement([1], 1)
+
diff --git a/python/python/028_Implement_strStr().py b/python/python/028_Implement_strStr().py
new file mode 100644
index 0000000..eece835
--- /dev/null
+++ b/python/python/028_Implement_strStr().py
@@ -0,0 +1,70 @@
+class Solution(object):
+ # def strStr(self, haystack, needle):
+ # """
+ # :type haystack: str
+ # :type needle: str
+ # :rtype: int
+ # """
+ # lsh, lsn = len(haystack), len(needle)
+ # if lsn == 0:
+ # return 0
+ # pos, index = 0, 0
+ # while index <= lsh - lsn:
+ # if haystack[index] == needle[pos]:
+ # backup = index
+ # while index < lsh and pos < lsn and haystack[index] == needle[pos]:
+ # pos += 1
+ # index += 1
+ # if pos == len(needle):
+ # return index - pos
+ # index = backup
+ # index += 1
+ # pos = 0
+ # return -1
+
+ # def strStr(self, haystack, needle):
+ # lsh, lsn = len(haystack), len(needle)
+ # if lsn == 0:
+ # return 0
+ # pos, index = 0, 0
+ # while index <= lsh - lsn:
+ # if haystack[index] == needle[0]:
+ # # slice index:index + lsn
+ # if haystack[index:index + lsn] == needle:
+ # return index
+ # index += 1
+ # return -1
+
+ # KMP
+ # https://discuss.leetcode.com/topic/3576/accepted-kmp-solution-in-java-for-reference/2
+ def strStr(self, haystack, needle):
+ lsh, lsn = len(haystack), len(needle)
+ if lsn == 0:
+ return 0
+ next = self.makeNext(needle)
+ i = j = 0
+ while i < lsh:
+ if j == -1 or haystack[i] == needle[j]:
+ i += 1
+ j += 1
+ if j == lsn:
+ return i - lsn
+ if i < lsh and haystack[i] != needle[j]:
+ j = next[j]
+ return -1
+
+ def makeNext(self, needle):
+ ls = len(needle)
+ next = [0] * ls
+ next[0], i, j = -1, 0, -1
+ while i < ls - 1:
+ if j == -1 or needle[i] == needle[j]:
+ next[i + 1] = j + 1
+ if needle[i + 1] == needle[j + 1]:
+ next[i + 1] = next[j + 1]
+ i += 1
+ j += 1
+ if needle[i] != needle[j]:
+ j = next[j]
+ return next
+
diff --git a/python/python/029_Divide_Two_Integers.py b/python/python/029_Divide_Two_Integers.py
new file mode 100644
index 0000000..15cedbe
--- /dev/null
+++ b/python/python/029_Divide_Two_Integers.py
@@ -0,0 +1,45 @@
+# class Solution(object):
+# def divide(self, dividend, divisor):
+# """
+# :type dividend: int
+# :type divisor: int
+# :rtype: int
+# """
+
+import math
+
+class Solution(object):
+ def divide(self, dividend, divisor):
+ if divisor == 0:
+ return MAX_INT
+ if dividend == 0:
+ return 0
+ isPositive = (dividend < 0) == (divisor < 0)
+ m = abs(dividend)
+ n = abs(divisor)
+ # ln and exp
+ res = math.log(m) - math.log(n)
+ res = int(math.exp(res))
+ if isPositive:
+ return min(res, 2147483647)
+ return max(0 - res, -2147483648)
+
+ # def divide(self, dividend, divisor):
+ # # (dividend >= 0) ^ (divisor < 0)
+ # isPositive = (dividend < 0) == (divisor < 0)
+ # dividend, divisor, result = abs(dividend), abs(divisor), 0
+ # while dividend >= divisor:
+ # n, nb = 1, divisor
+ # # fast minus
+ # while dividend >= nb:
+ # dividend, result = dividend - nb, result + n
+ # n, nb = n << 1, nb << 1
+ # if isPositive:
+ # return min(result, 2147483647)
+ # return max(-result, -2147483648)
+
+if __name__ == '__main__':
+ s = Solution()
+ print s.divide(1, 1)
+
+
diff --git a/python/python/030_Substring_with_Concatenation_of_All_Words.py b/python/python/030_Substring_with_Concatenation_of_All_Words.py
new file mode 100644
index 0000000..910a87b
--- /dev/null
+++ b/python/python/030_Substring_with_Concatenation_of_All_Words.py
@@ -0,0 +1,51 @@
+class Solution(object):
+ def findSubstring(self, s, words):
+ """
+ :type s: str
+ :type words: List[str]
+ :rtype: List[int]
+ """
+ ls = len(s)
+ word_ls = len(words[0])
+ target_dict = {}
+ # create a targe dict for match
+ for word in words:
+ try:
+ target_dict[word] += 1
+ except KeyError:
+ target_dict[word] = 1
+ res = []
+ for start in range(ls - word_ls * len(words) + 1):
+ curr_dict = target_dict.copy()
+ for pos in range(start, start + word_ls * len(words), word_ls):
+ curr = s[pos:pos + word_ls]
+ try:
+ curr_dict[curr] -= 1
+ # word appears more than target
+ if curr_dict[curr] < 0:
+ break
+ except KeyError:
+ # word not in words
+ break
+ else:
+ # all word in target dict
+ res.append(start)
+ return res
+
+ # def findSubstring(self, s, words):
+ # # https://leetcode.com/discuss/87745/3-line-python-solution-sorted-hash-112ms
+ # wLen, wtLen, wSet, sortHash, sLen = len(words[0]), len(words[0]) * len(words), set(words), sorted(
+ # [hash(w) for w in words]), len(s)
+ # h = [hash(s[i:i + wLen]) if s[i:i + wLen] in wSet else None for i in xrange(sLen - wLen + 1)]
+ # return [i for i in xrange(sLen - wtLen + 1) if h[i] and sorted(h[i: i + wtLen: wLen]) == sortHash]
+
+if __name__ == '__main__':
+ s = Solution()
+ # print s.longestValidParentheses(")(((((()())()()))()(()))(")
+ print s.findSubstring('wordgoodgoodgoodbestword', ["word", "good", "best", "good"])
+
+ # [6,9,12]
+
+
+
+
diff --git a/python/python/031_Next_Permutation.py b/python/python/031_Next_Permutation.py
new file mode 100644
index 0000000..cf7aca3
--- /dev/null
+++ b/python/python/031_Next_Permutation.py
@@ -0,0 +1,54 @@
+class Solution(object):
+ def nextPermutation(self, nums):
+ """
+ :type nums: List[int]
+ :rtype: void Do not return anything, modify nums in-place instead.
+ """
+ ls = len(nums)
+ if ls <= 1:
+ return
+ pair = []
+ for i in range(ls):
+ for j in range(i + 1, ls):
+ # append ascending order pair
+ if nums[i] < nums[j]:
+ pair.append([i,j])
+ pos = 0
+ if len(pair) > 0:
+ self.swap(nums, pair[-1][0], pair[-1][1])
+ pos = pair[-1][0] + 1
+ # sort from pos
+ for i in range(pos, ls):
+ for j in range(i + 1, ls):
+ if nums[i] > nums[j]:
+ self.swap(nums, i, j)
+
+ def swap(self, nums, index1, index2):
+ if index1 == index2:
+ return
+ nums[index1], nums[index2] = nums[index2], nums[index1]
+
+ # def nextPermutation(self, nums):
+ # # https://leetcode.com/discuss/86630/fast-and-easy-python-solution-beaten-79%25
+ # pos = -1
+ # ls = len(nums)
+ # for i in range(ls - 1, 0, -1):
+ # if nums[i] > nums[i - 1]:
+ # pos = i - 1
+ # break
+ # if pos == -1:
+ # self.re_order(nums, 0, ls - 1)
+ # return
+ # for i in range(ls - 1, -1, -1):
+ # if nums[pos] < nums[i]:
+ # nums[pos], nums[i] = nums[i], nums[pos]
+ # self.re_order(nums, pos + 1, ls - 1)
+ # break
+ #
+ # def re_order(self, a, start, end):
+ # for i in range(0, (end - start + 1) // 2):
+ # a[start + i], a[end - i] = a[end - i], a[start + i]
+
+
+
+
diff --git a/python/python/032_Longest_Valid_Parentheses.py b/python/python/032_Longest_Valid_Parentheses.py
new file mode 100644
index 0000000..0a23760
--- /dev/null
+++ b/python/python/032_Longest_Valid_Parentheses.py
@@ -0,0 +1,47 @@
+import pdb
+class Solution(object):
+ # def longestValidParentheses(self, s):
+ # """
+ # :type s: str
+ # :rtype: int
+ # """
+ # ls = len(s)
+ # start = [0] * (ls + 1)
+ # all = [0] * (ls + 1)
+ # for i in reversed(range(ls - 1)):
+ # if s[i] == '(':
+ # if s[i + 1] == ')':
+ # start[i] = 2
+ # if start[i + 1] + i + 1 < ls and s[start[i + 1] + i + 1] == ')':
+ # start[i] = 2 + start[i + 1]
+ # if start[start[i] + i] > 0:
+ # start[i] += start[start[i] + i]
+ # all[i] = max(start[i], all[i + 1])
+ # return all[0]
+
+ def longestValidParentheses(self, s):
+ # https://leetcode.com/discuss/87988/my-easy-o-n-java-solution-with-explanation
+ ls = len(s)
+ stack = []
+ data = [0] * ls
+ for i in range(ls):
+ curr = s[i]
+ if curr == '(':
+ stack.append(i)
+ else:
+ if len(stack) > 0:
+ data[i] = 1
+ data[stack.pop(-1)] = 1
+ tep, res = 0, 0
+ for t in data:
+ if t == 1:
+ tep += 1
+ else:
+ res = max(tep, res)
+ tep = 0
+ return max(tep, res)
+
+if __name__ == '__main__':
+ s = Solution()
+ # print s.longestValidParentheses(")(((((()())()()))()(()))(")
+ print s.longestValidParentheses(')()())')
diff --git a/python/python/033_Search_in_Rotated_Sorted_Array.py b/python/python/033_Search_in_Rotated_Sorted_Array.py
new file mode 100644
index 0000000..9f87344
--- /dev/null
+++ b/python/python/033_Search_in_Rotated_Sorted_Array.py
@@ -0,0 +1,27 @@
+class Solution:
+ def search(self, nums, target):
+ """
+ :type nums: List[int]
+ :type target: int
+ :rtype: int
+ """
+ # binary search
+ # if start < mid, then left part is sorted
+ # if mid < end, then right part is sorted
+ def get(start, end):
+ if start > end:
+ return -1
+ mid = (start + end) / 2
+ if nums[mid] == target:
+ return mid
+ elif nums[mid] >= nums[start]: # First half is sorted
+ if target >= nums[start] and target < nums[mid]:
+ return get(start, mid - 1)
+ else:
+ return get(mid + 1, end)
+ elif nums[mid] <= nums[end]: # Second half is sorted
+ if target > nums[mid] and target <= nums[end]:
+ return get(mid + 1, end)
+ else:
+ return get(start, mid - 1)
+ return get(0, len(nums) - 1)
\ No newline at end of file
diff --git a/python/python/034_Search_for_a_Range.py b/python/python/034_Search_for_a_Range.py
new file mode 100644
index 0000000..9053b2b
--- /dev/null
+++ b/python/python/034_Search_for_a_Range.py
@@ -0,0 +1,28 @@
+class Solution(object):
+ def searchRange(self, nums, target):
+ """
+ :type nums: List[int]
+ :type target: int
+ :rtype: List[int]
+ """
+ length = len(nums)
+ if length == 0:
+ return [-1, -1]
+ min = 0
+ max = length - 1
+ while min <= max:
+ pos = (min + max) / 2
+ if nums[pos] > target:
+ max = pos - 1
+ elif nums[pos] < target:
+ min = pos + 1
+ else:
+ # when nums[pos] == target
+ # find the min and max
+ for i in range(min, max + 1):
+ if nums[i] == target:
+ if min < i and nums[min] != nums[i]:
+ min = i
+ max = i
+ return [min, max]
+ return [-1, -1]
\ No newline at end of file
diff --git a/python/python/035_Search_Insert_Position.py b/python/python/035_Search_Insert_Position.py
new file mode 100644
index 0000000..9e6abd0
--- /dev/null
+++ b/python/python/035_Search_Insert_Position.py
@@ -0,0 +1,43 @@
+class Solution:
+ # def searchInsert(self, nums, target):
+ # """
+ # :type nums: List[int]
+ # :type target: int
+ # :rtype: int
+ # """
+ # min, pos = 0, 0
+ # max = len(nums) - 1
+ # while min <= max:
+ # # binary search
+ # pos = (max + min) / 2
+ # if nums[pos] == target:
+ # return pos
+ # elif nums[pos] > target:
+ # max = pos - 1
+ # else:
+ # min = pos + 1
+ # if min > pos:
+ # # this means that target is great than pos, and target
+ # # is not in nums
+ # return pos + 1
+ # return pos
+
+ def searchInsert(self, nums, target):
+ l, r = int(0), len(nums) - 1
+ while l < r:
+ mid = int((l + r) / 2)
+ if nums[mid] < target:
+ l = mid + 1
+ else:
+ r = mid
+ if nums[l] < target:
+ return l + 1
+ return l
+
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print (s.searchInsert([1,3,5,6],5))
+
diff --git a/python/python/036_Valid Sudoku.py b/python/python/036_Valid Sudoku.py
new file mode 100644
index 0000000..a2c6b84
--- /dev/null
+++ b/python/python/036_Valid Sudoku.py
@@ -0,0 +1,68 @@
+# class Solution(object):
+# def isValidSudoku(self, board):
+# """
+# :type board: List[List[str]]
+# :rtype: bool
+# """
+class Solution(object):
+ def isValidSudoku(self, board):
+ vset = [0] * 9
+ hset = [0] * 9
+ bset = [0] * 9
+ for i in range(9):
+ for j in range(9):
+ curr = board[i][j]
+ if curr != '.':
+ index = 1 << (ord(curr) - ord('0'))
+ if (hset[i] & index) > 0 or\
+ (vset[j] & index) > 0 or\
+ (bset[(i / 3) * 3 + j / 3] & index) > 0:
+ return False
+ hset[i] |= index
+ vset[j] |= index
+ bset[(i / 3) * 3 + j / 3] |= index
+ return True
+
+ # def isValidSudoku(self, board):
+ # if board is None:
+ # return True
+ # for i in range(9):
+ # table = {}
+ # for j in range(9):
+ # curr = board[i][j]
+ # if curr == '.':
+ # continue
+ # else:
+ # try:
+ # table[curr] += 1
+ # return False
+ # except KeyError:
+ # table[curr] = 1
+ # for j in range(9):
+ # table = {}
+ # for i in range(9):
+ # curr = board[i][j]
+ # if curr == '.':
+ # continue
+ # else:
+ # try:
+ # table[curr] += 1
+ # return False
+ # except KeyError:
+ # table[curr] = 1
+ # for i in range(3):
+ # for j in range(3):
+ # table = {}
+ # for k in range(9):
+ # curr = board[i * 3 + k / 3][j * 3 + k % 3]
+ # if curr == '.':
+ # continue
+ # else:
+ # try:
+ # table[curr] += 1
+ # return False
+ # except KeyError:
+ # table[curr] = 1
+ # return True
+
+
diff --git a/python/python/037_Sudoku_Solver.py b/python/python/037_Sudoku_Solver.py
new file mode 100644
index 0000000..4b60c04
--- /dev/null
+++ b/python/python/037_Sudoku_Solver.py
@@ -0,0 +1,43 @@
+class Solution(object):
+ def solveSudoku(self, board):
+ """
+ :type board: List[List[str]]
+ :rtype: void Do not return anything, modify board in-place instead.
+ """
+ #https://leetcode.com/discuss/84831/java-backtracking-stack-20ms
+ empty = []
+ for i in range(9):
+ for j in range(9):
+ if board[i][j] == '.':
+ empty.append(9 * i + j)
+ self.solve(board, empty)
+
+ def solve(self, board, empty):
+ if len(empty) == 0:
+ return True
+ first_value = empty[-1]
+ row, col = first_value / 9, first_value % 9
+ for k in range(1, 10):
+ if self.is_safe(board, row, col, str(k)):
+ board[row][col] = str(k)
+ empty.pop()
+ if self.solve(board, empty):
+ return True
+ board[row][col] = '.'
+ empty.append(first_value)
+ return False
+
+ def is_safe(self, board, row, col, ch):
+ for k in range(9):
+ if board[k][col] == ch:
+ return False
+ if board[row][k] == ch:
+ return False
+ start_row, start_col = 3 * (row / 3), 3 * (col / 3)
+ for i in range(start_row, start_row + 3):
+ for j in range(start_col, start_col + 3):
+ if board[i][j] == ch:
+ return False
+ return True
+
+
diff --git a/python/python/038_Count_and_Say.py b/python/python/038_Count_and_Say.py
new file mode 100644
index 0000000..a0ea1a8
--- /dev/null
+++ b/python/python/038_Count_and_Say.py
@@ -0,0 +1,27 @@
+class Solution:
+ def countAndSay(self, n):
+ """
+ :type n: int
+ :rtype: str
+ """
+ if n == 1:
+ return '1'
+ x = '1'
+ while n > 1:
+ # each round, read itself
+ x = self.count(x)
+ n -= 1
+ return x
+
+ def count(self, x):
+ m = list(x)
+ res = []
+ m.append(None)
+ i , j = 0 , 0
+ while i < len(m) - 1:
+ j += 1
+ if m[j] != m[i]:
+ # note j - i is the count of m[i]
+ res += [j - i, m[i]]
+ i = j
+ return ''.join(str(s) for s in res)
\ No newline at end of file
diff --git a/python/python/039_Combination_Sum.py b/python/python/039_Combination_Sum.py
new file mode 100644
index 0000000..91111c1
--- /dev/null
+++ b/python/python/039_Combination_Sum.py
@@ -0,0 +1,52 @@
+class Solution(object):
+ # def combinationSum(self, candidates, target):
+ # """
+ # :type candidates: List[int]
+ # :type target: int
+ # :rtype: List[List[int]]
+ # """
+ # candidates.sort()
+ # return self.getcombinationSum(candidates, [], 0, target)
+ #
+ #
+ # def getcombinationSum(self, candidates, prefix, curr, target):
+ # if len(prefix) == 0:
+ # max_value = candidates[0]
+ # else:
+ # max_value = prefix[-1]
+ # res = []
+ # for i in range(len(candidates)):
+ # if candidates[i] >= max_value:
+ # if curr + candidates[i] == target:
+ # res.append(prefix+[candidates[i]])
+ # elif curr + candidates[i] < target:
+ # res.extend(self.getcombinationSum(candidates, prefix+[candidates[i]], curr + candidates[i], target))
+ # else:
+ # pass
+ # return res
+
+
+ def combinationSum(self, candidates, target):
+ candidates.sort()
+ dp = [[] for _ in range(target + 1)]
+ dp[0].append([])
+ for i in range(1, target + 1):
+ for j in range(len(candidates)):
+ if candidates[j] > i:
+ break
+ for k in range(len(dp[i - candidates[j]])):
+ temp = dp[i - candidates[j]][k][:]
+ if len(temp) > 0 and temp[-1] > candidates[j]:
+ continue
+ temp.append(candidates[j])
+ dp[i].append(temp)
+ return dp[target]
+
+
+if __name__ == '__main__':
+ s = Solution()
+ print s.combinationSum([8,7,4,3], 11)
+
+
+
+
diff --git a/python/python/040_Combination_Sum_II.py b/python/python/040_Combination_Sum_II.py
new file mode 100644
index 0000000..9ef4ce7
--- /dev/null
+++ b/python/python/040_Combination_Sum_II.py
@@ -0,0 +1,32 @@
+class Solution(object):
+ def combinationSum2(self, candidates, target):
+ """
+ :type candidates: List[int]
+ :type target: int
+ :rtype: List[List[int]]
+ """
+ candidates.sort()
+ dp = [[] for _ in range(target + 1)]
+ dp[0].append([])
+ for i in range(1, target + 1):
+ for j in range(len(candidates)):
+ if candidates[j] > i:
+ break
+ for k in range(len(dp[i - candidates[j]])):
+ temp = dp[i - candidates[j]][k][:]
+ # check if this number is used
+ if len(temp) > 0 and temp[-1] >= j:
+ continue
+ # store index
+ temp.append(j)
+ dp[i].append(temp)
+ res = []
+ check = {}
+ for temp in dp[target]:
+ value = [candidates[t] for t in temp]
+ try:
+ check[str(value)] += 1
+ except KeyError:
+ check[str(value)] = 1
+ res.append(value)
+ return res
\ No newline at end of file
diff --git a/python/python/041_First_Missing_Positive.py b/python/python/041_First_Missing_Positive.py
new file mode 100644
index 0000000..2a08cdf
--- /dev/null
+++ b/python/python/041_First_Missing_Positive.py
@@ -0,0 +1,21 @@
+class Solution(object):
+ def firstMissingPositive(self, nums):
+ """
+ :type nums: List[int]
+ :rtype: int
+ """
+ # https://leetcode.com/discuss/86025/java-clean-o-n-solution-with-explanation
+ ls = len(nums)
+ index = 0
+ while index < ls:
+ # nums[nums[index] - 1] == nums[index] means that the num is in right position
+ if nums[index] <= 0 or nums[index] > ls or nums[nums[index] - 1] == nums[index]:
+ index += 1
+ else:
+ # swap current num to correct position
+ pos = nums[index] - 1
+ nums[index], nums[pos] = nums[pos], nums[index]
+ res = 0
+ while res < ls and nums[res] == res + 1:
+ res += 1
+ return res + 1
diff --git a/python/python/042_Trapping_Rain_Water.py b/python/python/042_Trapping_Rain_Water.py
new file mode 100644
index 0000000..6bf0d30
--- /dev/null
+++ b/python/python/042_Trapping_Rain_Water.py
@@ -0,0 +1,76 @@
+class Solution(object):
+ def trap(self, height):
+ """
+ :type height: List[int]
+ :rtype: int
+ """
+ ls = len(height)
+ if ls == 0:
+ return 0
+ res, left = 0, 0
+ while left < ls and height[left] == 0:
+ left += 1
+ pos = left + 1
+ while pos < ls:
+ if height[pos] >= height[left]:
+ # there is a right bar which is no less than left bar
+ res += self.rain_water(height, left, pos)
+ left = pos
+ pos += 1
+ elif pos == ls - 1:
+ # left bar is higher than all right bar
+ max_value, max_index = 0, pos
+ for index in range(left + 1, ls):
+ if height[index] > max_value:
+ max_value = height[index]
+ max_index = index
+ res += self.rain_water(height, left, max_index)
+ left = max_index
+ pos = left + 1
+ else:
+ pos += 1
+ return res
+
+ def rain_water(self, height, start, end):
+ # computer rain water
+ if end - start <= 1:
+ return 0
+ min_m = min(height[start], height[end])
+ res = min_m * (end - start - 1)
+ step = 0
+ for index in range(start + 1, end):
+ if height[index] > 0:
+ step += height[index]
+ return res - step
+
+ # def trap(self, height):
+ # ls = len(height)
+ # if ls == 0:
+ # return 0
+ # height.append(0)
+ # height.insert(0, 0)
+ # left = [0] * ls
+ # right = [0] * ls
+ # cur_left, cur_right = 0, 0
+ # for i in range(1, ls + 1):
+ # cur_left = max(cur_left, height[i - 1])
+ # # left[i] store max bar from left
+ # left[i - 1] = cur_left
+ # for i in reversed(range(ls)):
+ # cur_right = max(cur_right, height[i + 1])
+ # # right[i] store max bar from right
+ # right[i] = cur_right
+ # res = 0
+ # for i in range(ls):
+ # curr = min(left[i], right[i])
+ # if curr > height[i]:
+ # res += curr - height[i]
+ # return res
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.trap([2,6,3,8,2,7,2,5,0])
+
+
diff --git a/python/python/043_Multiply_Strings.py b/python/python/043_Multiply_Strings.py
new file mode 100644
index 0000000..3f66e45
--- /dev/null
+++ b/python/python/043_Multiply_Strings.py
@@ -0,0 +1,79 @@
+class Solution(object):
+ # def multiply(self, num1, num2):
+ # """
+ # :type num1: str
+ # :type num2: str
+ # :rtype: str
+ # """
+ # res = ''
+ # curr, pos = 0, 0
+ # if len(num1) > num2:
+ # num1, num2 = num2, num1
+ # ls1, ls2 = len(num1), len(num2)
+ # mid = []
+ # for i in reversed(range(ls1)):
+ # curr = 0
+ # fact = ''
+ # for j in reversed(range(ls2)):
+ # curr = curr + int(num1[i]) * int(num2[j])
+ # fact = str(curr % 10) + fact
+ # curr /= 10
+ # if curr > 0:
+ # fact = str(curr) + fact
+ # if int(fact) == 0:
+ # pass
+ # else:
+ # print fact
+ # mid.append(fact + '0' * pos)
+ # pos += 1
+ # res = self.add_strings(mid)
+ # return res
+ #
+ #
+ # def add_strings(self, s_list):
+ # if len(s_list) == 0:
+ # return '0'
+ # res = ''
+ # curr, pos = 0, 0
+ # max_ls = max([len(t) for t in s_list])
+ # while pos < max_ls:
+ # for s in s_list:
+ # if len(s) <= pos:
+ # continue
+ # curr += int(s[len(s) - pos - 1])
+ # res = str(curr % 10) + res
+ # curr /= 10
+ # pos += 1
+ # if curr > 0:
+ # res = str(curr) + res
+ # return res
+
+ def multiply(self, num1, num2):
+ if num1 == '0' or num2 == '0':
+ return '0'
+ res = ''
+ ls1, ls2, = len(num1), len(num2)
+ ls = ls1 + ls2
+ # list stores int
+ arr = [0] * ls
+ for i in reversed(range(ls1)):
+ for j in reversed(range(ls2)):
+ # store the direct results of multiply two ints
+ arr[i + j + 1] += int(num1[i]) * int(num2[j])
+ for i in reversed(range(1, ls)):
+ # digital plus
+ arr[i - 1] += arr[i] / 10
+ arr[i] %= 10
+ pos = 0
+ # to string
+ if arr[pos] == 0:
+ pos += 1
+ while pos < ls:
+ res = res + str(arr[pos])
+ pos += 1
+ return res
+
+
+if __name__ == '__main__':
+ s = Solution()
+ print s.multiply("98", "9")
diff --git a/python/python/044_Wildcard_Matching.py b/python/python/044_Wildcard_Matching.py
new file mode 100644
index 0000000..1ba2eb5
--- /dev/null
+++ b/python/python/044_Wildcard_Matching.py
@@ -0,0 +1,79 @@
+class Solution(object):
+ # def isMatch(self, s, p):
+ # """
+ # :type s: str
+ # :type p: str
+ # :rtype: bool
+ # """
+ # return self.dfs(s, p, 0, 0) > 1
+ #
+ #
+ # def dfs(self, s, p, s_index, p_index):
+ # if s_index == len(s) and p_index == len(p):
+ # return 2
+ # if s_index == len(s) and p[p_index] != '*':
+ # return 0
+ # if p_index == len(p):
+ # return 1
+ # if p[p_index] == '*':
+ # if p_index + 1 < len(p) and p[p_index + 1] == '*':
+ # # skip duplicate *
+ # return self.dfs(s, p, s_index, p_index + 1)
+ # for i in range(len(s) - s_index + 1):
+ # res = self.dfs(s, p, s_index + i, p_index + 1)
+ # if res == 0 or res == 2:
+ # return res
+ # if p[p_index] == '?' or s[s_index] == p[p_index]:
+ # return self.dfs(s, p, s_index + 1, p_index + 1)
+ # return 1
+
+ # def isMatch(self, s, p):
+ # #TODO
+ # # O(m * n) LTE
+ # m, n = len(s), len(p)
+ # dp = [[False] * (n + 1) for _ in range(m + 1)]
+ # dp[0][0] = True
+ # for j in range(1, n):
+ # dp[0][j + 1] = dp[0][j] and p[j] == '*'
+ # for i in range(m):
+ # for j in range(n):
+ # if p[j] == '?' or p[j] == s[i]:
+ # dp[i + 1][j + 1] = dp[i][j]
+ # elif p[j] == '*':
+ # dp[i + 1][j + 1] = dp[i + 1][j] or dp[i][j + 1]
+ # return dp[m][n]
+
+ def isMatch(self, s, p):
+ """
+ :type s: str
+ :type p: str
+ :rtype: bool
+ """
+ s_index, p_index = 0, 0
+ star, s_star = -1, 0
+ s_len, p_len = len(s), len(p)
+ while s_index < s_len:
+ if p_index < p_len and (s[s_index] == p[p_index] or p[p_index] == '?'):
+ s_index += 1
+ p_index += 1
+ elif p_index < p_len and p[p_index] == '*':
+ star = p_index
+ s_star = s_index
+ p_index += 1
+ elif star != -1:
+ p_index = star + 1
+ s_star += 1
+ s_index = s_star
+ else:
+ return False
+ while p_index < p_len and p[p_index] == '*':
+ p_index += 1
+ return p_index == p_len
+
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.isMatch("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+"*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*")
\ No newline at end of file
diff --git a/python/python/045_Jump_Game_II.py b/python/python/045_Jump_Game_II.py
new file mode 100644
index 0000000..dc8e137
--- /dev/null
+++ b/python/python/045_Jump_Game_II.py
@@ -0,0 +1,20 @@
+class Solution:
+ def jump(self, nums):
+ """
+ :type nums: List[int]
+ :rtype: int
+ """
+ if len(nums) <= 1:
+ return 0
+ end = 0 + nums[0]
+ start = 0
+ step = 1
+ maxDis = 0 + nums[0]
+ while end < len(nums) - 1:
+ for i in range(start + 1, end + 1):
+ # greedy
+ maxDis = max(maxDis, nums[i] + i)
+ start = end
+ end = maxDis
+ step += 1
+ return step
diff --git a/python/python/046_Permutations.py b/python/python/046_Permutations.py
new file mode 100644
index 0000000..3c21445
--- /dev/null
+++ b/python/python/046_Permutations.py
@@ -0,0 +1,44 @@
+class Solution:
+ # import itertools
+ # def permute(self, nums):
+ # """
+ # :type nums: List[int]
+ # :rtype: List[List[int]]
+ # """
+ # result = itertools.permutations(nums)
+ # result = [list(t) for t in result]
+ # return result
+
+ def permute(self, nums):
+ # DPS with swapping
+ res = []
+ if len(nums) == 0:
+ return res
+ self.get_permute(res, nums, 0)
+ return res
+
+ def get_permute(self, res, nums, index):
+ if index == len(nums):
+ res.append(list(nums))
+ return
+ for i in range(index, len(nums)):
+ nums[i], nums[index] = nums[index], nums[i]
+ # s(n) = 1 + s(n-1)
+ self.get_permute(res, nums, index + 1)
+ nums[i], nums[index] = nums[index], nums[i]
+
+ # def permute(self, nums):
+ # # iterative solution
+ # res = [[]]
+ # for i in range(len(nums)):
+ # cache = set()
+ # while len(res[0]) == i:
+ # curr = res.pop(0)
+ # for j in range(len(curr) + 1):
+ # # generate new n permutations from n -1 permutations
+ # new_perm = curr[:j] + [nums[i]] + curr[j:]
+ # stemp = ''.join(map(str, new_perm))
+ # if stemp not in cache:
+ # cache.add(stemp)
+ # res.append(new_perm)
+ # return res
diff --git a/python/python/047_Permutations_II.py b/python/python/047_Permutations_II.py
new file mode 100644
index 0000000..dac273c
--- /dev/null
+++ b/python/python/047_Permutations_II.py
@@ -0,0 +1,67 @@
+class Solution(object):
+ # def __init__(self):
+ # self.result = {}
+ #
+ # def permuteUnique(self, num):
+ # """
+ # :type nums: List[int]
+ # :rtype: List[List[int]]
+ # """
+ # if num is None:
+ # return []
+ # num.sort()
+ # self.getPermute([], num)
+ # return self.result.values()
+ #
+ # def getPermute(self, prefix, rest):
+ # ls = len(rest)
+ # if ls == 0:
+ # return
+ # elif ls == 1:
+ # temp = prefix + rest
+ # stemp = ''.join(str(t) for t in temp)
+ # self.result[stemp] = temp
+ # else:
+ # for i in range(ls):
+ # if i + 1 < ls and rest[i] == rest[i + 1]:
+ # continue
+ # temp = prefix[:]
+ # temp.append(rest[i])
+ # self.getPermute(temp, rest[:i] + rest[i + 1:])
+
+ def permuteUnique(self, num):
+ res = []
+ if len(num) == 0:
+ return res
+ self.permute(res, num, 0)
+ return res
+
+ def permute(self, res, num, index):
+ if index == len(num):
+ res.append(list(num))
+ return
+ appeared = set()
+ for i in range(index, len(num)):
+ if num[i] in appeared:
+ continue
+ appeared.add(num[i])
+ num[i], num[index] = num[index], num[i]
+ self.permute(res, num, index + 1)
+ num[i], num[index] = num[index], num[i]
+
+ def permuteUnique(self, num):
+ # iterative solution
+ res = [[]]
+ for i in range(len(nums)):
+ cache = set()
+ while len(res[0]) == i:
+ curr = res.pop(0)
+ for j in range(len(curr) + 1):
+ # generate new n permutations from n -1 permutations
+ new_perm = curr[:j] + [nums[i]] + curr[j:]
+ stemp = ''.join(map(str, new_perm))
+ if stemp not in cache:
+ cache.add(stemp)
+ res.append(new_perm)
+ return res
+
diff --git a/python/python/048_Rotate_Image.py b/python/python/048_Rotate_Image.py
new file mode 100644
index 0000000..85cf586
--- /dev/null
+++ b/python/python/048_Rotate_Image.py
@@ -0,0 +1,29 @@
+class Solution(object):
+ def rotate(self, matrix):
+ """
+ :type matrix: List[List[int]]
+ :rtype: void Do not return anything, modify matrix in-place instead.
+ """
+ # rotate from outside to inside
+ if matrix is None or len(matrix) == 1:
+ return
+ ls = len(matrix)
+ for i in range(ls / 2):
+ # border
+ begin, end = i, ls - 1 - i
+ for k in range(ls - 2 * i - 1):
+ temp = matrix[end - k][begin]
+ matrix[end - k][begin] = matrix[end][end - k]
+ matrix[end][end - k] = matrix[begin + k][end]
+ matrix[begin + k][end] = matrix[begin][begin + k]
+ matrix[begin][begin + k] = temp
+ return
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ s.rotate([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
+
+
+
+
diff --git a/python/python/049_Group_Anagrams.py b/python/python/049_Group_Anagrams.py
new file mode 100644
index 0000000..e48ca2f
--- /dev/null
+++ b/python/python/049_Group_Anagrams.py
@@ -0,0 +1,45 @@
+class Solution(object):
+ # def groupAnagrams(self, strs):
+ # """
+ # :type strs: List[str]
+ # :rtype: List[List[str]]
+ # """
+ # hash = {}
+ # for s in strs:
+ # key = self.hash_key(s)
+ # try:
+ # hash[key].append(s)
+ # except KeyError:
+ # hash[key] = [s]
+ # for k, v in hash.items():
+ # if len(v) > 1:
+ # # sort
+ # v.sort()
+ # return hash.values()
+ #
+ # def hash_key(self, s):
+ # # hash string with 26 length array
+ # table = [0] * 26
+ # for ch in s:
+ # index = ord(ch) - ord('a')
+ # table[index] += 1
+ # return str(table)
+
+ def groupAnagrams(self, strs):
+ strs.sort()
+ hash = {}
+ for s in strs:
+ key = self.hash_key(s)
+ try:
+ hash[key].append(s)
+ except KeyError:
+ hash[key] = [s]
+ return hash.values()
+
+ def hash_key(self, s):
+ # hash string with 26 length array
+ table = [0] * 26
+ for ch in s:
+ index = ord(ch) - ord('a')
+ table[index] += 1
+ return str(table)
\ No newline at end of file
diff --git a/python/python/050_Pow(x, n).py b/python/python/050_Pow(x, n).py
new file mode 100644
index 0000000..b27e60f
--- /dev/null
+++ b/python/python/050_Pow(x, n).py
@@ -0,0 +1,31 @@
+class Solution:
+ # def myPow(self, x, n):
+ # """
+ # :type x: float
+ # :type n: int
+ # :rtype: float
+ # """
+ # if n == 0:
+ # return 1
+ # temp = pow(x, n / 2)
+ # if n % 2 == 0:
+ # return temp * temp
+ # else:
+ # return temp * temp * x
+
+ def myPow(self, x, n):
+ # https://leetcode.com/discuss/93413/iterative-log-n-solution-with-clear-explanation
+ # 9 = 2^3 + 2^0 = 1001
+ # x^9 = x^(2^3)*x(2^0)
+ # multiple x^i when i place is 1
+ if n == 0:
+ return 1
+ res ,curr = 1, abs(n)
+ while curr > 0:
+ if curr & 1 == 1:
+ res *= x
+ curr >>= 1
+ x *= x
+ if n < 0:
+ return 1 / res
+ return res
diff --git a/python/python/051_N-Queens.py b/python/python/051_N-Queens.py
new file mode 100644
index 0000000..9a64e31
--- /dev/null
+++ b/python/python/051_N-Queens.py
@@ -0,0 +1,42 @@
+class Solution(object):
+ def solveNQueens(self, n):
+ """
+ :type n: int
+ :rtype: List[List[str]]
+ """
+ # recusive
+ if n == 0:
+ return 0
+ res = []
+ board = [['.'] * n for t in range(n)]
+ self.do_solveNQueens(res, board, n)
+ return res
+
+ def do_solveNQueens(self, res, board, num):
+ if num == 0:
+ res.append([''.join(t) for t in board])
+ return
+ ls = len(board)
+ pos = ls - num
+ check = [True] * ls
+ for i in range(pos):
+ for j in range(ls):
+ if board[i][j] == 'Q':
+ check[j] = False
+ step = pos - i
+ if j + step < ls:
+ check[j + step] = False
+ if j - step >= 0:
+ check[j - step] = False
+ break
+ for j in range(ls):
+ if check[j]:
+ board[pos][j] = 'Q'
+ self.do_solveNQueens(res, board, num - 1)
+ board[pos][j] = '.'
+
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.solveNQueens(4)
\ No newline at end of file
diff --git a/python/python/052_N-Queens II.py b/python/python/052_N-Queens II.py
new file mode 100644
index 0000000..39f8112
--- /dev/null
+++ b/python/python/052_N-Queens II.py
@@ -0,0 +1,78 @@
+class Solution(object):
+ # def totalNQueens(self, n):
+ # """
+ # :type n: int
+ # :rtype: int
+ # """
+ # if n == 0:
+ # return 0
+ # res = [0]
+ # board = [['.'] * n for t in range(n)]
+ # self.do_solveNQueens(res, board, n)
+ # return res[0]
+ #
+ # def do_solveNQueens(self, res, board, num):
+ # if num == 0:
+ # res[0] += 1
+ # return
+ # ls = len(board)
+ # pos = ls - num
+ # check = [True] * ls
+ # for i in range(pos):
+ # for j in range(ls):
+ # if board[i][j] == 'Q':
+ # check[j] = False
+ # step = pos - i
+ # if j + step < ls:
+ # check[j + step] = False
+ # if j - step >= 0:
+ # check[j - step] = False
+ # break
+ # if pos == 0:
+ # # mirror on the first row
+ # for j in range(ls / 2):
+ # if check[j]:
+ # board[pos][j] = 'Q'
+ # self.do_solveNQueens(res, board, num - 1)
+ # board[pos][j] = '.'
+ # res[0] *= 2
+ # if ls % 2 != 0:
+ # if check[ls / 2]:
+ # board[pos][ls / 2] = 'Q'
+ # self.do_solveNQueens(res, board, num - 1)
+ # board[pos][ls / 2] = '.'
+ # else:
+ # for j in range(ls):
+ # if check[j]:
+ # board[pos][j] = 'Q'
+ # self.do_solveNQueens(res, board, num - 1)
+ # board[pos][j] = '.'
+
+ def __init__(self):
+ self.count = 0
+
+ def totalNQueens(self, n):
+ self.dfs(0, n, 0, 0, 0)
+ return self.count
+
+ def dfs(self, row, n, column, diag, antiDiag):
+ # https://leetcode.com/discuss/89951/share-my-java-code-beats-97-83%25-run-times
+ if row == n:
+ self.count += 1
+ return
+ for index in range(n):
+ # column check
+ isColSafe = (1 << index) & column == 0
+ # diagonal, all nodes have the same n - 1 + row - index
+ isDigSafe = (1 << (n - 1 + row - index)) & diag == 0
+ # anti diagonal, all nodes have the same row + index
+ isAntiDiagSafe = (1 << (row + index)) & antiDiag == 0
+ if isAntiDiagSafe and isColSafe and isDigSafe:
+ self.dfs(row + 1, n, (1 << index) | column,
+ (1 << (n - 1 + row - index)) | diag,
+ (1 << (row + index)) | antiDiag)
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.totalNQueens(4)
\ No newline at end of file
diff --git a/python/python/053_Maximum_Subarray.py b/python/python/053_Maximum_Subarray.py
new file mode 100644
index 0000000..6a8977e
--- /dev/null
+++ b/python/python/053_Maximum_Subarray.py
@@ -0,0 +1,48 @@
+class Solution(object):
+ # def maxSubArray(self, nums):
+ # return self.maxSubArrayHelper(nums, 0, len(nums) - 1)
+ #
+ # def maxSubArrayHelper(self, nums, l, r):
+ # if l > r:
+ # return -2147483647
+ # mid = (l + r) / 2
+ # leftAns = self.maxSubArrayHelper(nums, l, mid - 1)
+ # rightAns = self.maxSubArrayHelper(nums, mid + 1, r)
+ # lMaxSum = res = 0
+ # for i in range(mid - 1, l -1, -1):
+ # res += nums[i]
+ # lMaxSum = max(res, lMaxSum)
+ # rMaxSum = res = 0
+ # for i in range(mid + 1, r + 1):
+ # res += nums[i]
+ # rMaxSum = max(res, rMaxSum)
+ # return max(lMaxSum + nums[mid] + rMaxSum, max(leftAns, rightAns))
+
+ # def maxSubArray(self, nums):
+ # """
+ # :type nums: List[int]
+ # :rtype: int
+ # """
+ # ls = len(nums)
+ # start = [0] * ls
+ # all = [0] * ls
+ # start[-1], all[-1] = nums[-1], nums[-1]
+ # for i in reversed(range(ls - 1)):
+ # start[i] = max(nums[i], nums[i] + start[i + 1])
+ # all[i] = max(start[i], all[i + 1])
+ # return all[0]
+
+ # def maxSubArray(self, nums):
+ # ls = len(nums)
+ # start, all = nums[-1], nums[-1]
+ # for i in reversed(range(ls - 1)):
+ # start = max(nums[i], nums[i] + start)
+ # all = max(start, all)
+ # return all
+
+ def maxSubArray(self, nums):
+ maxEndingHere = maxSofFar = nums[0]
+ for i in range(1, len(nums)):
+ maxEndingHere = max(maxEndingHere + nums[i], nums[i])
+ maxSofFar = max(maxEndingHere, maxSofFar)
+ return maxSofFar
\ No newline at end of file
diff --git a/python/python/054_Spiral_Matrix.py b/python/python/054_Spiral_Matrix.py
new file mode 100644
index 0000000..7713542
--- /dev/null
+++ b/python/python/054_Spiral_Matrix.py
@@ -0,0 +1,47 @@
+class Solution(object):
+ def spiralOrder(self, matrix):
+ """
+ :type matrix: List[List[int]]
+ :rtype: List[int]
+ """
+ if matrix is None or len(matrix) == 0:
+ return matrix
+ m, n = len(matrix), len(matrix[0])
+ return self.get_spiralOrder(matrix, 0, m - 1, 0, n - 1)
+
+ def get_spiralOrder(self, matrix, r_start, r_end, c_start, c_end):
+ if r_start > r_end or c_start > c_end:
+ return []
+ elif r_start == r_end:
+ return matrix[r_start][c_start:c_end + 1]
+ elif c_start == c_end:
+ return [matrix[j][c_end] for j in range(r_start, r_end + 1)]
+ curr = matrix[r_start][c_start:c_end + 1] + [matrix[j][c_end] for j in range(r_start + 1, r_end)] +\
+ matrix[r_end][c_start:c_end + 1][::-1] +\
+ [matrix[j][c_start] for j in reversed(range(r_start + 1, r_end))]
+ res = curr + self.get_spiralOrder(matrix, r_start + 1, r_end - 1, c_start + 1, c_end - 1)
+ return res
+
+
+ # def spiralOrder(self, matrix):
+ # res = []
+ # if not matrix:
+ # return []
+ # i, j, di, dj = 0, 0, 0, 1
+ # m, n = len(matrix), len(matrix[0])
+ # for v in xrange(m * n):
+ # res.append(matrix[i][j])
+ # matrix[i][j] = ''
+ # if matrix[(i + di) % m][(j + dj) % n] == '':
+ # # (0, 1) -> (1, 0) -> (0, -1) -> (-1, 0)
+ # # then loop
+ # di, dj = dj, -di
+ # i += di
+ # j += dj
+ # return res
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.spiralOrder([[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]])
+
diff --git a/python/python/055_Jump_Game.py b/python/python/055_Jump_Game.py
new file mode 100644
index 0000000..0e8b9ec
--- /dev/null
+++ b/python/python/055_Jump_Game.py
@@ -0,0 +1,14 @@
+class Solution(object):
+ def canJump(self, nums):
+ """
+ :type nums: List[int]
+ :rtype: bool
+ """
+ # greedy
+ # https://leetcode.com/articles/jump-game/
+ length = len(nums)
+ begin = length - 1
+ for i in reversed(range(length - 1)):
+ if i + nums[i] >= begin:
+ begin = i
+ return not begin
\ No newline at end of file
diff --git a/python/python/056_Merge_Intervals.py b/python/python/056_Merge_Intervals.py
new file mode 100644
index 0000000..f90b245
--- /dev/null
+++ b/python/python/056_Merge_Intervals.py
@@ -0,0 +1,36 @@
+# Definition for an interval.
+# class Interval(object):
+# def __init__(self, s=0, e=0):
+# self.start = s
+# self.end = e
+
+class Solution(object):
+ def merge(self, intervals):
+ """
+ :type intervals: List[Interval]
+ :rtype: List[Interval]
+ """
+ if intervals is None:
+ return
+ ls = len(intervals)
+ if ls <= 1:
+ return intervals
+ # sort by start
+ intervals.sort(key=lambda x: x.start)
+ pos = 0
+ while pos < len(intervals) - 1:
+ # check overlap
+ if intervals[pos].end >= intervals[pos + 1].start:
+ next = intervals.pop(pos + 1)
+ # check next is overlap or totally covered by pos
+ if next.end > intervals[pos].end:
+ intervals[pos].end = next.end
+ # print [(t.start, t.end) for t in intervals], pos
+ else:
+ pos += 1
+ return intervals
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.merge([[1,3],[2,6],[8,10],[15,18]])
\ No newline at end of file
diff --git a/python/python/057_Insert_Interval.py b/python/python/057_Insert_Interval.py
new file mode 100644
index 0000000..480bdcb
--- /dev/null
+++ b/python/python/057_Insert_Interval.py
@@ -0,0 +1,48 @@
+# Definition for an interval.
+# class Interval(object):
+# def __init__(self, s=0, e=0):
+# self.start = s
+# self.end = e
+
+class Solution(object):
+ def insert(self, intervals, newInterval):
+ """
+ :type intervals: List[Interval]
+ :type newInterval: Interval
+ :rtype: List[Interval]
+ """
+ if intervals is None or len(intervals) == 0:
+ return [newInterval]
+ intervals.sort(key=lambda x:x.start)
+ pos = 0
+ while pos < len(intervals):
+ # left of pos
+ if newInterval.end < intervals[pos].start:
+ intervals.insert(pos, newInterval)
+ return intervals
+ # overlap with pos
+ if self.check_overlap(intervals[pos], newInterval):
+ temp = intervals.pop(pos)
+ newInterval = self.merge_intervals(temp, newInterval)
+ else:
+ pos += 1
+ if len(intervals) == 0 or pos == len(intervals):
+ intervals.append(newInterval)
+ return intervals
+
+ def check_overlap(self, curr_int, new_int):
+ if curr_int.start <= new_int.start:
+ if curr_int.end > new_int.start:
+ return True
+ else:
+ if curr_int.start <= new_int.end:
+ return True
+ return False
+
+ def merge_intervals(self, int1, int2):
+ temp_int = Interval()
+ temp_int.start = min([int1.start, int2.start])
+ temp_int.end = max([int1.end, int2.end])
+ return temp_int
+
+
diff --git a/python/python/058_Length_of_Last_Word.py b/python/python/058_Length_of_Last_Word.py
new file mode 100644
index 0000000..40e835a
--- /dev/null
+++ b/python/python/058_Length_of_Last_Word.py
@@ -0,0 +1,14 @@
+class Solution(object):
+ def lengthOfLastWord(self, s):
+ """
+ :type s: str
+ :rtype: int
+ """
+ if len(s) == 0:
+ return 0
+ temp = s.split(' ')
+ temp = [t for t in temp if len(t) > 0]
+ if len(temp) == 0:
+ return 0
+ else:
+ return len(temp[-1])
\ No newline at end of file
diff --git a/python/python/059_Spiral_Matrix_II.py b/python/python/059_Spiral_Matrix_II.py
new file mode 100644
index 0000000..45ea222
--- /dev/null
+++ b/python/python/059_Spiral_Matrix_II.py
@@ -0,0 +1,22 @@
+class Solution(object):
+ def generateMatrix(self, n):
+ """
+ :type n: int
+ :rtype: List[List[int]]
+ """
+ res = [[0] * n for _ in range(n)]
+ pos = [0, 0]
+ move = (0, 1)
+ for index in range(1, n * n + 1):
+ res[pos[0]][pos[1]] = index
+ if res[(pos[0] + move[0]) % n][(pos[1] + move[1]) % n] > 0:
+ # (0, 1) -> (1, 0) -> (0, -1) -> (-1, 0)
+ move = (move[1], -1 * move[0])
+ pos[0] = pos[0] + move[0]
+ pos[1] = pos[1] + move[1]
+ return res
+
+if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print s.generateMatrix(2)
\ No newline at end of file
diff --git a/python/python/060_Permutation_Sequence.py b/python/python/060_Permutation_Sequence.py
new file mode 100644
index 0000000..e582b57
--- /dev/null
+++ b/python/python/060_Permutation_Sequence.py
@@ -0,0 +1,34 @@
+class Solution(object):
+ def getPermutation(self, n, k):
+ """
+ :type n: int
+ :type k: int
+ :rtype: str
+ """
+ # let permutations with first identical num be a block
+ # target in (k - 1) / (n - 1)! block
+ remain = range(1, n + 1)
+ if k <= 1:
+ return ''.join(str(t) for t in remain)
+ total = 1
+ for num in remain[:-1]:
+ total *= num
+ res = self.do_getPermutation(remain, total, n - 1, k - 1)
+ return ''.join(str(t) for t in res)
+
+
+ def do_getPermutation(self, remain, curr, n, k):
+ if n == 0 or k <= 0 or curr == 0:
+ return remain
+ # which block
+ step = k / curr
+ # remain k value
+ k %= curr
+ curr /= n
+ res = [remain[step]] + self.do_getPermutation(remain[:step] + remain[step + 1:], curr, n - 1, k)
+ return res
+
+if __name__ == '__main__':
+ s = Solution()
+ print s.getPermutation(3, 2)
+ # print s.getPermutation(2, 2)
\ No newline at end of file
diff --git a/python/python/061_Rotate_List.py b/python/python/061_Rotate_List.py
new file mode 100644
index 0000000..27941ae
--- /dev/null
+++ b/python/python/061_Rotate_List.py
@@ -0,0 +1,38 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+class Solution(object):
+ def rotateRight(self, head, k):
+ """
+ :type head: ListNode
+ :type k: int
+ :rtype: ListNode
+ """
+ if not head or k == 0:
+ return head
+
+ slow = fast = head
+ length = 1
+
+ while k and fast.next:
+ fast = fast.next
+ length += 1
+ k -= 1
+
+ if k != 0:
+ k = (k + length - 1) % length # original k % length
+ return self.rotateRight(head, k)
+ else:
+ while fast.next:
+ fast = fast.next
+ slow = slow.next
+ return self.rotate(head, fast, slow)
+
+ def rotate(self, head, fast, slow):
+ fast.next = head
+ head = slow.next
+ slow.next = None
+ return head
\ No newline at end of file
diff --git a/python/python/062_Unique_Paths.py b/python/python/062_Unique_Paths.py
new file mode 100644
index 0000000..acf44b2
--- /dev/null
+++ b/python/python/062_Unique_Paths.py
@@ -0,0 +1,21 @@
+class Solution:
+ def uniquePaths(self, m, n):
+ """
+ :type m: int
+ :type n: int
+ :rtype: int
+ """
+ dmap = [[0] * n for _ in range(m)]
+ for i in range(m):
+ dmap[i][0] = 1
+ for j in range(n):
+ dmap[0][j] = 1
+ for i in range(1, m):
+ for j in range(1, n):
+ l = u = 0
+ if i-1 >= 0:
+ u = dmap[i-1][j]
+ if j-1>= 0:
+ l = dmap[i][j-1]
+ dmap[i][j] = l + u
+ return dmap[m-1][n-1]
diff --git a/python/python/063_Unique_Paths_II.py b/python/python/063_Unique_Paths_II.py
new file mode 100644
index 0000000..c6653f1
--- /dev/null
+++ b/python/python/063_Unique_Paths_II.py
@@ -0,0 +1,43 @@
+class Solution(object):
+ # def uniquePathsWithObstacles(self, obstacleGrid):
+ # """
+ # :type obstacleGrid: List[List[int]]
+ # :rtype: int
+ # """
+ # m, n = len(obstacleGrid), len(obstacleGrid[0])
+ # dmap = [[0] * n for _ in range(m)]
+ # for i in range(m):
+ # if obstacleGrid[i][0] != 1:
+ # dmap[i][0] = 1
+ # else:
+ # break
+ # for j in range(n):
+ # if obstacleGrid[0][j] != 1:
+ # dmap[0][j] = 1
+ # else:
+ # break
+ # for i in range(1, m):
+ # for j in range(1, n):
+ # if obstacleGrid[i][j] == 1:
+ # continue
+ # l = u = 0
+ # if i - 1 >= 0:
+ # u = dmap[i - 1][j]
+ # if j - 1 >= 0:
+ # l = dmap[i][j - 1]
+ # dmap[i][j] = l + u
+ # return dmap[m - 1][n - 1]
+
+ def uniquePathsWithObstacles(self, obstacleGrid):
+ m, n = len(obstacleGrid), len(obstacleGrid[0])
+ if m == 0:
+ return 0
+ dmap = [[0] * (n + 1) for _ in range(m + 1)]
+ dmap[m - 1][n] = 1
+ for i in range(m - 1, -1, -1):
+ for j in range(n - 1, -1, -1):
+ if obstacleGrid[i][j] == 1:
+ dmap[i][j] = 0
+ else:
+ dmap[i][j] = dmap[i][j + 1] + dmap[i + 1][j]
+ return dmap[0][0]
\ No newline at end of file
diff --git a/python/python/064_Minimum_Path_Sum.py b/python/python/064_Minimum_Path_Sum.py
new file mode 100644
index 0000000..5d56e6b
--- /dev/null
+++ b/python/python/064_Minimum_Path_Sum.py
@@ -0,0 +1,24 @@
+class Solution(object):
+ def minPathSum(self, grid):
+ """
+ :type grid: List[List[int]]
+ :rtype: int
+ """
+ height = len(grid)
+ if height == 0:
+ return 0
+ width = len(grid[0])
+ pathmap = []
+ for i in range(height):
+ pathmap.append([100000000000] * width)
+ pathmap[0][0] = grid[0][0]
+ for i in range(height):
+ for j in range(width):
+ compare = [pathmap[i][j]]
+ if i - 1 >= 0:
+ compare.append(pathmap[i - 1][j] + grid[i][j])
+ if j - 1 >= 0:
+ compare.append(pathmap[i][j - 1] + grid[i][j])
+ # min choice
+ pathmap[i][j] = min(compare)
+ return pathmap[-1][-1]
\ No newline at end of file
diff --git a/python/python/065_Valid_Number.py b/python/python/065_Valid_Number.py
new file mode 100644
index 0000000..314422b
--- /dev/null
+++ b/python/python/065_Valid_Number.py
@@ -0,0 +1,52 @@
+class Solution(object):
+ # def isNumber(self, s):
+ # """
+ # :type s: str
+ # :rtype: bool
+ # """
+ # # remove lead and tail space
+ # s = s.strip()
+ # try:
+ # float(s)
+ # return True
+ # except:
+ # if '.' in s or ' ' in s:
+ # return False
+ # temp = s.split('e')
+ # if len(temp) == 2:
+ # try:
+ # int(temp[0])
+ # int(temp[1])
+ # except:
+ # return False
+ # return True
+ # return False
+
+ def isNumber(self, s):
+ s = s.strip()
+ ls, pos = len(s), 0
+ if ls == 0:
+ return False
+ if s[pos] == '+' or s[pos] == '-':
+ pos += 1
+ isNumeric = False
+ while pos < ls and s[pos].isdigit():
+ pos += 1
+ isNumeric = True
+ if pos < ls and s[pos] == '.':
+ pos += 1
+ while pos < ls and s[pos].isdigit():
+ pos += 1
+ isNumeric = True
+ elif pos < ls and s[pos] == 'e' and isNumeric:
+ isNumeric = False
+ pos += 1
+ if pos < ls and (s[pos] == '+' or s[pos] == '-'):
+ pos += 1
+ while pos < ls and s[pos].isdigit():
+ pos += 1
+ isNumeric = True
+ print pos, ls, isNumeric
+ if pos == ls and isNumeric:
+ return True
+ return False
diff --git a/python/python/066_Plus_One.py b/python/python/066_Plus_One.py
new file mode 100644
index 0000000..3dbc4d0
--- /dev/null
+++ b/python/python/066_Plus_One.py
@@ -0,0 +1,35 @@
+class Solution(object):
+ # def plusOne(self, digits):
+ # """
+ # :type digits: List[int]
+ # :rtype: List[int]
+ # """
+ # ls = len(digits)
+ # curr, pos = 1, 0
+ # while pos < ls:
+ # index = ls - pos - 1
+ # curr += digits[index]
+ # digits[index] = curr % 10
+ # curr /= 10
+ # if curr == 0:
+ # # do not need to continue
+ # break
+ # pos += 1
+ # if curr > 0:
+ # digits.insert(0, curr)
+ # return digits
+
+ def plusOne(self, digits):
+ ls = len(digits)
+ for index in reversed(range(ls)):
+ if digits[index] < 9:
+ digits[index] += 1
+ # do not need to continue
+ return digits
+ else:
+ # 10
+ digits[index] = 0
+ digits.insert(0, 1)
+ return digits
+
+
diff --git a/python/python/067_Add_Binary.py b/python/python/067_Add_Binary.py
new file mode 100644
index 0000000..70fd792
--- /dev/null
+++ b/python/python/067_Add_Binary.py
@@ -0,0 +1,60 @@
+class Solution(object):
+ # def addBinary(self, a, b):
+ # """
+ # :type a: str
+ # :type b: str
+ # :rtype: str
+ # """
+ # res = ''
+ # lsa, lsb = len(a), len(b)
+ # pos = -1
+ # plus = 0
+ # while (lsa + pos) >= 0 and (lsb + pos) >= 0:
+ # curr = int(a[pos]) + int(b[pos]) + plus
+ # if curr >= 2:
+ # plus = 1
+ # curr %= 2
+ # else:
+ # plus = 0
+ # res = str(curr) + res
+ # pos -= 1
+ # if lsa + pos >= 0:
+ # while (lsa + pos) >= 0:
+ # curr = int(a[pos]) + plus
+ # if curr >= 2:
+ # plus = 1
+ # curr %= 2
+ # else:
+ # plus = 0
+ # res = str(curr) + res
+ # pos -= 1
+ # if lsb + pos >= 0:
+ # while (lsb + pos) >= 0:
+ # curr = int(b[pos]) + plus
+ # if curr >= 2:
+ # plus = 1
+ # curr %= 2
+ # else:
+ # plus = 0
+ # res = str(curr) + res
+ # pos -= 1
+ # if plus == 1:
+ # res = '1' + res
+ # return res
+
+ def addBinary(self, a, b):
+ res = ''
+ lsa, lsb = len(a), len(b)
+ pos, plus, curr = -1, 0, 0
+ # plus a[pos], b[pos] and curr % 2
+ while (lsa + pos) >= 0 or (lsb + pos) >= 0:
+ if (lsa + pos) >= 0:
+ curr += int(a[pos])
+ if (lsb + pos) >= 0:
+ curr += int(b[pos])
+ res = str(curr % 2) + res
+ curr //= 2
+ pos -= 1
+ if curr == 1:
+ res = '1' + res
+ return res
diff --git a/python/python/068_Text_Justification.py b/python/python/068_Text_Justification.py
new file mode 100644
index 0000000..2166c05
--- /dev/null
+++ b/python/python/068_Text_Justification.py
@@ -0,0 +1,73 @@
+class Solution(object):
+ def fullJustify(self, words, maxWidth):
+ """
+ :type words: List[str]
+ :type maxWidth: int
+ :rtype: List[str]
+ """
+ res = []
+ res_list = []
+ curr = []
+ count, pos = 0, 0
+ while pos < len(words):
+ word = words[pos]
+ if len(word) > maxWidth:
+ pos += 1
+ if len(word) + count + len(curr)<= maxWidth:
+ count += len(word)
+ curr.append(word)
+ pos += 1
+ else:
+ res_list.append(curr)
+ curr = []
+ count = 0
+ if len(curr) > 0:
+ res_list.append(curr)
+ # print res_list
+ for index, curr in enumerate(res_list):
+ text = ''
+ remain = sum([len(t) for t in curr])
+ if len(curr) == 1:
+ # single word
+ text = curr[0] + ' ' * (maxWidth - remain)
+ elif index == len(res_list) - 1:
+ # last line
+ text = ' '.join(curr)
+ text += ' ' * (maxWidth - remain - len(curr) + 1)
+ else:
+ # multiple
+ step = (maxWidth - remain) / (len(curr) - 1 )
+ extra = (maxWidth - remain) % (len(curr) - 1 )
+ for index in range(len(curr) - 1):
+ text += curr[index] + ' ' * step
+ if extra > 0:
+ # assign from left
+ text += ' '
+ extra -= 1
+ text += curr[-1]
+ res.append(text)
+ return res
+
+ # def fullJustify(self, words, maxWidth):
+ # i, N, result = 0, len(words), []
+ # while i < N:
+ # # decide how many words to be put in one line
+ # oneLine, j, currWidth, positionNum, spaceNum = [words[i]], i + 1, len(words[i]), 0, maxWidth - len(words[i])
+ # while j < N and currWidth + 1 + len(words[j]) <= maxWidth:
+ # oneLine.append(words[j])
+ # currWidth += 1 + len(words[j])
+ # spaceNum -= len(words[j])
+ # positionNum, j = positionNum + 1, j + 1
+ # i = j
+ # # decide the layout of one line
+ # if i < N and positionNum:
+ # spaces = [' ' * (spaceNum / positionNum + (k < spaceNum % positionNum)) for k in range(positionNum)] + [
+ # '']
+ # else: # last line or the line only has one word
+ # spaces = [' '] * positionNum + [' ' * (maxWidth - currWidth)]
+ # result.append(''.join([s for pair in zip(oneLine, spaces) for s in pair]))
+ # return result
+
+if __name__ == '__main__':
+ s = Solution()
+ print s.fullJustify(["Don't","go","around","saying","the","world","owes","you","a","living;","the","world","owes","you","nothing;","it","was","here","first."],30)
diff --git a/python/python/069_Sqrt(x).py b/python/python/069_Sqrt(x).py
new file mode 100644
index 0000000..a697a45
--- /dev/null
+++ b/python/python/069_Sqrt(x).py
@@ -0,0 +1,35 @@
+class Solution:
+ # def mySqrt(self, x):
+ # """
+ # :type x: int
+ # :rtype: int
+ # """
+ # if x == 0:
+ # return 0
+ # low = 0
+ # high = x
+ # last = x
+ # while high >= low:
+ # mid = (low + high) / 2
+ # temp = mid * mid
+ # if temp == x:
+ # return mid
+ # elif temp < x:
+ # low = mid + 1
+ # last = mid
+ # else:
+ # high = mid - 1
+ # return last
+
+ def mySqrt(self, x):
+ # sqrt(x) = 2 * sqrt(x / 4) for n % 4 == 0
+ # sqrt(x) = 1 + 2 * sqrt(x / 4) for n % 4 != 0
+ if x == 0:
+ return 0
+ if x < 4:
+ return 1
+ res = 2 * self.mySqrt(x / 4)
+ # (res + 1) * (res + 1) >= 0 for avoiding overflow
+ if (res + 1) * (res + 1) <= x and (res + 1) * (res + 1) >= 0:
+ return res + 1
+ return res
\ No newline at end of file
diff --git a/python/python/070_Climbing_Stairs.py b/python/python/070_Climbing_Stairs.py
new file mode 100644
index 0000000..fe7ae69
--- /dev/null
+++ b/python/python/070_Climbing_Stairs.py
@@ -0,0 +1,37 @@
+class Solution(object):
+ # def climbStairs(self, n):
+ # """
+ # :type n: int
+ # :rtype: int
+ # """
+ # dp = [0] * (n + 1)
+ # dp[0] = 1
+ # dp[1] = 1
+ # for i in range(2, n + 1):
+ # dp[i] = dp[i - 2] + dp[i- 1]
+ # return dp[n]
+
+ def climbStairs(self, n):
+ if n <= 1:
+ return 1
+ dp = [1] * 2
+ for i in range(2, n + 1):
+ dp[1], dp[0] = dp[1] + dp[0], dp[1]
+ return dp[1]
+
+
+
+ # C = {1: 1, 2: 2}
+ # def climbStairs(self, n):
+ # """
+ # :type n: int
+ # :rtype: int
+ # """
+ # if n in Solution.C:
+ # return Solution.C[n]
+ # else:
+ # result = Solution.C.get(n - 1, self.climbStairs(n - 1)) + \
+ # Solution.C.get(n - 2, self.climbStairs(n - 2))
+ # Solution.C[n] = result
+ # return result
+
diff --git a/python/python/071_Simplify_Path.py b/python/python/071_Simplify_Path.py
new file mode 100644
index 0000000..39fa5e2
--- /dev/null
+++ b/python/python/071_Simplify_Path.py
@@ -0,0 +1,20 @@
+class Solution(object):
+ def simplifyPath(self, path):
+ """
+ :type path: str
+ :rtype: str
+ """
+ result = []
+ plist = path.split('/')
+ for pos in plist:
+ if pos:
+ if pos == '..':
+ try:
+ # up one level
+ result.pop()
+ except:
+ # arrive top level
+ result = []
+ elif pos != '.':
+ result.append(pos)
+ return '/'+'/'.join(result)
\ No newline at end of file
diff --git a/python/python/072_Edit_Distance.py b/python/python/072_Edit_Distance.py
new file mode 100644
index 0000000..f1dd491
--- /dev/null
+++ b/python/python/072_Edit_Distance.py
@@ -0,0 +1,45 @@
+class Solution(object):
+ # https://discuss.leetcode.com/topic/17639/20ms-detailed-explained-c-solutions-o-n-space/2
+ # def minDistance(self, word1, word2):
+ # """
+ # :type word1: str
+ # :type word2: str
+ # :rtype: int
+ # """
+ # ls_1, ls_2 = len(word1), len(word2)
+ # dp = [[0] * (ls_2 + 1) for _ in range(ls_1 + 1)]
+ # for i in range(1, ls_1 + 1):
+ # dp[i][0] = i
+ # for j in range(1, ls_2 + 1):
+ # dp[0][j] = j
+ # for i in range(1, ls_1 + 1):
+ # for j in range(1, ls_2 + 1):
+ # if word1[i - 1] == word2[j - 1]:
+ # dp[i][j] = dp[i - 1][j - 1]
+ # else:
+ # dp[i][j] = min(dp[i - 1][j - 1] + 1,
+ # dp[i][j - 1] + 1,
+ # dp[i - 1][j] + 1)
+ # return dp[ls_1][ls_2]
+
+ def minDistance(self, word1, word2):
+ ls_1, ls_2 = len(word1), len(word2)
+ dp = list(range(ls_1 + 1))
+ for j in range(1, ls_2 + 1):
+ pre = dp[0]
+ dp[0] = j
+ for i in range(1, ls_1 + 1):
+ temp = dp[i]
+ if word1[i - 1] == word2[j - 1]:
+ dp[i] = pre
+ else:
+ dp[i] = min(pre + 1, dp[i] + 1, dp[i - 1] + 1)
+ pre = temp
+ return dp[ls_1]
+
+
+ if __name__ == '__main__':
+ # begin
+ s = Solution()
+ print (s.minDistance("horse","ros"))
+ print (s.minDistance("intention","execution"))
diff --git a/python/python/073_Set_Matrix_Zeroes.py b/python/python/073_Set_Matrix_Zeroes.py
new file mode 100644
index 0000000..c0e6535
--- /dev/null
+++ b/python/python/073_Set_Matrix_Zeroes.py
@@ -0,0 +1,29 @@
+class Solution(object):
+ def setZeroes(self, matrix):
+ """
+ :type matrix: List[List[int]]
+ :rtype: void Do not return anything, modify matrix in-place instead.
+ """
+ if not matrix:
+ return
+ m = len(matrix)
+ if m == 0:
+ return
+ r = []
+ c = []
+ n = len(matrix[0])
+ for i in range(m):
+ for j in range(n):
+ if matrix[i][j] == 0:
+ r.append(i)
+ c.append(j)
+ # row with zero
+ r = set(r)
+ # column with zero
+ c = set(c)
+ for i in r:
+ for j in range(n):
+ matrix[i][j] = 0
+ for i in range(m):
+ for j in c:
+ matrix[i][j] = 0
diff --git a/python/python/074_Search_a_2D_Matrix.py b/python/python/074_Search_a_2D_Matrix.py
new file mode 100644
index 0000000..8666114
--- /dev/null
+++ b/python/python/074_Search_a_2D_Matrix.py
@@ -0,0 +1,62 @@
+class Solution(object):
+ # def searchMatrix(self, matrix, target):
+ # """
+ # :type matrix: List[List[int]]
+ # :type target: int
+ # :rtype: bool
+ # """
+ # try:
+ # ls_row, ls_col = len(matrix), len(matrix[0])
+ # except:
+ # return False
+ # begin, end = 0, ls_row - 1
+ # while begin <= end:
+ # mid = (begin + end) / 2
+ # res = self.search_row(matrix, mid, target)
+ # if res == 0:
+ # return True
+ # elif res < 0:
+ # end = mid - 1
+ # else:
+ # begin = mid + 1
+ # return False
+ #
+ #
+ # def search_row(self, matrix, row, target):
+ # if target < matrix[row][0]:
+ # return -1
+ # elif target > matrix[row][-1]:
+ # return 1
+ # begin, end = 0, len(matrix[row]) - 1
+ # while begin <= end:
+ # mid = (begin + end) / 2
+ # if matrix[row][mid] == target:
+ # return 0
+ # elif matrix[row][mid] < target:
+ # begin = mid + 1
+ # else:
+ # end = mid - 1
+ # return 1
+
+
+ def searchMatrix(self, matrix, target):
+ # binary search
+ try:
+ ls_row, ls_col = len(matrix), len(matrix[0])
+ except:
+ return False
+ if target < matrix[0][0] or target > matrix[-1][-1]:
+ return False
+ begin, end = 0, ls_row * ls_col - 1
+ while begin <= end:
+ mid = (begin + end) / 2
+ row, col = mid / ls_col, mid % ls_col
+ if matrix[row][col] == target:
+ return True
+ elif matrix[row][col] > target:
+ end = mid - 1
+ else:
+ begin = mid + 1
+ return False
+
+
diff --git a/python/python/075_Sort_Colors.py b/python/python/075_Sort_Colors.py
new file mode 100644
index 0000000..dcb73e5
--- /dev/null
+++ b/python/python/075_Sort_Colors.py
@@ -0,0 +1,34 @@
+class Solution(object):
+ # def sortColors(self, nums):
+ # """
+ # :type nums: List[int]
+ # :rtype: void Do not return anything, modify nums in-place instead.
+ # """
+ # # simple counting sort
+ # count = [0] * 3
+ # for num in nums:
+ # count[num] += 1
+ # pos = 0
+ # for index in range(3):
+ # while count[index] > 0:
+ # nums[pos] = index
+ # pos += 1
+ # count[index] -= 1
+ # return
+
+ def sortColors(self, nums):
+ # https://leetcode.com/discuss/85658/sharing-c-solution-with-good-explanation
+ low, mid, high = 0, 0, len(nums) - 1
+ while mid <= high:
+ if nums[mid] == 0:
+ # swap low mid
+ nums[low], nums[mid] = nums[mid], nums[low]
+ low += 1
+ mid += 1
+ elif nums[mid] == 1:
+ mid += 1
+ else:
+ # swap mid high
+ nums[high], nums[mid] = nums[mid], nums[high]
+ high -= 1
+ return
diff --git a/python/python/076_Minimum_Window_Substring.py b/python/python/076_Minimum_Window_Substring.py
new file mode 100644
index 0000000..88df545
--- /dev/null
+++ b/python/python/076_Minimum_Window_Substring.py
@@ -0,0 +1,127 @@
+class Solution(object):
+ # def minWindow(self, s, t):
+ # """
+ # :type s: str
+ # :type t: str
+ # :rtype: str
+ # """
+ # letters = set(t)
+ # ls = len(s)
+ #
+ # # find the first substring that works
+ # first_match = self.first_match(s, t)
+ # if not first_match:
+ # return ''
+ # else:
+ # start, end, extra = first_match
+ # min_window = (end - start, start, end)
+ #
+ # # traverse the string and update start and end
+ # while start < end < ls:
+ # discard = s[start]
+ #
+ # # move start on to the next letter
+ # while start < end:
+ # start += 1
+ # if s[start] in letters:
+ # break
+ #
+ # # if discarded letter has extra, no need update end
+ # if discard in extra:
+ # extra[discard] -= 1
+ # if extra[discard] == 0:
+ # extra.pop(discard)
+ # min_window = min(min_window, (end - start, start, end))
+ # continue
+ #
+ # # otherwise move end until it points to the discarded letter
+ # while end < ls:
+ # end += 1
+ # if end == ls:
+ # continue
+ #
+ # letter = s[end]
+ # if letter == discard:
+ # min_window = min(min_window, (end - start, start, end))
+ # break
+ #
+ # if letter in letters:
+ # extra[letter] += 1
+ #
+ # _, start, end = min_window
+ # return s[start: end + 1]
+ #
+ # def first_match(self, s, t):
+ # letters = set(t)
+ # to_find = collections.defaultdict(lambda: 0)
+ # extra = collections.defaultdict(lambda: 0)
+ #
+ # # build hash table
+ # for i in t:
+ # to_find[i] += 1
+ #
+ # # find the start position
+ # for index, letter in enumerate(s):
+ # if letter in to_find:
+ # start = index
+ # break
+ # else:
+ # return False
+ #
+ # # find the end position
+ # for index, letter in enumerate(s[start:], start):
+ # if letter not in letters:
+ # continue
+ # if letter in to_find:
+ # to_find[letter] -= 1
+ # if to_find[letter] == 0:
+ # to_find.pop(letter)
+ # else:
+ # extra[letter] += 1
+ # if not to_find:
+ # end = index
+ # break
+ # else:
+ # return False
+ # return start, end, extra
+ def minWindow(self, s, t):
+ # http://articles.leetcode.com/finding-minimum-window-in-s-which/
+ ls_s, ls_t = len(s), len(t)
+ need_to_find = [0] * 256
+ has_found = [0] * 256
+ min_begin, min_end = 0, -1
+ min_window = 100000000000000
+ for index in range(ls_t):
+ need_to_find[ord(t[index])] += 1
+ count, begin = 0, 0
+ for end in range(ls_s):
+ end_index = ord(s[end])
+ if need_to_find[end_index] == 0:
+ continue
+ has_found[end_index] += 1
+ if has_found[end_index] <= need_to_find[end_index]:
+ count += 1
+ if count == ls_t:
+ begin_index = ord(s[begin])
+ while need_to_find[begin_index] == 0 or\
+ has_found[begin_index] > need_to_find[begin_index]:
+ if has_found[begin_index] > need_to_find[begin_index]:
+ has_found[begin_index] -= 1
+ begin += 1
+ begin_index = ord(s[begin])
+ window_ls = end - begin + 1
+ if window_ls < min_window:
+ min_begin = begin
+ min_end = end
+ min_window = window_ls
+ # print min_begin, min_end
+ if count == ls_t:
+ return s[min_begin: min_end + 1]
+ else:
+ return ''
+
+
+if __name__ == '__main__':
+ s = Solution()
+ print s.minWindow('a', 'a')
+
diff --git a/python/python/077_Combinations.py b/python/python/077_Combinations.py
new file mode 100644
index 0000000..431b51a
--- /dev/null
+++ b/python/python/077_Combinations.py
@@ -0,0 +1,43 @@
+class Solution(object):
+ # def combine(self, n, k):
+ # """
+ # :type n: int
+ # :type k: int
+ # :rtype: List[List[int]]
+ # """
+ # res = []
+ # candidates = range(1, n + 1)
+ # self.get_combine(res, candidates, [], k, 0)
+ # return res
+ #
+ # def get_combine(self, res, candidates, prefix, k, start):
+ # # recursive
+ # if k == 0:
+ # res.append(prefix)
+ # for index in range(start, len(candidates)):
+ # self.get_combine(res, candidates,
+ # prefix + [candidates[index]],
+ # k - 1, index + 1)
+
+ def combine(self, n, k):
+ res = []
+ self.get_combine(res, [], n, k, 1)
+ return res
+
+ def get_combine(self, res, prefix, n, k, start):
+ # recursive with only one array
+ if k == 0:
+ res.append(list(prefix))
+ elif start <= n:
+ prefix.append(start)
+ self.get_combine(res, prefix,
+ n, k - 1, start + 1)
+ prefix.pop()
+ self.get_combine(res, prefix,
+ n, k, start + 1)
+
+
+
+if __name__ == "__main__":
+ s = Solution()
+ print s.combine(4, 2)
\ No newline at end of file
diff --git a/python/python/078_Subsets.py b/python/python/078_Subsets.py
new file mode 100644
index 0000000..9e3dfc0
--- /dev/null
+++ b/python/python/078_Subsets.py
@@ -0,0 +1,58 @@
+class Solution(object):
+ # def subsets(self, nums):
+ # """
+ # :type nums: List[int]
+ # :rtype: List[List[int]]
+ # """
+ # nums.sort()
+ # res = [[]]
+ # res.append(list(nums))
+ # for ls in range(1, len(nums)):
+ # self.get_subsets(res, nums, [], ls, 0)
+ # return res
+ #
+ # def get_subsets(self, res, nums, curr_set, ls, index):
+ # # recursive
+ # if ls == 0:
+ # res.append(list(curr_set))
+ # elif index < len(nums):
+ # curr_set.append(nums[index])
+ # self.get_subsets(res, nums, curr_set, ls - 1, index + 1)
+ # curr_set.pop()
+ # self.get_subsets(res, nums, curr_set, ls, index + 1)
+
+ # def subsets(self, nums):
+ # # https://leetcode.com/discuss/89343/c-8-lines-bit-operation
+ # # doesn't work when len(nums) > 32
+ # nums.sort()
+ # res = []
+ # for i in range(1 << len(nums)):
+ # res.append(self.get_subsets(nums, i))
+ # return res
+ #
+ # def get_subsets(self, nums, magic):
+ # res = []
+ # for i in range(len(nums)):
+ # if (1 << i) & magic != 0:
+ # res.append(nums[i])
+ # return res
+
+ def subsets(self, nums):
+ # Sort and iteratively generate n subset with n-1 subset, O(n^2) and O(2^n)
+ nums.sort()
+ res = [[]]
+ for index in range(len(nums)):
+ size = len(res)
+ # use existing subsets to generate new subsets
+ for j in range(size):
+ curr = list(res[j])
+ curr.append(nums[index])
+ res.append(curr)
+ return res
+
+
+
+
+if __name__ == "__main__":
+ s = Solution()
+ print s.subsets([1,2,3])
diff --git a/python/python/079_Word_Search.py b/python/python/079_Word_Search.py
new file mode 100644
index 0000000..eaac7da
--- /dev/null
+++ b/python/python/079_Word_Search.py
@@ -0,0 +1,39 @@
+class Solution(object):
+ def exist(self, board, word):
+ """
+ :type board: List[List[str]]
+ :type word: str
+ :rtype: bool
+ """
+ check_board = [[True] * len(board[0]) for _ in range(len(board))]
+ for i in range(len(board)):
+ for j in range(len(board[0])):
+ if board[i][j] == word[0] and check_board:
+ check_board[i][j] = False
+ res = self.check_exist(check_board, board, word, 1, len(word), i, j)
+ if res:
+ return True
+ check_board[i][j] = True
+ return False
+
+
+ def check_exist(self, check_board, board, word, index, ls, row, col):
+ if index == ls:
+ return True
+ for temp in [(0, 1),(0, -1),(1, 0),(-1, 0)]:
+ curr_row = row + temp[0]
+ curr_col = col + temp[1]
+ if curr_row >= 0 and curr_row < len(board) and curr_col >= 0 and curr_col < len(board[0]):
+ if check_board[curr_row][curr_col] and board[curr_row][curr_col] == word[index]:
+ check_board[curr_row][curr_col] = False
+ res = self.check_exist(check_board, board, word, index + 1, len(word), curr_row, curr_col)
+ if res:
+ return res
+ check_board[curr_row][curr_col] = True
+ return False
+
+
+
+if __name__ == "__main__":
+ s = Solution()
+ print s.exist(["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","aaaaaaaaaaaaaaaaaaaaaaaaaaaaab"], "baaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
\ No newline at end of file
diff --git a/python/python/080_Remove_Duplicates_from_Sorted_Array_II.py b/python/python/080_Remove_Duplicates_from_Sorted_Array_II.py
new file mode 100644
index 0000000..b54f7ed
--- /dev/null
+++ b/python/python/080_Remove_Duplicates_from_Sorted_Array_II.py
@@ -0,0 +1,29 @@
+class Solution:
+ def removeDuplicates(self, nums):
+ """
+ :type nums: List[int]
+ :rtype: int
+ """
+ if nums is None:
+ return 0
+ length = len(nums)
+ result = 0
+ i = j = 0
+ while i < length:
+ j = i
+ while j < length:
+ if nums[j] != nums[i]:
+ break
+ j += 1
+ if j-i > 2:
+ length -= j-i-2
+ for k in range(j-i-2):
+ del nums[i]
+ result += 2
+ j = i+2
+ else:
+ result += (j-i)
+ i = j
+ return result
+
+
diff --git a/python/python/081_Search_in_Rotated_Sorted_Array_II.py b/python/python/081_Search_in_Rotated_Sorted_Array_II.py
new file mode 100644
index 0000000..b8861c3
--- /dev/null
+++ b/python/python/081_Search_in_Rotated_Sorted_Array_II.py
@@ -0,0 +1,35 @@
+class Solution(object):
+ def search(self, nums, target):
+ """
+ :type nums: List[int]
+ :type target: int
+ :rtype: bool
+ """
+ def get(start, end):
+ if start > end:
+ return False
+ mid = (start + end) / 2
+ # handle duplicate
+ while mid < end and nums[mid + 1] == nums[mid]:
+ mid += 1
+ while start < mid and nums[start + 1] == nums[start]:
+ start += 1
+ if nums[mid] == target:
+ return True
+ elif mid == end:
+ return get(start, mid - 1)
+ elif start == mid:
+ return get(mid + 1, end)
+ elif nums[mid] >= nums[start]:
+ # First half is sorted
+ if target >= nums[start] and target < nums[mid]:
+ return get(start, mid - 1)
+ else:
+ return get(mid + 1, end)
+ elif nums[mid] <= nums[end]:
+ # Second half is sorted
+ if target > nums[mid] and target <= nums[end]:
+ return get(mid + 1, end)
+ else:
+ return get(start, mid - 1)
+ return get(0, len(nums) - 1)
\ No newline at end of file
diff --git a/python/python/083_Remove_Duplicates_from_Sorted_List.py b/python/python/083_Remove_Duplicates_from_Sorted_List.py
new file mode 100644
index 0000000..c64f069
--- /dev/null
+++ b/python/python/083_Remove_Duplicates_from_Sorted_List.py
@@ -0,0 +1,37 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+class Solution(object):
+ # def deleteDuplicates(self, head):
+ # """
+ # :type head: ListNode
+ # :rtype: ListNode
+ # """
+ # if head is None:
+ # return None
+ # temp = ListNode(2147483647)
+ # temp.next = head
+ # pos = head
+ # head = temp
+ # last = head
+ # while pos is not None:
+ # if last.val == pos.val:
+ # last.next = pos.next
+ # else:
+ # last = pos
+ # pos = pos.next
+ # return head.next
+
+ def deleteDuplicates(self, head):
+ if head is None:
+ return None
+ pos = head
+ while pos is not None and pos.next is not None:
+ if pos.val == pos.next.val:
+ pos.next = pos.next.next
+ else:
+ pos = pos.next
+ return head
diff --git a/python/python/084_Largest_Rectangle_in_Histogram.py b/python/python/084_Largest_Rectangle_in_Histogram.py
new file mode 100644
index 0000000..3732ea9
--- /dev/null
+++ b/python/python/084_Largest_Rectangle_in_Histogram.py
@@ -0,0 +1,29 @@
+class Solution(object):
+ def largestRectangleArea(self, heights):
+ """
+ :type heights: List[int]
+ :rtype: int
+ """
+ # https://leetcode.com/discuss/70983/4ms-java-solution-using-o-n-stack-space-o-n-time
+ largest_rectangle = 0
+ ls = len(heights)
+ # heights[stack[top]] > heights[pos] > heights[stack[top - 1]]
+ # keep the increase order
+ stack = [-1]
+ top, pos = 0, 0
+ for pos in range(ls):
+ while top > 0 and heights[stack[top]] > heights[pos]:
+ largest_rectangle = max(largest_rectangle, heights[stack[top]] * (pos - stack[top - 1] - 1))
+ top -= 1
+ stack.pop()
+ stack.append(pos)
+ top += 1
+ while top > 0:
+ largest_rectangle = max(largest_rectangle, heights[stack[top]] * (ls - stack[top - 1] - 1))
+ top -= 1
+ return largest_rectangle
+
+
+if __name__ == "__main__":
+ s = Solution()
+ print s.largestRectangleArea([2,1,5,6,2,3])
diff --git a/python/python/085_Maximal_Rectangle.py b/python/python/085_Maximal_Rectangle.py
new file mode 100644
index 0000000..90b1845
--- /dev/null
+++ b/python/python/085_Maximal_Rectangle.py
@@ -0,0 +1,35 @@
+class Solution(object):
+ def maximalRectangle(self, matrix):
+ """
+ :type matrix: List[List[str]]
+ :rtype: int
+ """
+ # https://discuss.leetcode.com/topic/6650/share-my-dp-solution/2
+ if matrix is None or len(matrix) == 0:
+ return 0
+ ls_row, ls_col = len(matrix), len(matrix[0])
+ left, right, height = [0] * ls_col, [ls_col] * ls_col, [0] * ls_col
+ maxA = 0
+ for i in range(ls_row):
+ curr_left, curr_right = 0, ls_col
+ for j in range(ls_col):
+ if matrix[i][j] == '1':
+ height[j] += 1
+ else:
+ height[j] = 0
+ for j in range(ls_col):
+ if matrix[i][j] == '1':
+ left[j] = max(left[j], curr_left)
+ else:
+ left[j], curr_left = 0, j + 1
+ for j in range(ls_col - 1, -1, -1):
+ if matrix[i][j] == '1':
+ right[j] = min(right[j], curr_right)
+ else:
+ right[j], curr_right = ls_col, j
+ for j in range(ls_col):
+ maxA = max(maxA, (right[j] - left[j]) * height[j])
+ return maxA
+
+
+
diff --git a/python/python/086_Partition_List.py b/python/python/086_Partition_List.py
new file mode 100644
index 0000000..6d93341
--- /dev/null
+++ b/python/python/086_Partition_List.py
@@ -0,0 +1,36 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+class Solution(object):
+ def partition(self, head, x):
+ """
+ :type head: ListNode
+ :type x: int
+ :rtype: ListNode
+ """
+ if head is None:
+ return None
+ less = lesshead = None
+ last = pos = head
+ while pos is not None:
+ if pos.val < x:
+ if lesshead is None:
+ lesshead = pos
+ else:
+ less.next = pos
+ less = pos
+ if head == pos:
+ last = head = pos.next
+ else:
+ last.next = pos.next
+ else:
+ last = pos
+ pos = pos.next
+ if lesshead is not None:
+ less.next = head
+ else:
+ lesshead = head
+ return lesshead
\ No newline at end of file
diff --git a/python/python/087_Scramble_String.py b/python/python/087_Scramble_String.py
new file mode 100644
index 0000000..238beed
--- /dev/null
+++ b/python/python/087_Scramble_String.py
@@ -0,0 +1,81 @@
+class Solution(object):
+ #https://discuss.leetcode.com/topic/20094/my-c-solutions-recursion-with-cache-dp-recursion-with-cache-and-pruning-with-explanation-4ms/2
+ # def isScramble(self, s1, s2):
+ # """
+ # :type s1: str
+ # :type s2: str
+ # :rtype: bool
+ # """
+ # # recursive
+ # if s1 == s2:
+ # return True
+ # if len(s1) != len(s2):
+ # return False
+ # ls = len(s1)
+ # letters = [0] * 26
+ # for i in range(ls):
+ # letters[ord(s1[i]) - ord('a')] += 1
+ # letters[ord(s2[i]) - ord('a')] -= 1
+ # for i in range(26):
+ # if letters[i] != 0:
+ # return False
+ # for i in range(1, ls):
+ # if self.isScramble(s1[0:i], s2[0:i]) and self.isScramble(s1[i:], s2[i:]):
+ # return True
+ # if self.isScramble(s1[0:i], s2[ls - i:]) and self.isScramble(s1[i:], s2[:ls - i]):
+ # return True
+ # return False
+
+ def isScramble(self, s1, s2, memo={}):
+ # recursive with memo
+ # Check with sorted is fundamental, otherwise TLE
+ if len(s1) != len(s2) or sorted(s1) != sorted(s2):
+ return False
+ if len(s1) <= len(s2) <= 1:
+ return s1 == s2
+ if s1 == s2:
+ return True
+ if (s1, s2) in memo:
+ return memo[s1, s2]
+ n = len(s1)
+ for i in range(1, n):
+ a = self.isScramble(s1[:i], s2[:i], memo) and self.isScramble(s1[i:], s2[i:], memo)
+ if not a:
+ b = self.isScramble(s1[:i], s2[-i:], memo) and self.isScramble(s1[i:], s2[:-i], memo)
+ if a or b:
+ memo[s1, s2] = True
+ return True
+ memo[s1, s2] = False
+ return False
+
+ # def isScramble(self, s1, s2):
+ # # dp TLE
+ # if s1 == s2:
+ # return True
+ # if len(s1) != len(s2):
+ # return False
+ # ls = len(s1)
+ # letters = [0] * 26
+ # for i in range(ls):
+ # letters[ord(s1[i]) - ord('a')] += 1
+ # letters[ord(s2[i]) - ord('a')] -= 1
+ # for i in range(26):
+ # if letters[i] != 0:
+ # return False
+ # dp = [[[False] * ls for i in range(ls)] for i in range(ls + 1)]
+ # for i in range(ls):
+ # for j in range(ls):
+ # dp[1][i][j] = (s1[i] == s2[j])
+ #
+ # for cur_len in range(2, ls + 1):
+ # for i in range(ls - cur_len + 1):
+ # for j in range(ls - cur_len + 1):
+ # dp[cur_len][i][j] = False
+ # for k in range(1, cur_len):
+ # if dp[cur_len][i][j]:
+ # break
+ # dp[cur_len][i][j] = dp[cur_len][i][j] or (dp[k][i][j] and dp[cur_len - k][i + k][j + k])
+ # dp[cur_len][i][j] = dp[cur_len][i][j] or (dp[k][i + cur_len - k][j] and dp[cur_len - k][i][j + k])
+ # return dp[ls][0][0]
+
+
diff --git a/python/python/088_Merge_Sorted_Array.py b/python/python/088_Merge_Sorted_Array.py
new file mode 100644
index 0000000..3d650df
--- /dev/null
+++ b/python/python/088_Merge_Sorted_Array.py
@@ -0,0 +1,38 @@
+class Solution(object):
+ def merge(self, nums1, m, nums2, n):
+ """
+ :type nums1: List[int]
+ :type m: int
+ :type nums2: List[int]
+ :type n: int
+ :rtype: void Do not return anything, modify nums1 in-place instead.
+ """
+ p1, p2 = m - 1, n - 1
+ pos = m + n - 1
+ while p1 >= 0 and p2 >= 0:
+ if nums1[p1] >= nums2[p2]:
+ nums1[pos] = nums1[p1]
+ p1 -= 1
+ else:
+ nums1[pos] = nums2[p2]
+ p2 -= 1
+ pos -= 1
+ while p2 >= 0:
+ nums1[pos] = nums2[p2]
+ p2 -= 1
+ pos -= 1
+
+ # def merge(self, nums1, m, nums2, n):
+ # # using slicing
+ # i, j, k = m - 1, n - 1, m + n - 1
+ # while i >= 0 and j >= 0:
+ # if nums1[i] > nums2[j]:
+ # nums1[k] = nums1[i]
+ # i -= 1
+ # else:
+ # nums1[k] = nums2[j]
+ # j -= 1
+ # k -= 1
+ #
+ # if j >= 0:
+ # nums1[:k + 1] = nums2[:j + 1]
\ No newline at end of file
diff --git a/python/python/089_Gray_Code.py b/python/python/089_Gray_Code.py
new file mode 100644
index 0000000..09cff79
--- /dev/null
+++ b/python/python/089_Gray_Code.py
@@ -0,0 +1,25 @@
+class Solution(object):
+ def grayCode(self, n):
+ """
+ :type n: int
+ :rtype: List[int]
+ """
+ # https://leetcode.com/discuss/86617/6-line-java-solution-very-concise
+ res = [0]
+ for i in range(n):
+ for j in reversed(range(len(res))):
+ res.append(res[j] + (1 << i))
+ return res
+
+
+ # def count_one(self, num):
+ # count = 0
+ # while num:
+ # num &= (num - 1)
+ # count += 1
+ # return count
+
+if __name__ == "__main__":
+ s = Solution()
+ print s.grayCode(2)
+
diff --git a/python/python/090_Subsets_II.py b/python/python/090_Subsets_II.py
new file mode 100644
index 0000000..520727c
--- /dev/null
+++ b/python/python/090_Subsets_II.py
@@ -0,0 +1,44 @@
+class Solution(object):
+ # def subsetsWithDup(self, nums):
+ # """
+ # :type nums: List[int]
+ # :rtype: List[List[int]]
+ # """
+ # nums.sort()
+ # res = []
+ # for i in range(1 << len(nums)):
+ # res.append(self.get_subsets(nums, i))
+ # # remove duplicate
+ # final_res = {}
+ # for subset in res:
+ # hash_key = ''.join([str(t) for t in subset])
+ # try:
+ # final_res[hash_key]
+ # except:
+ # final_res[hash_key] = subset
+ # return final_res.values()
+ #
+ # def get_subsets(self, nums, magic):
+ # res = []
+ # for i in range(len(nums)):
+ # if (1 << i) & magic != 0:
+ # res.append(nums[i])
+ # return res
+
+ def subsetsWithDup(self, nums):
+ nums.sort()
+ res = [[]]
+ begin = 0
+ for index in range(len(nums)):
+ if index == 0 or nums[index] != nums[index - 1]:
+ # generate all
+ begin = 0
+ size = len(res)
+ # use existing subsets to generate new subsets
+ for j in range(begin, size):
+ curr = list(res[j])
+ curr.append(nums[index])
+ res.append(curr)
+ # avoid duplicate subsets
+ begin = size
+ return res
diff --git a/python/python/091_Decode_Ways.py b/python/python/091_Decode_Ways.py
new file mode 100644
index 0000000..d1515dc
--- /dev/null
+++ b/python/python/091_Decode_Ways.py
@@ -0,0 +1,24 @@
+class Solution(object):
+ def numDecodings(self, s):
+ """
+ :type s: str
+ :rtype: int
+ """
+ ls = len(s)
+ if ls == 0:
+ return 0
+ dp = [0] * ls
+ for index in range(ls):
+ if index >= 1 and int(s[index - 1:index + 1]) < 27 and int(s[index - 1:index + 1]) >= 10:
+ if index == 1:
+ dp[index] = 1
+ else:
+ # 11-26
+ dp[index] += dp[index - 2]
+ if int(s[index]) != 0:
+ if index == 0:
+ dp[index] = 1
+ else:
+ # 1-9
+ dp[index] += dp[index - 1]
+ return dp[ls - 1]
diff --git a/python/python/092_Reverse_Linked_Lis_ II.py b/python/python/092_Reverse_Linked_Lis_ II.py
new file mode 100644
index 0000000..f66d929
--- /dev/null
+++ b/python/python/092_Reverse_Linked_Lis_ II.py
@@ -0,0 +1,40 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.next = None
+
+class Solution(object):
+ def reverseBetween(self, head, m, n):
+ """
+ :type head: ListNode
+ :type m: int
+ :type n: int
+ :rtype: ListNode
+ """
+ if m == n:
+ return head
+ split_node, prev, curr = None, None, head
+ count = 1
+ while count <= m and curr is not None:
+ if count == m:
+ split_node = prev
+ prev = curr
+ curr = curr.next
+ count += 1
+ tail, next_node = prev, None
+ while curr is not None and count <= n:
+ next_temp = curr.next
+ curr.next = prev
+ prev = curr
+ curr = next_temp
+ count += 1
+ if split_node is not None:
+ split_node.next = prev
+ if tail is not None:
+ tail.next = curr
+ if m == 1:
+ return prev
+ return head
+
+
\ No newline at end of file
diff --git a/python/python/093_Restore_IP_Addresses.py b/python/python/093_Restore_IP_Addresses.py
new file mode 100644
index 0000000..d6434b0
--- /dev/null
+++ b/python/python/093_Restore_IP_Addresses.py
@@ -0,0 +1,71 @@
+class Solution(object):
+ # def restoreIpAddresses(self, s):
+ # """
+ # :type s: str
+ # :rtype: List[str]
+ # """
+ # ls = len(s)
+ # if ls == 0 or ls > 12:
+ # return []
+ # if s == '0000':
+ # return ['0.0.0.0']
+ # return self.getremainIP(s, 0, 4)
+ #
+ # def getremainIP(self, s, pos, count):
+ # if count == 1:
+ # curr = s[pos:]
+ # if self.isNum(curr):
+ # return [curr]
+ # result = []
+ # for i in range(pos, pos + 3):
+ # if i + 1 < len(s):
+ # prefix = s[pos:i + 1]
+ # if self.isNum(prefix):
+ # res = self.getremainIP(s, i + 1, count - 1)
+ # result.extend([prefix + '.' + t for t in res])
+ # return result
+ #
+ # def isNum(self, prefix):
+ # curr = int(prefix)
+ # if curr > 255:
+ # return False
+ # if len(prefix) == 1:
+ # return True
+ # if prefix[0] == '0':
+ # return False
+ # return True
+
+ def restoreIpAddresses(self, s):
+ ls = len(s)
+ if ls == 0 or ls > 12:
+ return []
+ res = []
+ for i in range(1, 4):
+ for j in range(1, 4):
+ for k in range(1, 4):
+ m = ls - i - j - k
+ if m > 0 and m <= 3:
+ add1 = s[0:i]
+ add2 = s[i:i + j]
+ add3 = s[i + j:i + j + k]
+ add4 = s[i + j + k:]
+ if self.isValid(add1) and self.isValid(add2) and \
+ self.isValid(add3) and self.isValid(add4):
+ res.append(add1 + '.' + add2 + '.' + add3 + '.' + add4)
+ return res
+
+ def isValid(self, add):
+ if len(add) == 1:
+ return True
+ if add[0] == '0':
+ return False
+ if int(add) <= 255:
+ return True
+ return False
+
+
+if __name__ == '__main__':
+ s = Solution()
+ # print s.longestValidParentheses(")(((((()())()()))()(()))(")
+ print s.restoreIpAddresses('25525511135')
+
diff --git a/python/python/094_Binary_Tree_Inorder_Traversal.py b/python/python/094_Binary_Tree_Inorder_Traversal.py
new file mode 100644
index 0000000..08c3aa8
--- /dev/null
+++ b/python/python/094_Binary_Tree_Inorder_Traversal.py
@@ -0,0 +1,79 @@
+# 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 inorderTraversal(self, root):
+ # """
+ # :type root: TreeNode
+ # :rtype: List[int]
+ # """
+ # # recursively
+ # res = []
+ # self.do_inorderTraversal(res, root)
+ # return res
+ #
+ # def do_inorderTraversal(self, res, curr):
+ # if curr is None:
+ # return
+ # if curr.left is not None:
+ # self.do_inorderTraversal(res, curr.left)
+ # res.append(curr.val)
+ # if curr.right is not None:
+ # self.do_inorderTraversal(res, curr.right)
+
+ # def inorderTraversal(self, root):
+ # # iteratively, but break the tree
+ # res = []
+ # if root is None:
+ # return res
+ # queue = [root]
+ # while len(queue) > 0:
+ # curr = queue.pop(0)
+ # if curr.left is None and curr.right is None:
+ # res.append(curr.val)
+ # else:
+ # if curr.right is not None:
+ # queue.insert(0, curr.right)
+ # curr.right = None
+ # queue.insert(0, curr)
+ # if curr.left is not None:
+ # queue.insert(0, curr.left)
+ # curr.left = None
+ # return res
+ # def inorderTraversal(self, root):
+ # res = []
+ # stack = []
+ # while root is not None:
+ # stack.append(root)
+ # root = root.left
+ # while root is None:
+ # if len(stack) == 0:
+ # return res
+ # root = stack.pop()
+ # res.append(root.val)
+ # root = root.right
+ # return res
+
+ def inorderTraversal(self, root):
+ if root is None:
+ return []
+ res = []
+ stack = [root]
+ while len(stack) > 0:
+ curr = stack.pop()
+ if not isinstance(curr, TreeNode):
+ res.append(curr)
+ continue
+ if curr.right is not None:
+ stack.append(curr.right)
+ stack.append(curr.val)
+ if curr.left is not None:
+ stack.append(curr.left)
+ return res
+
+
+
diff --git a/python/python/095_Unique_Binary_Search_Trees_II.py b/python/python/095_Unique_Binary_Search_Trees_II.py
new file mode 100644
index 0000000..f27667f
--- /dev/null
+++ b/python/python/095_Unique_Binary_Search_Trees_II.py
@@ -0,0 +1,36 @@
+# 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 generateTrees(self, n):
+ """
+ :type n: int
+ :rtype: List[TreeNode]
+ """
+ if n == 0:
+ return []
+ return self.get_trees(1, n)
+
+ def get_trees(self, start, end):
+ # recursive solve this problem
+ res = []
+ if start > end:
+ res.append(None)
+ return res
+ for i in range(start, end + 1):
+ lefts = self.get_trees(start, i - 1)
+ rights = self.get_trees(i + 1, end)
+ for j in range(len(lefts)):
+ for k in range(len(rights)):
+ # root point
+ root = TreeNode(i)
+ root.left = lefts[j]
+ root.right = rights[k]
+ res.append(root)
+ return res
+
+
diff --git a/python/python/096_Unique_Binary_Search_Trees.py b/python/python/096_Unique_Binary_Search_Trees.py
new file mode 100644
index 0000000..1d288ce
--- /dev/null
+++ b/python/python/096_Unique_Binary_Search_Trees.py
@@ -0,0 +1,14 @@
+class Solution(object):
+ def numTrees(self, n):
+ """
+ :type n: int
+ :rtype: int
+ """
+ # https://leetcode.com/discuss/86650/fantastic-clean-java-dp-solution-with-detail-explaination
+ dp = [0] * (n + 1)
+ dp[0] = 1
+ dp[1] = 1
+ for level in range(2, n + 1):
+ for root in range(1, level + 1):
+ dp[level] += dp[level - root] * dp[root - 1]
+ return dp[n]
\ No newline at end of file
diff --git a/python/python/097_Interleaving_String.py b/python/python/097_Interleaving_String.py
new file mode 100644
index 0000000..75070ba
--- /dev/null
+++ b/python/python/097_Interleaving_String.py
@@ -0,0 +1,32 @@
+class Solution(object):
+ def isInterleave(self, s1, s2, s3):
+ """
+ :type s1: str
+ :type s2: str
+ :type s3: str
+ :rtype: bool
+ """
+ if len(s1) + len(s2) != len(s3):
+ return False
+ queue = [(0, 0), (-1, -1)]
+ visited = set()
+ isSuccess = False
+ index = 0
+ while len(queue) != 1 or queue[0][0] != -1:
+ p = queue.pop(0)
+ if p[0] == len(s1) and p[1] == len(s2):
+ return True
+ if p[0] == -1:
+ queue.append(p)
+ index += 1
+ continue
+ if p in visited:
+ continue
+ visited.add(p)
+ if p[0] < len(s1):
+ if s1[p[0]] == s3[index]:
+ queue.append((p[0] + 1, p[1]))
+ if p[1] < len(s2):
+ if s2[p[1]] == s3[index]:
+ queue.append((p[0], p[1] + 1))
+ return False
diff --git a/python/python/098_Validate_Binary_Search_Tree.py b/python/python/098_Validate_Binary_Search_Tree.py
new file mode 100644
index 0000000..bdb1777
--- /dev/null
+++ b/python/python/098_Validate_Binary_Search_Tree.py
@@ -0,0 +1,40 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+# def __init__(self, x):
+# self.val = x
+# self.left = None
+# self.right = None
+import sys
+class Solution(object):
+ # def isValidBST(self, root):
+ # """
+ # :type root: TreeNode
+ # :rtype: bool
+ # """
+ # if root is None:
+ # return True
+ # order_list = self.getOrder(root)
+ # length = len(order_list)
+ # for i in range(length):
+ # if (i + 1) < length and order_list[i + 1] <= order_list[i]:
+ # return False
+ # return True
+ #
+ # def getOrder(self, node):
+ # result = []
+ # if node is None:
+ # return result
+ # result.extend(self.getOrder(node.left))
+ # result.append(node.val)
+ # result.extend(self.getOrder(node.right))
+ # return result
+
+ def isValidBST(self, root):
+ return self.isVaild_helper(root, -sys.maxint - 1, sys.maxint)
+
+ def isVaild_helper(self, root, minVal, maxVal):
+ if root is None:
+ return True
+ if root.val >= maxVal or root.val <= minVal:
+ return False
+ return self.isVaild_helper(root.left, minVal, root.val) and self.isVaild_helper(root.right, root.val, maxVal)
diff --git a/python/python/099_Recover_Binary_Search_Tree.py b/python/python/099_Recover_Binary_Search_Tree.py
new file mode 100644
index 0000000..2ebef9e
--- /dev/null
+++ b/python/python/099_Recover_Binary_Search_Tree.py
@@ -0,0 +1,67 @@
+# 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 recoverTree(self, root):
+ # """
+ # :type root: TreeNode
+ # :rtype: void Do not return anything, modify root in-place instead.
+ # """
+ # # https://discuss.leetcode.com/topic/9305/detail-explain-about-how-morris-traversal-finds-two-incorrect-pointer/2
+ # pre = first = second = None
+ # while root is not None:
+ # if root.left is not None:
+ # temp = root.left
+ # while temp.right is not None and temp.right != root:
+ # temp = temp.right
+ # if temp.right is not None:
+ # if pre is not None and pre.val > root.val:
+ # if first is None:
+ # first = pre
+ # second = root
+ # pre = root
+ # temp.right = None
+ # root = root.right
+ # else:
+ # temp.right = root
+ # root = root.left
+ # else:
+ # if pre is not None and pre.val > root.val:
+ # if first is None:
+ # first = pre
+ # second = root
+ # pre = root
+ # root = root.right
+ # # only two elements are swapped
+ # if first is not None and second is not None:
+ # first.val, second.val = second.val, first.val
+
+
+ # https://discuss.leetcode.com/topic/3988/no-fancy-algorithm-just-simple-and-powerful-in-order-traversal/2
+ def __init__(self):
+ self.first = self.second = None
+ self.pre = TreeNode(-sys.maxint - 1)
+
+
+ def recoverTree(self, root):
+ self.traverse(root)
+ self.first.val, self.second.val = self.second.val, self.first.val
+
+ def traverse(self, root):
+ if root is None:
+ return
+ self.traverse(root.left)
+ if self.pre.val >= root.val:
+ if self.first is None:
+ self.first = self.pre
+ if self.first is not None:
+ self.second = root
+ self.pre = root
+ self.traverse(root.right)
+
+
+
diff --git a/python/python/100_Same_Tree.py b/python/python/100_Same_Tree.py
new file mode 100644
index 0000000..a8d0d39
--- /dev/null
+++ b/python/python/100_Same_Tree.py
@@ -0,0 +1,25 @@
+# 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
+ """
+ if p == q:
+ return True
+ try:
+ left = right = True
+ if p.val == q.val:
+ left = self.isSameTree(p.left, q.left)
+ right = self.isSameTree(p.right, q.right)
+ return (left and right)
+ except:
+ return False
+ return False
\ No newline at end of file
From 452ae9c101f5315d26aa8bcd1d9a7b70f504ed06 Mon Sep 17 00:00:00 2001
From: Vaishnvee Shinde <65480790+Vaishnvee-Shinde@users.noreply.github.com>
Date: Mon, 17 Oct 2022 16:51:47 +0530
Subject: [PATCH 2/3] Updated Participants.md file
---
PARTICIPANTS.md | 11 +++++++++++
1 file changed, 11 insertions(+)
diff --git a/PARTICIPANTS.md b/PARTICIPANTS.md
index 5a2e2f4..6e964ee 100644
--- a/PARTICIPANTS.md
+++ b/PARTICIPANTS.md
@@ -141,4 +141,15 @@
- š« Reach me: **rajpiyush100@gmail.com**
- š Connect with me: **[Piyushjar](https://github.com/piyushjar))**
+---
+
+ ### Connect with me:
+
+
+
+- šØāš» My name is **Vaishnvee Shinde**
+- š± Iām a Full Stack Developer Developer.
+- š« Reach me: **vaishnvee.s.shinde@gmail.com**
+- š Connect with me: **[Piyushjar](https://github.com/Vaishnvee-Shinde))**
+
---
From 365b5ef398e78431e7033ed406c799bff799024f Mon Sep 17 00:00:00 2001
From: Vaishnvee Shinde <65480790+Vaishnvee-Shinde@users.noreply.github.com>
Date: Mon, 17 Oct 2022 16:56:18 +0530
Subject: [PATCH 3/3] Added information in PARTICIPANTS.md file
---
PARTICIPANTS.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/PARTICIPANTS.md b/PARTICIPANTS.md
index 6e964ee..c1f14c9 100644
--- a/PARTICIPANTS.md
+++ b/PARTICIPANTS.md
@@ -145,7 +145,7 @@
### Connect with me:
-
+
- šØāš» My name is **Vaishnvee Shinde**
- š± Iām a Full Stack Developer Developer.