24、leetcode（python）

# -*- coding: utf-8 -*-
"""
Created on Thu May 30 23:55:33 2019

@author: 40292
"""

"""
1.
给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。

你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。

示例:

给定 nums = [2, 7, 11, 15], target = 9

因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]
"""

class Solution1:
    def twoSum(self, nums: [int], target: int) -> [int]:
        D = {}
        for i in range(len(nums)):
            a = target - nums[i]
            if a in D:
                return [D[a],i]
            else:
                D[nums[i]] = i
        return [-1,-1]

"""
2.
给出两个 非空 的链表用来表示两个非负的整数。其中，它们各自的位数是按照 逆序 的方式存储的，并且它们的每个节点只能存储 一位 数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

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

class ListNode:
    def __init__(self, x):
         self.val = x
         self.next = None
    def __str__(self):
        return [self.val] + self.next
    
class Solution2:
    def addTwoNumbers(self, l1: ListNode, l2: ListNode) -> ListNode:
        res = ListNode(0)
        m1 = l1
        m2 = l2
        m3 = res
        flag = 0
        
        while flag == 1 or m1 or m2:
            sum1 = 0
            if m1:
                sum1 += m1.val
                m1 = m1.next
            if m2:
                sum1 += m2.val
                m2 = m2.next
            m3.val = (sum1+flag)%10
            flag = (sum1+flag)//10
            if flag == 1 or m1 or m2:
                m3.next = ListNode(0)
                m3 = m3.next
        return res
        
l1 = ListNode(2)
l1.next = ListNode(4)
l1.next.next = ListNode(3)
l2 = ListNode(5)
l2.next = ListNode(6)
l2.next.next = ListNode(4)


"""
3.
给定一个字符串，请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。
示例 2:

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。
示例 3:

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
     请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。
"""
s = "abcabcbb"
left = 0
right = 1
class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        L = ''
        len_max = 0
        for i in range(len(s)):
            if s[i] in L:
                len_max = max(len_max, len(L))
                index = L.index(s[i])
                L = L[index+1:] + s[i]
            else:
                L += s[i]
        return  max(len_max, len(L))

#自写
class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        D = {}
        len_max = 0
        start = 0
        for i in range(len(s)):
            if s[i] not in D:
                D[s[i]] = i
            else:
                len_max = max(i-start, len_max)
                if start <= D[s[i]]:
                    start = D[s[i]] + 1
                D[s[i]] = i
        len_max = max(len(s)-start, len_max)
        return len_max