9月1日刷題:1-4

 

1. 給定一個整數數組 nums 和一個目標值 target，請你在該數組中找出和爲目標值的那 兩個 整數，並返回他們的數組下標。你可以假設每種輸入只會對應一個答案。但是，你不能重複利用這個數組中同樣的元素。

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

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        dict1 = {}    # 定義一個字典用來存儲nums中遍歷過的元素
        for i in range(len(nums)):
            num = target - nums[i]
            if num not in dict1:
                dict1[nums[i]] = i
            else:
                return [dict1[num], i]

2. 給出兩個 非空 的鏈表用來表示兩個非負的整數。其中，它們各自的位數是按照 逆序 的方式存儲的，並且它們的每個節點只能存儲 一位 數字。如果，我們將這兩個數相加起來，則會返回一個新的鏈表來表示它們的和。您可以假設除了數字 0 之外，這兩個數都不會以 0 開頭。

示例：

輸入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
輸出：7 -> 0 -> 8
原因：342 + 465 = 807

# Definition for singly-linked list.
class ListNode(object):

    def __init__(self, x):
        self.val = x
        self.next = None

    def print_node(self):
        print(self.val)


class Solution(object):

    def addTwoNumbers(self, l1, l2):
        """
        :type l1: ListNode
        :type l2: ListNode
        :rtype: ListNode
        """
        # 新建一個ListNode：值都是0
        head = ret = ListNode(0)

        # 當l1 和 l2不爲空時（或不等於0）
        while l1 and l2:
            # ret的指針指向l1與l2的和值
            ret.next = ListNode(l1.val + l2.val)
            # l1指向下一個值
            l1 = l1.next
            # l2指向下一個值
            l2 = l2.next
            # ret還是0.節點指向下一個節點
            ret = ret.next

        # 當l2位數小於l1時
        while l1:
            ret.next = ListNode(l1.val)
            l1 = l1.next
            ret = ret.next

        # 當l1位數小於l2時
        while l2:
            ret.next = ListNode(l2.val)
            l2 = l2.next
            ret = ret.next

        # 處理進位
        ret = head = head.next
        while head:
            if head.val > 9:
                if head.next == None:                   # 判斷下一個位置是否有數字
                    head.next = ListNode(0)
                head.next.val += int(head.val / 10)     # 進位
                head.val %= 10                          # 當前位置的數
            head = head.next
        print(ret)
        return ret                                      # 返回第一個位置的數


if __name__ == '__main__':

    l1 = ListNode(2)
    l1.next = ListNode(4)
    l1.next.next = ListNode(3)
    # l1.print_node()


    l2 = ListNode(5)
    l2.next = ListNode(6)
    l2.next.next = ListNode(4)
    # l2.print_node()

    solution = Solution()
    l3 = solution.addTwoNumbers(l1, l2)

    l3.print_node()
    l3.next.print_node()
    l3.next.next.print_node()

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

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

示例 1:

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

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

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

這道題主要用到思路是：滑動窗口
    什麼是滑動窗口？其實就是一個隊列,比如例題中的 abcabcbb，進入這個隊列（窗口）爲 abc 滿足題目要求，當再進入 a，隊列
變成了 abca，這時候不滿足要求。所以，我們要移動這個隊列！
    如何移動？我們只要把隊列的左邊的元素移出就行了，直到滿足題目要求！一直維持這樣的隊列，找出隊列出現最長的長度時候，
求出解！
    時間複雜度：O(n)

class Solution(object):
    def lengthOfLongestSubstring(self, s):
        """
        :type s: str
        :rtype: int
        """
        res = ''
        maxlen = 0
        for ch in s:
            if ch not in res:
                res += ch
            else:
                maxlen = max(maxlen, len(res))
                index = res.index(ch)
                res = res[index + 1:] + ch
        return max(maxlen, len(res))


if __name__ == '__main__':
    solution = Solution()
    # print(solution.lengthOfLongestSubstring('abdcagt'))
    print(solution.lengthOfLongestSubstring('abcabcbb'))
    print(solution.lengthOfLongestSubstring('bbbb'))
    print(solution.lengthOfLongestSubstring('pwwkew'))

關於以下代碼執行成功，提交報錯的分析：

class Solution(object):
    def findMedianSortedArrays(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: float
        """
        nums = sorted(nums1+nums2)
        if len(nums)%2 ==0:
            answer = (nums[int(len(nums)/2-1)]+nums[int(len(nums)/2)])/2
        else:
            answer = nums[int((len(nums)+1)/2)-1]
        return answer

解析：這是Python版本的問題。Python2.x和python3.x的語法差異造成的。

 

 

在Python3.0中變成真除法（無論任何類型都會保持小數部分，即使整除也會表示爲浮點數形式）。 

>>> 3/2

1.5

>>> 3/2.0

1.5

>>> 4/2

2.0

>>> 4/2.0

2.0