每日一題力扣

 目錄：

1. 兩數之和

3. 無重復字符的最長子串

7. 整數反轉

8. 字符串轉換整數 (atoi)

217. 存在重復元素

219. 存在重復元素 II

238. 除自身以外數組的乘積

345. 反轉字符串中的元音字母

 

 

1. 兩數之和

給定一個整數數組 nums 和一個整數目標值 target，請你在該數組中找出 和為目標值 的那 兩個 整數，並返回它們的數組下標。

你可以假設每種輸入只會對應一個答案。但是，數組中同一個元素在答案里不能重復出現。

你可以按任意順序返回答案。

示例 1：

輸入：nums = [2,7,11,15], target = 9
輸出：[0,1]
解釋：因為 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

輸入：nums = [3,2,4], target = 6
輸出：[1,2]
示例 3：

輸入：nums = [3,3], target = 6
輸出：[0,1]

 

解題思路如下：

這道題的重點在於首先找到這2個數，且輸出的值不重復。我們就做2個for循環，然后再輸出即可

 

代碼：

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        lenth = len(nums)
        for i in range(lenth):
            for j in range(i+1,lenth):
                c=nums[i]+nums[j]
                if c==target:
                    return [i,j]

 

3. 無重復字符的最長子串

給定一個字符串，請你找出其中不含有重復字符的 最長子串 的長度。

 

示例 1:

輸入: s = "abcabcbb"
輸出: 3
解釋: 因為無重復字符的最長子串是 "abc"，所以其長度為 3。
示例 2:

輸入: s = "bbbbb"
輸出: 1
解釋: 因為無重復字符的最長子串是 "b"，所以其長度為 1。
示例 3:

輸入: s = "pwwkew"
輸出: 3
解釋: 因為無重復字符的最長子串是 "wke"，所以其長度為 3。
  請注意，你的答案必須是 子串 的長度，"pwke" 是一個子序列，不是子串。
示例 4:

輸入: s = ""
輸出: 0

 

解題思路：使用滑動思想，只要該字符沒有出現，都可以添加進去，如果遇到重復字符，需要往后移動，具體看代碼吧，表達能力差

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        if s=='':
            return 0

        max_s=[s[0]] #最長子串
        max_l=1  #最長子串長度
        start , end =0,1  #子串起始位置

        while end<len(s):  #循環截止條件
            
            if s[end] not in s[start:end] and end<len(s)-1: #當結束位置的元素不在start:end中，
            #end+1,但是要注意end不能是最后一個
                end=end+1
            elif s[end] not in s[start:end] and end==len(s)-1: #對前面的條件的補充
                max_s=s[start:end+1]
                max_l=max(max_l,len(max_s))
                break

            else:  
                max_s=s[start:end]  #最大子串
                max_l=max(max_l,len(max_s))  #最大子串長度
                start=max_s.index(s[end])+start+1  #最大子串的開始位置
                end=end+1  #結束位置
                #print(max_l,max_s,start,end)
        return max_l
        

 

 

7. 整數反轉

給你一個 32 位的有符號整數 x ，返回將 x 中的數字部分反轉后的結果。

如果反轉后整數超過 32 位的有符號整數的范圍 [−231,  231 − 1] ，就返回 0。

假設環境不允許存儲 64 位整數（有符號或無符號）。
 

示例 1：

輸入：x = 123
輸出：321
示例 2：

輸入：x = -123
輸出：-321
示例 3：

輸入：x = 120
輸出：21
示例 4：

輸入：x = 0
輸出：0

 

解題思路：

翻轉可以使用str[::-1]實現，然后注意一下負數，以及尾部是0（反正類似100,10,1000之類的），這個可以使用int(解決）

 

代碼：

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        
        if x>=0:
            x=str(x)
            x=x[::-1]
            if int(x)<=2**31-1:
                return int(x)
            else:
                return 0
        else:
            x=abs(x)
            x=str(x)
            x=x[::-1]
            if int(x)<=2**31:
                return -int(x)
            else:
                return 0

 

8. 字符串轉換整數 (atoi)

請你來實現一個 myAtoi(string s) 函數，使其能將字符串轉換成一個 32 位有符號整數（類似 C/C++ 中的 atoi 函數）。

函數 myAtoi(string s) 的算法如下：

讀入字符串並丟棄無用的前導空格
檢查下一個字符（假設還未到字符末尾）為正還是負號，讀取該字符（如果有）。 確定最終結果是負數還是正數。 如果兩者都不存在，則假定結果為正。
讀入下一個字符，直到到達下一個非數字字符或到達輸入的結尾。字符串的其余部分將被忽略。
將前面步驟讀入的這些數字轉換為整數（即，"123" -> 123， "0032" -> 32）。如果沒有讀入數字，則整數為 0 。必要時更改符號（從步驟 2 開始）。
如果整數數超過 32 位有符號整數范圍 [−231,  231 − 1] ，需要截斷這個整數，使其保持在這個范圍內。具體來說，小於 −231 的整數應該被固定為 −231 ，大於 231 − 1 的整數應該被固定為 231 − 1 。
返回整數作為最終結果。
注意：

本題中的空白字符只包括空格字符 ' ' 。
除前導空格或數字后的其余字符串外，請勿忽略 任何其他字符。
 

解題思路：首先去空格，然后讀取字符，注意首位一定是list('+-1234567890')中的一個，然后后面的只能是數字，還的找到循環中斷的條件，最后轉換成int，然后判斷怎么輸出好

class Solution(object):
    def myAtoi(self, s):
        """
        :type s: str
        :rtype: int
        """
        s = s.lstrip()
        a=list('+-1234567890')
        b=list('1234567890')
        l=''
        for i in range(len(s)):
            if i==0 and s[i] in a:
                l=l+s[i]
            elif i>=1 and s[i] in b:
                l=l+s[i]
            else:
                break
        if l=='' or l=='+' or l=='-':
            return 0
        else:
            l=int(l)
        if l>2147483647:
            return 2147483647
        elif l<(-2147483648):
            return -2147483648
        else:
            return l

 

9. 回文數

給你一個整數 x ，如果 x 是一個回文整數，返回 true ；否則，返回 false 。

回文數是指正序（從左向右）和倒序（從右向左）讀都是一樣的整數。例如，121 是回文，而 123 不是。

 

示例 1：

輸入：x = 121
輸出：true
示例 2：

輸入：x = -121
輸出：false
解釋：從左向右讀, 為 -121 。 從右向左讀, 為 121- 。因此它不是一個回文數。
示例 3：

輸入：x = 10
輸出：false
解釋：從右向左讀, 為 01 。因此它不是一個回文數。
示例 4：

輸入：x = -101
輸出：false

 

解題思路：

這個也可以使用翻轉的思路str[::-1]，然后注意一下細節問題

 

代碼：

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
   
        if x<0:
            return False
        elif x==0:
            return True
        else:
            x=str(x)
            if x==x[::-1]:
                return True
            else:
                return False

 

13. 羅馬數字轉整數

羅馬數字包含以下七種字符: I， V， X， L，C，D 和 M。

字符 數值
I 1
V 5
X 10
L 50
C 100
D 500
M 1000
例如， 羅馬數字 2 寫做 II ，即為兩個並列的 1。12 寫做 XII ，即為 X + II 。 27 寫做  XXVII, 即為 XX + V + II 。

通常情況下，羅馬數字中小的數字在大的數字的右邊。但也存在特例，例如 4 不寫做 IIII，而是 IV。數字 1 在數字 5 的左邊，所表示的數等於大數 5 減小數 1 得到的數值 4 。同樣地，數字 9 表示為 IX。這個特殊的規則只適用於以下六種情況：

I 可以放在 V (5) 和 X (10) 的左邊，來表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左邊，來表示 40 和 90。 
C 可以放在 D (500) 和 M (1000) 的左邊，來表示 400 和 900。
給定一個羅馬數字，將其轉換成整數。輸入確保在 1 到 3999 的范圍內。

 

示例 1:

輸入: "III"
輸出: 3
示例 2:

輸入: "IV"
輸出: 4
示例 3:

輸入: "IX"
輸出: 9
示例 4:

輸入: "LVIII"
輸出: 58
解釋: L = 50, V= 5, III = 3.
示例 5:

輸入: "MCMXCIV"
輸出: 1994
解釋: M = 1000, CM = 900, XC = 90, IV = 4.

 

解題思路：

首先構造一個字典，將7個字符作為key，對應值作為value，然后每一個位置的值都要和下一個位置的值比較，如果后面的值得等級比前面的值得等級大，則前面的值需要減，最后將結果全部加起來

 

代碼：

class Solution(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """
        dict1={"I":1,
"V":5,
"X":10,
"L":50,
"C":100,
"D":500,
"M":1000}
        lenth = len(s)
        a=0
        for i in range(lenth):
            if i<lenth-1:
                if dict1[s[i]]>=dict1[s[i+1]]:
                    a=a+dict1[s[i]]
                else:
                    a=a-dict1[s[i]]
            else:
                a=a+dict1[s[i]]
        return a

 

14. 最長公共前綴

編寫一個函數來查找字符串數組中的最長公共前綴。

如果不存在公共前綴，返回空字符串 ""。

 

示例 1：

輸入：strs = ["flower","flow","flight"]
輸出："fl"
示例 2：

輸入：strs = ["dog","racecar","car"]
輸出：""
解釋：輸入不存在公共前綴。

 

解題思路：

利用max(str),min(str)得到排序好的字段，后面只需要比較這2個字段即可

代碼

class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        if not strs: 
            return ""
        s1 = min(strs)
        s2 = max(strs)
        for i,x in enumerate(s1):
            if x != s2[i]:
                return s2[:i]
        return s1

 

20. 有效的括號

給定一個只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判斷字符串是否有效。

有效字符串需滿足：

左括號必須用相同類型的右括號閉合。
左括號必須以正確的順序閉合。
 

示例 1：

輸入：s = "()"
輸出：true
示例 2：

輸入：s = "()[]{}"
輸出：true
示例 3：

輸入：s = "(]"
輸出：false
示例 4：

輸入：s = "([)]"
輸出：false
示例 5：

輸入：s = "{[]}"
輸出：true

 

解題思路：

該題重點是括號成對且順序不能亂，因此我們只需要采取消消樂的思想，將一對對消成空即可

 

代碼：

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        

        while '{}' in s or '()' in s or '[]' in s:
            s = s.replace('{}', '')
            s = s.replace('[]', '')
            s = s.replace('()', '')
        return s == ''

 

22. 括號生成

數字 n 代表生成括號的對數，請你設計一個函數，用於能夠生成所有可能的並且 有效的 括號組合。

 

示例 1：

輸入：n = 3
輸出：["((()))","(()())","(())()","()(())","()()()"]
示例 2：

輸入：n = 1
輸出：["()"]

 

class Solution(object):
    def generateParenthesis(self, n):
        """
        :type n: int
        :rtype: List[str]
        """
        def get_pwd(str, num):
            if(num == 1):
                for x in str:
                    yield x
            else:
                for x in str:
                    for y in get_pwd(str, num-1):
                        yield x+y
        l=[]
        strKey="()"
        import copy
        for x in get_pwd(strKey,2*n):
            s=copy.deepcopy(x)
            while '()' in s :
                s = s.replace('()', '')
            if s=='':
                l.append(x)
        return l

 

26. 刪除有序數組中的重復項

給你一個有序數組 nums ，請你 原地 刪除重復出現的元素，使每個元素 只出現一次 ，返回刪除后數組的新長度。

不要使用額外的數組空間，你必須在 原地 修改輸入數組 並在使用 O(1) 額外空間的條件下完成。

 

說明:

為什么返回數值是整數，但輸出的答案是數組呢?

請注意，輸入數組是以「引用」方式傳遞的，這意味着在函數里修改輸入數組對於調用者是可見的。

你可以想象內部操作如下:

// nums 是以“引用”方式傳遞的。也就是說，不對實參做任何拷貝
int len = removeDuplicates(nums);

// 在函數里修改輸入數組對於調用者是可見的。
// 根據你的函數返回的長度, 它會打印出數組中 該長度范圍內 的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}
 
示例 1：

輸入：nums = [1,1,2]
輸出：2, nums = [1,2]
解釋：函數應該返回新的長度 2 ，並且原數組 nums 的前兩個元素被修改為 1, 2 。不需要考慮數組中超出新長度后面的元素。
示例 2：

輸入：nums = [0,0,1,1,1,2,2,3,3,4]
輸出：5, nums = [0,1,2,3,4]
解釋：函數應該返回新的長度 5 ， 並且原數組 nums 的前五個元素被修改為 0, 1, 2, 3, 4 。不需要考慮數組中超出新長度后面的元素。
 

提示：

0 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按升序排列

解題思路：nums[:]=去重后的list，還得注意set(list)之后的順序問題，set之后改變了順序，如果我們使用set，則需要sort

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """

        l = []
        for i in nums:
            if i not in l:
                l.append(i)
        nums[:]=l
        
        
        return len(nums)

方法二：

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """

        a=list(set(nums))
        a.sort()
        nums[:]=a
        
        
        return len(nums)

 

53. 最大子序和

給定一個整數數組 nums ，找到一個具有最大和的連續子數組（子數組最少包含一個元素），返回其最大和。

 

示例 1：

輸入：nums = [-2,1,-3,4,-1,2,1,-5,4]
輸出：6
解釋：連續子數組 [4,-1,2,1] 的和最大，為 6 。
示例 2：

輸入：nums = [1]
輸出：1
示例 3：

輸入：nums = [0]
輸出：0
示例 4：

輸入：nums = [-1]
輸出：-1
示例 5：

輸入：nums = [-100000]
輸出：-100000

解題思路：

本來想使用2次循環的思路，但是超時， 翻看了一下別人的做法，發現一個比較好的思路，具體看代碼

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        for i in range(1, len(nums)):
            nums[i]= nums[i] + max(nums[i-1], 0)
        return max(nums)

 

125. 驗證回文串

給定一個字符串，驗證它是否是回文串，只考慮字母和數字字符，可以忽略字母的大小寫。

說明：本題中，我們將空字符串定義為有效的回文串。

示例 1:

輸入: "A man, a plan, a canal: Panama"
輸出: true
示例 2:

輸入: "race a car"
輸出: false

解題思路：本來想使用正則表達式，但是用得不是很熟練，就使用簡單的枚舉了

class Solution(object):
    def isPalindrome(self, s):
        """
        :type s: str
        :rtype: bool
        """
        
        
        s=s.lower()
        l=[]
        for i in s:
            if  i in 'qwertyuiopasdfghjklzxcvbnm0987654321':
                l.append(i)
            
        s=''.join(l)
        if s==s[::-1]:
            return True
        else:
            return False

 

122. 買賣股票的最佳時機 II

給定一個數組 prices ，其中 prices[i] 是一支給定股票第 i 天的價格。

設計一個算法來計算你所能獲取的最大利潤。你可以盡可能地完成更多的交易（多次買賣一支股票）。

注意：你不能同時參與多筆交易（你必須在再次購買前出售掉之前的股票）。

 

示例 1:

輸入: prices = [7,1,5,3,6,4]
輸出: 7
解釋: 在第 2 天（股票價格 = 1）的時候買入，在第 3 天（股票價格 = 5）的時候賣出, 這筆交易所能獲得利潤 = 5-1 = 4 。
  隨后，在第 4 天（股票價格 = 3）的時候買入，在第 5 天（股票價格 = 6）的時候賣出, 這筆交易所能獲得利潤 = 6-3 = 3 。
示例 2:

輸入: prices = [1,2,3,4,5]
輸出: 4
解釋: 在第 1 天（股票價格 = 1）的時候買入，在第 5 天 （股票價格 = 5）的時候賣出, 這筆交易所能獲得利潤 = 5-1 = 4 。
  注意你不能在第 1 天和第 2 天接連購買股票，之后再將它們賣出。因為這樣屬於同時參與了多筆交易，你必須在再次購買前出售掉之前的股票。
示例 3:

輸入: prices = [7,6,4,3,1]
輸出: 0
解釋: 在這種情況下, 沒有交易完成, 所以最大利潤為 0。
 

解題思路：這個比之前的股票題簡單很多，我們只需要求出后面一個減去前面的值，然后將大於0的值全部加起來，得到就是全部收益

class Solution(object):
    def maxProfit(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        import numpy as np 
        s=0
        for i in np.diff(prices):
            if i>0:
                s=s+i
        return s

 

217. 存在重復元素

給定一個整數數組，判斷是否存在重復元素。

如果存在一值在數組中出現至少兩次，函數返回 true 。如果數組中每個元素都不相同，則返回 false 。

 

示例 1:

輸入: [1,2,3,1]
輸出: true
示例 2:

輸入: [1,2,3,4]
輸出: false
示例 3:

輸入: [1,1,1,3,3,4,3,2,4,2]
輸出: true

解題思路：這個更加簡單了，只需要比較原來的長度和set之后的長度

class Solution(object):
    def containsDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        l=len(nums)
        l1=len(set(nums))

        if l>l1:
            return True
        else:
            return False

 

219. 存在重復元素 II

給定一個整數數組和一個整數 k，判斷數組中是否存在兩個不同的索引 i 和 j，使得 nums [i] = nums [j]，並且 i 和 j 的差的 絕對值 至多為 k。

 

示例 1:

輸入: nums = [1,2,3,1], k = 3
輸出: true
示例 2:

輸入: nums = [1,0,1,1], k = 1
輸出: true
示例 3:

輸入: nums = [1,2,3,1,2,3], k = 2
輸出: false

解題思路：詳情見代碼

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        l_ = len(nums)
        if l_ == len(set(nums)): #如果長度相等，則沒有重復值
            return False
        else:
            for i in range(l_):
                if nums[i] in nums[i+1:i+k+1]:  #如果能在i+k+1內找到和第i個值相等的值，則返回true，並且找到即可中斷循環break
                    return True
                    break
                elif i==l_-1:  #否則等到i為最后一個未知，則反正false
                    return False

 

238. 除自身以外數組的乘積

給你一個長度為 n 的整數數組 nums，其中 n > 1，返回輸出數組 output ，其中 output[i] 等於 nums 中除 nums[i] 之外其余各元素的乘積。

 

示例:

輸入: [1,2,3,4]
輸出: [24,12,8,6]
 

提示：題目數據保證數組之中任意元素的全部前綴元素和后綴（甚至是整個數組）的乘積都在 32 位整數范圍內。

說明: 請不要使用除法，且在 O(n) 時間復雜度內完成此題。

進階：
你可以在常數空間復雜度內完成這個題目嗎？（ 出於對空間復雜度分析的目的，輸出數組不被視為額外空間。）

解題思路：1、本來是想將nums的乘積計算出來，然后做一次for循環，每次除以該位置的值即可，但是如果元素中存在着0，這種做法就不適用了

2、每次計算一次乘積，該方法超時了

3、使用進出思想，減少乘的計算，只需要原來的乘/出去的*進來的，最后注意一下0，減少了操作時間

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        def f(x,a):
            if a > 1:
                return f(x,a-1)*x[a-1]
            else:
                return x[0] 
        l_= len(nums)   
        s=f(nums[1:],l_-1)  #先計算不要第一個數后的乘
        l=[s]
        in_num , ou_num = 1,1
        for i in range(1,l_):  #從第二個元素開始
            in_num = nums[i-1]  #進來的元素
            out_num = nums[i] #出去的元素
            if out_num!=0:
                s=int(s/out_num*in_num)  #出去的元素非0，就可以直接計算
            else:
                s=f([nums[j] for j in range(0,l_) if j!=i ],l_-1)  #出去的元素為0，等重新再計算乘
            l.append(s)
            
        return l

 

 

345. 反轉字符串中的元音字母

編寫一個函數，以字符串作為輸入，反轉該字符串中的元音字母。

 

示例 1：

輸入："hello"
輸出："holle"
示例 2：

輸入："leetcode"
輸出："leotcede"

解題思路：看代碼，主要是記住這個位置和值得使用

class Solution:
    def reverseVowels(self, s: str) -> str:
        yuanyin = list('aeiouAEIOU')  #元音字母
        a=''
        l=[]
        for i in range(len(s)): 
            if s[i] in yuanyin:
                a=a+s[i] #保存s出現的元音字母
                l.append(i) #保存出現的位置
        a=a[::-1]  #反轉元音
        s=list(s) #主要是str不能直接切片賦值
        for i,j in enumerate(l): #只需要遍歷出現的位置
           s[j]=a[i]  #直接替換
        return ''.join(s) #再合並

 

 

367. 有效的完全平方數

給定一個 正整數 num ，編寫一個函數，如果 num 是一個完全平方數，則返回 true ，否則返回 false 。

進階：不要 使用任何內置的庫函數，如  sqrt 。

 

示例 1：

輸入：num = 16
輸出：true
示例 2：

輸入：num = 14
輸出：false

解題思路：只要能找到一個正整數n*n=num,即可，本來是想使用for循環的，但是超時警告，然后轉為while 

class Solution(object):
    def isPerfectSquare(self, num):
        """
        :type num: int
        :rtype: bool
        """
        l=[]
        i=1
        while i*i<=num:
            if i**2==num:
                
                l.append(i)
            i=i+1
            
        if len(l)>=1:
            return True
        else:
            return False
                

 

349. 兩個數組的交集

給定兩個數組，編寫一個函數來計算它們的交集。

 

示例 1：

輸入：nums1 = [1,2,2,1], nums2 = [2,2]
輸出：[2]
示例 2：

輸入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
輸出：[9,4]
 

說明：

輸出結果中的每個元素一定是唯一的。
我們可以不考慮輸出結果的順序。

解題思路：首先將2個數組合在一起，在set()去重，然后for循環去重后的set，如果在2個數組中都能找到，則添加到一個list里面去，最后輸出list

class Solution(object):
    def intersection(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        l=[]
        for i in set(nums1+nums2):
            if i in nums1 and i in nums2:
                l.append(i)
        return l

 

350. 兩個數組的交集 II

給定兩個數組，編寫一個函數來計算它們的交集。

 

示例 1：

輸入：nums1 = [1,2,2,1], nums2 = [2,2]
輸出：[2,2]
示例 2:

輸入：nums1 = [4,9,5], nums2 = [9,4,9,8,4]
輸出：[4,9]
 

說明：

輸出結果中每個元素出現的次數，應與元素在兩個數組中出現次數的最小值一致。
我們可以不考慮輸出結果的順序。
進階：

如果給定的數組已經排好序呢？你將如何優化你的算法？
如果 nums1 的大小比 nums2 小很多，哪種方法更優？
如果 nums2 的元素存儲在磁盤上，內存是有限的，並且你不能一次加載所有的元素到內存中，你該怎么辦？

解題思路：這個和上面的思路基本一致，只不過在添加到list里面時，根據元素出現最小次數覺得生成元素的個數

class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        l=[]
        for i in set(nums1+nums2):
            if i in nums1 and i in nums2:
                n=min(nums1.count(i),nums2.count(i)) l=l+([i]*n) return l

 

374. 猜數字大小

猜數字游戲的規則如下：

每輪游戲，我都會從 1 到 n 隨機選擇一個數字。 請你猜選出的是哪個數字。
如果你猜錯了，我會告訴你，你猜測的數字比我選出的數字是大了還是小了。
你可以通過調用一個預先定義好的接口 int guess(int num) 來獲取猜測結果，返回值一共有 3 種可能的情況（-1，1 或 0）：

-1：我選出的數字比你猜的數字小 pick < num
1：我選出的數字比你猜的數字大 pick > num
0：我選出的數字和你猜的數字一樣。恭喜！你猜對了！pick == num
返回我選出的數字。

 

示例 1：

輸入：n = 10, pick = 6
輸出：6
示例 2：

輸入：n = 1, pick = 1
輸出：1
示例 3：

輸入：n = 2, pick = 1
輸出：1
示例 4：

輸入：n = 2, pick = 2
輸出：2

解題思路：本來想使用while循環，在1-n里面選擇答案，但是這種方法很容易超時，因此改用二分法去尋找，每次使用i~(n-i)/2（就是說i~n的中值）尋找，猜中值和pick是否相等

# The guess API is already defined for you.
# @param num, your guess
# @return -1 if my number is lower, 1 if my number is higher, otherwise return 0
# def guess(num):

class Solution(object):
    def guessNumber(self, n):
        """
        :type n: int
        :rtype: int
        """

            
        left = 1
        right = n
        while left < right:
            mid = left + (right - left) // 2 #二分法，也即是說在1~(n-i)/2里面去尋找
            if guess(mid) == 1:
                left = mid + 1
            else:
                right = mid
        return left

 

434. 字符串中的單詞數

統計字符串中的單詞個數，這里的單詞指的是連續的不是空格的字符。

請注意，你可以假定字符串里不包括任何不可打印的字符。

示例:

輸入: "Hello, my name is John"
輸出: 5
解釋: 這里的單詞是指連續的不是空格的字符，所以 "Hello," 算作 1 個單詞。

解題思路：str.split(' ')，然后再注意一下分割之后是否是空格，將非空格的裝到一個list去，然后計算list的長度

class Solution(object):
    def countSegments(self, s):
        """
        :type s: str
        :rtype: int
        """
        l = (s.split(' '))
        l1=[]
        for i in l:
            if i!='':
                l1.append(i)

        return len(l1)