力扣天天练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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一只小百里

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值