如何根据一个特定字母的出现来确定两个字符串是否相等？

Question

For this project, two strings are equal if they both have the same number of occurrences of the character 'X' and if the character 'X' is in the same position in each of the strings. Note that this allows for strings of different lengths as long as the longer string does not have any 'X's in its extra characters at the end. I need to implement this equals function with the function prototype bool equalsChar(const string& strA, const string& strB, char ch) .

Examples

• equalsChar( "X", "X", 'X' ) is true
• equalsChar( "aaaXaaaX", "abcXcbaX", 'X') is true
• equalsChar( "XaXbXcX", "XtXoXpXdef", 'X') is true
• equalsChar( "XaXbXcX", "XtXoXpXdXf", 'X') is false
• equalsChar( "XXXX", "XX", 'X') is false
• equalsChar( "aXaXbXcX", "XtXoXpX", 'X') is false

We can use helper functions, but we are not allowed to allocate any extra memory (eg do not use substring). We need to work with indices as we process the strings.

I have tried the knowledge I have so far and looked for similar questions on different websites, but this seems like a unique question.

Here is the code:

bool equalsChar(const string& strA, const string& strB, char ch){
   int low1=0;
   int low2=0;
   int high1=strA.length()-1;
   int high2=strB.length()-1;
   return equalsChar(strA, low1, high1, strB, low2, high2, ch);
}

I am using an overloaded function:

bool equalsChar(const string& strA, int low1, int high1, const string& strB, int low2, int high2, char ch){
   int count1=0;
   int count2=0;
   for(int i=low1; i<=high1; i++){
      if(strA[i]==ch)
         count1++;
   }
   for(int j=low2; j<=high2; j++){
      if(strB[j]==ch)
         count2++;
   }
   if(count1==0 && count2==0)
      return false;
   else if(count1!=count2)
      return false;
   else{
      for(int i=low1; i<=high1; i++){
         if(strA[i]==ch){
            for(int j=low2; j<=high2; j++){
               if(strB[j]==ch){
                  if(i==j)
                     return true;
               }
            }
         }
      }
   }
   return false;
}

There are two problems:
1. I need to make this code recursively.
2. I am only checking for the first character that equals ch from strA and strB and then compare their indices, while what I need to do is to compare for all the Xs in the both strings.

It returns true for equalsChar( "aaaXaaXa", "abcXcbaX", 'X') but it should return false.

Answer 1

First ensure the longer string is strB . We use recursion to swap the parameters if needed.

Then test common length. We project each letter to bool with == ch , and compare those bool s.

Finally we test whether ch occurs after 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());
}

Or with C++17's string_view and a ranges library to tidy up.

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);
}

Answer 2

In recursive, I would write it:

// 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);
}

Demo

Answer 3

Ideally you have to

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.  

Both iterations may be recursive of course, but obviously you need only one index. Alternatively, if that's std::string you can use iterators instead of indexes and passing string\\substring. You have to pass str.end() though so iteration would stop when iterator would equal to it.

Note , that calling overloaded functions technically is not recursion. They are different functions.

Let the first iteration function to be something like

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

be called like this:

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() );
}

and would increment iterators while calling itself.

Second one would be

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

and be called from tail case of the first one

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

Now, the cherry. By required behavior it can be same function with swapped arguments.

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

And we can do so from start, by checking which string is longer, calling it so first one is always the longer one.

A non-ideal version, is assuming that two string that do not contain X are equal)

#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;
}