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  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 == ) {
             // empty patterns are regarded as match.
             return ls == ;
         }

         // validate the pattern string.
         for (j = ; j < lp; ++j) {
             if (p[j] == '*' && (j ==  || p[j - ] == '*')) {
                 // invalid pattern string, can't match.
                 return false;
             }
         }

         int last_i, last_j;

         i = j = ;
         last_i = -;
         last_j = -;
         while (i < ls) {
             if (j +  < lp && p[j + ] == '*') {
                 last_i_arr.push_back(i);
                 last_j_arr.push_back(j);
                 ++last_i;
                 ++last_j;
                 j += ;
             } else if (p[j] == '.' || s[i] == p[j]) {
                 ++i;
                 ++j;
             } else if (last_j != -) {
                 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] + ;
                 } else if (last_j > ) {
                     while (last_j  >= ) {
                         // backtrack to the last backtracking point.
                         --last_i;
                         --last_j;
                         last_i_arr.pop_back();
                         last_j_arr.pop_back();
                         if (last_j >=  && (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] + ;
                             break;
                         }
                     }
                     if (last_j == -) {
                         return false;
                     }
                 } else {
                     // no more backtracking is possible.
                     return false;
                 }
             } else {
                 return false;
             }
         }

         while (j < lp) {
             if (j +  < lp && p[j + ] == '*') {
                 j += ;
             } else {
                 break;
             }
         }

         last_i_arr.clear();
         last_j_arr.clear();
         return j == lp;
     }
 };