1.交替合并字符串
给你两个字符串 word1 和 word2 。请你从 word1 开始，通过交替添加字母来合并字符串。如果一个字符串比另一个字符串长，就将多出来的字母追加到合并后字符串的末尾。
返回 合并后的字符串 。
示例 1：
输入：word1 = "abc", word2 = "pqr" 输出："apbqcr" 解释：字符串合并情况如下所示： word1： a b c word2： p q r 合并后： a p b q c r
class Solution:
def mergeAlternately(self, word1: str, word2: str) -> str:
if len(word2)>len(word1):
max=word2
min=word1
else:
max=word1
min=word2
str=''
for i in range(len(min)):
str+=word1[i]+word2[i]
str=str+max[len(min):]
return str2.找不同
给定两个字符串 s 和 t ，它们只包含小写字母。
字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。
请找出在 t 中被添加的字母。
示例 1：
输入：s = "abcd", t = "abcde" 输出："e" 解释：'e' 是那个被添加的字母。
class Solution:
def findTheDifference(self, s: str, t: str) -> str:
#法一：排序后逐一比较
s,t=sorted(s)+[' '],sorted(t)
for i,j in zip(s,t):
if i!=j:
return j
#法二：计数相减
return (Counter(t)-Counter(s)).popitem()[0]
'''
解释:
1.Counter(t) 会统计字符串 t 中每个字符出现的次数，返回一个类似字典的对象。
2.Counter(s) 同样会统计字符串 s 中每个字符出现的次数。
3.两个 Counter 对象相减后得到的结果是一个包含了不同字符及其出现次数的 Counter 对象。
4.使用 popitem() 方法可以随机弹出 Counter 对象中的一个键值对，然后通过 [0] 取出键，即为不同的字符。
5.Counter()为collection包中的函数
'''3.找出字符串中第一个匹配项的下标
给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回 -1 。
示例 1：
输入：haystack = "sadbutsad", needle = "sad" 输出：0 解释："sad" 在下标 0 和 6 处匹配。 第一个匹配项的下标是 0 ，所以返回 0 。
示例 2：
输入：haystack = "leetcode", needle = "leeto" 输出：-1 解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。
class Solution:
def strStr(self, haystack: str, needle: str) -> int:
n=len(needle)
m=len(haystack)
lst=[]
if n>m:
return -1
else:
for i in range(m-n+1):
if needle==haystack[i:i+n]:
return i
else:
continue
return -14.有效的字母异位词
给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
注意：若 s 和 t 中每个字符出现的次数都相同，则称 s 和 t 互为字母异位词。
示例 1:
输入: s = "anagram", t = "nagaram" 输出: true
示例 2:
输入: s = "rat", t = "car" 输出: false
class Solution:
def isAnagram(self, s: str, t: str) -> bool:
#法一：使用Counter函数统计各个字符出现次数
if Counter(s)==Counter(t):
return True
else:
return False
#法二：自行编写和Counter函数功能一样的代码，用字典完成对s和t字符的统计，并比较
dict1,dict2={},{}
for i in s:
if i not in dict1:
dict1[i]=1
else:
dict1[i]+=1
for j in t:
if j not in dict2:
dict2[j]=1
else:
dict2[j]+=1
if dict1==dict2:
return True
else:
return False5.重复的子字符串
给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。
示例 1:
输入: s = "abab" 输出: true 解释: 可由子串 "ab" 重复两次构成。
示例 2:
输入: s = "aba" 输出: false
class Solution:
def repeatedSubstringPattern(self, s: str) -> bool:
#解法:子串长度范围为1~字符串长度的一半
# for循环依次添加一个字符序：①判断字符串长度摩子串长度后是否余数为0，不是则进入下一步循环
# ②判断字符串s以子串为分隔单元分隔后，列表里是否都为空元素，是则返回True
sub_s=''
for i in range(len(s)//2):
sub_s+=s[i]
if len(s) % len(sub_s) != 0:
continue
else:
if set(s.split(sub_s))=={''}:
return True
return False6.移动零
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
请注意 ，必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums =[0,1,0,3,12]输出:[1,3,12,0,0]
示例 2:
输入: nums =[0]输出:[0]
class Solution:
def moveZeroes(self, nums: List[int]) -> None:
"""
Do not return anything, modify nums in-place instead.
"""
#解法：统计0元素的个数count，用for循环将列表remove个count次，最后在结尾填count个0
count=Counter(nums)[0]
for i in range(count):
nums.remove(0)
nums.extend([0 for i in range(count)])7.加一
给定一个由 整数 组成的 非空 数组所表示的非负整数，在该数的基础上加一。
最高位数字存放在数组的首位， 数组中每个元素只存储单个数字。
你可以假设除了整数 0 之外，这个整数不会以零开头。
示例 1：
输入：digits = [1,2,3] 输出：[1,2,4] 解释：输入数组表示数字 123。
示例 2：
输入：digits = [4,3,2,1] 输出：[4,3,2,2] 解释：输入数组表示数字 4321。
class Solution:
def plusOne(self, digits: List[int]) -> List[int]:
#解法：将列表join变成数字+1后，将数字采用取余和整除的方法转换成新列表
digits=[str(i) for i in digits]
num=''.join(digits)
num=int(num)+1
lst=[]
while num>0:
lst.append(num%10)
num=num//10
return lst[::-1]8. 数组元素积的符号
已知函数 signFunc(x) 将会根据 x 的正负返回特定值：
- 如果
x是正数，返回1。 - 如果
x是负数，返回-1。 - 如果
x是等于0，返回0。
给你一个整数数组 nums 。令 product 为数组 nums 中所有元素值的乘积。
返回 signFunc(product) 。
示例 1：
输入：nums = [-1,-2,-3,-4,3,2,1] 输出：1 解释：数组中所有值的乘积是 144 ，且 signFunc(144) = 1
class Solution:
def arraySign(self, nums: List[int]) -> int:
#解法：定义函数signFunc，遍历数组乘积，对其进行判断
product=1
def signFunc(x):
if x>0:
return 1
elif x<0:
return -1
else:
return 0
for i in nums:
product*=i
return signFunc(product)9.判断能否形成等差数列
给你一个数字数组 arr 。
如果一个数列中，任意相邻两项的差总等于同一个常数，那么这个数列就称为 等差数列 。
如果可以重新排列数组形成等差数列，请返回 true ；否则，返回 false 。
示例 1：
输入：arr = [3,5,1] 输出：true 解释：对数组重新排序得到 [1,3,5] 或者 [5,3,1] ，任意相邻两项的差分别为 2 或 -2 ，可以形成等差数列。
class Solution:
def canMakeArithmeticProgression(self, arr: List[int]) -> bool:
#解法：①排序后列表的前n-1个元素和后n-1个元素作差
# ②判断差值是否都相同：将差值列表转化为集合去重，判断集合元素个数是否为1
difference=[i-j for i,j in zip(sorted(arr)[1:],sorted(arr)[0:-1])]
if len(set(difference))==1:
return True
else:
return False10.单调数列
如果数组是单调递增或单调递减的，那么它是 单调 的。
如果对于所有 i <= j，nums[i] <= nums[j]，那么数组 nums 是单调递增的。 如果对于所有 i <= j，nums[i]> = nums[j]，那么数组 nums 是单调递减的。
当给定的数组 nums 是单调数组时返回 true，否则返回 false。
示例 1：
输入：nums = [1,2,2,3] 输出：true
class Solution:
def isMonotonic(self, nums: List[int]) -> bool:
#法一：两次遍历，两个函数分别判断是否为递增或递减数列，当有其一成立就说明是单调数列
return self.isDescend(nums) or self.isAscend(nums)
def isDescend(self,nums):
for i in range(len(nums)-1):
if nums[i]<nums[i+1]:
return False
return True
def isAscend(self,nums):
for i in range(len(nums)-1):
if nums[i]>nums[i+1]:
return False
return True
#法二：一次遍历，两个标记符号（递增和递减），有相反情况出现就是false，有其一成立为单调数列
desc,asc=True,True
for i in range(len(nums)-1):
if nums[i]>nums[i+1]:
asc=False
if nums[i]<nums[i+1]:
desc=False
return desc or asc
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
