算法工程师第八天（●151.翻转字符串里的单词●卡码网：55.右旋转字符串●28. 实现 strStr()●459.重复的子字符串●字符串总结 ●双指针回顾 ）

 参考文献 代码随想录

一、反转字符串中的单词

        给你一个字符串 s ，请你反转字符串中 单词 的顺序。单词 是由非空格字符组成的字符串。s 中使用至少一个空格将字符串中的 单词 分隔开。返回 单词 顺序颠倒且 单词 之间用单个空格连接的结果字符串。

注意：输入字符串 s中可能会存在前导空格、尾随空格或者单词间的多个空格。返回的结果字符串中，单词间应当仅用单个空格分隔，且不包含任何额外的空格。

示例 1：

输入：s = "the sky is blue"
输出："blue is sky the"

示例 2：

输入：s = "  hello world  "
输出："world hello"
解释：反转后的字符串中不能存在前导空格和尾随空格。

示例 3：

输入：s = "a good   example"
输出："example good a"
解释：如果两个单词间有多余的空格，反转后的字符串需要将单词间的空格减少到仅有一个。

问题分析：对s分割，然后一个列表，在调用一个方法reverse()，最后一空格输出

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        strList = list(map(str, s.split()))
        strList.reverse()
        return ' '.join(strList)

双指针：

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        strList = list(map(str, s.split()))
        left = 0
        right = len(strList) - 1
        while left < right:
            strList[left], strList[right] = strList[right], strList[left]
            left += 1
            right -= 1
        return ' '.join(strList)

栈：

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        strList = list(map(str, s.split()))
        ans = []
        while len(strList) != 0:
            tmp = strList.pop()
            ans.append(tmp)
        return ' '.join(ans)

        想一下，我们将整个字符串都反转过来，那么单词的顺序指定是倒序了，只不过单词本身也倒序了，那么再把单词反转一下，单词不就正过来了。

所以解题思路如下：

• 移除多余空格
• 将整个字符串反转
• 将每个单词反转

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        # 删除前后空白
        s = s.strip()
        # 反转整个字符串
        s = s[::-1]
        # 将字符串拆分为单词，并反转每个单词
        s = ' '.join(word[::-1] for word in s.split())
        return s

二、右旋字符串（第八期模拟笔试）

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

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

输入描述

输入共包含两行，第一行为一个正整数 k，代表右旋转的位数。第二行为字符串 s，代表需要旋转的字符串。

输出描述

输出共一行，为进行了右旋转操作后的字符串。

输入示例

2
abcdefg

输出示例

fgabcde

提示信息

数据范围：
1 <= k < 10000,
1 <= s.length < 10000;

问题分析：翻转

n = int(input())
strList = list(input())

newList = strList[len(strList) - n:]
newList += strList[:len(strList) - n]

# strList.reverse()
# left = n
# right = len(strList) - 1
# while left < right:
#     strList[left], strList[right] = strList[right], strList[left]
#     left += 1
#     right -= 1
print(''.join(newList))

三级翻转：

n = int(input())
strList = list(input())

strList.reverse()  # 翻转

newList = strList[:n]
newList.reverse()
newList += strList[len(strList) - 1: n - 1: -1]

print(''.join(newList))

三、找出字符串中第一个匹配项的下标

        给你两个字符串 haystack 和 needle ，请你在 haystack 字符串中找出 needle 字符串的第一个匹配项的下标（下标从 0 开始）。如果 needle 不是 haystack 的一部分，则返回  -1 。

示例 1：

输入：haystack = "sadbutsad", needle = "sad"
输出：0
解释："sad" 在下标 0 和 6 处匹配。
第一个匹配项的下标是 0 ，所以返回 0 。

示例 2：

输入：haystack = "leetcode", needle = "leeto"
输出：-1
解释："leeto" 没有在 "leetcode" 中出现，所以返回 -1 。

提示：

• 1 <= haystack.length, needle.length <= 104
• haystack 和 needle 仅由小写英文字符组成

class Solution(object):
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        n = len(needle)
        tmp = 0
        while tmp <= len(haystack):
            if haystack[tmp:n] == needle:
                return  tmp
            tmp += 1
            n += 1
       
        
        return -1
            

四、 重复的子字符串

给定一个非空的字符串 s ，检查是否可以通过由它的一个子串重复多次构成。

示例 1:

输入: s = "abab"
输出: true
解释: 可由子串 "ab" 重复两次构成。

示例 2:

输入: s = "aba"
输出: false

示例 3:

输入: s = "abcabcabcabc"
输出: true
解释: 可由子串 "abc" 重复四次构成。 (或子串 "abcabc" 重复两次构成。)

提示：

• 1 <= s.length <= 104
• s 由小写英文字母组成

问题分析：题目说只有一个子串重复多次构成，而怎么样理解的呢？如果s不包含重复子串，那么s自己就是一次重复的子串，那么把s + s去头去尾中就一定不包含s自己。如果s包含重复子串，那么在s + s去头去尾中就一定能找到s自己

class Solution:
    def repeatedSubstringPattern(self, s: str) -> bool:
        n = len(s)
        if n <= 1:
            return False
        ss = s[1:]  + s[:-1] 
                
        return ss.find(s) != -1
        

总结：双指针，要理解它们的含义，并且在不同的题目中，它们的功能不同，感觉多做题吧