update at 2018-07-24

Author: bonfy

011-container-with-most-water/container-with-most-water.py

@@ -1,9 +1,23 @@
 # -*- coding:utf-8 -*-
 
 
-# Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.
+# Given n non-negative integers a1, a2, ..., an , where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i is at (i, ai) and (i, 0). Find two lines, which together with x-axis forms a container, such that the container contains the most water.
 #
-# Note: You may not slant the container and n is at least 2.
+# Note: You may not slant the container and n is at least 2.
+#
+#  
+#
+#
+#
+# The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49. 
+#
+#  
+#
+# Example:
+#
+#
+# Input: [1,8,6,2,5,4,8,3,7]
+# Output: 49
 #
 
 

034-find-first-and-last-position-of-element-in-sorted-array/find-first-and-last-position-of-element-in-sorted-array.py

@@ -0,0 +1,46 @@
+# -*- coding:utf-8 -*-
+
+
+# Given an array of integers nums sorted in ascending order, find the starting and ending position of a given target value.
+#
+# Your algorithm's runtime complexity must be in the order of O(log n).
+#
+# If the target is not found in the array, return [-1, -1].
+#
+# Example 1:
+#
+#
+# Input: nums = [5,7,7,8,8,10], target = 8
+# Output: [3,4]
+#
+# Example 2:
+#
+#
+# Input: nums = [5,7,7,8,8,10], target = 6
+# Output: [-1,-1]
+#
+
+
+class Solution(object):
+    def searchRange(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        n = len(nums)
+        left, right = -1, -1
+        l, r = 0, n-1
+        while l < r:
+            m = (l+r)/2
+            if nums[m] < target: l = m+1
+            else: r = m
+        if nums[l] != target: return -1, -1
+        left = l
+        l, r = left, n-1
+        while l < r:
+            m = (l+r)/2+1
+            if nums[m] == target: l = m
+            else: r = m-1
+        right = l
+        return left, right

237-delete-node-in-a-linked-list/delete-node-in-a-linked-list.py

@@ -1,12 +1,40 @@
 # -*- coding:utf-8 -*-
 
 
-#
 # Write a function to delete a node (except the tail) in a singly linked list, given only access to that node.
 #
+# Given linked list -- head = [4,5,1,9], which looks like following:
+#
+#
+#     4 -> 5 -> 1 -> 9
+#
+#
+# Example 1:
+#
+#
+# Input: head = [4,5,1,9], node = 5
+# Output: [4,1,9]
+# Explanation: You are given the second node with value 5, the linked list
+#              should become 4 -> 1 -> 9 after calling your function.
+#
+#
+# Example 2:
+#
+#
+# Input: head = [4,5,1,9], node = 1
+# Output: [4,5,9]
+# Explanation: You are given the third node with value 1, the linked list
+#              should become 4 -> 5 -> 9 after calling your function.
+#
+#
+# Note:
+#
 #
+# 	The linked list will have at least two elements.
+# 	All of the nodes' values will be unique.
+# 	The given node will not be the tail and it will always be a valid node of the linked list.
+# 	Do not return anything from your function.
 #
-# Supposed the linked list is 1 -> 2 -> 3 -> 4 and you are given the third node with value 3, the linked list should become 1 -> 2 -> 4 after calling your function.
 #
 
 

240-search-a-2d-matrix-ii/search-a-2d-matrix-ii.py

@@ -8,6 +8,8 @@
 # 	Integers in each column are sorted in ascending from top to bottom.
 #
 #
+# Example:
+#
 # Consider the following matrix:
 #
 #
@@ -20,19 +22,9 @@
 # ]
 #
 #
-# Example 1:
-#
-#
-# Input: matrix, target = 5
-# Output: true
-#
-#
-# Example 2:
-#
-#
-# Input: matrix, target = 20
-# Output: false
+# Given target = 5, return true.
 #
+# Given target = 20, return false.
 #
 
 

274-h-index/h-index.py

@@ -13,7 +13,7 @@
 # Explanation: [3,0,6,1,5] means the researcher has 5 papers in total and each of them had 
 #              received 3, 0, 6, 1, 5 citations respectively. 
 #              Since the researcher has 3 papers with at least 3 citations each and the remaining 
-#              two with no more than 3 citations each, his h-index is 3.
+#              two with no more than 3 citations each, her h-index is 3.
 #
 # Note: If there are several possible values for h, the maximum one is taken as the h-index.
 #

275-h-index-ii/h-index-ii.py

@@ -1,9 +1,9 @@
 # -*- coding:utf-8 -*-
 
 
-# Given an array of citations in ascending order (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.
+# Given an array of citations sorted in ascending order (each citation is a non-negative integer) of a researcher, write a function to compute the researcher's h-index.
 #
-# According to the definition of h-index on Wikipedia: "A scientist has index h if h of his/her N papers have at least h citations each, and the other N − h papers have no more than hcitations each."
+# According to the definition of h-index on Wikipedia: "A scientist has index h if h of his/her N papers have at least h citations each, and the other N − h papers have no more than h citations each."
 #
 # Example:
 #
@@ -13,9 +13,18 @@
 # Explanation: [0,1,3,5,6] means the researcher has 5 papers in total and each of them had 
 #              received 0, 1, 3, 5, 6 citations respectively. 
 #              Since the researcher has 3 papers with at least 3 citations each and the remaining 
-#              two with no more than 3 citations each, his h-index is 3.
+#              two with no more than 3 citations each, her h-index is 3.
+#
+# Note:
+#
+# If there are several possible values for h, the maximum one is taken as the h-index.
+#
+# Follow up:
+#
+#
+# 	This is a follow up problem to H-Index, where citations is now guaranteed to be sorted in ascending order.
+# 	Could you solve it in logarithmic time complexity?
 #
-# Note: If there are several possible values for h, the maximum one is taken as the h-index.
 #
 
 

313-super-ugly-number/super-ugly-number.py

@@ -10,7 +10,7 @@
 #
 # Input: n = 12, primes = [2,7,13,19]
 # Output: 32 
-# Explanation: [1, 2, 4, 7, 8, 13, 14, 16, 19, 26, 28, 32]  is the sequence of the first 12 
+# Explanation: [1,2,4,7,8,13,14,16,19,26,28,32] is the sequence of the first 12 
 #              super ugly numbers given primes = [2,7,13,19] of size 4.
 #
 # Note:

335-self-crossing/self-crossing.py

@@ -1,56 +1,52 @@
 # -*- coding:utf-8 -*-
 
 
+# You are given an array x of n positive numbers. You start at point (0,0) and moves x[0] metres to the north, then x[1] metres to the west, x[2] metres to the south, x[3] metres to the east and so on. In other words, after each move your direction changes counter-clockwise.
 #
-#     You are given an array x of n positive numbers. You start at point (0,0) and moves x[0] metres to the north, then x[1] metres to the west,
-#     x[2] metres to the south,
-#     x[3] metres to the east and so on. In other words, after each move your direction changes
-#     counter-clockwise.
+# Write a one-pass algorithm with O(1) extra space to determine, if your path crosses itself, or not.
 #
-#
-#     Write a one-pass algorithm with O(1) extra space to determine, if your path crosses itself, or not.
+# Example 1:
 #
 #
+# Input: [2,1,1,2]
 #
-# Example 1:
-#
-# Given x = [2, 1, 1, 2],
 # ?????
 # ?   ?
 # ???????>
 #     ?
 #
-# Return true (self crossing)
+# Input: true 
+# Explanation: self crossing
 #
 #
+# Example 2:
 #
 #
-# Example 2:
+# Input: [1,2,3,4]
 #
-# Given x = [1, 2, 3, 4],
 # ????????
 # ?      ?
 # ?
 # ?
 # ?????????????>
 #
-# Return false (not self crossing)
+# Output: false 
+# Explanation: not self crossing
 #
 #
+# Example 3:
 #
 #
-# Example 3:
+# Input: [1,1,1,1]
 #
-# Given x = [1, 1, 1, 1],
 # ?????
 # ?   ?
 # ?????>
 #
-# Return true (self crossing)
-#
+# Output: true 
+# Explanation: self crossing
 #
 #
-# Credits:Special thanks to @dietpepsi for adding this problem and creating all test cases.
 
 
 class Solution(object):

458-poor-pigs/poor-pigs.py

@@ -0,0 +1,28 @@
+# -*- coding:utf-8 -*-
+
+
+# There are 1000 buckets, one and only one of them contains poison, the rest are filled with water. They all look the same. If a pig drinks that poison it will die within 15 minutes. What is the minimum amount of pigs you need to figure out which bucket contains the poison within one hour.
+#
+# Answer this question, and write an algorithm for the follow-up general case.
+#
+# Follow-up: 
+#
+# If there are n buckets and a pig drinking poison will die within m minutes, how many pigs (x) you need to figure out the "poison" bucket within p minutes? There is exact one bucket with poison.
+#
+
+
+class Solution(object):
+    def poorPigs(self, buckets, minutesToDie, minutesToTest):
+        """
+        :type buckets: int
+        :type minutesToDie: int
+        :type minutesToTest: int
+        :rtype: int
+        """
+        # corner case
+        if buckets == 1:
+            return 0
+        if minutesToTest // minutesToDie <= 1:
+            return buckets - 1
+        # general case: just get the n in n^(test_times + 1) = buckets
+        return int(math.ceil(math.log(buckets, (minutesToTest // minutesToDie) + 1)))