该题为字符串翻转的基础题型，为后续题目提供了算法模板

from typing import List
'''
344. 反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
示例 1:输入: s = ["h","e","l","l","o"]输出: ["o","l","l","e","h"]
题眼：字符串数组原地反转
思路：双指针分别指向数组两端进行两两交换。
'''class Solution:def reverseString(self, s: List[str]) -> None:left, right = 0, len(s) - 1while left < right:  # 不同的两个字符串交换，所以不用取等号s[left], s[right] = s[right], s[left]left += 1right -= 1if __name__ == "__main__":obj = Solution()while True:try:s = [n[1: -1] for n in input().strip().split('=')[1].strip()[1: -1].split(',')]print(s)obj.reverseString(s)print(s)except EOFError:break

“344. 反转字符串”的扩展； 每隔 2k 个字符的前 k 个字符进行反转

from typing import List
'''
541. 反转字符串 II
给定一个字符串 s 和一个整数 k，从字符串开头算起，每计数至 2k 个字符，就反转这 2k 字符中的前 k 个字符。
如果剩余字符少于 k 个，则将剩余字符全部反转。
如果剩余字符小于 2k 但大于或等于 k 个，则反转前 k 个字符，其余字符保持原样。
示例 1:输入: s = "abcdefg", k = 2输出: "bacdfeg"
题眼：字符串反转
思路：“344. 反转字符串”的扩展； 每隔 2k 个字符的前 k 个字符进行反转
'''class Solution:def reverseStr(self, s: str, k: int) -> str:# 注意不是按照字符数组的形式给定了，需要一开始就转换为字符数组sList = list(s)for i in range(0, len(sList), 2 * k):# “344. 反转字符串”的模板代码left = iright = left + k - 1  # 注意这里需要-1if right >= len(sList):  # 剩余字符少于 k 个，则将剩余字符全部反转right = len(sList) - 1while left < right:sList[left], sList[right] = sList[right], sList[left]left += 1right -= 1return ''.join(sList)if __name__ == "__main__":obj = Solution()while True:try:in_line = input().strip().split('=')s = in_line[1].strip().split(',')[0][1: -1]k = int(in_line[2].strip())print(s, k)print(obj.reverseStr(s, k))except EOFError:break

“344. 反转字符串”的扩展； 额外增加了对元音字母的检索

from typing import List
'''
345. 反转字符串中的元音字母
给你一个字符串 s ，仅反转字符串中的所有元音字母，并返回结果字符串。
元音字母包括 'a'、'e'、'i'、'o'、'u'，且可能以大小写两种形式出现。
示例 1:输入：s = "hello"输出："holle"
题眼：字符串反转
思路：
'''class Solution:def reverseVowels(self, s: str) -> str:# 字符串转换为字符串数组sList = list(s)hashTable = {'a', 'A', 'e', 'E', 'i', 'I', 'o', 'O', 'u', 'U'}left, right = 0, len(sList) - 1while left < right:while left < right and sList[left] not in hashTable:  # 注意添加 left < rightleft += 1while left < right and sList[right] not in hashTable:  # 注意添加 left < rightright -= 1if left < right:  # 注意添加 left < rightsList[left], sList[right] = sList[right], sList[left]left += 1right -= 1return ''.join(sList)if __name__ == "__main__":obj = Solution()while True:try:s = input().strip().split('=')[1].strip()[1: -1]print(obj.reverseVowels(s))except EOFError:break

1、字符串中的单词翻转题目里最难的一道题，搞清楚这道题目O(1)空间复杂度的算法思路，后续几道题都会比较简单
2、第一步，按照“27.移除元素”移除所有空格稍加改动，并给单词之间添加一个空格；第二步，将所有元素翻转；第三步，将每个单词翻转
3、注意 添加单词到新的字符串数组、删除字符串中的多余空格 和 将每个单词翻转 都可以套用同一个模板，即 按照“27.移除元素”移除所有空格稍加改动 的模板

from typing import List
'''
151. 反转字符串中的单词
给一个字符串s，请反转字符串中 单词 的顺序。
单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。
返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。
注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。
示例 2:输入：s = "  hello world  "输出："world hello"解释：反转后的字符串中不能存在前导空格和尾随空格。
题眼：单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串
思路1、第一步，将单词取出来，并存放到一个待定List[str]中 —— 用双指针之左右指针的思路；第二步，将List[str]反转
思路2、O(1)空间复杂度；第一步，按照“27.移除元素”移除所有空格稍加改动，并给单词之间添加一个空格；第二步，将所有元素翻转；第三步，将每个单词翻转
'''class Solution:def reverseWords(self, s: str) -> str:# # 思路1、两步操作# # 第一步，将输入转换为字符串数组# # 新的思路写法：双指针之快慢指针，快指针遍历字符串：检测单词左边界+标记单词右边界，慢指针标记单词左边界# sList = []# slow, fast = 0, 0# while fast < len(s):#     if s[fast] != ' ':  # 检测到单词开头，将整个单词检索下来#         slow = fast  # 慢指针标记单词左边界#         while fast < len(s) and s[fast] != ' ':  # 快指针标记单词右边界+1的位置#             fast += 1#         sList.append(s[slow: fast])  # 此时，一定可以添加到一个单词#     else:#         fast += 1# # 之前的思路写法# # wordLeft, wordRight = 0, 0# # while wordRight < len(s):# #     while wordRight < len(s) and s[wordRight] == ' ':  # wordRight指示到遍历到的单词的首字母位置# #         wordRight += 1# #     wordLeft = wordRight  # wordLeft&wordRight同时指示到遍历到的单词的首字母位置# #     while wordRight < len(s) and s[wordRight] != ' ':  # wordRight指示到单词的尾字母的下一位置# #         wordRight += 1# #     if wordLeft < wordRight:  # 确保单词是有效的，wordLeft==wordRight是个空字符# #         sList.append(s[wordLeft: wordRight])# # 第二步，将字符串数组反转# left, right = 0, len(sList) - 1# while left < right:#     sList[left], sList[right] = sList[right], sList[left]#     left += 1#     right -= 1# return ' '.join(sList)# # 思路2、O(1)空间复杂度：C++可以直接实现；Python实际上还是O(N)的，不过可以模拟一下# 第一步，按照“27.移除元素”移除所有空格稍加改动，并给单词之间添加一个空格# 最终slow标记到了新字符串的末尾+1的位置，表示新字符串的长度sList = list(s)slow, fast = 0, 0while fast < len(sList):if sList[fast] != ' ':  # 检测到单词开头if slow != 0:  # 此时意味着开始检测到第二个及后续的单词了，对整个单词前移前先添加一个空格sList[slow] = ' 'slow += 1while fast < len(sList) and sList[fast] != ' ':  # 将整个单词进行前移sList[slow] = sList[fast]slow += 1fast += 1else:fast += 1newStrLen = slow# 第二步，将所有元素翻转# 定义翻转函数def reverseFunc(s: List[str], left: int, right: int):while left < right:s[left], s[right] = s[right], s[left]left += 1right -= 1reverseFunc(sList, 0, newStrLen - 1)# 第三步，将每个单词翻转：发现检测单词的思路 可以继续沿用上面 添加单词、删除空格 的模板slow, fast = 0, 0while fast < newStrLen:if sList[fast] != ' ':  # 检测到单词开头，将整个单词检索下来slow = fastwhile fast < newStrLen and sList[fast] != ' ':  # 快指针标记单词右边界+1的位置fast += 1reverseFunc(sList, slow, fast - 1)  # 此时，一定可以检测到一个单词，调用翻转函数else:fast += 1return ''.join(sList[0: newStrLen])if __name__ == "__main__":obj = Solution()while True:try:in_line = input().strip().split('=')s = in_line[1].strip()[1: -1]print(s)print(obj.reverseWords(s))except EOFError:break

“151. 反转字符串中的单词”的简化版：第一步，将所有元素翻转；第二步，将每个单词翻转

from typing import List
'''
186. 反转字符串中的单词II
给你一个字符数组 s ，反转其中 单词 的顺序。
单词 的定义为：单词是一个由非空格字符组成的序列。s 中的单词将会由单个空格分隔。
必须设计并实现 原地 解法来解决此问题，即不分配额外的空间。
注意：输入字符串中不会包含前置或尾随的空格，单词与单词之间永远是以单个空格隔开的。
示例 1:输入：s = [“t”,“h”,“e”," “,“s”,“k”,“y”,” “,“i”,“s”,” “,“b”,“l”,“u”,“e”]输出：[“b”,“l”,“u”,“e”,” “,“i”,“s”,” “,“s”,“k”,“y”,” ",“t”,“h”,“e”]
示例 2:输入：s = [“a”]输出：[“a”]
题眼：O(1)空间复杂度
思路、第一步，将所有元素翻转；第二步，将每个单词翻转
'''class Solution:def reverseWords(self, s: List[str]):# 定义翻转函数def reverseFunc(s: List[str], left: int, right: int):while left < right:s[left], s[right] = s[right], s[left]left += 1right -= 1# 第一步，将所有元素翻转reverseFunc(s, 0, len(s) - 1)# 第二步，将每个单词翻转slow, fast = 0, 0while fast < len(s):if s[fast] != ' ':  # 检测到单词开头slow = fast  # 标记单词左边界while fast < len(s) and s[fast] != ' ':  # 标记单词右边界+1的位置fast += 1reverseFunc(s, slow, fast - 1)  # 一定可以检测到完整的一个单词，完成翻转操作else:fast += 1if __name__ == "__main__":obj = Solution()while True:try:in_line = input().strip().split('=')s = [c[1: -1] for c in in_line[1].strip()[1: -1].split(',')]print(s)obj.reverseWords(s)print(s)except EOFError:break

“186. 反转字符串中的单词II”的简化版：直接将每个单词翻转

from typing import List
'''
557. 反转字符串中的单词 III
给定一个字符串 s ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
提示：s 不包含任何开头或结尾空格。s 里 至少 有一个词。s 中的所有单词都用一个空格隔开。
示例 2:输入：s = "Let's take LeetCode contest"输出："s'teL ekat edoCteeL tsetnoc"
题眼：
思路、直接将每个单词翻转
'''class Solution:def reverseWords(self, s: str) -> str:# 字符串转换为字符串数组sList = list(s)# 定义翻转函数def reverseFunc(s: List[str], left: int, right: int):while left < right:s[left], s[right] = s[right], s[left]left += 1right -= 1# 将每个单词翻转slow, fast = 0, 0while fast < len(sList):if sList[fast] != ' ':  # 检测到单词开头slow = fast  # 标记单词左边界while fast < len(sList) and sList[fast] != ' ':  # 标记单词右边界+1的位置fast += 1reverseFunc(sList, slow, fast - 1)  # 一定可以检测到完整的一个单词，完成翻转操作else:fast += 1return ''.join(sList)if __name__ == "__main__":obj = Solution()while True:try:in_line = input().strip().split('=')s = in_line[1].strip()[1: -1]print(obj.reverseWords(s))except EOFError:break

O(1)空间复杂度的解法（Python只能模拟一下）：将字符串一分为二地看待，看成是两个单词（一个长度为k，一个长度为len(s)-k），
最终的效果就相当于是把两个单词翻转；类似于“186. 反转字符串中的单词II”的思路

from typing import List
'''
剑指 Offer 58 - II. 左旋转字符串
字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，
该函数将返回左旋转两位得到的结果"cdefgab"。
示例 1:输入: s = "abcdefg", k = 2输出: "cdefgab"
题眼：旋转
思路：O(1)空间复杂度的解法（Python只能模拟一下）：将字符串一分为二地看待，看成是两个单词（一个长度为k，一个长度为len(s)-k），
最终的效果就相当于是把两个单词翻转；类似于“186. 反转字符串中的单词II”的思路
'''class Solution:def reverseLeftWords(self, s: str, n: int) -> str:# 字符串转换为字符串数组sList = list(s)# 定义翻转函数def reverseFunc(s: List[str], left: int, right: int):while left < right:s[left], s[right] = s[right], s[left]left += 1right -= 1# 第一步，将所有元素翻转reverseFunc(sList, 0, len(sList) - 1)# 第二步，将两个单词分别翻转，第一个单词左右边界[0, len(s)-n-1]，第二个单词左右边界[len(s)-n, len(s)-1]reverseFunc(sList, 0, len(s) - n - 1)reverseFunc(sList, len(s) - n, len(s) - 1)return ''.join(sList)if __name__ == "__main__":obj = Solution()while True:try:in_line = input().strip().split('=')s = in_line[1].strip().split(',')[0].strip()[1: -1]k = int(in_line[2])print(obj.reverseLeftWords(s, k))except EOFError:break