1,兩數之和

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

你可以假設每種輸入只會對應一個答案。但是，陣列中同一個元素不能使用兩遍。

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

我的解答:

時間複雜度為O(n^2)

def twoSum(self, nums: List[int], target: int) -> List[int]:
        
        dic = {i:v for i,v in enumerate(nums)}
        
        for i in dic:
            res = target-dic[i]
            for k in dic:
                if res == dic[k] and k!=i:
                    return i,k
 #解題中遇到的問題:
	1. list.index()如果列表中有相同元素,也只返回的第一個元素的索引
  2. enumerate()返回一個生成器,如果用兩層迴圈去迴圈同一個生成器,那麼內層迴圈不會從第一個元素開始
  3. 不能用列表的值做字典的key,除非你知道如何處理相同key值得覆蓋問題
 

優質解答:

def twoSum(self, nums, target):

        hashmap = {}
        for index, num in enumerate(nums):
            another_num = target - num
            if another_num in hashmap:
                return [hashmap[another_num], index]
            hashmap[num] = index
        return None
特點:
  我的思路是用第一個數找第二個數,本答案思路是由第二個數找第一個數,一個集合中的元素內部有關係時都可以用此方法降低求解難度.
 

2,整數反轉

給出一個 32 位的有符號整數，你需要將這個整數中每位上的數字進行反轉

我的解答:

def reverse(self, x: int) -> int:
        
        _x = list(str(abs(x)))
        _x.reverse()   #這裡沒有必要用列表的reverse,還要拼接回來的,字串和列表都可以用[::-1]反轉
        num = int("".join(_x))
        tag = 2**31
        if x>0 and num <=tag-1:
            return num
        elif x <0 and num <=tag:
            return -num
        else:
            return 0
 

優質解答:

def reverse(self, x: int) -> int:
        a = str(x) if x>0 else str(-x)+'-'
        a = int(a[::-1])
        return a if a <= 2**31-1 and a >= -2**31-1 else 0

3,迴文數

判斷一個整數是否是迴文數。迴文數是指正序（從左向右）和倒序（從右向左）讀都是一樣的整數。

我的解答:

def isPalindrome(self, x: int) -> bool:
        if x>=0:
            _x = str(x)
            _x = int(_x[::-1])
            if x == _x:
                return True
        return False

優質解答:

def isPalindrome(self, x: int) -> bool:
        return True if str(x) == str(x)[::-1] else False
  
  #解析:字串也能比是否相等,先轉成字串反轉再轉int比較多此一舉

4,羅馬陣列轉數字

例如， 羅馬數字 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 的範圍內。

我的解答:一遍過

def romanToInt(self, s: str) -> int:
        dic = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
        res = 0
        i = 0
        while i <len(s)-1:
        
            item = s[i]
            next_item = s[i+1]
            if dic[item]<dic[next_item]:
                res-=dic[item]
            else:
                res += dic[item]
            i+=1
        res += dic[s[i]]
        return res
      #思路:左邊小與右邊減,左邊大於右邊加上

5,最大公共字首

編寫一個函式來查詢字串陣列中的最長公共字首。

如果不存在公共字首，返回空字串 ""。

我的答案:

def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs or '' in strs :
            return ''
        if len(strs) == 1:
            return strs[0]

        res = []
        for i in range(len(strs[0])):
            s = strs[0][0:i+1]
            for item in strs:
                if not item.startswith(s):
                    break
            else: #程式碼走到這說明上面的迴圈是正常結束的
                res.append(s)
                continue #這個continue是用來控制外層迴圈的,跳過下面的程式碼break直接進入下次迴圈
            break #如果內層迴圈是正常結束的這個break永遠都不會執行
        if res:
            return res[-1]
        return ''
      #暴力求解雙迴圈的控制,內層迴圈結束整個迴圈結束rhe控制

優質答案:

def longestCommonPrefix(strs) :
    res = ""
    r = zip(*strs)
    print(r)
    for tmp in zip(*strs):
        tmp_set = set(tmp)
        if len(tmp_set) == 1:
            res += tmp[0]
        else:
            break
    return res

  #1.zip函式的特點,zip可以打包多個物件,迴圈zip物件得到元組

6,有效的括號

我的解答:超過了98.8%的python

def isValid(self, s: str) -> bool:
        dic = {'(':')','{':'}','[':']'}
        lifo = []
        for i in range(len(s)):
            if not lifo:
                lifo.append(s[i])
            else:
                try:
                    if not dic[lifo[-1]] == s[i]:
                        lifo.append(s[i])
                    else:
                        lifo.pop()
                except:
                    return False

        return False if lifo else True

能配對的話一定是一左配一右,按這個規律存入字典裡
迴圈字串,不匹配就加到列表裡,能匹配就刪除列表的最後一個元素
迴圈結束後列表內沒有元素就返回true
如果出現右括號在前,字典內沒有這個key,就直接報錯