解题报告
Day1
1. 2235.两数之和
给你两个整数 num1 和 num2，返回这两个整数的和。
示例 1：
输入：num1 = 12, num2 = 5
输出：17
解释：num1 是 12，num2 是 5 ，它们的和是 12 + 5 = 17 ，因此返回 17 。
示例 2：
输入：num1 = -10, num2 = 4
输出：-6
解释：num1 + num2 = -6 ，因此返回 -6 。
提示：
-100 <= num1, num2 <= 100
初次解
class Solution:
def sum(self, num1: int, num2: int) -> int:
return num1 + num2
通过
2. 1929.数组串联
给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标 从 0 开始计数 ，对于所有 0 <= i < n 的 i ，满足下述所有要求：
ans[i] == nums[i]ans[i + n] == nums[i]
具体而言，ans 由两个 nums 数组 串联 形成。
返回数组 ans 。
示例 1：
输入：nums = [1,2,1]
输出：[1,2,1,1,2,1]
解释：数组 ans 按下述方式形成：
- ans = [nums[0],nums[1],nums[2],nums[0],nums[1],nums[2]]
- ans = [1,2,1,1,2,1]
示例 2：
输入：nums = [1,3,2,1]
输出：[1,3,2,1,1,3,2,1]
解释：数组 ans 按下述方式形成：
- ans = [nums[0],nums[1],nums[2],nums[3],nums[0],nums[1],nums[2],nums[3]]
- ans = [1,3,2,1,1,3,2,1]
提示：
n == nums.length1 <= n <= 10001 <= nums[i] <= 1000
初次解
class Solution:
def getConcatenation(self, nums: List[int]) -> List[int]:
for i in range(len(nums)):
nums.insert(len(nums)+i, nums[i])
ans = nums
return ans
思路
遍历数组加后边
但是感觉for应该没有必要
其他题解
官方解
class Solution:
def getConcatenation(self, nums: List[int]) -> List[int]:
nums.extend(nums)
return nums
网友分享
class Solution:
def getConcatenation(self, nums: List[int]) -> List[int]:
return nums * 2
作者：int_64
链接：https://leetcode.cn/problems/concatenation-of-array/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
反省
-
想复杂了
-
忘记了extend和直接的*2甚至直接相加就行
extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。
3. 0771.宝石与石头
给你一个字符串 jewels 代表石头中宝石的类型，另有一个字符串 stones 代表你拥有的石头。 stones 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
字母区分大小写，因此 "a" 和 "A" 是不同类型的石头。
示例 1：
输入：jewels = "aA", stones = "aAAbbbb"
输出：3
示例 2：
输入：jewels = "z", stones = "ZZ"
输出：0
提示：
1 <= jewels.length, stones.length <= 50jewels和stones仅由英文字母组成jewels中的所有字符都是 唯一的
初次解
class Solution:
def numJewelsInStones(self, jewels: str, stones: str) -> int:
count = 0
for i in jewels:
count += stones.count(i)
return count
思路
用了python List中的count()函数
遍历stones，分别用jewels中的元素寻找是否有一致的
其他题解
不用自带方法
class Solution:
def numJewelsInStones(self, jewels: str, stones: str) -> int:
count = 0
for i in jewels:
for j in stones:
if i == j:
count += 1
return count
官方解
# 暴力解
class Solution:
def numJewelsInStones(self, jewels: str, stones: str) -> int:
return sum(s in jewels for s in stones) # 生成器表达式
# 降低时间复杂度 使用哈希字符集
class Solution:
def numJewelsInStones(self, jewels: str, stones: str) -> int:
jewelsSet = set(jewels)
return sum(s in jewelsSet for s in stones)
反省
-
生成器表达式
Python中的生成器表达式是一种紧凑的语法形式，用于创建生成器对象。生成器对象可以用于迭代，一次生成一个值，而不是一次性生成所有值，从而节省内存和提高效率。生成器表达式的语法类似于列表推导式，但使用()来定义，而不是[]
(expression for item in iterable if condition)- expression：这是生成器要生成的值的表达式。
- item：这是在每次迭代中从可迭代对象 iterable中取出的元素。
- iterable：这是要迭代的可迭代对象，通常是列表、元组、集合、字符串等。
- condition（可选）：这是一个条件表达式，用于筛选哪些元素将被包括在生成器中。只有满足条件的元素才会生成。
故上述代码意思为判断s是否在jewels中，其中s是从stones中取出来的，值为true的时候才会被sum函数计数
-
集合的查找操作的平均时间复杂度是平均O(1)，因为集合是基于哈希表（hash table）实现的数据结构。
哈希表是一种高效的数据结构，用于存储和检索数据。
它的工作原理是将每个元素映射到一个特定的位置（称为哈希桶）以进行快速查找。
哈希表的平均查找时间是常数时间，这意味着无论哈希表中有多少元素，查找单个元素所需的时间大致相同。
Day2
1. 1480.一维数组的动态和
给你一个数组 nums 。数组「动态和」的计算公式为：runningSum[i] = sum(nums[0]…nums[i]) 。
请返回 nums 的动态和。
示例 1：
输入：nums = [1,2,3,4]
输出：[1,3,6,10]
解释：动态和计算过程为 [1, 1+2, 1+2+3, 1+2+3+4] 。
示例 2：
输入：nums = [1,1,1,1,1]
输出：[1,2,3,4,5]
解释：动态和计算过程为 [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1] 。
示例 3：
输入：nums = [3,1,2,10,1]
输出：[3,4,6,16,17]
提示：
1 <= nums.length <= 1000-10^6 <= nums[i] <= 10^6
初次解
class Solution:
def runningSum(self, nums: List[int]) -> List[int]:
for i in range(len(nums)):
if i > 0:
nums[i] = nums[i-1]+nums[i]
return nums
思路
直接从第二个开始前一项加本项
其他题解
官方解
class Solution:
def runningSum(self, nums: List[int]) -> List[int]:
n = len(nums)
for i in range(1, n):
nums[i] += nums[i - 1]
return nums
2. 转换成小写字母
给你一个字符串 s ，将该字符串中的大写字母转换成相同的小写字母，返回新的字符串。
示例 1：
输入：s = "Hello"
输出："hello"
示例 2：
输入：s = "here"
输出："here"
示例 3：
输入：s = "LOVELY"
输出："lovely"
提示：
1 <= s.length <= 100s由 ASCII 字符集中的可打印字符组成
初次解
class Solution:
def toLowerCase(self, s: str) -> str:
t = ""
for i in range(len(s)):
if ord('A') <= ord(s[i]) <= ord('Z'):
t += chr(ord(s[i]) + 32)
else:
t += s[i]
return t
# 使用函数
class Solution:
def toLowerCase(self, s: str) -> str:
return s.lower()
思路
看ASCII码是否在AZ之间，是的话-32得到小写字母
其他题解
官方解
class Solution:
def toLowerCase(self, s: str) -> str:
return "".join(chr(asc | 32) if 65 <= (asc := ord(ch)) <= 90 else ch for ch in s) # 列表推导式
反省
-
列表推导式
和生成器表达式的语法类似，但使用[]来定义，而不是()
-
:=
在
asc := ord(ch)中它将计算ord(ch)的结果并将其赋值给asc变量。该运算符可以在表达式阶段就赋值
3. 最富有客户的资产总量
给你一个 m x n 的整数网格 accounts ，其中 accounts[i][j] 是第 i 位客户在第 j 家银行托管的资产数量。返回最富有客户所拥有的 资产总量 。
客户的 资产总量 就是他们在各家银行托管的资产数量之和。最富有客户就是 资产总量 最大的客户。
示例 1：
输入：accounts = [[1,2,3],[3,2,1]]
输出：6
解释：
第 1 位客户的资产总量 = 1 + 2 + 3 = 6
第 2 位客户的资产总量 = 3 + 2 + 1 = 6
两位客户都是最富有的，资产总量都是 6 ，所以返回 6 。
示例 2：
输入：accounts = [[1,5],[7,3],[3,5]]
输出：10
解释：
第 1 位客户的资产总量 = 6
第 2 位客户的资产总量 = 10
第 3 位客户的资产总量 = 8
第 2 位客户是最富有的，资产总量是 10
示例 3：
输入：accounts = [[2,8,7],[7,1,3],[1,9,5]]
输出：17
提示：
m == accounts.lengthn == accounts[i].length1 <= m, n <= 501 <= accounts[i][j] <= 100
初次解
class Solution:
def maximumWealth(self, accounts: List[List[int]]) -> int:
m_w = 0
for i in accounts:
w = 0
for j in i:
w += j
if w > m_w:
m_w = w
return m_w
思路
遍历二维数组，在每一行做加法得到的值和max作比较，更大就替换，最后输出
其他题解
官方解
class Solution:
def maximumWealth(self, accounts: List[List[int]]) -> int:
return max(map(sum, accounts))
反省
-
map()会根据提供的函数对指定序列做映射
map(function, iterable, ...)