Datawhale LeetCode算法练题记录（Day1-Day2)

LeetCode算法练题记录

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(object):
    def sum(self, num1, num2):
        """
        :type num1: int
        :type num2: int
        :rtype: int
        """
        return num1+num2

通过率超高的一道题目啦~

1929.数组串联

给你一个长度为 n 的整数数组 nums 。请你构建一个长度为 2n 的答案数组 ans ，数组下标 从 0 开始计数 ，对于所有 0 <= i < n 的 i ，满足下述所有要求：

ans[i] == nums[i]
ans[i + n] == nums[i]
具体而言，ans 由两个 nums 数组 串联 形成。

返回数组 ans 。

一开始根据提示选择了数组拼接，呈现代码如下：

class Solution(object):
    def getConcatenation(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        n = len(nums)
        ans = nums
        ans[n:2n-1] = nums
        return ans

结果一看题解，好家伙，还有更简单的代码：

class Solution(object):
    def getConcatenation(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        return nums+nums

0771.宝石与石头

给你一个字符串 jewels 代表石头中宝石的类型，另有一个字符串 stones 代表你拥有的石头。 stones 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。

字母区分大小写，因此 “a” 和 “A” 是不同类型的石头。

示例 1：

输入：jewels = “aA”, stones = “aAAbbbb”
输出：3
示例 2：

输入：jewels = “z”, stones = “ZZ”
输出：0

第一反应，遍历两个字符串
代码如下：

class Solution(object):
    def numJewelsInStones(self, jewels, stones):
        """
        :type jewels: str
        :type stones: str
        :rtype: int
        """
        count = 0
        for i in jewels:
            for j in stones:
                if i == j:
                    count = count +1
        return count

一看题解，果然是暴力解法，此时复杂度如下：

• 时间复杂度：O(mn)O(mn)O(mn)，其中 m是字符串 jewels的长度，n是字符串 stones 的长度。遍历字符串 stones 的时间复杂度是 O(n)O(n)O(n)，对于 stones 中的每个字符，需要遍历字符串 jewels 判断是否是宝石，时间复杂度是 O(m)，因此总时间复杂度是 O(mn)。
• 空间复杂度：O(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]

class Solution(object):
    def runningSum(self, nums):
        """
        :type nums: List[int]
        :rtype: List[int]
        """
        sum = nums
        for i in range(len(nums)):
            if i >=1:
                sum[i] = nums[i]+sum[i-1]
        return sum

踩的坑：索引从0开始，因此if语句判断条件为i>=1

0709.转换成小写字母

给你一个字符串 s ，将该字符串中的大写字母转换成相同的小写字母，返回新的字符串。

代码：

class Solution(object):
    def toLowerCase(self, s):
        """
        :type s: str
        :rtype: str
        """
        return s.lower()

直接调用内置函数
看到一个暴力解题的，直接将26个大写字母replace为小写字母

1672.最富有客户的资产总量

给你一个 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 。

首先求一下每位客户的资产总量，然后从中选出资产总量最大的客户。
代码：

class Solution(object):
    def maximumWealth(self, accounts):
        """
        :type accounts: List[List[int]]
        :rtype: int
        """
        return max(map(sum, accounts))