使用递归搜索字符串以查找另一个字符串

Question

I'm working on the following simple program:

/**
    Recursively searches a string to find a second string.
    @param s the string to search through.
    @param t the string to search for
    @return true if t is found in s.

    Tests whether the string t is contained in a string s.
    For instance, calling the function like this:
        bool b = find("Mississippi", "sip");
    returns true, since "sip" is contained in "Mississippi".
    You must write this as a recursive function, not by just
    calling the string::find() function, or by using a loop.

*/

bool find(const string& s, const string& t)

{
    string temp = s;    
    if(temp.size() < t.size())    
        return false;   
    temp.erase(0, 1);     
    find(temp, t);    
}

Here's my testing output:

Checking function: Checking the find recursive function. -------------

   + find("Mississipi", "ipi")
   X find("Mississipi", "ipx") should be false, but is true.
   + find("Sommertown", "Som")
   + find("Sommertown", "Sommertowne")
   + find("Somewhere in the middle", "in")

----------------------------------------------------------------------
  Tests passing 4/5 (80%).

I've written it about 4 other ways, all similar...including one with find(temp.substr(1),t) instead of the temp.erase.

Would anyone mind pointing me in the right direction? I know it's a simple mistake but I'm not seeing it!

Thank you!

Answer 1

There are two problems with your solution:

1. Not all control paths in find explicitly return a value
2. t is never compared to s in any way, so find isn't actually checking for t - it's simply getting erased, one character at a time.

A better way to write your function might be something like this:

bool find(const string& s, const string& t)
{
    string temp = s;

    // Boundary condition which should return true
    if (temp.substr(0, t.size()) == t)
        return true;

    // Boundary condition which should return false
    if (temp.size() < t.size())
        return false;

    return find(temp.substr(1), t); // Recursive call
}

^^ Note that in this function, all possible control paths return a value, and t will always be compared to s .

Also note that I said that in your solution, not all control paths were explicitly returning a value. A C++ function will return a value even if you don't have a return statement, but as @Johan pointed out, it's the last thing evaluated, not true. For instance, I coded up your solution and received the response "224" from find , whereas if find returned true, I would have received the response "1" - or true.

Answer 2

Your function will always return false. What it does is it removes one character of string s until s.size() < t.size().

I would write the function the following way.:)

bool find( const std::string &s, const std::string &t )
{
    return ( s.size() < t.size() ? 
             false : 
             ( s.compare( 0, t.size(), t ) == 0 ? 
               true :
               find( std::string( s, 1 ), t ) ) );
}

Answer 3

I figured it out guys:

bool find(const string& s, const string& t)
{
    if(s.length() < t.length()) 
        return false;
    else if(s.substr(0, t.size()) == t)
        return true;

    return find(s.substr(1),t);
}

TESTING H37, loginID
----------------------------------------------------------------------
Checking function: Checking the find recursive function. -------------------
   + find("Mississipi", "ipi")
   + find("Mississipi", "ipx")
   + find("Sommertown", "Som")
   + find("Sommertown", "Sommertowne")
   + find("Somewhere in the middle", "in")
----------------------------------------------------------------------
  Tests passing 5/5 (100%).

Press any key to continue . . .

I appreciate all your help! This site is a godsend for a new programmer!