由於剛開始練習，所以比較菜。python學了感覺跟沒學一樣，所以想找些題來練習練習。日後將會不斷的更新，如果哪位大神有更好的思路可以在評論區留言。

1. 兩數之和

解題思路：由於剛開始，演算法知道的比較少，所以就想來分享一下大神們的思路，20個案例用時40ms。他的思路是這樣的：建立一個用來存放檢查的字典，用target去逐個減去nums列表裡的值，將這些差值存入字典，然後遍歷列表nums，如果之後遇到的數字有和字典中的值一樣，那麼輸出字典中之所對應的key（被減數的索引）和當前數的索引。

程式碼如下

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

        check={}
        for i in range(len(nums)):
            if nums[i] in check:
                return [check[nums[i]],i]
            else:
                check[target-nums[i]]=i
 

2. 兩數相加

解題思路：之前沒有怎麼學過連結串列，對連結串列不是很懂，在查閱了一些資料之後，稍微有些理解了。如果有說的不對的地方歡迎糾正指導。首先要知道單鏈表由兩部分組成：元素和指標，元素是用來存放資料的，指標是用來存放下一個節點元素的地址。

兩數相加就意味著兩個連結串列對應節點的元素值相加。在程式碼前五行就定義了一個連結串列，self.val為元素的值，self.next為指標。在寫程式碼的過程中要注意設一個負責進位的變數。具體的程式碼流程我在程式碼中加具體的註釋。

程式碼如下

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        #先初始化temp連結串列，l3連結串列指向temp的0值地址
        temp = ListNode(0)
        l3 = temp
        a = 0   #進位的數字
        #當l1不為空或者l2不為空或者a不等於0的時候
        while l1 != None or l2 !=None or a != 0:
            if l1 != None:
                #a等於a加上l1當前的值
                a += l1.val
                #l1的指標指向下一個元素，下次呼叫l1.val就是下一個元素的值
                l1 = l1.next
            if l2 != None:
                a += l2.val      #把l2和l1相應節點的值相加賦給a
                l2 = l2.next
            #temp的下一個的值就是 a%10
            temp.next = ListNode(a%10)   
            temp = temp.next   
            a=a//10
        #l3代替temp來輸出連結串列
        return l3.next
 

另外一種寫法的程式碼

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        # 如果有一個連結串列為空，返回另外一個
        if l1 is None:
            return l2
        if l2 is None:
            return l1
        # tmp是暫存（temporal）
        tmp = ListNode(0)  # 引用ListNode類定義了一個連結串列節點並賦給tmp
        # res是重置（reset）
        res = tmp  # 賦值
        # flag 標示
        flag = 0  # 初始化
        while l1 or l2:  # l1或l2不為空就持續執行
            tmp_sum = 0  # 連結串列節點值的和
            if l1:  # 如果l1不為空，把l1的某個節點值的和賦給tmp_sum
                tmp_sum = l1.val  # 把l1的某個節點的值賦給tmp_sum
                l1 = l1.next
            if l2:  # 如果l2不為空，把l2中和l1對應的節點的值加到tmp_sum
                tmp_sum += l2.val
                l2 = l2.next  # 指向下一個節點，為下一次的加和做準備
            tmp_res = ((tmp_sum + flag) % 10)  # 個位數字
            flag = ((tmp_sum + flag) // 10)  # 進位的數
            res.next = ListNode(tmp_res)
            res = res.next  # res後移
            if flag:  # 如果flag不為0，就是對應位置相加後有進位
                res.next = ListNode(1)  # res的下一節點設為1
        res = tmp.next  # 賦值
        del tmp  # 刪除tmp變數
        return res  # 返回res連結串列
 

7.反轉整數

自己的解題思路：首先將輸入的有符整數轉換為字串，然後進行判斷，正數直接反轉，負數去除符號後進行反轉，最後將反轉後的字串轉換為整數進行輸出，在返回的時候加一個判斷數字範圍的條件。大神的解題思路和我們的差不多，不過他的程式碼更為簡便。

自己程式碼如下

class Solution:
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        str_x = str(x)
        if '-' in str_x:
            flip = str_x[1:][::-1]
            result = -int(flip)
        else:
            flip = str_x[::-1]
            result = int(flip)
        return result if -2147483648 < result < 2147483647 else 0

大神程式碼如下

class Solution:
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        flag = 0
        if x > 0:
            flag = 1
        else:
            flag = -1
        s = str(abs(x))[::-1]
        n = int(s) * flag
        return n if n.bit_length() < 32 else 0

8. 字串轉整數 (atoi)

這個程式碼調的我真的要吐了，由於自己的邏輯性不好，所以調了有六七次才通過。希望自己以後在考慮問題的時候邏輯性強一些，考慮問題全一些。

解題思路：按照題目的要求一步一步來，先移除字串句首的空格，如果句首如果為+或者-，那麼就從字串的第二個字元開始後續工作，如果為空字元就返回0，然後逐位進行遍歷判斷，是數字就保留，不是數字就截止，最後進行判斷，空字元返回0，是數字進行返回並進行範圍考慮。

程式碼如下：

class Solution:
    def myAtoi(self, str):
        """
        :type str: str
        :rtype: int
        """
        str = str.strip()
        if not str:
            return 0
        num = ['0','1','2','3','4','5','6','7','8','9',]
        flag = 1
        if (str[0] == '-'):
            str = str[1:]
            flag= -1
        elif(str[0] == '+'):
            str = str[1:]
        for x in range(len(str)):
            if str[x] not in num:
                str = str[0:x]
                break
        if str == '':
            return 0
        result = int(str)*flag
        if result < -2**31:
            return -2**31
        elif result > 2**31-1:
            return 2**31-1
        else:
            return result

直接上前幾名的程式碼，思路也非常明確。直接從字串開始一位一位判斷，不去轉換為整數。

class Solution:
    def myAtoi(self, str):
        """
        :type str: str
        :rtype: int
        """
        if (str == ""):
            return 0
        res = ''
        index = 0
        while index < len(str) and str[index] == ' ':
            index += 1
        if index < len(str) and str[index] in '-+':
            res += str[index]
            index += 1
        while index < len(str) and str[index] in '0123456789':
            res += str[index]
            index += 1
    
        if (res == '' or res == '+' or res == '-'):
            return 0
        if (int(res) > 2**31 - 1):
            return 2**31 - 1
        elif (int(res) < -2**31):
            return -2**31
        else:
            return int(res)

class Solution:  
    def myAtoi(self, str):  
        """ 
        :type str: str 
        :rtype: int 
        """  
        import re  
        res = re.findall(r"^[\+\-]?\d+",str.strip())  
        print(res)  
        if res !=[]:  
            if int(res[0]) > (2**31-1):  
                return (2**31-1)  
            if int(res[0]) < (-2**31):  
                return (-2**31)  
            return int(res[0])  
        else:  
            return 0 

9. 迴文數

解題思路：這道題有兩種解法。1、常規的解法就是將輸入的整形數轉換為字串，再將字串進行反轉，之後與原數進行判斷。2、第二種方法是採用數學的方法。方法為逐次整除，將餘數提取出來帶入,重新組建數字，不斷乘以10去加上新算出的餘數，如果是迴文數字，那麼新組建的數字就和輸入的一樣。

注意：python中" / "就表示 浮點數除法，返回浮點結果;" // "表示整數除法

方法一程式碼如下

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

方法二程式碼

class Solution:
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        if x > 0:
            n,newed = 0,0
            n = x
            while x > 0:
                newed = newed *10 + x % 10
                x = x//10
            if newed == n:
                return True
            else:
                return False
        elif x == 0:
            return True
        elif x < 0:
            return False

看了第一名的程式碼不得不佩服是大佬，請欣賞大佬的表演

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

13、羅馬數字轉整數

解題思路：首先要讀懂題目，對於羅馬這7個字元要熟悉，應該要想到使用字典去構建這個羅馬數字轉字元的儲存，接著去讀懂羅馬數字規則，前面這個數字比後面數字大就正常加上這個數字本身值，如果小的話就用後面這個數字減去前面這個數字的值。初步的想法就是去遍歷每一個字元，與其後面的字元比較，將結果加入總和中，最後存在一個問題，最後一個數字沒有辦法加上，在返回值中加入最後一個數字在比如IV這樣的案例中會重複計算。所以轉換一下想法，在總和的基礎上只添加當前這個數字，比後面大的話為+號，比後面小的話為-號。

我的程式碼如下：

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

這種方法耗時太長，將sum = sum - convert[s[i]]寫為sum -= convert[s[i]]會節約一些時間，我看用時比較快的人寫法是將可能出現的情況都列入字典中，減少了計算的過程，然後從輸入的字元中從前往後遍歷。遍歷的過程中分為兩種情況，一種兩個字元，一種一個字元，然後在字典中尋找相應的值相加。程式碼如下

class Solution:
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """
        convert = {"I":1,"IV":4,"V":5,"IX":9,"X":10,"XL":40,"L":50,"XC":90,"C":100,"CD":400,"D":500,"CM":900,"M":1000}
        len_n = len(s)
        n = 0
        i = 0
        while(i < len_n):
            key = s[i:i+2]
            if key in convert:
                n+=convert[key]
                i+=2
                continue
            key = s[i]
            if key in convert:
                n+=convert[key]
                i+=1
        return n