update at 2019-03-29

bonfy · bonfy · commit 849cd54b36e9 · 2019-03-29T09:37:59.000+08:00
diff --git a/README.md b/README.md
diff --git a/solutions/003-longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.py b/solutions/003-longest-substring-without-repeating-characters/longest-substring-without-repeating-characters.py
@@ -33,7 +33,6 @@
 #
 #
 #
-#
 
 
 class Solution(object):
diff --git a/solutions/066-plus-one/plus-one.py b/solutions/066-plus-one/plus-one.py
@@ -22,7 +22,6 @@
 # Output: [4,3,2,2]
 # Explanation: The array represents the integer 4321.
 #
-#
 
 
 class Solution(object):
diff --git a/solutions/227-basic-calculator-ii/basic-calculator-ii.py b/solutions/227-basic-calculator-ii/basic-calculator-ii.py
@@ -31,6 +31,7 @@
 # 	You may assume that the given expression is always valid.
 # 	Do not use the eval built-in library function.
 #
+#
 
 
 class Solution(object):
diff --git a/solutions/335-self-crossing/self-crossing.py b/solutions/335-self-crossing/self-crossing.py
@@ -5,46 +5,43 @@
 #
 # Write a one-pass algorithm with O(1) extra space to determine, if your path crosses itself, or not.
 #
-# Example 1:
+#  
 #
+# Example 1:
 #
-# Input: [2,1,1,2]
 #
-# ?????
-# ?   ?
-# ???????>
-#     ?
+# ┌───┐
+# │   │
+# └───┼──>
+#     │
 #
-# Input: true 
-# Explanation: self crossing
+# Input: [2,1,1,2]
+# Output: true
 #
 #
 # Example 2:
 #
 #
-# Input: [1,2,3,4]
-#
-# ????????
-# ?      ?
-# ?
-# ?
-# ?????????????>
+# ┌──────┐
+# │      │
+# │
+# │
+# └────────────>
 #
+# Input: [1,2,3,4]
 # Output: false 
-# Explanation: not self crossing
 #
 #
 # Example 3:
 #
 #
-# Input: [1,1,1,1]
-#
-# ?????
-# ?   ?
-# ?????>
+# ┌───┐
+# │   │
+# └───┼>
 #
+# Input: [1,1,1,1]
 # Output: true 
-# Explanation: self crossing
+#
 #
 
 
diff --git a/solutions/454-4sum-ii/4sum-ii.py b/solutions/454-4sum-ii/4sum-ii.py
@@ -7,6 +7,7 @@
 #
 # Example:
 #
+#
 # Input:
 # A = [ 1, 2]
 # B = [-2,-1]
@@ -22,6 +23,8 @@
 # 2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0
 #
 #
+#  
+#
 
 
 class Solution(object):
diff --git a/solutions/458-poor-pigs/poor-pigs.py b/solutions/458-poor-pigs/poor-pigs.py
@@ -1,13 +1,24 @@
 # -*- 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.
+# There are 1000 buckets, one and only one of them is poisonous, while the rest are filled with water. They all look identical. If a pig drinks the poison it will die within 15 minutes. What is the minimum amount of pigs you need to figure out which bucket is poisonous within one hour?
 #
-# Answer this question, and write an algorithm for the follow-up general case.
+# Answer this question, and write an algorithm for the 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.
+# General case: 
+#
+# 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 poisonous bucket within p minutes? There is exactly one bucket with poison.
+#
+#  
+#
+# Note:
+#
+#
+# 	A pig can be allowed to drink simultaneously on as many buckets as one would like, and the feeding takes no time.
+# 	After a pig has instantly finished drinking buckets, there has to be a cool down time of m minutes. During this time, only observation is allowed and no feedings at all.
+# 	Any given bucket can be sampled an infinite number of times (by an unlimited number of pigs).
 #
 
 

Original file line number	Diff line number	Diff line change
`@@ -33,7 +33,6 @@`
`33`	`33`	`#`
`34`	`34`	`#`
`35`	`35`	`#`
`36`		`-#`
`37`	`36`
`38`	`37`
`39`	`38`	`class Solution(object):`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@`
`22`	`22`	`# Output: [4,3,2,2]`
`23`	`23`	`# Explanation: The array represents the integer 4321.`
`24`	`24`	`#`
`25`		`-#`
`26`	`25`
`27`	`26`
`28`	`27`	`class Solution(object):`
Original file line number	Diff line number	Diff line change
`@@ -31,6 +31,7 @@`
`31`	`31`	`# You may assume that the given expression is always valid.`
`32`	`32`	`# Do not use the eval built-in library function.`
`33`	`33`	`#`
	`34`	`+#`
`34`	`35`
`35`	`36`
`36`	`37`	`class Solution(object):`
Original file line number	Diff line number	Diff line change
`@@ -5,46 +5,43 @@`
`5`	`5`	`#`
`6`	`6`	`# Write a one-pass algorithm with O(1) extra space to determine, if your path crosses itself, or not.`
`7`	`7`	`#`
`8`		`-# Example 1:`
	`8`	`+#`
`9`	`9`	`#`
	`10`	`+# Example 1:`
`10`	`11`	`#`
`11`		`-# Input: [2,1,1,2]`
`12`	`12`	`#`
`13`		`-# ?????`
`14`		`-# ? ?`
`15`		`-# ???????>`
`16`		`-# ?`
	`13`	`+# ┌───┐`
	`14`	`+# │ │`
	`15`	`+# └───┼──>`
	`16`	`+# │`
`17`	`17`	`#`
`18`		`-# Input: true`
`19`		`-# Explanation: self crossing`
	`18`	`+# Input: [2,1,1,2]`
	`19`	`+# Output: true`
`20`	`20`	`#`
`21`	`21`	`#`
`22`	`22`	`# Example 2:`
`23`	`23`	`#`
`24`	`24`	`#`
`25`		`-# Input: [1,2,3,4]`
`26`		`-#`
`27`		`-# ????????`
`28`		`-# ? ?`
`29`		`-# ?`
`30`		`-# ?`
`31`		`-# ?????????????>`
	`25`	`+# ┌──────┐`
	`26`	`+# │ │`
	`27`	`+# │`
	`28`	`+# │`
	`29`	`+# └────────────>`
`32`	`30`	`#`
	`31`	`+# Input: [1,2,3,4]`
`33`	`32`	`# Output: false`
`34`		`-# Explanation: not self crossing`
`35`	`33`	`#`
`36`	`34`	`#`
`37`	`35`	`# Example 3:`
`38`	`36`	`#`
`39`	`37`	`#`
`40`		`-# Input: [1,1,1,1]`
`41`		`-#`
`42`		`-# ?????`
`43`		`-# ? ?`
`44`		`-# ?????>`
	`38`	`+# ┌───┐`
	`39`	`+# │ │`
	`40`	`+# └───┼>`
`45`	`41`	`#`
	`42`	`+# Input: [1,1,1,1]`
`46`	`43`	`# Output: true`
`47`		`-# Explanation: self crossing`
	`44`	`+#`
`48`	`45`	`#`
`49`	`46`
`50`	`47`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`#`
`8`	`8`	`# Example:`
`9`	`9`	`#`
	`10`	`+#`
`10`	`11`	`# Input:`
`11`	`12`	`# A = [ 1, 2]`
`12`	`13`	`# B = [-2,-1]`
`@@ -22,6 +23,8 @@`
`22`	`23`	`# 2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0`
`23`	`24`	`#`
`24`	`25`	`#`
	`26`	`+#`
	`27`	`+#`
`25`	`28`
`26`	`29`
`27`	`30`	`class Solution(object):`