1. 兩數之和

給定一個整數陣列和一個目標值，找出陣列中和為目標值的兩個數。
你可以假設每個輸入只對應一種答案，且同樣的元素不能被重複利用。

示例:
給定 nums = [2, 7, 11, 15], target = 9
因為 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

思路：先使用enumerate()將nums轉換為可遍歷的物件，接下來開始遍歷，用已知的兩數之和target減去nums遍歷的值，得到一個數字，如果這個數字在nums[index+1:]中，我們就可以得到這個數字的索引了。注意如何還原在該數字在原nums中的索引。

class Solution:
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        for index, value in enumerate(nums):
            sub = target - value            if sub in nums[index+1:]:                return [index, nums[index+1:].index(sub)+len(nums[:index+1])]            else:                pass

7.反轉整數

給定一個 32 位有符號整數，將整數中的數字進行反轉。
注意:
假設我們的環境只能儲存 32 位有符號整數，其數值範圍是 [−231, 231 − 1]。根據這個假設，如果反轉後的整數溢位，則返回 0。

示例 1:
輸入: 123
輸出: 321

示例 2:
輸入: -123
輸出: -321

示例 3:
輸入: 120
輸出: 21

思路：這道題非常簡單，利用Python的切片很容易的將轉為str型別的整數反轉，只需要判斷符號，負數就在反轉之後的數字加上負號。本題的坑就在於32位有符號整數，在返回值時不能越界。

class Solution:
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        if x > 0:
            nums = str(x)[::-1]        else:
            nums =  '-' + str(-x)[::-1]    
        if int(nums) < 2147483648 and int(nums) >= -2147483648:            return int(nums)        else:            return 0

9.迴文數

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

示例 1:
輸入: 121
輸出: true

示例 2:
輸入: -121
輸出: false
解釋: 從左向右讀, 為 -121 。從右向左讀, 為 121- 。因此它不是一個迴文數。

示例 3:
輸入: 10
輸出: false
解釋: 從右向左讀, 為 01 。因此它不是一個迴文數。

思路：本題同樣使用Python的切片，將數字反轉，若反轉之後的list與反轉之前的list值相同，則這個數字是一個迴文數。

class Solution:
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        num = str(x)        if x >= 0:            if num[::-1] == num:                return True
            else:                return False
        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
解釋: C = 100, L = 50, XXX = 30, III = 3.

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

思路：建立羅馬數字對應整數的dict，將輸入的羅馬數字轉為list，遍歷這個list（除去最後一個元素），從左往右，左邊的數字大於右邊的數字，則加左邊對應的整數，若是左邊的數字小與右邊的數字，則減去左邊對應的整數。最後加最後一個羅馬數字對應的整數。

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

14.最長公共字首

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

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

示例 1:
輸入: ["flower","flow","flight"]
輸出: "fl"

示例 2:
輸入: ["dog","racecar","car"]
輸出: ""
解釋: 輸入不存在公共字首。
說明:
所有輸入只包含小寫字母 a-z 。

思路：首先選出這個list中最長的字串，將最長的這個字串作為基準，巢狀遍歷最長的字串以及剩下的字串，判斷作為基準的字串的第一個字母是否等於下一個字串的第一個字元，如果相同則將這個字元加入公共字首，以此類推，若不相等，則開始檢查下一個字串。

class Solution:
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        common = ""
        if len(strs) == 0:            return common

        temp = strs[0]        for word in strs:            if len(word) < len(temp):
                temp = word    
        for i in range(len(temp)):            for j in range(len(strs)):                if temp[i] != strs[j][i]:                    return common
            common += temp[i]        return common

20.有效的括號

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

有效字串需滿足：
左括號必須用相同型別的右括號閉合。
左括號必須以正確的順序閉合。
注意空字串可被認為是有效字串。

示例 1:
輸入: "()"
輸出: true

示例 2:
輸入: "()[]{}"
輸出: true

示例 3:
輸入: "(]"
輸出: false

示例 4:
輸入: "([)]"
輸出: false

示例 5:
輸入: "{[]}"
輸出: true

思路：設定這樣一個dict，key為左括號，value為右括號。遍歷這個由括號組成的字串，如果這個符號不是這個dict的key，將這個符號加入一個名為brackets_list的list中，如果這個符號是dict中的key，則將這個符號加入另一個名為reult的list中，當遍歷到一個符號對應的dict中的key在result這個list中，則將對應的key從result中刪除，同時刪除brackets_list中的這個符號，否則開始下一輪迴圈。遍歷結束後，若result與brackets_list中都沒有任何元素，則返回Ture，反之返回False。

class Solution:
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        brackets_dict = {"(" : ")", "[": "]", "{": "}"}
        str_list = list(s)
        result = []
        brackets_list = []        for bracket in str_list:            if bracket not in brackets_dict:
                brackets_list.append(bracket) 
            if bracket in brackets_dict:
                result.append(bracket)            if len(result) > 0:                if bracket == brackets_dict[result[-1]]:
                    result.pop(-1)
                    brackets_list.remove(bracket)        if len(result) > 0 or len(brackets_list) > 0:            return False
        else:            return True

小禮物走一走，來簡書關注我

作者：3inchtime
連結：

「LeetCode By Python」簡單篇（一）