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 resulttopic75-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 resulttopic75-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 Truetopic75-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 resulttopic75-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
