Datawhale第九期组队学习--数据结构与算法（上）Task05：字符串（2天）

理论部分

• 用数组实现一个顺序的串结构。
• 为该串结构提供丰富的操作，比如插入子串、在指定位置移除给定长度的子串、在指定位置取子串、连接串、串匹配等。

练习部分

1. 无重复字符的最长子串
   https://leetcode-cn.com/problems/longest-substring-without-repeating-characters/

给定一个字符串，请你找出其中不含有重复字符的最长子串的长度。
示例1

输入: "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc"，所以其长度为 3。

示例2

输入: "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b"，所以其长度为 1。

示例3

输入: "pwwkew"
输出: 3
解释: 因为无重复字符的最长子串是 "wke"，所以其长度为 3。
请注意，你的答案必须是 子串 的长度，"pwke" 是一个子序列，不是子串。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        longest_str = []
        max_size = [0]
        for i in s:
            if i not in longest_str:
                longest_str.append(i)
                max_size.append(len(longest_str))
            else:
                max_size.append(len(longest_str))
                index = longest_str.index(i)
                del longest_str[0: index+1]
                longest_str.append(i)
        return max(max_size)

2. 串联所有单词的子串
   https://leetcode-cn.com/problems/substring-with-concatenation-of-all-words/

给定一个字符串s和一些长度相同的单词 words。找出 s 中恰好可以由 words 中所有单词串联形成的子串的起始位置。

注意子串要与 words 中的单词完全匹配，中间不能有其他字符，但不需要考虑 words 中单词串联的顺序。

示例1

输入：
  s = "barfoothefoobarman",
  words = ["foo","bar"]
输出：[0,9]
解释：
从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar" 。输出的顺序不重要, [9,0] 也是有效答案。

示例2

输入：
  s = "wordgoodgoodgoodbestword",
  words = ["word","good","best","word"]
输出：[]

from collections import Counter
class Solution:
     def findSubstring(self, s: str, words: List[str]) -> List[int]:
        if not s or not words:
            return []
        one_word = len(words[0])
        word_num = len(words)
        n = len(s)
        if n < one_word:
            return []
        words = Counter(words)
        res = []
        for i in range(0, one_word):
            cur_cnt = 0
            left = i
            right = i
            cur_Counter = Counter()
            while right + one_word <= n:
                w = s[right:right + one_word]
                right += one_word
                if w not in words:
                    left = right
                    cur_Counter.clear()
                    cur_cnt = 0
                else:
                    cur_Counter[w] += 1
                    cur_cnt += 1
                    while cur_Counter[w] > words[w]:
                        left_w = s[left:left+one_word]
                        left += one_word
                        cur_Counter[left_w] -= 1
                        cur_cnt -= 1
                    if cur_cnt == word_num :
                        res.append(left)
        return res

3. 替换子串得到平衡字符串
   https://leetcode-cn.com/problems/replace-the-substring-for-balanced-string/

有一个只含有’Q’, ‘W’, ‘E’,'R’四种字符，且长度为 n的字符串。假如在该字符串中，这四个字符都恰好出现n/4次，那么它就是一个「平衡字符串」。

给你一个这样的字符串 s，请通过「替换一个子串」的方式，使原字符串 s变成一个「平衡字符串」。你可以用和「待替换子串」长度相同的任何其他字符串来完成替换。

请返回待替换子串的最小可能长度。

如果原字符串自身就是一个平衡字符串，则返回 0。

示例1：

输入：s = "QWER"
输出：0
解释：s 已经是平衡的了。

示例2：

输入：s = "QQWE"
输出：1
解释：我们需要把一个 'Q' 替换成 'R'，这样得到的 "RQWE" (或 "QRWE") 是平衡的。

示例3：

输入：s = "QQQW"
输出：2
解释：我们可以把前面的 "QQ" 替换成 "ER"。

示例4：

输入：s = "QQQQ"
输出：3
解释：我们可以替换后 3 个 'Q'，使 s = "QWER"。

有点问题

class Solution:
    def balancedString(self, s: str) -> int:
        q_count = s.count('Q')
        w_count = s.count('W')
        e_count = s.count('E')
        r_count = s.count('R')
        all_count = []
        all_count.append(q_count)
        all_count.append(w_count)
        all_count.append(e_count)
        all_count.append(r_count)

        counts = 0
        if q_count != len(s) / 4:
            counts += 1
        if w_count != len(s) / 4:
            counts += 1
        if e_count != len(s) / 4:
            counts += 1
        if r_count != len(s) / 4:
            counts += 1

        min_count = min(all_count)
        if min_count:
            if counts - 1 >= 0:
                return counts - 1
            else:
                return 0
        else:
            all_count.pop(min_count)
            min_count = min(all_count)
            all_count = all_count.map(lambda x: x-min_count, all_count)
            if min_count:
                if counts - 1 >= 0:
                    return counts - 1
                else:
                    return 0