力扣天天练week3-LeetCode75

topic75-1-t1768交替合并字符串

题目描述：给你两个字符串word1和word2。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。返回 合并后的字符串 。

示例：

输入：word1 = "abc", word2 = "pqr"
输出："apbqcr"
解释：字符串合并情况如下所示：
word1：  a   b   c
word2：    p   q   r
合并后：  a p b q c r

 思路：将word1和word2逐项加到result中，直到其中一个为空，再将剩余元素加到结果中

class Solution:
    def mergeAlternately(self, word1: str, word2: str) -> str:
        length1=len(word1)
        length2=len(word2)
        result=''   #用来存储最后的结果
        i=0
        while i<length1 and i<length2:
            result+=word1[i]
            result+=word2[i]
            i+=1
        if length1>length2:
            result+=word1[i:]
        else:
            result+=word2[i:]
        return result

topic75-2-t1071字符串的最大公因子

题目描述：对于字符串 s 和 t，只有在 s = t + ... + t（t 自身连接 1 次或多次）时，我们才认定 “t 能除尽 s”。给定两个字符串 str1 和 str2 。返回 最长字符串 x，要求满足 x 能除尽 str1 且 x 能除尽 str2 。

示例：

 思路：先求出两个字符串长度，然后利用math库中的gcd函数求长度的最小公因数，判断前最小公因数子串是否为最大公因子串

class Solution:
    def gcdOfStrings(self, str1: str, str2: str) -> str:
        length1=len(str1)
        length2=len(str2)      #记录两个字符串长度

        #使用math库中的gcd函数求两个字符串长度的公因数
        gcd=math.gcd(length1,length2)
        maxSameStr=str1[0:gcd]    #字符串最大公因子
        if maxSameStr*(length1//gcd)==str1 and maxSameStr*(length2//gcd)==str2:
            return maxSameStr
        return ''

topic75-3-t1431：拥有最多糖果的孩子

题目描述：

给你一个数组 candies 和一个整数 extraCandies ，其中 candies[i] 代表第 i 个孩子拥有的糖果数目。对每一个孩子，检查是否存在一种方案，将额外的 extraCandies 个糖果分配给孩子们之后，此孩子有 最多 的糖果。注意，允许有多个孩子同时拥有 最多 的糖果数目。

示例：

 思路：先找出小孩中拥有的最大糖果数，然后遍历数组，判断当前元素加额外元素是否小于最大值，是则返回False，否则返回True

class Solution:
    def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]:
        maxnum=max(candies)    #求出最多糖果
        length=len(candies)
        result=[]     
        for i in range(length):
            if candies[i]+extraCandies>=maxnum:
                result.append(True)
            else:
                result.append(False)
        return result

topic75-4-t605：种花问题

题目描述：

假设有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花不能种植在相邻的地块上，它们会争夺水源，两者都会死去。

给你一个整数数组 flowerbed 表示花坛，由若干 0 和 1 组成，其中 0 表示没种植花，1 表示种植了花。另有一个数 n ，能否在不打破种植规则的情况下种入 n 朵花？能则返回 true ，不能则返回 false 。

示例：

 思路：先首尾加0(用来判断首尾为0的特殊情况)，如果当前为0，并且前后都为0，count+1，将该点标记为1，遍历，最后判断count与n的大小关系。

class Solution:
    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:
        count=0  #计数，记录符合条件的位置个数
        flowerbed.insert(0,0)  #首尾都加0，不影响结果
        flowerbed.append(0)
        length=len(flowerbed)   
        for i in range(1,length-1):
            if flowerbed[i]==0 and flowerbed[i+1]==0 and flowerbed[i-1]==0:
                count+=1
                flowerbed[i]=1  #满足条件则记录，然后将该点标记为1
        if count<n:
            return False
        return True

topic75-5-t345：反转字符串中的元音字母

题目描述：

给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。

元音字母包括 'a'、'e'、'i'、'o'、'u'，且可能以大小写两种形式出现不止一次。

示例：

 思路：双指针，遍历，如果两头都指向元音字母，交换，然后左右指针向中间移动

class Solution:
    def reverseVowels(self, s: str) -> str:
        length=len(s)
        string=list(s)
        left,right=0,length-1   #初始化左右指针
        demo=['a','o','e','i','u','A','O','E','I','U']      #元音列表
        while left<right:
            if string[left] not in demo:
                left+=1
            if string[right] not in demo:
                right-=1
            if string[left] in demo and string[right] in demo:   
                #元音则交换
                temp=string[left]
                string[left]=string[right]
                string[right]=temp
                left+=1
                right-=1
        result=''
        for item in string:
            result+=str(item)
        return result

topic75-6-t151:反转字符串中的单词

题目描述：

给你一个字符串 s ，请你反转字符串中 单词 的顺序。

单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。

返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例：

 思路：1.去掉空格 2.反转 3.转化为字符串输出

class Solution:    #直接用split函数
    def reverseWords(self, string: str) -> str:
        return ' '.join(string.split()[::-1])

class Solution:  #一步步去重

    def reverseWords(self, string: str) -> str:
        length=len(string)
        count=0
        for i in range(length-1,-1,-1):   #去除多余的空格，方便使用split函数
            if string[i]==' ':
                count+=1
                if count>1:
                    string=string[0:i]+string[i+1:]
                    count-=1
            else:
                count=0
        if string[0]==' ':   #如果开头是空格
            string=string[1:]
        new_string=string
        #去除重复的空格，换成单空格
        turn_to_reverse=new_string.split(' ')[::-1]
        result=''
        for item in turn_to_reverse:
            if item !='':
                result=result+str(item)+' '
        return result[0:-1]

topic75-7-t238：除自身以外数组的乘积

题目描述：

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积 。

题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在  32 位 整数范围内。

请不要使用除法，且在 O(n) 时间复杂度内完成此题。

示例：

 思路：其余元素乘积=左边元素*右边元素

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        length = len(nums)
        answer = [0]*length
        
        # answer[i] 表示索引 i 左侧所有元素的乘积
        # 因为索引为 '0' 的元素左侧没有元素， 所以 answer[0] = 1
        answer[0] = 1
        for i in range(1, length):
            answer[i] = nums[i - 1] * answer[i - 1]
        
        # R 为右侧所有元素的乘积
        # 刚开始右边没有元素，所以 R = 1
        R = 1;
        for i in reversed(range(length)):
            # 对于索引 i，左边的乘积为 answer[i]，右边的乘积为 R
            answer[i] = answer[i] * R
            # R 需要包含右边所有的乘积，所以计算下一个结果时需要将当前值乘到 R 上
            R *= nums[i]
        
        return answer

##没做出来

topic75-8-t334：递增的三元子序列

题目描述：

给你一个整数数组 nums ，判断这个数组中是否存在长度为 3 的递增子序列。

如果存在这样的三元组下标 (i, j, k) 且满足 i < j < k ，使得 nums[i] < nums[j] < nums[k] ，返回 true ；否则，返回 false 。

示例：

 思路：算法的核心思想是贪心算法，通过维护最小值和中间值来判断是否存在三元递增子序列。具体来说，我们首先将最小值初始化为整数的最大值，然后遍历整个数组，对于每个遍历到的数，如果它小于等于最小值，我们将最小值设为该数；如果它不小于最小值但小于等于中间值，我们将中间值设为该数；如果它大于中间值，说明找到了三元递增子序列，直接返回true。如果整个数组遍历完后都没有找到三元递增子序列，说明不存在这样的子序列，返回false。时间复杂度O(n)，空间复杂度O(1)

class Solution:
    def increasingTriplet(self, nums: List[int]) -> bool:
        # 获取数组长度
        length = len(nums)
        # 如果数组长度小于3，则不可能存在三元递增子序列，返回false
        if length < 3:
            return False
        # 定义两个变量，分别表示当前遍历到的最小值和中间值，初始化为最大的整数
        small = mid = sys.maxsize
        # 遍历数组中的每个数
        for num in nums:
            # 如果当前数小于等于最小值，更新最小值
            if num <= small:
                small = num
            # 如果当前数不小于最小值，但小于等于中间值，更新中间值
            elif num <= mid:
                mid = num
            # 如果当前数大于中间值，说明找到了三元递增子序列，直接返回true
            elif num > mid:
                return True
        # 遍历完整个数组也没有找到三元递增子序列，返回false
        return False