需要帮助查看字符串是否包含使用递归的字符列表

Question

My teacher gave me an assignment where there are two strings, a full word, and a substring that contains letters that might be in the full word. The objective is to use recursion to see if the full word contains the letters of the substring in order they are given. here are some examples of what I am talking about:

-"xd", "test" returns false because one or more of the substring letters does not exist in the full word.

-"ts", "test" returns true because both letters are found found in the full word.

-"trl", "turtle" returns true because all the letters are found in the full word and are found in the correct order.

-"tlr", "turtle" returns false because although the all the letters exist in the full word, they were not found in the substring's order.

I have tried:

public boolean contains_recursive(String partial, String full) {

    String[] partialArray = partial.split("");

    if(full.contains(partialArray[0])) {
        partialArray = Arrays.copyOfRange(partialArray, 1, partialArray.length);
        String newPartial = "";
        for(String character : partialArray) {
            System.out.println(character);
            newPartial += character;
        }
        contains_recursive(newPartial, full);
    }

    return false;
}

but do not know where to go from there. Thanks for any help.

Answer 1

Try this:

public boolean containsRecursive(String partial, String full) {
  if (partial.isEmpty()) return true;
  if (full.isEmpty()) return false;

  int firstOccurrence = full.indexOf(partial.charAt(0));

  return firstOccurrence >= 0 && containsRecursive(partial.substring(1), full.substring(firstOccurrence + 1));
}

Explanation:

if (partial.isEmpty()) return true;

• If there is nothing to look for in the full string, then the "substring" technically exists (ie an empty string is a substring of all strings).

if (full.isEmpty()) return false;

• If we've got to this point that means there are characters in the partial string that we're looking for but unfortunately the full string doesn't have any characters to compare to, so those characters in the partial string will definitely not be in full , return false .

int firstOccurrence = full.indexOf(partial.charAt(0));

• We've got this far so both partial and full are non-empty, let's utilize String 's indexOf instance method. This method will return the location of the first occurrence of the given character or -1 if the character doesn't exist in the string.
• We use partial.charAt(0) because if the first character of partial doesn't exist in full then why should we check the remaining characters in partial ? In other words, let's make sure that the first character exists before checking the rest.

return firstOccurrence >= 0 && containsRecursive(partial.substring(1), full.substring(firstOccurrence + 1));

• We check firstOccurrence >= 0 because if firstOccurrence is -1 then that means partial 's first character wasn't in full so this should return false .
• The && is used for short-circuiting. In other words, if firstOccurrence >= 0 is false the second half of the boolean check (ie the recursive call) won't be evaluated because false && anyOtherBooleanExpression ==> false .
• The second half of boolean check is the recursive call. We only get this far if the first character of partial is in full . Now we call our function again by taking all the characters of partial minus its first character or partial.substring(1) .
• Since firstOccurrence represents the first location of the first character of partial in full , we don't care about the (possible) skipped locations.
  • For example, if partial = "mtr" and full = "computer" , m matches at position 2 , we should start checking partial = "tr" within full = "puter" on the next recursive call.

Hope this helps!