求职刷题 力扣 day08 ---翻转字符串

344.反转字符串

编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。

不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。

思路：
双指针

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

541. 反转字符串 II

给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。

如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
思路：
双指针

class Solution:
    def reverseStr(self, s: str, k: int) -> str:
        s_list = list(s)
        n = len(s)
        def reverse(string_list: list) -> list:
            left, right = 0, len(string_list) - 1
            while left < right:
                string_list[left], string_list[right] = string_list[right], string_list[left]
                left += 1
                right -= 1
            return string_list

        for i in range(0, n, 2*k):
            s_list[i:i + k] = reverse(s_list[i:i + k])

        return "".join(s_list)

        # s_list = [char for char in s]
        # def swap(left, right):
        #     # print("init left {} and right  {}".format(left, right))
        #     while left < right:
        #         # print(f" left {left} right {right} in cycle")
        #         s_list[left], s_list[right] = s_list[right], s_list[left]
        #         left += 1
        #         right -= 1
        # lower, upper = 0, 2 * k - 1
        # n = len(s)
        # while upper <= n - 1:
        #     left, right = lower, upper - k 
        #     swap(left, right)
        #     lower += 2 * k
        #     upper += 2 * k
        #     # print(f" upper {upper}")
        # if lower < n:
        #     if n - lower < k:
        #         left, right = lower, n - 1
        #         swap(left, right)
        #     else:
        #         left, right = lower, lower + k - 1
        #         swap(left, right)
        # s = "".join(s_list)
        # return s

4.2 卡码网：54.替换数字

给定一个字符串 s，它包含小写字母和数字字符，请编写一个函数，将字符串中的字母字符保持不变，而将每个数字字符替换为number。 例如，对于输入字符串 “a1b2c3”，函数应该将其转换为 “anumberbnumbercnumber”。

思路

1. 使用python，list 对应列表位置替换为 "number"字符串就行了

python实现

s = input()
s_list = list(s)
for i in range(len(s)):
    if s_list[i].isdigit():
        s_list[i] = 'number'
print("".join(s_list))

2. 使用数组实现，从后往前双指针

JAVA实现

import java.util.*;


public class Main {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String s = sc.next();
        int len = s.length();
        
        for (int i = 0; i < s.length(); i++){
            if (s.charAt(i) >= '0' && s.charAt(i) <= '9'){
                len += 5;
            }
        }
        
        char[] ret = new char[len];
        
        for (int i = 0; i < s.length(); i++){
            ret[i] = s.charAt(i);
        }
        
        for (int i = s.length() - 1, j = len - 1; i >= 0; i--){
            if ('0' < ret[i] && ret[i] <= '9'){
                ret[j--] = 'r';
                ret[j--] = 'e';
                ret[j--] = 'b';
                ret[j--] = 'm';
                ret[j--] = 'u';
                ret[j--] = 'n';
            }
            else{
                ret[j--] = s.charAt(i);
            }
        }
        System.out.println(ret);
    }
}

4.3 151.翻转字符串里的单词

给定一个字符串，逐个翻转字符串中的每个单词。

示例 1：
输入: “the sky is blue”
输出: “blue is sky the”

示例 2：
输入: " hello world! "
输出: “world! hello”
解释: 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。

示例 3：
输入: “a good example”
输出: “example good a”
解释: 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。

这道题如果使用split + python 列表很简单，但是如果要使用C++的话，可以O(1)的复杂度，涉及到数组移除元素，翻转元素，都是双指针，因为split使用太简单，但是python不能改变字符串，所以使用python写了个复杂的代码，但还是需要创建新的空间

class Solution:
    def reverseWords(self, s: str) -> str:
        def reverse(input_list: list) -> list:
            left, right = 0, len(input_list) - 1
            # print(f" input list {''.join(input_list)}")
            while left < right:
                input_list[left], input_list[right] = input_list[right], input_list[left]
                left += 1
                right -= 1
            return input_list

        #去除空格
        new_char_list = []
        slow = 0
        i = 0
        while i <  len(s):
            if s[i] != ' ':
                if slow != 0:
                    new_char_list.append(' ')
                    slow += 1
                while i < len(s) and s[i] != ' ':
                    new_char_list.append(s[i])
                    slow += 1
                    i += 1
                    print(f" i {i}")
            else:
                i += 1
        # print("new_char_list ", new_char_list)
        # 反转整个单词列表
        reverse_char_list = reverse(new_char_list)

        #反转每个单词
        start = 0
        k = 0
        # print("reverse_char_list ", reverse_char_list)
        while k <= len(reverse_char_list):
            if k == len(reverse_char_list) or reverse_char_list[k] == ' ':
                # print("new k ", k)
                reverse_char_list[start:k] = reverse(reverse_char_list[start:k])
                start = k + 1
            k += 1

        return "".join(reverse_char_list)

4.4 55. 右旋字符串（第八期模拟笔试）

https://kamacoder.com/problempage.php?pid=1065

字符串的右旋转操作是把字符串尾部的若干个字符转移到字符串的前面。给定一个字符串 s 和一个正整数 k，请编写一个函数，将字符串中的后面 k 个字符移到字符串的前面，实现字符串的右旋转操作。

例如，对于输入字符串 “abcdefg” 和整数 2，函数应该将其转换为 “fgabcde”。

k = int(input())
s = input()
def reverse(strings: list) -> list:
    left, right = 0, len(strings) - 1
    while left < right:
        strings[left], strings[right] = strings[right], strings[left]
        left += 1 
        right -= 1
    return strings
    
#整体翻转
strings = list(s)
strings = reverse(strings)

#局部两个翻转
n = len(strings)
strings[:k] = reverse(strings[:k])

strings[k:n] = reverse(strings[k:n])

print(''.join(strings))