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中,创建一个空列表有几种方式,这里列举几种常见的方法:
这是创建空列表最简单和最常见的方式。
通过
|
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. 空字典初始化: 这是最常用的方式,创建一个空字典,准备存储键值对。 2. 使用 这个方式与 3.非常好的方法 # 使用从 collections 模块导入整个模块 |
给定一个大小为 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"
15