LeetCode刷刷题（一）

进来工作不是很饱和，有空去LeetCode上刷刷题，随手记录一下

两数之和

题目描述：
给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
比如：

给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

答案如下：

class solution():
    def twosum(self,nums,target):
        length = len(nums)
        print(length)
        i = 0
        while i < length:
            other = target - nums[i]
            for j in range(i + 1, length):
                if other == nums[j]:
                    return (i, j)
            i += 1
if __name__=='__main__':
    s=solution()
    a,b=s.twosum([3,5,4,8],7)
    print(a,b)    ----0,2

反转整数

题目描述：
给定一个 32 位有符号整数，将整数中的数字进行反转。
比如：

输入: 123 -123 120
输出: 321 -321 21

这边有个坑， 32 位有符号整数，其数值范围是 [−2^31, 2^31 − 1],有些数虽然一开始在区间内，但是一反转之后超出范围，对于这些超出范围的数，也返回0

答案如下：

class solution():
    def reverseint(self,x):
        if x <= -(2 ** 31) or x >= 2 ** 31 or x == 0:
            return 0
        else:
            num = str(x)
            if num[0] == '-':
                num = "-" + num[::-1][:-1]
                i = 0
                while i < len(num):
                    if num[1] == 0:
                        num = num[0] + num[2:]
                    else:
                        break
                    i += 1
                if int(num) <= -(2 ** 31):
                    return 0
                else:
                    return int(num)
            else:
                num = num[::-1]
                i = 0
                while i < len(num):
                    if num[0] == '0':
                        num = num[1:]
                    else:
                        break
                    i += 1
                if int(num) >= 2 ** 31:
                    return 0
                else:
                    return int(num)
if __name__=='__main__':
    s=solution()
    a = s.reverseint(1534236469)
    print(a)    ---- 0

回文数

题目描述：
判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数

输入: 121 -121
输出: true false

简单一点可以转换为str之后，利用步进切片，判断是否一致，有点类似上个题目。
这边要求不转换为str
答案如下：

class solution():
    def isPalindrome(self,x):
        # x=str(x)
        # return x == x[::-1]

        pre=x
        back=0
        while pre >0:
            back = back*10 + pre %10
            pre = pre // 10
        return back == x

if __name__=='__main__':
    s=solution()
    a=s.isPalindrome(124421)
    print(a)   ---True

移除元素

题目描述：
给定一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组**并在使用 O(1) 额外空间的条件下完成。
元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

给定 nums = [0,1,2,2,3,0,4,2], val = 2,
函数应该返回新的长度 5, 并且 nums 中的前五个元素为 0, 1, 3, 0, 4。
注意这五个元素可为任意顺序。

答案如下：

class Solution():
    def removeElement(self,nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        i=0
        while i < len(nums):
            if nums[i] == val:
                del(nums[i])
                continue
            i+=1
        print (nums)

if __name__=='__main__':
    s=Solution()
    nums=[1,2,3,4,5,1,3,7,4,3,2]
    val=2
    s.removeElement(nums,val)   ---- [1, 3, 4, 5, 1, 3, 7, 4, 3]

删除排序数组中的重复项

个人觉得这个就是上一个的升级版

题目描述：给定一个排序数组，你需要在原地删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。

给定 nums = [0,0,1,1,1,2,2,3,3,4],
函数应该返回新的长度 5, 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4。

答案如下：

class solution():
    def removeduplicate(self,A):
        i=0
        while i < len(A)-1:
            if A[i] == A[i+1]:
                del(A[i])
                continue
            i+=1
        return A

if __name__=='__main__':
    s=solution()
    nums = [0,0,1,1,1,2,2,3,3,4]
    a=s.removeduplicate(nums)
    print(a)

暂时就写这么多，后面继续刷，继续写。