RUST GYM v0.2.4

1023. Camelcase Matching

A query word matches a given pattern if we can insert lowercase letters to the pattern word so that it equals the query. (We may insert each character at any position, and may insert 0 characters.)

Given a list of queries, and a pattern, return an answer list of booleans, where answer[i] is true if and only if queries[i] matches the pattern.

 

Example 1:

Input: queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FB"
Output: [true,false,true,true,false]
Explanation: 
"FooBar" can be generated like this "F" + "oo" + "B" + "ar".
"FootBall" can be generated like this "F" + "oot" + "B" + "all".
"FrameBuffer" can be generated like this "F" + "rame" + "B" + "uffer".

Example 2:

Input: queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FoBa"
Output: [true,false,true,false,false]
Explanation: 
"FooBar" can be generated like this "Fo" + "o" + "Ba" + "r".
"FootBall" can be generated like this "Fo" + "ot" + "Ba" + "ll".

Example 3:

Input: queries = ["FooBar","FooBarTest","FootBall","FrameBuffer","ForceFeedBack"], pattern = "FoBaT"
Output: [false,true,false,false,false]
Explanation: 
"FooBarTest" can be generated like this "Fo" + "o" + "Ba" + "r" + "T" + "est".

 

Note:

  1. 1 <= queries.length <= 100
  2. 1 <= queries[i].length <= 100
  3. 1 <= pattern.length <= 100
  4. All strings consists only of lower and upper case English letters.

Rust Solution

struct Solution;

impl Solution {
    fn camel_match(queries: Vec<String>, pattern: String) -> Vec<bool> {
        queries
            .into_iter()
            .map(|query| Self::query_match(query.chars().collect(), pattern.chars().collect()))
            .collect()
    }

    fn query_match(query: Vec<char>, pattern: Vec<char>) -> bool {
        let mut j = 0;
        for i in 0..query.len() {
            if j < pattern.len() && query[i] == pattern[j] {
                j += 1;
            } else {
                if query[i].is_uppercase() {
                    return false;
                }
            }
        }
        j == pattern.len()
    }
}

#[test]
fn test() {
    let queries = vec_string![
        "FooBar",
        "FooBarTest",
        "FootBall",
        "FrameBuffer",
        "ForceFeedBack"
    ];
    let pattern = "FB".to_string();
    let res = vec![true, false, true, true, false];
    assert_eq!(Solution::camel_match(queries, pattern), res);
    let queries = vec_string![
        "FooBar",
        "FooBarTest",
        "FootBall",
        "FrameBuffer",
        "ForceFeedBack"
    ];
    let pattern = "FoBa".to_string();
    let res = vec![true, false, true, false, false];
    assert_eq!(Solution::camel_match(queries, pattern), res);
    let queries = vec_string![
        "FooBar",
        "FooBarTest",
        "FootBall",
        "FrameBuffer",
        "ForceFeedBack"
    ];
    let pattern = "FoBaT".to_string();
    let res = vec![false, true, false, false, false];
    assert_eq!(Solution::camel_match(queries, pattern), res);
}

Having problems with this solution? Click here to submit an issue on github.