LeetCode学习笔记1

1.判断是否回文数：

def isPalindrome(x):
    x=str(x)
    xx=x[::-1]
    return True if xx==x else False

isPalindrome(-121)#False
isPalindrome(121)#True

2.给定一个无序的整数数组，找到其中最长上升子序列的长度。（动态规划）

输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        if nums==[]:
            return 0
        L=len(nums)
        dp=[1 for _ in range(L)]
        for i in range(L):
            for j in range(i):
                if nums[j]<nums[i]:
                    dp[i]=max(dp[i],dp[j]+1)
        return max(dp)

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

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        start,res,cache=0,0,{}
        for idx,c in enumerate(s):
            if c in cache and cache[c]>=start:
                start=cache[c]+1
                cache[c]=idx
            else:
                cache[c]=idx
                cur=idx-start+1
                res=max(res,cur)
        return res

4.给定两个大小为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出这两个正序数组的中位数，

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        nums3=nums1+nums2
        nums3.sort()
        i=len(nums3)//2
        j=len(nums3)//2-int(len(nums3)%2==0)
        return (nums3[i]+nums3[j])/2

6.将一个给定字符串根据给定的行数，以从上往下、从左到右进行 Z 字形排列。

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        cache=[i for i in range(numRows)]+[i for i in range(1,numRows-1)][::-1]
        res=['']*numRows
        for i ,c in enumerate(s):
            res[cache[i%len(cache)]]+=c
        return ''.join(res)

　　

7.给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。

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

8.首先，该函数会根据需要丢弃无用的开头空格字符，直到寻找到第一个非空格的字符为止。接下来的转化规则如下：

如果第一个非空字符为正或者负号时，则将该符号与之后面尽可能多的连续数字字符组合起来，形成一个有符号整数。
假如第一个非空字符是数字，则直接将其与之后连续的数字字符组合起来，形成一个整数。
该字符串在有效的整数部分之后也可能会存在多余的字符，那么这些字符可以被忽略，它们对函数不应该造成影响。
注意：假如该字符串中的第一个非空格字符不是一个有效整数字符、字符串为空或字符串仅包含空白字符时，则你的函数不需要进行转换，即无法进行有效转换。

在任何情况下，若函数不能进行有效的转换时，请返回 0 。

提示：

本题中的空白字符只包括空格字符 ' ' 。
假设我们的环境只能存储 32 位大小的有符号整数，那么其数值范围为 [−231,  231 − 1]。如果数值超过这个范围，请返回  INT_MAX (231 − 1) 或 INT_MIN (−231) 。

class Solution:
    def myAtoi(self, str: str) -> int:
        str=str.lstrip()
        if len(str)==0 or (str[0].isdigit()==False and str[0] not in ['-','+']):
            return 0
        res,i=str[0],1
        while i<len(str) and str[i].isdigit():
            res+=str[i]
            i+=1
        try:
            res=int(res)
            return min(max(res,-2**31),2**31-1)
        except:
            return 0

9.判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。

class Solution:
    def isPalindrome(self, x: int) -> bool:
        return x>=0 and int(str(x)[::-1])==x
class Solution:
    def isPalindrome(self, x: int) -> bool:
        if x<0 :return False
        res,temp=0,x
        while temp:#数字反取
            res=res*10+temp%10
            temp//=10
        return res==x

13. 罗马数字转整数

class Solution:
    def romanToInt(self, s: str) -> int:
        ref={'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M' : 1000}
        if not str:
            return 0
        res=ref[s[0]]#第一数字先确定
        for i in range(1,len(s)):
            prev=s[i-1]
            cur=s[i]
            if ref[prev]<ref[cur]:
                res+=(ref[cur]-2*ref[prev])#因为prev已经加过一次了，所以减2倍
            else:
                res+=ref[cur]#加上后面的值
        return res

　　

14.查找字符串数组中的最长公共前缀　　

class Solution:
    def longestCommonPrefix(self, strs: List[str]) -> str:
        if not strs:
            return ''
        res=min(strs,key=len)
        for j in strs:
            for i in range(len(res)):
                if j[i]!=res[i]:
                    res=res[:i]
                    break
        return res

　

15.给你一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？请你找出所有满足条件且不重复的三元组。

20.给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。

class Solution:
    def isValid(self, s: str) -> bool:
        stack=[]
        cache={'(':')','[':']','{':'}'}
        for c in s:
            if c in cache:
                stack.append(c)
                continue
            if len(stack)==0 or cache[stack.pop()] !=c:
                return False
        return stack==[]