update at 2018-04-10

bonfy · bonfy · commit ef8bb8919527 · 2018-04-10T13:31:56.000+08:00
diff --git a/001-two-sum/two-sum.js b/001-two-sum/two-sum.js
@@ -2,15 +2,17 @@
 //
 // You may assume that each input would have exactly one solution, and you may not use the same element twice.
 //
-//
 // Example:
 //
+//
 // Given nums = [2, 7, 11, 15], target = 9,
 //
 // Because nums[0] + nums[1] = 2 + 7 = 9,
 // return [0, 1].
 //
 //
+// &nbsp;
+//
 
 
 /**
diff --git a/001-two-sum/two-sum.py b/001-two-sum/two-sum.py
@@ -5,15 +5,17 @@
 #
 # You may assume that each input would have exactly one solution, and you may not use the same element twice.
 #
-#
 # Example:
 #
+#
 # Given nums = [2, 7, 11, 15], target = 9,
 #
 # Because nums[0] + nums[1] = 2 + 7 = 9,
 # return [0, 1].
 #
 #
+# &nbsp;
+#
 
 
 class Solution(object):
diff --git a/006-zigzag-conversion/zigzag-conversion.py b/006-zigzag-conversion/zigzag-conversion.py
@@ -1,22 +1,26 @@
 # -*- coding:utf-8 -*-
 
 
+# The string &quot;PAYPALISHIRING&quot; is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)
 #
-# The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)
 #
 # P   A   H   N
 # A P L S I I G
 # Y   I   R
 #
 #
-# And then read line by line: "PAHNAPLSIIGYIR"
+# And then read line by line: &quot;PAHNAPLSIIGYIR&quot;
 #
+# &nbsp;
 #
 # Write the code that will take a string and make this conversion given a number of rows:
 #
+#
 # string convert(string text, int nRows);
 #
-# convert("PAYPALISHIRING", 3) should return "PAHNAPLSIIGYIR".
+# convert(&quot;PAYPALISHIRING&quot;, 3) should return &quot;PAHNAPLSIIGYIR&quot;.
+#
+# &nbsp;
 #
 
 
diff --git a/016-3sum-closest/3sum-closest.py b/016-3sum-closest/3sum-closest.py
@@ -8,6 +8,7 @@
 #
 #     The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).
 #
+#
 
 
 class Solution(object):
diff --git a/017-letter-combinations-of-a-phone-number/letter-combinations-of-a-phone-number.py b/017-letter-combinations-of-a-phone-number/letter-combinations-of-a-phone-number.py
@@ -3,15 +3,13 @@
 
 # Given a digit string, return all possible letter combinations that the number could represent.
 #
-#
-#
 # A mapping of digit to letters (just like on the telephone buttons) is given below.
 #
 #
 #
-# Input:Digit string "23"
-# Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
 #
+# Input:Digit string &quot;23&quot;
+# Output: [&quot;ad&quot;, &quot;ae&quot;, &quot;af&quot;, &quot;bd&quot;, &quot;be&quot;, &quot;bf&quot;, &quot;cd&quot;, &quot;ce&quot;, &quot;cf&quot;].
 #
 #
 # Note:
diff --git a/024-swap-nodes-in-pairs/swap-nodes-in-pairs.py b/024-swap-nodes-in-pairs/swap-nodes-in-pairs.py
@@ -1,15 +1,10 @@
 # -*- coding:utf-8 -*-
 
 
-#
 # Given a linked list, swap every two adjacent nodes and return its head.
 #
-#
-#
 # For example,
-# Given 1->2->3->4, you should return the list as 2->1->4->3.
-#
-#
+# Given 1-&gt;2-&gt;3-&gt;4, you should return the list as 2-&gt;1-&gt;4-&gt;3.
 #
 # Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.
 #
diff --git a/067-add-binary/add-binary.py b/067-add-binary/add-binary.py
@@ -1,15 +1,12 @@
 # -*- coding:utf-8 -*-
 
 
-#
 # Given two binary strings, return their sum (also a binary string).
 #
-#
-#
 # For example,
-# a = "11"
-# b = "1"
-# Return "100".
+# a = &quot;11&quot;
+# b = &quot;1&quot;
+# Return &quot;100&quot;.
 #
 
 
diff --git a/071-simplify-path/simplify-path.py b/071-simplify-path/simplify-path.py
@@ -4,20 +4,22 @@
 # Given an absolute path for a file (Unix-style), simplify it.
 #
 # For example,
-# path = "/home/", => "/home"
-# path = "/a/./b/../../c/", => "/c"
-#
+# path = &quot;/home/&quot;, =&gt; &quot;/home&quot;
+# path = &quot;/a/./b/../../c/&quot;, =&gt; &quot;/c&quot;
 #
 # click to show corner cases.
 #
 # Corner Cases:
 #
+# &nbsp;
+#
+# &nbsp;
 #
 #
-# Did you consider the case where path = "/../"?
-# In this case, you should return "/".
-# Another corner case is the path might contain multiple slashes '/' together, such as "/home//foo/".
-# In this case, you should ignore redundant slashes and return "/home/foo".
+# 	Did you consider the case where path = &quot;/../&quot;?
+# 	In this case, you should return &quot;/&quot;.
+# 	Another corner case is the path might contain multiple slashes &#39;/&#39; together, such as &quot;/home//foo/&quot;.
+# 	In this case, you should ignore redundant slashes and return &quot;/home/foo&quot;.
 #
 #
 
diff --git a/080-remove-duplicates-from-sorted-array-ii/remove-duplicates-from-sorted-array-ii.py b/080-remove-duplicates-from-sorted-array-ii/remove-duplicates-from-sorted-array-ii.py
@@ -1,16 +1,13 @@
 # -*- coding:utf-8 -*-
 
 
-#
-# Follow up for "Remove Duplicates":
+# Follow up for &quot;Remove Duplicates&quot;:
 # What if duplicates are allowed at most twice?
 #
-#
 # For example,
 # Given sorted array nums = [1,1,1,2,2,3],
 #
-#
-# Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3. It doesn't matter what you leave beyond the new length.
+# Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3. It doesn&#39;t matter what you leave beyond the new length.
 #
 
 
diff --git a/083-remove-duplicates-from-sorted-list/remove-duplicates-from-sorted-list.py b/083-remove-duplicates-from-sorted-list/remove-duplicates-from-sorted-list.py
@@ -1,13 +1,11 @@
 # -*- coding:utf-8 -*-
 
 
-#
 # Given a sorted linked list, delete all duplicates such that each element appear only once.
 #
-#
 # For example,
-# Given 1->1->2, return 1->2.
-# Given 1->1->2->3->3, return 1->2->3.
+# Given 1-&gt;1-&gt;2, return 1-&gt;2.
+# Given 1-&gt;1-&gt;2-&gt;3-&gt;3, return 1-&gt;2-&gt;3.
 #
 
 
diff --git a/086-partition-list/partition-list.py b/086-partition-list/partition-list.py
@@ -3,13 +3,11 @@
 
 # Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.
 #
-#
 # You should preserve the original relative order of the nodes in each of the two partitions.
 #
-#
 # For example,
-# Given 1->4->3->2->5->2 and x = 3,
-# return 1->2->2->4->3->5.
+# Given 1-&gt;4-&gt;3-&gt;2-&gt;5-&gt;2 and x = 3,
+# return 1-&gt;2-&gt;2-&gt;4-&gt;3-&gt;5.
 #
 
 
diff --git a/093-restore-ip-addresses/restore-ip-addresses.py b/093-restore-ip-addresses/restore-ip-addresses.py
@@ -3,12 +3,10 @@
 
 # Given a string containing only digits, restore it by returning all possible valid IP address combinations.
 #
-#
 # For example:
-# Given "25525511135",
-#
+# Given &quot;25525511135&quot;,
 #
-# return ["255.255.11.135", "255.255.111.35"]. (Order does not matter)
+# return [&quot;255.255.11.135&quot;, &quot;255.255.111.35&quot;]. (Order does not matter)
 #
 
 
diff --git a/097-interleaving-string/interleaving-string.py b/097-interleaving-string/interleaving-string.py
@@ -1,19 +1,15 @@
 # -*- coding:utf-8 -*-
 
 
-#
 # Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.
 #
-#
-#
 # For example,
 # Given:
-# s1 = "aabcc",
-# s2 = "dbbca",
-#
+# s1 = &quot;aabcc&quot;,
+# s2 = &quot;dbbca&quot;,
 #
-# When s3 = "aadbbcbcac", return true.
-# When s3 = "aadbbbaccc", return false.
+# When s3 = &quot;aadbbcbcac&quot;, return true.
+# When s3 = &quot;aadbbbaccc&quot;, return false.
 #
 
 
diff --git a/118-pascals-triangle/pascals-triangle.py b/118-pascals-triangle/pascals-triangle.py
@@ -1,12 +1,12 @@
 # -*- coding:utf-8 -*-
 
 
-# Given numRows, generate the first numRows of Pascal's triangle.
-#
+# Given numRows, generate the first numRows of Pascal&#39;s triangle.
 #
 # For example, given numRows = 5,
 # Return
 #
+#
 # [
 #      [1],
 #     [1,1],
@@ -16,6 +16,8 @@
 # ]
 #
 #
+# &nbsp;
+#
 
 
 class Solution(object):
diff --git a/119-pascals-triangle-ii/pascals-triangle-ii.py b/119-pascals-triangle-ii/pascals-triangle-ii.py
@@ -1,14 +1,11 @@
 # -*- coding:utf-8 -*-
 
 
-# Given an index k, return the kth row of the Pascal's triangle.
-#
+# Given an index k, return the kth row of the Pascal&#39;s triangle.
 #
 # For example, given k = 3,
 # Return [1,3,3,1].
 #
-#
-#
 # Note:
 # Could you optimize your algorithm to use only O(k) extra space?
 #
diff --git a/125-valid-palindrome/valid-palindrome.py b/125-valid-palindrome/valid-palindrome.py
@@ -1,16 +1,11 @@
 # -*- coding:utf-8 -*-
 
 
-#
 # Given a string, determine if it is a palindrome, considering only alphanumeric characters and ignoring cases.
 #
-#
-#
 # For example,
-# "A man, a plan, a canal: Panama" is a palindrome.
-# "race a car" is not a palindrome.
-#
-#
+# &quot;A man, a plan, a canal: Panama&quot; is a palindrome.
+# &quot;race a car&quot; is not a palindrome.
 #
 # Note:
 # Have you consider that the string might be empty? This is a good question to ask during an interview.
diff --git a/README.md b/README.md
@@ -1,9 +1,9 @@
 # :pencil2: Leetcode Solutions with Python,Javascript
-Update time:  2018-04-08 09:51:11
+Update time:  2018-04-10 13:31:56
 
 Auto created by [leetcode_generate](https://github.com/bonfy/leetcode)
 
-I have solved **97   /   726** problems
+I have solved **97   /   730** problems
 while there are **133** problems still locked.
 
 If you want to use this tool please follow this [Usage Guide](https://github.com/bonfy/leetcode/blob/master/README_leetcode_generate.md)
@@ -742,3 +742,7 @@ If you are loving solving problems in leetcode, please contact me to enjoy it to
 |827|[expressive-words](https://leetcode.com/problems/expressive-words)||[:memo:](https://leetcode.com/articles/expressive-words/)|Medium|
 |828|[chalkboard-xor-game](https://leetcode.com/problems/chalkboard-xor-game)||[:memo:](https://leetcode.com/articles/chalkboard-xor-game/)|Hard|
 |829|[subdomain-visit-count](https://leetcode.com/problems/subdomain-visit-count)||[:memo:](https://leetcode.com/articles/subdomain-visit-count/)|Easy|
+|830|[largest-triangle-area](https://leetcode.com/problems/largest-triangle-area)||[:memo:](https://leetcode.com/articles/largest-triangle-area/)|Easy|
+|831|[largest-sum-of-averages](https://leetcode.com/problems/largest-sum-of-averages)||[:memo:](https://leetcode.com/articles/largest-sum-of-averages/)|Medium|
+|832|[binary-tree-pruning](https://leetcode.com/problems/binary-tree-pruning)||[:memo:](https://leetcode.com/articles/binary-tree-pruning/)|Medium|
+|833|[bus-routes](https://leetcode.com/problems/bus-routes)||[:memo:](https://leetcode.com/articles/bus-routes/)|Hard|

Original file line number	Diff line number	Diff line change
`@@ -5,15 +5,17 @@`
`5`	`5`	`#`
`6`	`6`	`# You may assume that each input would have exactly one solution, and you may not use the same element twice.`
`7`	`7`	`#`
`8`		`-#`
`9`	`8`	`# Example:`
`10`	`9`	`#`
	`10`	`+#`
`11`	`11`	`# Given nums = [2, 7, 11, 15], target = 9,`
`12`	`12`	`#`
`13`	`13`	`# Because nums[0] + nums[1] = 2 + 7 = 9,`
`14`	`14`	`# return [0, 1].`
`15`	`15`	`#`
`16`	`16`	`#`
	`17`	`+#  `
	`18`	`+#`
`17`	`19`
`18`	`20`
`19`	`21`	`class Solution(object):`
Original file line number	Diff line number	Diff line change
`@@ -1,22 +1,26 @@`
`1`	`1`	`# -- coding:utf-8 --`
`2`	`2`
`3`	`3`
	`4`	`+# The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)`
`4`	`5`	`#`
`5`		`-# The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you may want to display this pattern in a fixed font for better legibility)`
`6`	`6`	`#`
`7`	`7`	`# P A H N`
`8`	`8`	`# A P L S I I G`
`9`	`9`	`# Y I R`
`10`	`10`	`#`
`11`	`11`	`#`
`12`		`-# And then read line by line: "PAHNAPLSIIGYIR"`
	`12`	`+# And then read line by line: "PAHNAPLSIIGYIR"`
`13`	`13`	`#`
	`14`	`+#  `
`14`	`15`	`#`
`15`	`16`	`# Write the code that will take a string and make this conversion given a number of rows:`
`16`	`17`	`#`
	`18`	`+#`
`17`	`19`	`# string convert(string text, int nRows);`
`18`	`20`	`#`
`19`		`-# convert("PAYPALISHIRING", 3) should return "PAHNAPLSIIGYIR".`
	`21`	`+# convert("PAYPALISHIRING", 3) should return "PAHNAPLSIIGYIR".`
	`22`	`+#`
	`23`	`+#  `
`20`	`24`	`#`
`21`	`25`
`22`	`26`
Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`#`
`9`	`9`	`# The sum that is closest to the target is 2. (-1 + 2 + 1 = 2).`
`10`	`10`	`#`
	`11`	`+#`
`11`	`12`
`12`	`13`
`13`	`14`	`class Solution(object):`
Original file line number	Diff line number	Diff line change
`@@ -3,15 +3,13 @@`
`3`	`3`
`4`	`4`	`# Given a digit string, return all possible letter combinations that the number could represent.`
`5`	`5`	`#`
`6`		`-#`
`7`		`-#`
`8`	`6`	`# A mapping of digit to letters (just like on the telephone buttons) is given below.`
`9`	`7`	`#`
`10`	`8`	`#`
`11`	`9`	`#`
`12`		`-# Input:Digit string "23"`
`13`		`-# Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].`
`14`	`10`	`#`
	`11`	`+# Input:Digit string "23"`
	`12`	`+# Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].`
`15`	`13`	`#`
`16`	`14`	`#`
`17`	`15`	`# Note:`
Original file line number	Diff line number	Diff line change
`@@ -1,15 +1,10 @@`
`1`	`1`	`# -- coding:utf-8 --`
`2`	`2`
`3`	`3`
`4`		`-#`
`5`	`4`	`# Given a linked list, swap every two adjacent nodes and return its head.`
`6`	`5`	`#`
`7`		`-#`
`8`		`-#`
`9`	`6`	`# For example,`
`10`		`-# Given 1->2->3->4, you should return the list as 2->1->4->3.`
`11`		`-#`
`12`		`-#`
	`7`	`+# Given 1->2->3->4, you should return the list as 2->1->4->3.`
`13`	`8`	`#`
`14`	`9`	`# Your algorithm should use only constant space. You may not modify the values in the list, only nodes itself can be changed.`
`15`	`10`	`#`
Original file line number	Diff line number	Diff line change
`@@ -4,20 +4,22 @@`
`4`	`4`	`# Given an absolute path for a file (Unix-style), simplify it.`
`5`	`5`	`#`
`6`	`6`	`# For example,`
`7`		`-# path = "/home/", => "/home"`
`8`		`-# path = "/a/./b/../../c/", => "/c"`
`9`		`-#`
	`7`	`+# path = "/home/", => "/home"`
	`8`	`+# path = "/a/./b/../../c/", => "/c"`
`10`	`9`	`#`
`11`	`10`	`# click to show corner cases.`
`12`	`11`	`#`
`13`	`12`	`# Corner Cases:`
`14`	`13`	`#`
	`14`	`+#  `
	`15`	`+#`
	`16`	`+#  `
`15`	`17`	`#`
`16`	`18`	`#`
`17`		`-# Did you consider the case where path = "/../"?`
`18`		`-# In this case, you should return "/".`
`19`		`-# Another corner case is the path might contain multiple slashes '/' together, such as "/home//foo/".`
`20`		`-# In this case, you should ignore redundant slashes and return "/home/foo".`
	`19`	`+# Did you consider the case where path = "/../"?`
	`20`	`+# In this case, you should return "/".`
	`21`	`+# Another corner case is the path might contain multiple slashes '/' together, such as "/home//foo/".`
	`22`	`+# In this case, you should ignore redundant slashes and return "/home/foo".`
`21`	`23`	`#`
`22`	`24`	`#`
`23`	`25`
Original file line number	Diff line number	Diff line change
`@@ -1,16 +1,13 @@`
`1`	`1`	`# -- coding:utf-8 --`
`2`	`2`
`3`	`3`
`4`		`-#`
`5`		`-# Follow up for "Remove Duplicates":`
	`4`	`+# Follow up for "Remove Duplicates":`
`6`	`5`	`# What if duplicates are allowed at most twice?`
`7`	`6`	`#`
`8`		`-#`
`9`	`7`	`# For example,`
`10`	`8`	`# Given sorted array nums = [1,1,1,2,2,3],`
`11`	`9`	`#`
`12`		`-#`
`13`		`-# Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3. It doesn't matter what you leave beyond the new length.`
	`10`	`+# Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3. It doesn't matter what you leave beyond the new length.`
`14`	`11`	`#`
`15`	`12`
`16`	`13`
Original file line number	Diff line number	Diff line change
`@@ -1,13 +1,11 @@`
`1`	`1`	`# -- coding:utf-8 --`
`2`	`2`
`3`	`3`
`4`		`-#`
`5`	`4`	`# Given a sorted linked list, delete all duplicates such that each element appear only once.`
`6`	`5`	`#`
`7`		`-#`
`8`	`6`	`# For example,`
`9`		`-# Given 1->1->2, return 1->2.`
`10`		`-# Given 1->1->2->3->3, return 1->2->3.`
	`7`	`+# Given 1->1->2, return 1->2.`
	`8`	`+# Given 1->1->2->3->3, return 1->2->3.`
`11`	`9`	`#`
`12`	`10`
`13`	`11`