代码随想录算法训练营day8 | 344反转字符 | 541反转字符II | 05替换空格 | 151反转字符串里的单词 | 58左旋转字符

一、344反转字符

 卡哥视频里一说到有的语言直接赋值就能实现反转操作，我就猜到在点Python的名了哈哈哈，果然Py连库函数都不用调用就可以实现，好强。

二、541反转字符II

当有固定规律需要一段一段处理字符串时，我们考虑在for循环的时候更改步长为每段固定的长度

这种写法相当于是先确定一个点p，从0开始计数，与它间隔为k距离的点记为p2，s是反转操作，其中s[:p]是保留从头到点p的值，s[p:p2][::-1]相当于是截取p~p2这k个长度进行反转，s[p2:]代表保留p2后的点的值。然后再进行2k步长的循环。

python中 s == s[::-1]是什么意思？_dev_zyx的博客-CSDN博客_s[::-1]

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        """
        1. 使用range(start, end, step)来确定需要调换的初始位置
        2. 对于字符串s = 'abc'，如果使用s[0:999] ===> 'abc'。字符串末尾如果超过最大长度，则会返回至字符串最后一个值，这个特性可以避免一些边界条件的处理。
        3. 用切片整体替换，而不是一个个替换.
        """
        def reverse_substring(text):
            left, right = 0, len(text) - 1
            while left < right:
                text[left], text[right] = text[right], text[left]
                left += 1
                right -= 1
            return text
        
        res = list(s)

        for cur in range(0, len(s), 2 * k):
            res[cur: cur + k] = reverse_substring(res[cur: cur + k])
        
        return ''.join(res)

这种就是普通的双指针思路的写法，多学上面那种。

三、05替换空格 

method1后面还标了very rude，好可爱哈哈哈哈，不过简单粗暴的解法看着还挺爽的

method2要记得注意enumerate后面括号里不是s，而是s[::1]，给s取了倒序，所以才会出现下面三部分相加得到s那样的具体写法。

四、 151反转字符串里的单词

class Solution:
  #1.去除多余的空格
        def trim_spaces(self,s):     
            n=len(s)
            left=0
            right=n-1
        
            while left<=right and s[left]==' ':       #去除开头的空格
                left+=1
            while left<=right and s[right]==' ':        #去除结尾的空格
                right=right-1
            tmp=[]
            while left<=right:                                    #去除单词中间多余的空格
                if s[left]!=' ':
                    tmp.append(s[left])
                elif tmp[-1]!=' ':                                  #当前位置是空格，但是相邻的上一个位置不是空格，则该空格是合理的
                    tmp.append(s[left])
                left+=1
            return tmp
#2.翻转字符数组
        def reverse_string(self,nums,left,right):
            while left<right:
                nums[left], nums[right]=nums[right],nums[left]
                left+=1
                right-=1
            return None
#3.翻转每个单词
        def reverse_each_word(self, nums):
            start=0
            end=0
            n=len(nums)
            while start<n:
                while end<n and nums[end]!=' ':
                    end+=1
                self.reverse_string(nums,start,end-1)
                start=end+1
                end+=1
            return None

#4.翻转字符串里的单词
        def reverseWords(self, s): #测试用例："the sky is blue"
            l = self.trim_spaces(s)                     #输出：['t', 'h', 'e', ' ', 's', 'k', 'y', ' ', 'i', 's', ' ', 'b', 'l', 'u', 'e'
            self.reverse_string( l,  0, len(l) - 1)   #输出：['e', 'u', 'l', 'b', ' ', 's', 'i', ' ', 'y', 'k', 's', ' ', 'e', 'h', 't']
            self.reverse_each_word(l)               #输出：['b', 'l', 'u', 'e', ' ', 'i', 's', ' ', 's', 'k', 'y', ' ', 't', 'h', 'e']
            return ''.join(l)                                 #输出：blue is sky the

这个就是完全按照卡尔的逻辑一步一步实现

lass Solution:
    def reverseWords(self, s: str) -> str:
        # method 1 - Rude but work & efficient method.
        s_list = [i for i in s.split(" ") if len(i) > 0]
        return " ".join(s_list[::-1])

        # method 2 - Carlo's idea
        def trim_head_tail_space(ss: str):
            p = 0
            while p < len(ss) and ss[p] == " ":
                p += 1
            return ss[p:]

        # Trim the head and tail space
        s = trim_head_tail_space(s)
        s = trim_head_tail_space(s[::-1])[::-1]

        pf, ps, s = 0, 0, s[::-1] # Reverse the string.
        while pf < len(s):
            if s[pf] == " ":
                # Will not excede. Because we have clean the tail space.
                if s[pf] == s[pf + 1]:
                    s = s[:pf] + s[pf + 1:]
                    continue
                else:
                    s = s[:ps] + s[ps: pf][::-1] + s[pf:]
                    ps, pf = pf + 1, pf + 2
            else:
                pf += 1
        return s[:ps] + s[ps:][::-1] # Must do the last step, because the last word is omit though the pointers are on the correct positions,

这个补充一句，i for i in s.split(“ ”) ，意思就是把列表中按空格分开的每个单词遍历并取出来，直接写入s_list中。 

 五、58左旋转字符

 也是用局部反转+整体反转的思路，先反转前n个字符串，然后反转其余字符串，最后做一个整体反转就可以达到想要的效果。

不用切片的方法还挺特别的，具体逻辑看下图：