1023.驼峰式匹配

链接：1023.驼峰式匹配
难度：Medium
标签：字典树、数组、双指针、字符串、字符串匹配
简介：如果我们可以将小写字母插入模式串 pattern 得到待查询项 query，那么待查询项与给定模式串匹配。

题解 1 - cpp

• 编辑时间：2023-04-14
• 执行用时：4ms
• 内存消耗：6.9MB
• 编程语言：cpp
• 解法介绍：遍历。

class Solution {
public:
    vector<bool> camelMatch(vector<string>& queries, string pattern) {
        auto check = [&](string &s) {
            int pidx = 0;
            for (int i = 0; i < s.size(); i++) {
                if (pidx < pattern.size() && s[i] == pattern[pidx]) pidx++;
                else if (isupper(s[i])) return false;
            }
            return pidx == pattern.size();
        };
        vector<bool> res;
        for (auto &q : queries) res.push_back(check(q));
        return res;
    }
};

题解 2 - rust

• 编辑时间：2023-04-14
• 内存消耗：2MB
• 编程语言：rust
• 解法介绍：同上。

impl Solution {
    pub fn camel_match(queries: Vec<String>, pattern: String) -> Vec<bool> {
        let pattern = pattern.chars().collect::<Vec<_>>();
        queries
            .into_iter()
            .map(|s| {
                let mut pidx = 0;
                for c in s.chars() {
                    if pidx < pattern.len() && c == pattern[pidx] {
                        pidx += 1
                    } else if c.is_uppercase() {
                        return false;
                    }
                }
                pidx == pattern.len()
            })
            .collect::<Vec<_>>()
    }
}

题解 3 - python

• 编辑时间：2023-04-14
• 执行用时：36ms
• 内存消耗：14.8MB
• 编程语言：python
• 解法介绍：同上。

class Solution:
    def camelMatch(self, queries: List[str], pattern: str) -> List[bool]:
        def check(s: str):
            pidx = 0
            for c in s:
                if pidx < len(pattern) and c == pattern[pidx]:
                    pidx += 1
                elif c.isupper():
                    return False
            return pidx == len(pattern)
        return [check(s) for s in queries]