训练营Day 8 : 344.反转字符串 || 541. 反转字符串 ||剑05.替换空格 || 151. 反转字符串中的单词||剑58 - II. 左旋转字符串

344.反转字符串

自己写了两种，一种是自己调用python库函数，一种是考虑到了双指针；

class Solution(object):
    def reverseString(self, s):
        """
        :type s: List[str]
        :rtype: None Do not return anything, modify s in-place instead.
        """
        #return s.reverse()
        left = 0 
        right = len(s)-1

        while (left<right):
            temp = s[left]
            s[left] = s[right]
            s[right] = temp
            right -=1
            left +=1

        return s

541. 反转字符串II

确实比之前的第一道上了一点难度，刚开始审题没有到位，是每计数到2k时便执行该操作，那么自然这是由规律的循环的结构，不过也有几个python的知识点需要注意；

• 在python中由经典的切片语法；

比如s[cur : cur+k] 如果实际可取的长度小于k呢，那么就是会将剩下的部分全部取到，类似s[:]酒泉市全部了

• 在python的 .join函数

Python join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

class Solution(object):
    
    def reverseStr(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """
        

        def reverseStr_substring(s_list):
            left , right = 0, len(s_list) -1
            while left < right:
                temp = s_list[left]
                s_list[left] = s_list[right]
                s_list[right] = temp
                left += 1
                right -= 1
            return s_list
        
        res = list(s)
        for cur in range(0, len(s), 2 * k): # 这个 range 其实也多次用到
            res[cur:cur + k] = reverseStr_substring(res[cur:cur + k])
        #当最后剩余元素小于k时，ss[i: i+k]只会表达到ss截止的地方，不会继续往后查找，就像ss[:]表示的是从最开始项到最后项一样
        return ''.join(res)

# 这样写也太酷了 ！！！
# 真的对于python的切片语法拿捏了

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        # Two pointers. Another is inside the loop.
        p = 0
        while p < len(s):
            p2 = p + k
            # Written in this could be more pythonic.
            s = s[:p] + s[p: p2][::-1] + s[p2:]
            p = p + 2 * k
        return s

剑指Offer 05.替换空格

第二种解法中又用到了join函数；

class Solution(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: str
        """
        return s.replace(' ', '%20')

class Solution(object):
    def replaceSpace(self, s):
        """
        :type s: str
        :rtype: str
        """
        s_list = list(s)
        print(s_list,len(s_list))
        res =[]
        for string in s_list:
            if string != " ":
                res.append(string)
            else:
                res.append('%20')
        return ''.join(res)

151. 反转字符串中的单词

难点： 空格无规律需要考虑到，单词也许不是由单个空格来切分的；在最开始或者最末尾都可能存在空格或多个

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        # 有个难点在于这里的空格其实数目无规律， 而且前后的空格或者中间的空格多了其实无意义的
        # step1: 先记录有效单词为list 
        # step2: 再使用双指针完成这个list的反转
        left = 0 
        res = []
        for i in range(len(s)):
            """
            #这里考虑指针可以利用空格条件作为一个有效的指引 如果遇到空格，那么可能就是一个单词
            结合当前位置和左指针来实现获取到一个单词，并把单词并入进去
            """
            if s[i] ==' ': 
                if s[left:i] != '':
                    res.append(s[left:i]) 
                left = i+1
        # 因为用空格来切分单词，如果最后一个单词无空格，那么就切分不了，所以之后单独考虑了
        if s[-1] != ' ':
            res.append(s[left:])
        
        # 列表的反转已经进行多次了
        left, right = 0, len(res)-1
        while left < right:
            res[left], res[right] = res[right], res[left] 
            right -= 1
            left += 1
        
        # 这里考虑到要最后复原时还要空格，要额外加上空格
        final_res = []
        for i in range(len(res)-1):
            final_res.append(res[i])
            final_res.append(' ')
        final_res.append(res[len(res)-1])

        return ''.join(final_res)

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        # 有个难点在于这里的空格其实数目无规律， 而且前后的空格或者中间的空格多了其实无意义的
        # step1: 先记录有效单词为list 
        # step2: 再使用双指针完成这个list的反转
        left = 0 
        res = []
        for i in range(len(s)):
            """
            #这里考虑指针可以利用空格条件作为一个有效的指引 如果遇到空格，那么可能就是一个单词
            结合当前位置和左指针来实现获取到一个单词，并把单词并入进去
            """
            if s[i] ==' ': 
                if s[left:i] != '':
                    res.append(s[left:i]) 
                left = i+1
        # 因为用空格来切分单词，如果最后一个单词无空格，那么就切分不了，所以之后单独考虑了
        if s[-1] != ' ':
            res.append(s[left:])
        
        # 列表的反转已经进行多次了
        left, right = 0, len(res)-1
        while left < right:
            res[left], res[right] = res[right], res[left] 
            right -= 1
            left += 1

        return ' '.join(final_res) # 这样子就不需要设置那个新的final_res 数组了，可以节省一下空间复杂度

#太优雅了！！！ 还是要充分了解python语言的特点的
class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """        
        s_list = [i for i in s.split(" ") if len(i) > 0]
        return " ".join(s_list[::-1])

剑指 Offer 58 - II. 左旋转字符串

class Solution(object):
    def reverseLeftWords(self, s, n):
        """
        :type s: str
        :type n: int
        :rtype: str
        """
        res =[]
        left = 0 
        for i in range(len(s)):
            if i == n:
                res.append(s[left:i])
                left = i
        res.append(s[left:])
        return ''.join(res[::-1])

每个语言有每个语言的妙处，我觉得切片的特点就是python的一个天然妙处，要多用，用的熟悉