代码随想录字符串第一天

344.反转字符串

反转字符串：网上使用了好多方法，我觉得双指针和切片还行

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        # 方法一：双指针
        # left = 0
        # right = len(s) - 1
        # while left < right:
        #     temp = s[left]
        #     s[left] = s[right]
        #     s[right] = temp
        #     left += 1
        #     right -= 1
        # return s
        # 方法二：切片
        # s[:] = s[::-1]
        # return s

 541. 反转字符串II

反转字符串II：这种方法显得比较臃肿，但是容易理解

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        def swaps(s, left: int, right: int):
            while left < right:
                temp = s[left]
                s[left] = s[right]
                s[right] = temp
                left += 1
                right -= 1
            return s
        s = list(s)
        if len(s) >= 2*k:
            left = 0
            right = k - 1
            s = swaps(s, left, right)
            # while left < right:
            #     temp = s[left]
            #     s[left] = s[right]
            #     s[right] = temp
            #     left += 1
            #     right -= 1
            if len(s) - 2*k < k:
                left1 = 2*k
                right1 = len(s)
                # while left1 < right1:
                #     temp = s[left1]
                #     s[left1] = s[right1]
                #     s[right1] = temp
                #     left1 += 1
                #     right1 -= 1
                s = swaps(s, left1, right1)
            elif len(s) - 2*k < 2*k and len(s) - 2*k > k:
                left1 = 2*k
                right1 = 3*k - 1
                # while left1 < right1:
                #     temp = s[left1]
                #     s[left1] = s[right1]
                #     s[right1] = temp
                #     left1 += 1
                #     right1 -= 1
                s = swaps(s, left1, right1)
        s = ''.join(s)
        return s

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)

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

上面这两部分答案，上面部分是我自己写的；下面是代码随想录中给的答案，表示一时半会想不到。

卡码网：54.替换数字：这部分没什么难度，就是在列表中找到待替换的数字，将其替换成number，代码见下部分：

def replaceNum(strs):
    strs = list(strs)
    for i in range(len(strs)):
        if strs[i].isdigit():
            strs[i] = 'number'
    strs = ''.join(strs)
    return strs

strs = input()
result = replaceNum(strs)
print(result)

151.翻转字符串里的单词

结题思路：先去除字符串中多余的空格：这部分分去除开头结尾的空格和中间连续的空格，仅保留一个；接着对列表进行整体翻转；然后分别对其中的每个单词进行翻转；

解法一：可读性强些，我觉得

class Solution:
    def reverseWords(self, s: str) -> str:
        # 解法一：生撕代码
        s = list(s)
        while s[0] == ' ' or s[-1] == ' ':
            # s.remove(' ')
            del s[0]
            del s[-1]
            
        # slow = 0
        # fast = 0
        # for i in range(len(s)):
        #     if s[slow]
        # for循环中，列表s变化时，不能及时更新
        # for i in range(len(s)):
        #     if s[i] == ' ':
        #         if s[i + 1] == ' ':
        #             del s[i]
        #             i -= 1

        # i未定义
        i = 0
        # IndexError: list index out of range
        # 删除多余的空格，设计精妙
        while i < len(s) - 1:
            if s[i] == ' ':
                if s[i + 1] == ' ':
                    del s[i]
                    i -= 1
            i += 1
        # 进行总体的列表翻转
        left = 0
        right = len(s) - 1
        while left < right:
            temp = s[left]
            s[left] = s[right]
            s[right] = temp
            left += 1
            right -= 1
            
        left_record = 0
        # range(s) 不正确
        for j in range(len(s)):
            if s[j] == ' ':
                j_ = j
                while left_record < j - 1:
                    temp = s[left_record]
                    s[left_record] = s[j - 1]
                    s[j - 1] = temp
                    left_record += 1
                    j -= 1
                left_record = j_ + 1
            elif j == len(s) - 1:
                j_ = j
                while left_record < j:
                    temp = s[left_record]
                    s[left_record] = s[j]
                    s[j] = temp
                    left_record += 1
                    j -= 1
                left_record = j_ + 1
        s = ''.join(s)
        return s

解法二和三：都是调用库：strip()和split()

# 解法二：调用库
# s = s.strip()
# s = s[::-1]
# s = ' '.join(word[::-1] for word in s.split())
# return s

# 解法三双指针
# word = s.split()
# left, right = 0, len(word) - 1
# while left < right:
#     word[left], word[right] = word[right], word[left]
#     left += 1
#     right -= 1
# return ' '.join(word)

卡码网：55.右旋转字符串：

下面这是我写的，感觉可读性强些

def reverse(s, k):
    print(type(k))
    s = list(s)
    s[:] = s[::-1]
    def reverse1(left, right, s):
        while left < right:
            temp = s[left]
            s[left] = s[right]
            s[right] = temp
            left += 1
            right -= 1
        return s
    left = 0
    right = int(k) - 1
    s = reverse1(left, right, s)
    
    left = int(k)
    right = len(s) - 1
    s = reverse1(left, right, s)
    return s
k = input()
s = input()
output = reverse(s, k)
output = ''.join(output)
print(output)