Careercup - Microsoft面试题 - 4639756264669184

2014-05-12 06:42

题目链接

原题：

Write your own regular expression parser for following condition: 

az*b can match any string that starts with and ends with b and 0 or more Z's between. for e.g. azb, azzzb etc. 

a.b can match anything between a and b e.g. ajsdskjb etc. 

Your function will have to parameters: Input String and Regex. Return true/false if the input string satisfies the regex condition. Note: The input string can contain multiple regex. For e.g. az*bc.g

题目：实现正则表达式中的“*”和“.”功能，不过题目中给定的“.”实际上是“.*”。

解法：Leetcode上有这题，所以我估计是这题的出题者自己记错了，所以说错了“.”的意义。我的Leetcode题解在此：LeetCode - Regular Expression Matching。

代码：

// http://www.careercup.com/question?id=4639756264669184
#include <cstring>
#include <vector>
using namespace std;

class Solution {
public:
    bool isMatch(const char *s, const char *p) {
        int i, j;
        int ls, lp;
        vector<int> last_i_arr;
        vector<int> last_j_arr;
        
        if (s == nullptr || p == nullptr) {
            return false;
        }
        
        ls = strlen(s);
        lp = strlen(p);
        if (lp == 0) {
            // empty patterns are regarded as match.
            return ls == 0;
        }
        
        // validate the pattern string.
        for (j = 0; j < lp; ++j) {
            if (p[j] == '*' && (j == 0 || p[j - 1] == '*')) {
                // invalid pattern string, can't match.
                return false;
            }
        }
        
        int last_i, last_j;
        
        i = j = 0;
        last_i = -1;
        last_j = -1;
        while (i < ls) {
            if (j + 1 < lp && p[j + 1] == '*') {
                last_i_arr.push_back(i);
                last_j_arr.push_back(j);
                ++last_i;
                ++last_j;
                j += 2;
            } else if (p[j] == '.' || s[i] == p[j]) {
                ++i;
                ++j;
            } else if (last_j != -1) {
                if (p[last_j_arr[last_j]] == '.' || s[last_i_arr[last_i]] == p[last_j_arr[last_j]]) {
                    // current backtracking position is still available.
                    i = (++last_i_arr[last_i]);
                    j = last_j_arr[last_j] + 2;
                } else if (last_j > 0) {
                    while (last_j  >= 0) {
                        // backtrack to the last backtracking point.
                        --last_i;
                        --last_j;
                        last_i_arr.pop_back();
                        last_j_arr.pop_back();
                        if (last_j >= 0 && (p[last_j_arr[last_j]] == '.' || s[last_i_arr[last_i]] == p[last_j_arr[last_j]])) {
                            i = (++last_i_arr[last_i]);
                            j = last_j_arr[last_j] + 2;
                            break;
                        }
                    }
                    if (last_j == -1) {
                        return false;
                    }
                } else {
                    // no more backtracking is possible.
                    return false;
                }
            } else {
                return false;
            }
        }
        
        while (j < lp) {
            if (j + 1 < lp && p[j + 1] == '*') {
                j += 2;
            } else {
                break;
            }
        }
        
        last_i_arr.clear();
        last_j_arr.clear();
        return j == lp;
    }
};