initial commit

Author: chris

add-binary.py

@@ -0,0 +1,4 @@
+#https://leetcode.com/problems/add-binary/
+class Solution(object):
+    def addBinary(self, a, b):
+        return bin(int(a, 2)+int(b, 2))[2:]

add-digits.py

@@ -0,0 +1,11 @@
+#https://leetcode.com/problems/add-digits/
+class Solution(object):
+    def addDigits(self, num):
+        if num==0: return 0
+        
+        while len(str(num))>1:
+            counter = 0
+            for i in str(num):
+                counter+=int(i)
+            num = counter
+        return num

backspace-string-compare.py

@@ -0,0 +1,41 @@
+#https://leetcode.com/problems/backspace-string-compare/
+class Solution:
+    #Compare from backward. Because we need to count the hashtags first.
+    #Compare the char that are not canceled by the hashtags, letter by letter.
+    #So we don't have to convert the whole string if they are not the same.
+    #Return Fasle, as soon as we find out that they are not the same.
+    
+    def backspaceCompare(self, S1, S2):
+		#index compared so far
+        i = len(S1)-1
+        j = len(S2)-1
+		
+        while i>=0 or j>=0:
+			#the first char that are not canceled by the hashtags
+            c1 = ''
+            c2 = ''
+            
+            if i>=0:
+                c1, i = self.getChar(S1, i)
+            if j>=0:
+                c2, j = self.getChar(S2, j)
+            if c1!=c2:
+                return False
+        return True
+    
+    def getChar(self, s, i):
+		#return the first character that are not canceled by the hashtag
+		#return inedx compared so far so we don't have to do that again
+        c = ''
+        hashtag = 0
+        
+        while i>=0 and c=='':
+            char = s[i]
+            if char=='#':
+                hashtag+=1
+            elif hashtag==0:
+                c = char
+            else:
+                hashtag-=1
+            i-=1
+        return c, i

best-time-to-buy-an-stock.py

@@ -0,0 +1,14 @@
+#https://leetcode.com/problems/best-time-to-buy-and-sell-stock/
+class Solution(object):
+    def maxProfit(self, prices):
+        if (len(prices)==0):
+            return 0
+        
+        minPrice = prices[0]
+        maxProfit = 0
+        for price in prices:
+            if (price<minPrice):
+                minPrice = price
+            if (price-minPrice>maxProfit):
+                maxProfit = price-minPrice
+        return maxProfit

big-countries.sql

@@ -0,0 +1,2 @@
+-- https://leetcode.com/problems/big-countries/
+select name, population, area from World where area>3000000 or population>25000000

climbing-stairs.py

@@ -0,0 +1,46 @@
+#https://leetcode.com/problems/climbing-stairs/
+class Solution(object):
+    #if there are 13 stairs
+    #the max two steps are 6, so there can be 
+    #6 two step, 1 one step -> case1
+    #5 two step, 3 one step -> case2
+    # ...
+    #0 two step, 13 one step -> case7
+    
+    #each case may have more than one way to arrange
+    #take case2 as example, 22222111. how many combination can it be?
+    #you can think this as, there are 8 seats you have to choose 3 seats for number 1 to sit on it.
+    
+    #we call this combination m choose n, thus
+    #case1 is combination 7 choose 1
+    #case2 is combination 8 choose 3
+    # ...
+    #case7 is combination 13 choose 13
+    #the calculation of combination is m!/(n!*(m-n)!)
+    #https://en.wikipedia.org/wiki/Combination
+    
+    #Efficaiency is O(N), N is the stairs count.
+    #Space is O(1)
+    
+    def climbStairs(self, n):
+        counter = 0
+        max_two_step = n/2
+        for two_step in range(max_two_step+1):
+            one_step = n-two_step*2
+            combination = self.combination(two_step+one_step, one_step)
+            counter+=combination
+        return counter
+            
+            
+    #combination m choose n
+    def combination(self, m, n):
+        def factorial(int_num):
+            if int_num<0: return None
+            if int_num==0: return 1
+            counter = 1
+            while int_num>=1:
+                counter*=int_num
+                int_num-=1
+            return counter
+        
+        return factorial(m)/(factorial(n)*factorial(m-n))

combine-two-tables.sql

@@ -0,0 +1,4 @@
+-- https://leetcode.com/problems/combine-two-tables/
+select FirstName, LastName, City, State 
+from Person left join Address
+on Person.PersonId = Address.PersonId

convert-binary-search-tree-to-sorted-doubly-linked-list.py

@@ -0,0 +1,46 @@
+#https://leetcode.com/problems/convert-binary-search-tree-to-sorted-doubly-linked-list/
+class Solution(object):
+    def treeToDoublyList(self, root):
+        
+        #the helper gets you an sorted double link list that originally start at node
+        #if you put a node's left to the helper, it will need to return the right most node of the sorted link list
+        #if you put a node's right to the helper, it will need to return the left most node of the sorted link list
+        #so we use hook_left to control returning right most or left most
+        def helper(node, hook_left=True):
+            if node is None: return None
+            node.left = helper(node.left)
+            node.right = helper(node.right, False)
+            
+            if node.left:
+                node.left.right = node
+            if node.right:
+                node.right.left = node
+                
+            if hook_left:
+                while node.right:
+                    node = node.right
+            else:
+                while node.left:
+                    node = node.left
+                    
+            return node
+        
+        
+        if root is None: return None
+        
+        #get the right most before sorted(the right most is still right most after sorted)
+        #we need this to link the left most after sorting
+		#we do this before sorting because, it is faster to find the right most in the tree
+        right_most = root
+        while right_most.right:
+            right_most = right_most.right
+        
+        #get the sorted double link list that originally start at root
+        #set hook_left to False, so it will return the left most (head)
+        root = helper(root, False)
+        
+        #linked two end together
+        root.left = right_most
+        right_most.right = root
+        
+        return root

diameter-of-binary-tree.py

@@ -0,0 +1,27 @@
+#https://leetcode.com/problems/diameter-of-binary-tree/
+#what we want to find?
+#max depth that goes right add max depth that goes left
+#it could be from any node
+#so we iterate through every node to update our the diameter to max
+
+class Solution(object):
+    def diameterOfBinaryTree(self, root):
+        self.diameter = 0
+        
+        def traverse(node):
+            if not node: return 0
+            
+            #the max depth go left from this node
+            #the max depth go right from this node
+            left, right = traverse(node.left), traverse(node.right)
+            
+            #update diameter if left+right is bigger
+            self.diameter = max(self.diameter, left+right)
+            
+            #add 1 is for the step that get to this node
+            #max(left, right) is for the left or right path that goes to the deepest
+            return max(left, right)+1
+        
+        #iterate through the tree
+        traverse(root)
+        return self.diameter

first-unique-character-in-a-string.py

@@ -0,0 +1,17 @@
+#https://leetcode.com/problems/first-unique-character-in-a-string/
+class Solution(object):
+    def firstUniqChar(self, string):
+        counter = {}
+        
+        for char in string:
+            if char in counter:
+                counter[char]+=1
+            else:
+                counter[char] = 1
+            
+        for i in range(len(string)):
+            char = string[i]
+            if counter[char]==1:
+                return i
+            
+        return -1

fizz-buzz.py

@@ -0,0 +1,16 @@
+#https://leetcode.com/problems/fizz-buzz/
+class Solution(object):
+    def fizzBuzz(self, n):
+        nums = []
+        for num in range(1, n+1):
+            
+            if num%3==0 and num%5==0:
+                nums.append('FizzBuzz')
+            elif num%3==0:
+                nums.append('Fizz')
+            elif num%5==0:
+                nums.append('Buzz')
+            else:
+                nums.append(str(num))
+
+        return nums

group-anagrams.py

@@ -0,0 +1,14 @@
+#https://leetcode.com/problems/group-anagrams/
+class Solution(object):
+    def groupAnagrams(self, strs):
+        dic = collections.defaultdict(list)
+        
+        for string in strs:
+            string_count = [0]*26
+            a = ord('a')
+            for char in string:
+                string_count[ord(char)-a] += 1
+                
+            dic[tuple(string_count)].append(string)
+        
+        return dic.values()

intersection-of-two-arrays.py

@@ -0,0 +1,22 @@
+#https://leetcode.com/problems/intersection-of-two-arrays/
+class Solution(object):
+    #put nums1 to d1'keys, so even if it is repeated, it won't matter
+    #if nums2 is d1's keys, put it to nums2'keys
+    #the point of using keys to store numbers is to avoid repetition
+    def intersection(self, nums1, nums2):
+        d1 = {}
+        d2 = {}
+        for n1 in nums1:
+            d1[n1] = 0
+        
+        for n2 in nums2:
+            if n2 in d1:
+                d2[n2] = 0
+        
+        return d2.keys()
+    
+    #a more elegant way to solve this is to use SET
+    #element in set is not repeated
+    #set has some convenient build-in operator
+    def intersection(self, nums1, nums2):
+        return list(set(nums1) & set(nums2))

jewels-and-stones.py

@@ -0,0 +1,7 @@
+#https://leetcode.com/problems/jewels-and-stones/
+class Solution(object):
+    def numJewelsInStones(self, J, S):
+        n=0
+        for j in J:
+            n+=S.count(j)
+        return n

license-key-formatting.py

@@ -0,0 +1,20 @@
+#https://leetcode.com/problems/license-key-formatting/
+class Solution(object):
+    def licenseKeyFormatting(self, S, K):
+        r = ''
+        s = S.replace('-', '').upper()
+        
+        #cut first part of string
+        remainder = len(s)%K
+        if remainder!=0:
+            r = s[:remainder]+'-'
+            s = s[remainder:]
+        
+        while len(s)>0:
+            r += s[:K]+'-'
+            s = s[K:]
+        
+        #remove last '-'
+        r = r[:-1]
+        
+        return r

linked-list-cycle.py

@@ -0,0 +1,11 @@
+#https://leetcode.com/problems/linked-list-cycle/
+class Solution(object):
+    def hasCycle(self, head):
+        fast = head
+        slow = head
+        while fast and fast.next:
+            fast = fast.next.next
+            slow = slow.next
+            if (fast==slow):
+                return True
+        return False

longest-common-prefix.py

@@ -0,0 +1,17 @@
+#https://leetcode.com/problems/longest-common-prefix/
+class Solution(object):
+    def longestCommonPrefix(self, strs):
+        if len(strs)==0 or strs==None:
+            return ''
+        
+        bench_mark = strs[0]
+        
+        for i in range(1, len(bench_mark)+1):
+            common_substring = bench_mark[:i]
+            for s in strs:
+                if s[:i]!=common_substring:
+                    if i==1:
+                        return ''
+                    else:
+                        return bench_mark[:i-1]
+        return bench_mark

max-stack.py

@@ -0,0 +1,37 @@
+#https://leetcode.com/problems/max-stack/
+
+#peekMax() and popMax() are O(N)
+#Else are O(1)
+class MaxStack(object):
+
+    def __init__(self):
+        self.stack = []
+        
+
+    def push(self, x):
+        self.stack.append(x)
+        
+
+    def pop(self):
+        return self.stack.pop()
+        
+        
+    def top(self):
+        return self.stack[-1]
+        
+
+    def peekMax(self):
+        return max(self.stack)
+        
+
+    def popMax(self):
+        max_num = None
+        max_index = None
+        
+        for i in range(len(self.stack)):
+            num = self.stack[i]
+            if num>=max_num:
+                max_num = num
+                max_index = i
+
+        return self.stack.pop(max_index)