代码随想录第八天 | 344.反转字符串 | 541. 反转字符串II | 卡码网54.替换数字 | 151.翻转字符串里的单词 | 卡码网55.右旋转字符串

344.反转字符串

采用双指针法的双向指针法，左右向中间靠近，替换左右指针的指向元素，直到左右指针重合或者反超对方。

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        left,right=0,len(s)-1
        while left<right:
            s[left],s[right]=s[right],s[left] 
            left+=1
            right-=1
        

s[left],s[right]=s[right],s[left] 在python中为并行赋值，前后赋值不会互相影响。

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s[:]=s[::-1] # 切片

[::-1]是Python中用于字符串、列表等可迭代对象的切片操作，它表示逆序访问的意思。具体来说，它是[start:stop:step]的一种简化写法，其中start表示起始索引，stop表示结束索引，step表示步长。

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        # 原地反转,无返回值
        s.reverse()

或者直接使用reverse()函数

---

541. 反转字符串II

本题主要是为了确认每次循环的起点。其实在遍历字符串的过程中，只要让i 每次移动 2 * k 就可以了，然后判断是否需要有反转的区间。因为要找的也就是每2 * k 区间的起点，这样写，程序会高效很多。

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        res=list(s)
        for i in range(0,len(s),2*k):
            res[i:i+k]=res[i:i+k][::-1] # 将前k个字符逆转
        return ''.join(res) # 使列表转化为字符串                        

range(start,stop,step): 具体来说，start表示序列的起始值（包含在序列中），stop表示序列的结束值（不包含在序列中），step表示序列中相邻两个元素之间的差值。我们用step来规律我们寻找起点的方法。

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        p=0
        while p<len(s):
            s=s[:p]+s[p:p+k][::-1]+s[p+k:] # 只逆转调整p:p+k部分
            p+=2*k # 区间化
        return s

---

卡码网 54.替换数字

卡码网原题链接

依旧采用双指针法，先将字符串改成列表，双指针遍历列表，碰到数字后，把其中的数字元素转化成"number"

class Solution:
    def replaceNum(self,s:str)->str:
        slow,fast=0,0
        res=list(s)
        while fast<len(s):
            if res[fast].isdigit():
                res[slow]='number' # 使['a',1,'b',2,'c',3]变成['a','number','b','number','c','number']
                slow+=1
            else:
                res[slow]=res[fast]
                slow+=1
            fast+=1
        return ''.join(res)
sol=Solution()
print(sol.replaceNum(input()))

或者创建一个字符串result来储存结果，直接用string.isdigit()判定是否为数字，是则转化，不是则记入。缺点是要用额外的空间。

def replacenum(s):
    result=''
    for i in s:
        if i.isdigit():
            result+='number'
        else:
            result+=i
    return result
s=input()
print(replacenum(s))

---

151.翻转字符串里的单词

先反转整个字符串，再逐一单词逆转一遍。

class Solution:
    def reverseWords(self, s: str) -> str:
         # 删除前后空白
        s = s.strip()
        # 反转整个字符串
        s = s[::-1]
        # 将字符串拆分为单词，并反转每个单词
        s = ' '.join(word[::-1] for word in s.split())
        return s

或者直接split解决，用split可以不用多担心有多少空格的问题。两种办法思路一样。

class Solution:
    def reverseWords(self, s: str) -> str:
        words=s.split()
        left,right=0,len(words)-1
        while left<right:
            words[left],words[right]=words[right],words[left]
            left+=1
            right-=1
        return ' '.join(words)

class Solution:
    def reverseWords(self, s: str) -> str:
        s=s.split()
        return ' '.join(s[::-1])    

---

卡码网55.右旋转字符串

卡码网原题链接
我们需要将字符串分成了两个部分，右旋转实际就是把第一部分放到第二段，第二部分放在第一段。

class Solution:
    def rotateright(self,s:str,k:int)->str:
        n=len(s)
        return s[n-k:]+s[:n-k] # 对调两部分
sol=Solution()
k=int(input())
s=input()
print(sol.rotateright(s,k))

或者可以通过整体倒叙，把两段子串都顺序颠倒，然后两段子串里的的字符再倒叙一把，这样负负得正，就不影响子串里面字符的顺序了。

class Solution:
    def rotateright(self,s:str,k:int)->str:
        s=s[::-1] # 整体倒叙
        s=s[:k][::-1]+s[k:][::-1] # 两段再分别倒叙，以索引为k为分界点
        return s
 
sol=Solution()
k=int(input())
s=input()
print(sol.rotateright(s,k))