1. 一维数组的动态和
class Solution:
def runningSum(self, nums: List[int]) -> List[int]:
result = [nums[0]]
for i in range(1, len(nums)):
result.append(result[i-1] + nums[i])
return result感觉有点类似高中的数列，后一个等于前一个加n，以此类推。但是要先定义好第一个是什么，因为第一个没有前一个，从第二个开始才有这个规律。
即： a(n) = a(n - 1) + ???
以下是官方答案：
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
作者：力扣官方题解
链接：https://leetcode.cn/problems/running-sum-of-1d-array/solutions/962723/yi-wei-shu-zu-de-dong-tai-he-by-leetcode-flkm/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。我看了一下，我的思维习惯是，怕在原数据上修改，所以喜欢自己新开一个内存取处理数据，所以跟官方的解法不一样，官方的解法是直接在原数据上修改，hh。
小知识：
def runningSum(self, nums: List[int]) -> List[int]:
这是Python的类型注解（Type Hints）语法。类型注解是Python 3.5版本引入的一个新特性，它允许你为函数的参数和返回值指定预期的类型。这可以帮助开发者理解函数应该如何使用，以及函数的预期输出。
nums: List[int]表示这个函数接受一个名为nums的参数，其预期类型为List[int]，即元素类型为整数的列表。-> List[int]表示这个函数的返回值预期是一个元素类型为整数的列表。
Python的类型注解是可选的，并且Python解释器不会因为类型注解而改变它的行为。类型注解主要用于提高代码的可读性和可维护性，以及支持某些IDE和工具提供更好的代码补全和错误检查功能。
2. 将数字变成0的操作次数
第一脑回路想法：
class Solution:
def numberOfSteps(self, num: int) -> int:
times = 0
while (num):
times += 1
if num % 2 == 0:
num = num/2
else:
num -= 1
return times官方解法：
class Solution:
def numberOfSteps(self, num: int) -> int:
ans = 0
while num:
ans += num & 1
if num > 1:
ans += 1
num >>= 1
return ans
作者：力扣官方题解
链接：https://leetcode.cn/problems/number-of-steps-to-reduce-a-number-to-zero/solutions/1237903/jiang-shu-zi-bian-cheng-0-de-cao-zuo-ci-ucaa4/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。还有糕手（别人）：
class Solution:
def numberOfSteps(self, num: int) -> int:
steps = 0
while num:
steps += 1 + num % 2
num >>= 1
return max(0, steps - 1)如果一个数是偶数，必定至少要经过两部才有可能变成0。
因此，如果一个数是偶数，直接加2次次数再说。
如果不是偶数，steps += 1 + 0。不用担心出问题。
num >>= 1是这个方法的精髓，假设num的二进制为10，那么num的二进制表示是1010，num >> 1的结果是101，也就是5，所以num >>= 1会将num的值改变为5。
num >>= 1是一个位运算符，它的作用是将num的二进制表示向右移动一位。
在Python中，>>是右移运算符，num >> 1等价于将num除以2并向下取整，也就是说，它将num的所有二进制位向右移动一位。=是赋值运算符，num >>= 1等价于num = num >> 1，也就是说，它将num除以2并向下取整的结果赋值给num。
假设一个数是偶数，它的二进制必然是以0结尾（0不是偶数，但也是以0结尾）
假设一个数是奇数，它的二进制必然是以1结尾
如果一个数是奇数，num >>= 1在这种算法中一共是同时做了2步，分别是：除以2 并且 减去1
如果一个数是偶数，num >>= 1在这种算法中一共是1步，是：除以2
就是这样了。
最后，返回0或者steps - 1，而不是直接返steps，这个代码的结果可能会比实际的步骤数多1。这是因为在每次执行函数最后一次迭代中，当num变为1时，steps会增加2，但实际上只需要一步就可以将num减少到0。
3. 列表求和 以及 列表最大值
class Solution:
def maximumWealth(self, accounts: List[List[int]]) -> int:
sums = [sum(item) for item in accounts]
max_value = max(sums)
# rich_man_index = sums.index(max_value)
return max_value我这里使用了列表生成式，
列表生成式的套路是：【赋值给谁 for 父项目 in 祖父项目 for 子项目 in 父项目】
max（列表），可得列表中最大的元素。如果是嵌套列表，则返回最大的子列表，
力扣官方解法：
class Solution:
def maximumWealth(self, accounts: List[List[int]]) -> int:
return max(map(sum, accounts))
作者：力扣官方题解
链接：https://leetcode.cn/problems/richest-customer-wealth/solutions/1411600/zui-fu-you-ke-hu-de-zi-chan-zong-liang-b-8p06/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 map函数会对一个可迭代对象（如列表）中的每个元素应用一个函数。在这个例子中，map函数对accounts中的每个元素（也就是每个子列表）应用sum函数，计算每个子列表的和。map函数返回一个迭代器，它包含了应用函数后的结果。
max函数会返回一个可迭代对象中的最大值。在这个例子中，max函数返回了map函数返回的迭代器中的最大值，也就是所有子列表的和中的最大值。
4. 字符串
class Solution:
def fizzBuzz(self, n: int) -> List[str]:
answer = []
for i in range(1, n+1):
if i % 3 == 0 and i % 5 == 0:
answer.append("FizzBuzz")
elif i % 3 == 0:
answer.append("Fizz")
elif i % 5 == 0:
answer.append("Buzz")
else:
answer.append(str(i))
return answer这个，没想到什么妙招。
5. 链表的中间节点
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, val=0, next=None):
# self.val = val
# self.next = next
class Solution:
def middleNode(self, head: ListNode) -> ListNode:
dummy = ListNode(0, head)
slow, fast = dummy, head
while fast and fast.next:
slow = slow.next
fast = fast.next.next
slow.next = slow.next.next
return dummy.next慢指针走一步，快指针走两步，快指针遍历完列表的时候，慢指针刚好在中间，如果是奇数长度，慢指针刚好在中间节点的第二个节点。
6. 赎金信
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
for char in set(ransomNote):
if magazine.count(char) < ransomNote.count(char):
return False
return True如果如果magazine中有字符余量少于ransomNote中的字符，那么直接False，
否则，magazine的字符是富足的，溢出的，那就True。
这是我的第一想法，但是还有糕手：
那就是力扣官方解：
class Solution:
def canConstruct(self, ransomNote: str, magazine: str) -> bool:
if len(ransomNote) > len(magazine):
return False
return not collections.Counter(ransomNote) - collections.Counter(magazine)
作者：力扣官方题解
链接：https://leetcode.cn/problems/ransom-note/solutions/1135839/shu-jin-xin-by-leetcode-solution-ji8a/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 使用collections.Counter和减法操作符更高效。这是因为collections.Counter会返回一个字典，其中键是元素，值是元素在输入中出现的次数。当你从一个Counter对象中减去另一个Counter对象时，结果将包含那些在第一个Counter对象中出现次数更多的元素。
collections.Counter(ransomNote) - collections.Counter(magazine)将返回一个Counter对象，其中包含的是在ransomNote中出现次数更多的元素。
如果ransomNote可以由magazine构成，那么这个Counter对象应该是空的，所以not collections.Counter(ransomNote) - collections.Counter(magazine)将返回True。
如果ransomNote不能由magazine构成，那么这个Counter对象将包含至少一个元素，所以not collections.Counter(ransomNote) - collections.Counter(magazine)将返回False。
这种方法的时间复杂度是O(n)。n = ransomNoteLenth + magazineLenth
而我的方法需要对每一个元素都调用count方法，所以它的时间复杂度是O(n^2)。n = ransomNoteLenth + magazineLenth