【程序人生】leetcode（五）

最新推荐文章于 2022-08-23 18:24:49 发布

Zhang_Chen_

最新推荐文章于 2022-08-23 18:24:49 发布

阅读量272

点赞数

分类专栏：程序人生

原文链接：https://leetcode-cn.com/problemset/all/

版权

程序人生专栏收录该内容

26 篇文章 2 订阅

订阅专栏

【程序人生】leetcode（五）

说在前面
旋转图像(转载)
字母异位词分组(原创)
最大子序和(转载)
最后一个单词的长度(原创)
加一(原创)
二进制求和(原创)
x的平方根(原创)
爬楼梯(转载)
删除排序链表中的重复元素(原创)
合并两个有序数组(转载)
结语

说在前面

这篇博客中部分题目答案来自leetcode评论区，不是本人原创。感谢原作者的工作。这里记录在这篇博客中，方便日后回顾、学习

旋转图像(转载)

给定一个 $n \times n$ 的二维矩阵表示一个图像。
将图像顺时针旋转90度。

你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。

示例：

给定 matrix =
[
[1,2,3],
[4,5,6],
[7,8,9]
],
原地旋转输入矩阵，使其变为:
[
[7,4,1],
[8,5,2],
[9,6,3]
]

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        """
        Do not return anything, modify matrix in-place instead.
        """
        # 行数
        row = len(matrix)
        # 列数
        col = len(matrix[0])

        # 转置
        # [1][2] 和 [2][1]换，[1][3]和[3][1]换 ... [2][3]和[3][2]换 ... [n-1][n]和[n][n-1]换
        for i in range(row - 1):
            for j in range(i + 1, col):
                temp = matrix[i][j]
                matrix[i][j] = matrix[j][i]
                matrix[j][i] = temp
    
        # 镜像
        for i in range(row):
            matrix[i] = matrix[i][::-1]

字母异位词分组(原创)

给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。

示例：

输入: [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]
输出:
[
[“ate”,“eat”,“tea”],
[“nat”,“tan”],
[“bat”]
]

说明：

所有输入均为小写字母。
不考虑答案输出的顺序。

注意python列表操作时间较慢，尽量用字典或者字符串

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        result = {}
        for each in strs:
            # src = list(each)
            # src.sort()
            # key = str(src)
            key = "".join(sorted(each))
            if key not in result:
                result[key] = [each]
            else:
                result[key].append(each)
                
        return list(result.values())

最大子序和(转载)

给定一个整数数组nums，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例：

输入: [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。

指针从1起到最后一个，如果指针位置之前的数组和小于零，则舍弃当前指针之前的部分

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        for i in range(1, len(nums)):
            nums[i]= nums[i] + max(nums[i-1], 0)
            
        return max(nums)

最后一个单词的长度(原创)

给定一个仅包含大小写字母和空格’ '的字符串s，返回其最后一个单词的长度。如果字符串从左向右滚动显示，那么最后一个单词就是最后出现的单词。

如果不存在最后一个单词，请返回0 。

说明：一个单词是指仅由字母组成、不包含任何空格字符的最大子字符串。

示例：

输入: “Hello World”
输出: 5

class Solution:
    def lengthOfLastWord(self, s: str) -> int:
        return len(list(s.strip().split(" ")[-1].strip()))

加一(原创)

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。

最高位数字存放在数组的首位，数组中每个元素只存储单个数字。

你可以假设除了整数 0 之外，这个整数不会以零开头。

示例：

输入: [1,2,3]
输出: [1,2,4]
解释: 输入数组表示数字 123。

示例：

输入: [4,3,2,1]
输出: [4,3,2,2]
解释: 输入数组表示数字 4321。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        result = []
        key = 0
        for i, each in enumerate(digits[::-1]):
            if i == 0:
                result.append((each + key + 1) % 10)
                key = (each + key + 1) // 10
                if len(digits) == 1:
                    if key == 1:
                        result.append(1)
                        break

            elif i == len(digits) - 1:
                result.append((each + key) % 10)
                key = (each + key) // 10

                if key == 1:
                    result.append(1)
            else:
                result.append((each + key) % 10)
                key = (each + key) // 10

        return result[::-1]

二进制求和(原创)

给你两个二进制字符串，返回它们的和（用二进制表示）。

输入为非空字符串且只包含数字1和0。

示例：

输入: a = “11”, b = “1”
输出: “100”

示例：

输入: a = “1010”, b = “1011”
输出: “10101”

class Solution:
    def addBinary(self, a: str, b: str) -> str:
        result = ""
        alist = list(a)[::-1]
        blist = list(b)[::-1]

        if len(alist) > len(blist):
            while len(alist) != len(blist):
                blist.append("0")
        
        if len(alist) < len(blist):
            while len(alist) != len(blist):
                alist.append("0")

        key = 0
        for i, each in enumerate(alist):
            if int(each) + int(blist[i]) + key == 3:
                result = result + "1"
                key = 1
            elif int(each) + int(blist[i]) + key == 2:
                result = result + "0"
                key = 1
            elif int(each) + int(blist[i]) + key == 1:
                result = result + "1"
                key = 0
            else:
                result = result + "0"
                key = 0
        if key == 1:
            result = result + "1"

        return result[::-1]

x的平方根(原创)

实现int sqrt(int x)函数。

计算并返回x的平方根，其中x是非负整数。

由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。

示例：

输入: 8
输出: 2
说明: 8 的平方根是 2.82842…,
由于返回类型是整数，小数部分将被舍去。

class Solution:
    def mySqrt(self, x: int) -> int:
        p = 0
        q = x
        key = False

        while p <= q:
            print(p, q)
            mid = int((p + q) / 2)

            if mid * mid == x:
                return mid
            
            
            if mid * mid > x:
                key = True
                q = mid - 1
            
            if mid * mid < x:
                key = False
                p = mid + 1

        if key is True:
            return mid - 1
        else:
            return mid

爬楼梯(转载)

假设你正在爬楼梯。需要n阶你才能到达楼顶。

每次你可以爬1或2个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定n是一个正整数。

示例：

输入： 2
输出： 2
解释：有两种方法可以爬到楼顶。
1 阶 + 1 阶
2 阶

示例：

输入： 3
输出： 3
解释：有三种方法可以爬到楼顶。
1 阶 + 1 阶 + 1 阶
1 阶 + 2 阶
2 阶 + 1 阶

class Solution:
    def climbStairs(self, n: int) -> int:
        if n <= 2:
            return n 
        else:
            p = 1
            q = 2
            for i in range(3, n + 1):
                temp = p + q
                # 前一个的
                p = q
                # 当前的
                q = temp
            

            return q

删除排序链表中的重复元素(原创)

给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。

示例：

输入: 1->1->2->3->3
输出: 1->2->3

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def deleteDuplicates(self, head: ListNode) -> ListNode:
        node = head
        result = head
        p = head

        if head is None:
            return head

        while node.next is not None:
            node = node.next
            if result.val == node.val:
                continue
            else:
                result.next.val = node.val
                result = result.next

        result.next = None
        return p

合并两个有序数组(转载)

给你两个有序整数数组nums1和nums2，请你将nums2合并到nums1中，使nums1成为一个有序数组。

说明：

初始化nums1和nums2的元素数量分别为m和n。
你可以假设nums1有足够的空间（空间大小大于或等于m + n）来保存 nums2 中的元素。

示例：

输入:
nums1 = [1,2,3], m = 3
nums2 = [2,5,6], n = 3
输出: [1,2,2,3,5,6]

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        for i in range(n): 
            nums1[i + m] = nums2[i] 
        nums1.sort()