leetcode::strong_password_checker::Solution类 参考

#include <leetcode.h>

静态 Public 成员函数
static int	strongPasswordChecker (const string &password)

详细描述

在文件 leetcode.h 第 2007 行定义.

成员函数说明

strongPasswordChecker()

int leetcode::strong_password_checker::Solution::strongPasswordChecker ( const string &  password )

static

在文件 leetcode.cpp 第 5373 行定义.

                                                                  {
            const int n    = password.length();
            bool has_lower = false;
            bool has_upper = false;
            bool has_digit = false;
            for(const char ch: password) {
                if(islower(ch) != 0) {
                    has_lower = true;
                } else if(isupper(ch) != 0) {
                    has_upper = true;
                } else if(isdigit(ch) != 0) {
                    has_digit = true;
                }
            }
            const int categories = static_cast<int>(has_lower) + static_cast<int>(has_upper) + static_cast<int>(has_digit);
 
            if(n < 6) {
                return max(6 - n, 3 - categories);
            }
            if(n <= 20) {
                int replace  = 0;
                int count    = 0;
                char current = '#';
 
                for(const char ch: password) {
                    if(ch == current) {
                        ++count;
                    } else {
                        replace += count / 3;
                        count   = 1;
                        current = ch;
                    }
                }
                replace += count / 3;
                return max(replace, 3 - categories);
            }
            // 替换次数和删除次数
            int replace = 0;
            int remove  = n - 20;
            // k mod 3 = 1 的组数，即删除 2 个字符可以减少 1 次替换操作
            int rm2   = 0;
            int count = 0;
            char cur  = '#';
 
            for(const char ch: password) {
                if(ch == cur) {
                    ++count;
                } else {
                    if(remove > 0 && count >= 3) {
                        if(count % 3 == 0) {
                            // 如果是 k % 3 = 0 的组，那么优先删除 1 个字符，减少 1 次替换操作
                            --remove;
                            --replace;
                        } else if(count % 3 == 1) {
                            // 如果是 k % 3 = 1 的组，那么存下来备用
                            ++rm2;
                        }
                        // k % 3 = 2 的组无需显式考虑
                    }
                    replace += count / 3;
                    count = 1;
                    cur   = ch;
                }
            }
            if(remove > 0 && count >= 3) {
                if(count % 3 == 0) {
                    --remove;
                    --replace;
                } else if(count % 3 == 1) {
                    ++rm2;
                }
            }
            replace += count / 3;
 
            // 使用 k % 3 = 1 的组的数量，由剩余的替换次数、组数和剩余的删除次数共同决定
            const int use2 = min({replace, rm2, remove / 2});
            replace -= use2;
            remove -= use2 * 2;
            // 由于每有一次替换次数就一定有 3 个连续相同的字符（k / 3 决定），因此这里可以直接计算出使用 k % 3 = 2 的组的数量
            const int use3 = min(replace, remove / 3);
            replace -= use3;
            remove -= use3 * 3;
            return n - 20 + max(replace, 3 - categories);
        }

引用了 acwing::acwing3786::remove().

被这些函数引用 leetcode::strong_password_checker::TEST().

---

该类的文档由以下文件生成:

• leetcode.h
• leetcode.cpp