数组题目及答案（Python）

题目备忘录

已于 2024-09-12 20:09:58 修改

阅读量399

点赞数 7

文章标签：算法数据结构 python

于 2024-09-09 12:15:51 首次发布

本文链接：https://blog.csdn.net/2301_78005408/article/details/142026051

版权

1.加一

给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。最高位数字存放在数组的首位，数组中每个元素只存储单个数字。你可以假设除了整数 0 之外，这个整数不会以零开头。

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        a=len(List)-1
        if List[a]!=9:
            b=list[a]
            b=b+1
            list[a]=b
        else:
            list[a]=0
            c=list[a-1]
            c=c+1
            list[a-1]=c

错误，没有考虑全是9的情况

class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        n = len(digits)
        
        # 从最后一位开始处理
        for i in range(n - 1, -1, -1):
            if digits[i] < 9:
                digits[i] += 1
                return digits
            digits[i] = 0  # 处理进位
            
        # 如果所有位都是9
        return [1] + digits  # 在最前面加一个1，表示新的更高位

这才是正确的，注意：return直接退出循环

2、合并两个数组

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

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.
        """
        nums1[m:] = nums2
        nums1.sort()

还有一种方法

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.
        """
        sorted_list = []
        a, b = 0, 0
        while a < m or b < n:
            if a == m:
                sorted_list.append(nums2[b])
                b += 1
            elif b == n:
                sorted_list.append(nums1[a])
                a += 1
            elif nums1[a] < nums2[b]:
                sorted_list.append(nums1[a])
                a += 1
            else:
                sorted_list.append(nums2[b])
                b += 1
        for i in range(len(sorted_list)):
            nums1[i] = sorted_list[i]

for i in range(len(sorted_list)):
            nums1[i] = sorted_list[i]

3、给定一个非负整数 `numRows`，生成「杨辉三角」的前 `numRows` 行。

在Python中，创建一个空列表有几种方式，这里列举几种常见的方法：

使用空的方括号 []

empty_list = []

这是创建空列表最简单和最常见的方式。empty_list 就是一个空列表，不包含任何元素。

使用 list() 函数：

empty_list = list()

通过 list() 函数也可以创建一个空列表。这种方式较少见，一般建议直接使用 []。

使用推导式的方式：

empty_list = [x for x in []]

class Solution:
    def generate(self, numRows: int) -> List[List[int]]:
        abc=[]
        for i in range (numRows):
            mn=[]
            for j in range(0,i+1):
                if j==0 or j==i:
                    mn.append(1)
                else:
                    mn.append(abc[i - 1][j] + abc[i - 1][j - 1])
            abc.append(mn)
        return abc

注意：for i in range (numRows):而不是for i in range numRows:
需要括号

4、买卖股票

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

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

暴力，还有一种方法

class Solution {
public:
   int maxProfit(vector<int>& prices) {
       int pre = prices[0], ans = 0;
       for (int i = 0; i < prices.size(); i++) {
           ans = max(ans, prices[i] - pre);
           pre = min(pre, prices[i]);
       }
       return ans;
   }
};

第二种方法真好

5、只出现一次的数字

给你一个非空整数数组 nums ，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。你必须设计并实现线性时间复杂度的算法来解决此问题，且该算法只使用常量额外空间。

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        nums.sort()
        for i in range(0, len(nums) - 1, 2):
            if nums[i] != nums[i + 1]:
                return nums[i]
        return nums[-1]

首先，索引问题：在for i in nums循环中，i是nums列表中的元素，而不是索引。因此，nums[i]会产生错误，因为i应该是索引。其次，位运算要学习。最后，为啥最后一句返回最后一个数字呢，因为如果没找到，那么它就是最后一个，比如 11 22 3，或者 11 2 33，但是在上一步就已经返回了。

6、多数元素

创建新字典方法

1. 空字典初始化: counts = {}

这是最常用的方式，创建一个空字典，准备存储键值对。

2. 使用 dict() 构造函数: counts = dict()

这个方式与 {} 的效果相同，也会创建一个空字典。

3.非常好的方法

# 使用从 collections 模块导入整个模块
import collections
mp2 = collections.defaultdict(list) # 正确使用

给定一个大小为 n 的数组 nums ，返回其中的多数元素。多数元素是指在数组中出现次数大于 ⌊ n/2 ⌋ 的元素。你可以假设数组是非空的，并且给定的数组总是存在多数元素。

class Solution:
    def majorityElement(self, nums: List[int]) -> int:
        counts = {}
        
        # 遍历数组
        for num in nums:
            # 如果 num 已经在字典中，计数加1，否则初始化为1
            if num in counts:
                counts[num] += 1
            else:
                counts[num] = 1
            
            # 判断当前元素的计数是否超过了 n/2
            if counts[num] > len(nums) // 2:
                return num

还有哈希表的方法

7、截断句子

句子是一个单词列表，列表中的单词之间用单个空格隔开，且不存在前导或尾随空格。每个单词仅由大小写英文字母组成（不含标点符号）。

例如，"Hello World"、"HELLO" 和 "hello world hello world" 都是句子。

给你一个句子 s 和一个整数 k ，请你将 s 截断，使截断后的句子仅含前 k 个单词。返回截断 s 后得到的句子。

class Solution:
    def truncateSentence(self, s: str, k: int) -> str:
        words = s.split()  # 按空格分割字符串为单词列表
        return ' '.join(words[:k])  # 取前 k 个单词并拼接成字符串

8、数组元素积的符号

可以只看余数是多少，不用一个一个乘起来。

from typing import List

class Solution:
    def arraySign(self, nums: List[int]) -> int:
        # 用于跟踪负数的数量
        negative_count = 0
        
        for num in nums:
            if num == 0:
                return 0
            elif num < 0:
                negative_count += 1
        
        # 如果负数的数量是偶数，则乘积是正数；否则是负数
        if negative_count % 2 == 0:
            return 1
        else:
            return -1

9、检查是否区域内所有整数都被覆盖

class Solution:
    def isCovered(self, ranges: List[List[int]], left: int, right: int) -> bool:
       
    # 创建一个长度为 51 的数组来记录数字是否被覆盖（因为题目中的范围是 1 到 50）
        covered = [False] * 51
    
    # 标记 ranges 中所有覆盖的数字
        for start, end in ranges:
            for i in range(start, end + 1):
                covered[i] = True
    
    # 检查 [left, right] 范围内的每个数字是否都被覆盖
        for i in range(left, right + 1):
            if not covered[i]:
                return False
    
        return True

10、旋转图像

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        n = len(matrix)
        # Python 这里不能 matrix_new = matrix 或 matrix_new = matrix[:] 因为是引用拷贝
        matrix_new = [[0] * n for _ in range(n)]  

        #这句话非常好，记得

        for i in range(n):
            for j in range(n):
                matrix_new[j][n - i - 1] = matrix[i][j]
        # 不能写成 matrix = matrix_new
        matrix[:] = matrix_new

但是有没有更高级的方法呢

class Solution:
    def rotate(self, matrix: List[List[int]]) -> None:
        n = len(matrix)
        for i in range(n // 2):
            for j in range((n + 1) // 2):
                matrix[i][j], matrix[n - j - 1][i], matrix[n - i - 1][n - j - 1], matrix[j][n - i - 1] \
                    = matrix[n - j - 1][i], matrix[n - i - 1][n - j - 1], matrix[j][n - i - 1], matrix[i][j]

解释：48. 旋转图像 - 力扣（LeetCode）https://leetcode.cn/problems/rotate-image/

11、字母异位词分组

首先，字典，输出为值；键为归好的顺序，值为所有包括里面的。

class Solution:
    def groupAnagrams(self, strs: List[str]) -> List[List[str]]:
        mp = collections.defaultdict(list)

        for st in strs:
            key = "".join(sorted(st))
            mp[key].append(st)
        
        return list(mp.values())

1 2、Z字形变化

class Solution:
    def convert(self, s: str, numRows: int) -> str:
        if numRows < 2: return s
        res = ["" for _ in range(numRows)]
        i, flag = 0, -1
        for c in s:
            res[i] += c
            if i == 0 or i == numRows - 1: flag = -flag
            i += flag
        return "".join(res)

13、整数反转

这道题，一开始我想的是把它转换成字符串，然后从右到左重新添加
后来，可以//的方法进行写，注意，为啥res = res * 10 + a
是因为在后面添加一位，就要进10,10进制另一种理解。

class Solution:
    def reverse(self, x: int) -> int:
        res = 0
        if x>0:
            b=1
        else:
            b=-1
        x = abs(x)
        while x != 0:
            a = x % 10
            res = res * 10 + a
            x //= 10  # 使用整数除法
            
            # 溢出检查
            if res > 2147483647 or res < -2147483648:
                return 0
        res=res*b
        return res

14、验证回文子串

class Solution:
    def isPalindrome(self, s: str) -> bool:
        # 初始化mn字符串
        mn = ''
        
        # 遍历字符串s
        for char in s:
            # 判断是否是字母或数字
            if char.isalnum():
                # 转换为小写并添加到mn
                mn += char.lower()
        
        # 将mn倒序
        abc = mn[::-1]
        
        # 判断mn和abc是否相同
        return mn == abc

判断字母

class Solution:
    def isPalindrome(self, s: str) -> bool:
        sgood = "".join(ch.lower() for ch in s if ch.isalnum())
        return sgood == sgood[::-1]

14、猜数字游戏

class Solution {
    public String getHint(String secret, String guess) {
        int n = secret.length();
        int a = 0, b = 0;
        int[] cnt1 = new int[10], cnt2 = new int[10];
        for (int i = 0; i < n; i++) {
            int c1 = secret.charAt(i) - '0', c2= guess.charAt(i) - '0';
            if (c1 == c2) {
                a++;
            } else {
                cnt1[c1]++;
                cnt2[c2]++;
            }
        }
        for (int i = 0; i < 10; i++) b += Math.min(cnt1[i], cnt2[i]);
        return a + "A" + b + "B";
    }
}

class Solution:
    def getHint(self, secret: str, guess: str) -> str:
        A = sum(starmap(eq, zip(secret, guess)))
        B = sum((Counter(secret) & Counter(guess)).values()) - A
        return f"{A}A{B}B"