【LeetCode-滑动窗口题目2】

双指针_键盘映射_连续字符串.cpp

输入法初始默认为“数字状态”，并可在“数字状态”与“英文状态”间切换。
输入法在“数字状态”下，数字键对应为单个数字，摁几次显示几个该数字。
输入法在“英文状态”下，如果数字键为 0，则对应为单字符（空格），摁几次显示几个该字符。
输入法在“英文状态”下，如果数字键为非 0，则对应为多个字符，可通过连续多次快速摁该键循环选择对应字符：
以英文状态下的数字键 2 为例，摁1次为 a ，2次为 b ，3次为 c ，4次又循环回 a 。
若连续多次摁键循环选择时被其它键或停顿中断，则输出所选择的字符。
现给定一个仅含字符集合为 [0-9#/] 的字符串，表示用户的摁键操作，请输出实际显示出来的字符串。

0-9 为数字键。
#   表示在“数字状态”与“英文状态”之间切换。
/   停顿符，表示用户有意停顿。

#22/23044444411
输出样例 2

bad i.

class Solution {
public:
    map <int, string> mp = {
        { '1', ",."},
        { '2', "abc"},
        { '3', "def"},
        { '4', "ghi"},
        { '5', "jkl"},
        { '6', "mno"},
        { '7', "pqrs"},
        { '8', "tuv"},
        { '9', "wxyz"},
        { '0', " "},
    };

    // 遇到滑动窗口，真的是很浪费时间
    const string GetResult(const string &input)
    {
        int flag = 1;
        string res = "";
        for (int i = 0; i < input.size(); i++) {
            if (input[i] == '#') {
                flag = -flag; // 交替通过相反值操作 
                continue; // i++替换成continue，for循环中会自加
            }

            //  /无论是flag是什么值都需要跳过,这种公共字符需要放在特殊处理之前
            if (input[i] == '/') {
                continue;
            }

            if (flag == 1) {
                res += input[i];
                continue;
            }
            
            int len  = 0;
            while (input[i] != '0' && (i < input.size() - 1) && input[i] == input[i + 1]) { // 连续的0，只会统计一个, 少了一个条件通过16/20
                len++; // 只需要去处长度即可，首字符通过input[i]确定
                i++;
            }
            string mpStr = mp[input[i]];
            res += mpStr[len % mpStr.size()];
        }
        return res;
    }
};

双指针_连续_最长相同字符_重要 重要 重要！！！.cpp

给定一个整数 n ，查找其二进制表示中最长的连续数字0或1的个数。
注：二进制表示无须在高位补 0

17
输出样例 2

3
提示样例 2
17的二进制表示为10001，最长连续数字为 000，个数为3。

class Solution {
public:
    vector<int> bin;
    void dec2Bin(long num)
    {
        if (num == 0) {
            bin.push_back(0);
            return;
        }
        while (num != 0) {
            int mod = num % 2;
            bin.push_back(mod);
            num /= 2;
        }
    }

// 1、求最长的连续数字串/字符串
    // 优化(纯逻辑统计)
    for (int i = 0; i < bin.size(); i++) {
        int len = 0;
        int maxLen = INT_MIN;
        while (i < bin.size() - 1 && bin[i] == bin[i + 1]) {
            len++;
            i++;
        }
        maxLen = max(len, maxLen);
    }
    return maxLen;

// 2.1、最长元音串（无法用while循环判断，直接用if else）
bool check(char c)
{
    string name = "aeiouAEIOU";
    if (name.find_first_of(c) == -1) {
        return false;
    }
    return true;
}
int GetLongestVowelStringLength(const string& input)
{
    int result = 0;
    int left = 0;
    int right = 0;
    int len = 0;
    while (right < input.size()) {
        char cha = input[right];

        if (check(cha)) { // 指定字符
            len++;
        } else {
            left = right;
            result = max(result, len);
            len = 0;
        }

        right++;
    }
    return max(result, len);
}

// 2.2、求最长不重复串（不同元素最长）
int lengthOfLongestSubstring(string s) {
    map<char, int> window;

    int left = 0, right = 0;
    int res = 0; // 记录结果
    while (right < s.size()) {
        char c = s[right];
        right++;
        window[c]++;

        while (window[c] > 1) { // 元素超过两个左侧索引右移
            char d = s[left];
            left++;
            window[d]--;
        }

        res = max(res, right - left); // 每次更新最长区间
    }
    return res;
}

// 2.3 最长包含指定瑕疵长度的字符串（考了很多次，换着花样考试！！！）
（瑕疵可以是非元音字符，可以是数字0, ..x..x..xx...删除指定的x，让.连续最多）
（1到10000任务上报，数组给出上报失败的序号，M次纠错机会，求最长的连续成功上报）
// 获取最大值的校验条件有变化
class Solution {
public:
    bool check(char c)
    {
        string name = "aeiouAEIOU";
        if (name.find_first_of(c) == -1) {
            return false;
        }
        return true;
    }

    int GetLongestFlawedVowelSubstrLen(const size_t flaw, const string& input)
    {
        int left = 0, right = 0; // 什么时候需要窗，什么时候只需要变量

        int result = 0;
        int flawCount = 0;
        while (right < input.size()) {
            char c = input[right];
            if (!check(c)) {
                flawCount++; 
            }

            // 用于超过目标值，左侧索引直接跳到下一个元素，删减了许多遍历
            while (flawCount > flaw) { // 这里自己最开始的思路是> == 是等于还是> 进行for循环
                char d = input[left];
                if (!check(d)) {
                    flawCount--;
                }
                left++;
            }

            // 每次都会更新长度
            if (flawCount == flaw && check(input[left]) && check(input[right])) { // 下标写错。left写成right
                result = max(result, right - left + 1); // 下标值加以减一计算  结果更新是在while循环内还是在while循环外
            }
            right++; // 右索是在前面还是在后面
        }
        return result;
    }
};

// 3、求连续拆分(while中if判断)
    // "#22223044444411" -> # 2222 3 0 444444 11
    // "#22/23044444411" -> # 2222 3 0 444444 11
    // 包含特殊符号，实际就是加一些校验条件，可以先把连续数字的框架写出来，然后再看特殊条件在哪个位置增加
    // 优化(for循环中嵌套while循环，纯逻辑没有双指针)
    vector<string> string GetResult(const string &input)
    {
        vector<string> vec;
        for (int i = 0; i < input.size(); i++) { 
            int len  = 0;
            while ((i < input.size() - 1) && input[i] == input[i + 1]) {
                len++;
                i++;
            }
            char curCha = input[i]; // 当前字符，取前面一个字符
            string curStr = string(len + 1, curCha); // 注意长度加1
            vec.push_back(curStr);
        }
        return res;
    }
    // 简单题 纯粹连续拆分已考真题，先划分连续串，再求值（这个题目之前自己做不出来，总结了套路，发现有了自己的思路，很简单！！！）
    题目2：求字符串中单字符子串出现的次数，单字符子串要求字符必须相同且连续
    输入1：“11121”
    输出1: 8
    解释：1：4次
    11：2次
    111:1次
    2：1次
    输入2：“6666666666”
    输出2: 55

    // 中等题，连续拆分中掺杂特殊字符，加了很多特殊字符，只需要加上对应if条件判断，特殊字符# /处理后直接跳过
    #22/23044444411
    输出样例 2

    bad i.
    map <int, string> mp = {
        { '1', ",."},
        { '2', "abc"},
        { '3', "def"},
        { '4', "ghi"},
        { '5', "jkl"},
        { '6', "mno"},
        { '7', "pqrs"},
        { '8', "tuv"},
        { '9', "wxyz"},
        { '0', " "},
    };
    class Solution {
    public:
        // 遇到滑动窗口，真的是很浪费时间（早上来了把滑动窗口总结复习下！！！不想在考试中被恶心到！！！）
        const string GetResult(const string &input)
        {
            int flag = 1;
            string res = "";
            for (int i = 0; i < input.size(); i++) {
                if (input[i] == '#') {
                    flag = -flag; // 交替通过相反值操作 
                    continue; // i++替换成continue，for循环中会自加
                }

                // 无论是flag是什么值都需要跳过,这种公共字符需要放在特殊处理之前
                if (input[i] == '/') {
                    continue;
                }

                if (flag == 1) {
                    res += input[i];
                    continue;
                }
                
                int len  = 0;
                while (input[i] != '0' && (i < input.size() - 1) && input[i] == input[i + 1]) { // 遇到/，while循环会结束
                    len++;
                    i++;
                }
                string mpStr = mp[input[i]];
                res += mpStr[len % mpStr.size()];
            }
            return res;
        }
    };


// 求最长无重复