Pattern Matching

16.18 Pattern Matching: You are given two strings, pattern and value. The pattern string consists of just the letters a and b, describing a pattern within a string. For example, the string cat catgoc at go matches the pattern aabab (where cat is a and go is b). It also matches patterns like a, ab, and b. Write a method to determine if value matches pattern.

• Brute Force:

  • Generate all possible substrings of the value. This will generate n^2 different 'words'. Then, with these these words, pair it up with all the substrings. This will generate n^4 pairs. Now using each pair of substrings, pass it into a function that use these pairs as the two distinguishing strings, and determine whether or not it matches the sequence pattern.

• Optimized:

  • There are some basic cases we can eliminate:

    • If the value is empty or if the pattern exceeds the value, is it always false.

    • If the pattern is 1 char, then we know that it can represent any 'word', so set to true

  • With the remainder of the cases, one thing we can do is generate the number of valid combinations. This is best demonstrated with an example.

• If we're given pattern = aabaa and value=catcatgocatcat

• Then are are only so many patterns (number of characters) that we can define to a and b, just that they make out the full sequence of the string.

A = freq(a) = 4
B = freq(b) = 1
l = length = 14

a = number of letters assigned to a
b = number of letters assigned to b

Aa + Bb = l
b = (l - Aa) / B
4a + b = 14

• Now we have an infinity number of solutions that are defined by this number line. We can constrain it in the following ways:

  • Valid solutions must be in the top left quadrant of the cartisian plane, since we need a and b to both be positive.

  • Both a and b must exist at least once so $a \neq b \neq 0$ because we cannot have zero characters.

  • a must be defined from $1 \leq a \leq zero(b)$ and b defined $1 \leq b \leq zero(a)$ because of the two statements above.

  • Both a and b must be discrete values (we cannot have half a character). To test for discrete values, we must check for whole numbers from $1 \leq a \leq zero(b)$ .

• On this number line, we are given 3 possibilities:

  • (1,10), (2,6), (3,2)

• Testing our solution:

  • (1,10) implies that a = value.at(0) = c, then a = value.at(1) = a, so invalid.

  • (2,6) == a = ca; tc; so invalud

  • and finally (3,2); cat ; cat; cat; go; cat; cat (valid)

class Line {
public:
    Line(double length, double freq_a, double freq_b) {
        // edge cases, (vertical or horizontal lines)
        // then there is only 1 valid point
        // vertical
        bool flag = true;
        if (freq_b == 0) {
            valid_points.push_back({ { int(length / freq_a) },{ 0 } });
            flag = false;
        }
        // horizontal
        if (freq_a == 0) {
            valid_points.push_back({ { 0 },{ int(length / freq_b) } });
            flag = false;
        }

        if (flag) {
            // solving for b
            y_int = length / freq_b;
            slope = freq_a / freq_b;

            // finding zeros 0 = l - Aa / B simplifies to
            zero_a = length / freq_a;
            zero_b = length / freq_b;

            // defining all valid points - using floor ensures a non negative number
            for (double i = 1; i < zero_a; i++) {
                // b = l - Aa / B
                double y = length / freq_b - (freq_a * i) / freq_b;
                // check for whole number
                if (y == int(y)) {
                    valid_points.push_back({ { int(i) },{ int(y) } });
                }
            }
        }

    }


    vector<pair<int, int>> valid_points;

private:
    float y_int, slope;
    double zero_a, zero_b;
};


bool check_if_valid_point(pair<int, int> &point, string pattern, string value) {
    string interp_a = "";
    string interp_b = "";
    string last_a, last_b;
    int count = 0;

    for (int i = 0; i < pattern.length(); i++) {
        if (pattern.at(i) == 'a') {
            for (int i = 0; i < point.first; i++) {
                interp_a += value.at(count++);
            }
            if (!last_a.empty() && last_a != interp_a) {
                return false;
            }
            last_a = interp_a;
            interp_a = "";
        }
        else {
            for (int i = 0; i < point.second; i++) {
                interp_b += value.at(count++);
            }
            if (!last_b.empty() && last_b != interp_b) {
                return false;
            }
            last_b = interp_b;
            interp_b = "";
        }
    }
    return true;
}

bool pattern_match(string pattern, string value) {
    // pattern cannot exceed value
    if (pattern.empty() || value.empty() || 
        pattern.size() > value.size()) return false;

    // a and b are ambigious and value is not empty
    else if (pattern.length() == 1) return true;

    // algorithm:
    // 1) Find frequencies of a and b
    double freq_a = 0, freq_b = 0;
    double length = value.length();
    for (auto i : pattern) {
        if (i == 'a') freq_a++;
        else if (i == 'b') freq_b++;
    }

    // 2) Define the line and check for valid points
    Line line(value.length(), freq_a, freq_b);
    vector<pair<int, int>> points = line.valid_points;
    for (auto &i : points) {
        if (check_if_valid_point(i, pattern, value)) {
            return true;
        }
    }
    return false;
}


int main() {
    cout << boolalpha << pattern_match("aabaa", "catcatgocatcat") << endl;
    cout << boolalpha << pattern_match("bbabb", "catcatgocatcat") << endl;
    cout << boolalpha << pattern_match("aba", "catgocat") << endl;
    cout << boolalpha << pattern_match("aab", "catcatgo") << endl;
    cout << boolalpha << pattern_match("bbaba", "dandandavdandav") << endl;
    cout << boolalpha << pattern_match("aaa", "catcatcat") << endl;

    cout << boolalpha << pattern_match("aabba", "catcatgocatcat") << endl;
    cout << boolalpha << pattern_match("baabb", "catcatgocatcat") << endl;
    cout << boolalpha << pattern_match("abb", "catgocat") << endl;
    cout << boolalpha << pattern_match("abb", "catcatgo") << endl;
    cout << boolalpha << pattern_match("bbb", "catcatgo") << endl;