Как узнать, равны ли две строки на основе появления одной конкретной буквы?

Сначала убедитесь, что более длинная строка strB. Мы используем рекурсию для замены параметров, если это необходимо.

Затем проверьте общую длину. Мы проецируем каждую букву на bool с == ch и сравниваем эти bool.

Наконец, мы проверяем, происходит ли ch после strA.size().

bool equalsChar(const string& strA, const string& strB, char ch) {
    if (strA.size() > strB.size()) { return equalsChar(strB, strA, ch); }

    auto common = [ch](char a, char b) { return (a == ch) == (b == ch); };
    return std::equal(strA.begin(), strA.end(), strB.begin(), common)
        && (std::find(strB.begin() + strA.size(), strB.end(), ch) == strB.end());
}

Или с string_view С++ 17 и библиотекой диапазонов для очистки.

bool equalsChar(string_view strA, string_view strB, char ch) {
    if (strA.size() > strB.size()) { return equalsChar(strB, strA, ch); }

    auto common = [ch](char a, char b) { return (a == ch) == (b == ch); };
    string_view prefix = strB.substr(0, strA.size());
    string_view suffix = strB.substr(strA.size());

    return ranges::equal(strA, prefix, common)
        && !ranges::contains(suffix, ch);
}

В рекурсии я бы написал это:

// Does s contains given char?
bool hasChar(const char* s, char c)
{
    if (*s == '\0') {
        return false;
    }
    if (*s == c) {
        return true;
    }
    return hasChar(s + 1, c);
}

bool equalsChar(const char* strA, const char* strB, char ch)
{
    // one string is finished, check the other one.
    if (*strA == '\0') {
        return !hasChar(strB, ch);
    } else if (*strB == '\0') {
        return !hasChar(strA, ch);
    }
    // Are strings compare different?
    if (*strA != *strB && (*strA == ch || *strB == ch)) {
        return false;   
    }
    // next index
    return equalsChar(strA + 1, strB + 1, ch);
}

Демо

В идеале вы должны

1. iterate through first string `str1` by i
2. if you encounter `str1[i] == ch`,and 
3    if `i <= str2.length()` 
4.      check if `str2[i] == ch`.  
5.           if false then  strings are not equal
6.   else if `i > str2.length()` you would cut the iteration 
7. else if `str2[i] == ch` then  strings are not equal

8. continue to iterate through string str2 by i, 
9.             if `str2[i] == ch` strings are not equal
A. if end reached , strings are equal.  

Обе итерации, конечно, могут быть рекурсивными, но, очевидно, вам нужен только один индекс. В качестве альтернативы, если это std::string, вы можете использовать итераторы вместо индексов и передачи строки\подстроки. Вы должны передать str.end(), чтобы итерация остановилась, когда итератор сравнялся с ним.

Обратите внимание, что технически вызов перегруженных функций не является рекурсией. Это разные функции.

Пусть первая функция итерации будет чем-то вроде

bool equalsChar(string::const_iterator& at1, 
                string::const_iterator& at2, 
                const char& ch, 
                const string::const_iterator& end1, 
                const string::const_iterator& end2);

называться так:

bool equalsChar(const string& strA, const string& strB, char ch)
{
     // maybe do checks if strings are empty to shortcut the function?
     auto it1 = strA.begin(), it2 = strB.begin();
     return equalsChar(it1, it2, ch, strA.end(), strB.end() );
}

и будет увеличивать итераторы при вызове самого себя.

Второй был бы

bool equalsChar(string::iterator& at, 
                const char& ch, const string::iterator& end);

и вызываться из хвостового регистра первого

// assuming we checked that it2 not equal to end2 before
if(it1 == end1) return equalsChar(it2 , ch, end2 );

Теперь вишенка. По требуемому поведению это может быть та же функция с переставленными аргументами.

if(it1 == end1) return equalsChar(it2 , it1, ch, end2, end1 );

И мы можем сделать это с самого начала, проверяя, какая строка длиннее, вызывая ее так, чтобы первая всегда была длиннее.

Неидеальная версия предполагает, что две строки, не содержащие X, равны)

#include <iostream>
#include <vector>
#include <string>

using std::string; 
bool equalsChar(string::const_iterator& at1, 
                string::const_iterator& at2, 
                const char& ch, 
                string::const_iterator& end1, 
                string::const_iterator& end2)
{    
    if(at2 == end2) {
        if(at1 == end1)
            return true; // two empty strings are equal, right?
        if(*at1 == ch)
            return false;    
    }
    else
    { 
        if((*at1 != *at2) && (*at1 == ch || *at2 == ch)) return false; 
        ++at2;
    }

    ++at1;    
    return equalsChar( at1, at2, ch, end1, end2);
}

bool equalsChar(const string& strA, const string& strB, char ch)
{
     // maybe do checks if strings are empty to shortcut the function?
     auto it1 = strA.begin(), it2 = strB.begin();
     decltype(it1) end1 = strA.end(), end2 = strB.end();

     if(strA.length() < strB.length()) 
        std::swap(it1,it2), std::swap(end1,end2);
     return equalsChar(it1, it2, ch, end1, end2 );
}

int main()
{
    std::vector<std::pair<string,string>> data= {
    { "X", "X" },
    { "aaaXaaaX", "abcXcbaX" },
    { "XaXbXcX", "XtXoXpXdef" },
    { "XaXbXcX", "XtXoXpXdXf" },
    { "XXXX", "XX" },
    { "aXaXbXcX", "XtXoXpX" }};


    for(auto& item : data)
        std::cout << "equalsChar( " << item.first << ", " << item.second  << " )" 
              << string{ equalsChar(item.first,item.second,'X') ? " is true" : " is false"} << std::endl;
}