如何检查我在字符串中查找的单词的前一个字母是否存在？ 递归

Question

I am currently creating a java program that counts the number of occurrences of a specific word in a string using recursion, however, if the preceding letter is an 'a', the count won't be incremented. I cannot find a way to check the preceding letter before the first letter of the word I am looking for. I tried using indexOf then subtracting one to check the preceding letter, but it won't work.

Here's my working function at the moment:

//The value of text is abrichbbarichacrich
//While the value of find is rich
//Expected output should be 2
static int Count(String text, String find) {
    if (text.length() == 0 || text.length() < find.length()) {
        return 0;
    }
    if (text.contains(find)) {
        return 1 + Count(text.replaceFirst(find, ""), find);
    }
    return 0;
}

Here's my second version, but it gives me a StringIndexOutOfBoundsException and the output should be 2, but instead it gives me an output of 3.

if (text.length() == 0 || text.length() < find.length()) {
    return 0;
}
if (text.contains(find)) {
    int index = text.indexOf(find) - 1;
    if (text.charAt(index) == 'a')
        return Count(text.replaceFirst(find, ""), find);
    return 1 + Count(text.replaceFirst(find, ""), find);
}

Any help would be appreciated:)

Answer 1

Correct if else condition.replaceFirst() method returns the updated string.We have to update the string.

static int Count(String text, String find) {
        if (text.length() == 0 || text.length() < find.length()) {
            return 0;
        }
        if (text.contains(find)) {
            int index = text.indexOf(find) - 1;
            text=text.replaceFirst(find, "");
            if (index!=-1&&text.charAt(index) != 'a'){
             
                return 1+Count(text,find);
            }
            else
            return Count(text,find);
        }
        return 0;
       
    }

Answer 2

Just working the answer out in pseudocode, here's how I'd approach the problem.

Define a helper function as follows:

countHelper(string text, string find, bool previousWasNotA) = 
  if (length of text < length of find) {
    0
  } else {
    let prefixEqualsFind = if (previousWasNotA and find is a prefix of text) {
        0
    } else {
        1
    } 
    in 
    prefixEqualsFind + countHelper(text without first character, find, first character of text != 'a')
  }

count(string text, string find) = countHelper(text, find, true)

The idea here is that countHelper(text, find, previousWasNotA) returns the number of occurences of find in text , not counting any occurences where find is directly preceded by an a , and not counting an occurence of find at the very beginning of text if previousWasNotA is false.

In Java, this look like

static int countHelper(String text, String find, bool previousWasNotA) {
   if (text.length() < find.length()) {
       return 0;
    } else {
        const int prefixEqualsEnd = previousWasNotA && text.startsWith(find) ? 1 : 0;
        return prefixEqualsEnd + countHelper(text.substring(1), find, text.charAt(0) != 'a');
    }
}

static int count(String text, String find) {
   return countHelper(text, find, true);
}

Note that this doesn't work for the case of find = "" . But in that case, it's not clear the problem even has an answer at all, since we can put infinitely many ""s together to make a single "" and hence infinitely many ""s are contained in any string at all.

Also note that this is not an asymptotically optimal algorithm. For that, you'll want to use the KMP algorithm .