Added problem subjects

Author: shichao-an

count_and_say/solution.py

@@ -1,6 +1,22 @@
-class Solution:
-    # @return a string
+"""
+The count-and-say sequence is the sequence of integers beginning as follows:
+1, 11, 21, 1211, 111221, ...
+
+1 is read off as "one 1" or 11.
+11 is read off as "two 1s" or 21.
+21 is read off as "one 2, then one 1" or 1211.
+Given an integer n, generate the nth sequence.
+
+Note: The sequence of integers will be represented as a string.
+"""
+
+
+class Solution(object):
     def countAndSay(self, n):
+        """
+        :type n: int
+        :rtype: str
+        """
         ln = list(str(1))
         for i in range(1, n):
             tn = []
@@ -19,6 +35,7 @@ def countAndSay(self, n):
             ln = tn
         return ''.join(ln)
 
+
 s = Solution()
 print s.countAndSay(1)
 print s.countAndSay(2)

implement_strstr/solution.py

@@ -1,3 +1,10 @@
+"""
+Implement strStr().
+
+Returns the index of the first occurrence of needle in haystack, or -1 if
+needle is not part of haystack.
+"""
+
 class Solution(object):
     def strStr(self, haystack, needle):
         """

implement_strstr/solution2.py

@@ -1,9 +1,19 @@
+"""
+Implement strStr().
+
+Returns the index of the first occurrence of needle in haystack, or -1 if
+needle is not part of haystack.
+"""
+
 class Solution(object):
     def strStr(self, haystack, needle):
         """
         :type haystack: str
         :type needle: str
         :rtype: int
+
+          needle: |       n       |
+        haystack: |   n - m   | m |
         """
         n = len(haystack)
         m = len(needle)

longest_common_prefix/solution.py

@@ -1,6 +1,15 @@
-class Solution:
-    # @return a string
+"""
+Write a function to find the longest common prefix string amongst an array of
+strings.
+"""
+
+
+class Solution(object):
     def longestCommonPrefix(self, strs):
+        """
+        :type strs: List[str]
+        :rtype: str
+        """
         if not strs:
             return ""
         res = strs[0]

permutations_ii/solution.py

@@ -1,21 +1,32 @@
-class Solution:
-    # @param num, a list of integer
-    # @return a list of lists of integers
-    def permuteUnique(self, num):
+"""
+Given a collection of numbers that might contain duplicates, return all
+possible unique permutations.
+
+For example,
+[1,1,2] have the following unique permutations:
+[1,1,2], [1,2,1], and [2,1,1].
+"""
+
+class Solution(object):
+    def permuteUnique(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """
         d = {}
-        return self.permute(num, d)
+        return self.permute(nums, d)
 
-    def permute(self, num, d):
-        if not num:
+    def permute(self, nums, d):
+        if not nums:
             return [[]]
         else:
             res = []
-            for i, c in enumerate(num):
+            for i, c in enumerate(nums):
                 if c in d:
                     continue
                 else:
                     d[c] = True
-                rest_perms = self.permuteUnique(num[:i] + num[i + 1:])
+                rest_perms = self.permuteUnique(nums[:i] + nums[i + 1:])
                 for perm in rest_perms:
                     perm.insert(0, c)
                 res += rest_perms

permutations_ii/solution2.py

@@ -1,18 +1,29 @@
-class Solution:
-    # @param num, a list of integer
-    # @return a list of lists of integers
-    def permuteUnique(self, num):
-        return self.permute(sorted(num))
+"""
+Given a collection of numbers that might contain duplicates, return all
+possible unique permutations.
 
-    def permute(self, num):
-        if not num:
+For example,
+[1,1,2] have the following unique permutations:
+[1,1,2], [1,2,1], and [2,1,1].
+"""
+
+class Solution(object):
+    def permuteUnique(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: List[List[int]]
+        """
+        return self.permute(sorted(nums))
+
+    def permute(self, nums):
+        if not nums:
             return [[]]
         else:
             res = []
             prev = None
-            for i, e in enumerate(num):
+            for i, e in enumerate(nums):
                 if prev is None or prev != e:
-                    rest = num[:i] + num[i + 1:]
+                    rest = nums[:i] + nums[i + 1:]
                     rest_perms = self.permute(rest)
                     for perm in rest_perms:
                         perm.append(e)

reverse_integer/solution.py

@@ -1,6 +1,16 @@
-class Solution:
-    # @return an integer
+"""
+Reverse digits of an integer.
+
+Example1: x = 123, return 321
+Example2: x = -123, return -321
+"""
+
+class Solution(object):
     def reverse(self, x):
+        """
+        :type x: int
+        :rtype: int
+        """
         pos = True
         if x < 0:
             pos = False

valid_palindrome/solution.py

@@ -14,10 +14,12 @@
 """
 
 
-class Solution:
-    # @param s, a string
-    # @return a boolean
+class Solution(object):
     def isPalindrome(self, s):
+        """
+        :type s: str
+        :rtype: bool
+        """
         if not s:
             return True
         left = 0