0613”

Author: princewen

easy/二进制/461_Hamming Distance.py

@@ -0,0 +1,40 @@
+"""
+
+The Hamming distance between two integers is the number of positions at which the corresponding bits are different.
+
+Given two integers x and y, calculate the Hamming distance.
+
+Note:
+0 ≤ x, y < 231.
+
+Example:
+
+Input: x = 1, y = 4
+
+Output: 2
+
+Explanation:
+1   (0 0 0 1)
+4   (0 1 0 0)
+       ↑   ↑
+
+The above arrows point to positions where the corresponding bits are different.
+
+"""
+
+"""
+my solution 二进制解法，异或之后计算1的个数
+"""
+class Solution(object):
+    def hammingDistance(self, x, y):
+        """
+        :type x: int
+        :type y: int
+        :rtype: int
+        """
+        t = x ^ y
+        count = 0
+        while t != 0:
+            count = count + 1
+            t = t & (t-1)
+        return count

easy/二进制/476_Number Complement.py

@@ -0,0 +1,45 @@
+"""
+
+Given a positive integer, output its complement number. The complement strategy is to flip the bits of its binary representation.
+
+Note:
+The given integer is guaranteed to fit within the range of a 32-bit signed integer.
+You could assume no leading zero bit in the integer’s binary representation.
+Example 1:
+Input: 5
+Output: 2
+Explanation: The binary representation of 5 is 101 (no leading zero bits), and its complement is 010. So you need to output 2.
+Example 2:
+Input: 1
+Output: 0
+Explanation: The binary representation of 1 is 1 (no leading zero bits), and its complement is 0. So you need to output 0.
+
+
+"""
+"""与1进行按位与运算，保存每一位，存入stack中，随后转换为十进制"""
+class Solution(object):
+    def findComplement(self, num):
+        """
+        :type num: int
+        :rtype: int
+        """
+        res = 0
+        stack = []
+        while num > 0:
+            stack.append(1-(num & 1))
+            num = num >> 1
+        for i in range(len(stack)-1,-1,-1):
+            res = res * 2 + stack[i]
+        return res
+
+"""更巧妙的方法，要得到对位取反，其实就是用全1的数字进行按位异或，但是要位数刚刚好"""
+class Solution(object):
+    def findComplement(self, num):
+        """
+        :type num: int
+        :rtype: int
+        """
+        i=1
+        while i<=num:
+            i = i << 1
+        return (i-1) ^ num

easy/其他/492_Construct the Rectangle.py

@@ -0,0 +1,32 @@
+"""
+
+For a web developer, it is very important to know how to design a web page's size. So, given a specific rectangular web page’s area, your job by now is to design a rectangular web page, whose length L and width W satisfy the following requirements:
+
+1. The area of the rectangular web page you designed must equal to the given target area.
+
+2. The width W should not be larger than the length L, which means L >= W.
+
+3. The difference between length L and width W should be as small as possible.
+You need to output the length L and the width W of the web page you designed in sequence.
+Example:
+Input: 4
+Output: [2, 2]
+Explanation: The target area is 4, and all the possible ways to construct it are [1,4], [2,2], [4,1]. 
+But according to requirement 2, [1,4] is illegal; according to requirement 3,  [4,1] is not optimal compared to [2,2]. So the length L is 2, and the width W is 2.
+
+"""
+"""
+暴力搜索
+"""
+import math
+class Solution(object):
+    def constructRectangle(self, area):
+        """
+        :type area: int
+        :rtype: List[int]
+        """
+        mid = int(math.sqrt(area))
+        while mid > 0:
+            if area % mid == 0:
+                return [int(area/mid),int(mid)]
+            mid -= 1

easy/字符串/438_Find All Anagrams in a String.py

@@ -0,0 +1,92 @@
+"""
+
+Given a string s and a non-empty string p, find all the start indices of p's anagrams in s.
+
+Strings consists of lowercase English letters only and the length of both strings s and p will not be larger than 20,100.
+
+The order of output does not matter.
+
+Example 1:
+
+Input:
+s: "cbaebabacd" p: "abc"
+
+Output:
+[0, 6]
+
+Explanation:
+The substring with start index = 0 is "cba", which is an anagram of "abc".
+The substring with start index = 6 is "bac", which is an anagram of "abc".
+Example 2:
+
+Input:
+s: "abab" p: "ab"
+
+Output:
+[0, 1, 2]
+
+Explanation:
+The substring with start index = 0 is "ab", which is an anagram of "ab".
+The substring with start index = 1 is "ba", which is an anagram of "ab".
+The substring with start index = 2 is "ab", which is an anagram of "ab".
+
+"""
+
+"""
+
+使用一个字典保存应该出现的各字符的次数
+
+"""
+
+
+class Solution(object):
+    def findAnagrams(self, s, p):
+        """
+        :type s: str
+        :type p: str
+        :rtype: List[int]
+        """
+        res = []
+        left = right = 0
+        count = len(p)
+        dic = dict()
+        for i in p:
+            dic[i] = dic.get(i, 0) + 1
+        while right < len(s):
+            if s[right] in dic.keys():
+                if dic[s[right]] >= 1:
+                    count = count - 1
+                dic[s[right]] = dic[s[right]] - 1
+            right = right + 1
+
+            if count == 0:
+                res.append(left)
+            if right - left == len(p):
+                if s[left] in dic.keys():
+                    if dic[s[left]] >= 0:
+                        count = count + 1
+                    dic[s[left]] += 1
+                left = left + 1
+        return res
+
+"""使用counter会更简单"""
+from collections import Counter
+
+class Solution(object):
+    def findAnagrams(self, s, p):
+        """
+        :type s: str
+        :type p: str
+        :rtype: List[int]
+        """
+        res = []
+        pCounter = Counter(p)
+        sCounter = Counter(s[:len(p)-1])
+        for i in range(len(p)-1,len(s)):
+            sCounter[s[i]] += 1   # include a new char in the window
+            if sCounter == pCounter:    # This step is O(1), since there are at most 26 English letters
+                res.append(i-len(p)+1)   # append the starting index
+            sCounter[s[i-len(p)+1]] -= 1   # decrease the count of oldest char in the window
+            if sCounter[s[i-len(p)+1]] == 0:
+                del sCounter[s[i-len(p)+1]]   # remove the count if it is 0
+        return res

easy/字符串/459_Repeated Substring Pattern.py

@@ -0,0 +1,62 @@
+"""
+
+Given a non-empty string check if it can be constructed by taking a substring of it and appending multiple copies of the substring together. You may assume the given string consists of lowercase English letters only and its length will not exceed 10000.
+
+Example 1:
+Input: "abab"
+
+Output: True
+
+Explanation: It's the substring "ab" twice.
+Example 2:
+Input: "aba"
+
+Output: False
+Example 3:
+Input: "abcabcabcabc"
+
+Output: True
+
+Explanation: It's the substring "abc" four times. (And the substring "abcabc" twice.)
+
+"""
+"""my solution"""
+
+class Solution(object):
+    def repeatedSubstringPattern(self, s):
+        """
+        :type s: str
+        :rtype: bool
+        """
+        for i in range(1, len(s) / 2 + 1):
+            if len(s) % i == 0:
+                leng = len(s) / i
+
+                if s[:i] * leng == s:
+                    return True
+        return False
+
+"""
+Basic idea:
+
+First char of input string is first char of repeated substring
+Last char of input string is last char of repeated substring
+Let S1 = S + S (where S in input string)
+Remove 1 and last char of S1. Let this be S2
+If S exists in S2 then return true else false
+Let i be index in S2 where S starts then repeated substring length i + 1 and repeated substring S[0: i+1]
+
+巧妙的思路，首先将字符串首尾想接，然后掐头去尾，如果字符串出现的话，说明是有重复字串的
+"""
+
+
+def repeatedSubstringPattern(self, str):
+    """
+    :type str: str
+    :rtype: bool
+    """
+    if not str:
+        return False
+
+    ss = (str + str)[1:-1]
+    return ss.find(str) != -1

easy/字符串/520_Detect Capital.py

@@ -0,0 +1,29 @@
+"""
+
+Given a word, you need to judge whether the usage of capitals in it is right or not.
+
+We define the usage of capitals in a word to be right when one of the following cases holds:
+
+All letters in this word are capitals, like "USA".
+All letters in this word are not capitals, like "leetcode".
+Only the first letter in this word is capital if it has more than one letter, like "Google".
+Otherwise, we define that this word doesn't use capitals in a right way.
+Example 1:
+Input: "USA"
+Output: True
+Example 2:
+Input: "FlaG"
+Output: False
+
+"""
+
+class Solution(object):
+    def detectCapitalUse(self, word):
+        """
+        :type word: str
+        :rtype: bool
+        """
+        return word==word.lower() or word==word.upper() or word==(word[0].upper()+word[1:].lower())
+
+def detectCapitalUse(self, word):
+    return word.isupper() or word.islower() or word.istitle()

easy/搜索相关/441_Arranging Coins.py

@@ -0,0 +1,56 @@
+"""
+
+You have a total of n coins that you want to form in a staircase shape, where every k-th row must have exactly k coins.
+
+Given n, find the total number of full staircase rows that can be formed.
+
+n is a non-negative integer and fits within the range of a 32-bit signed integer.
+
+Example 1:
+
+n = 5
+
+The coins can form the following rows:
+¤
+¤ ¤
+¤ ¤
+
+Because the 3rd row is incomplete, we return 2.
+Example 2:
+
+n = 8
+
+The coins can form the following rows:
+¤
+¤ ¤
+¤ ¤ ¤
+¤ ¤
+
+Because the 4th row is incomplete, we return 3.
+
+"""
+
+"""binary search"""
+
+class Solution(object):
+    def arrangeCoins(self, n):
+        """
+        :type n: int
+        :rtype: int
+        """
+        if n == 0:
+            return 0
+        left = 1
+        right = n/2
+        while left <= right:
+            mid = (right-left)/2+left
+            total = (mid * (mid+1)) / 2
+            if total > n:
+                right = mid - 1
+            elif n - total < mid + 1:
+                return mid
+            elif n-total == mid + 1:
+                return mid+1
+            else:
+                left = left + 1
+        return left