给定两个字符串，确定1是否是递归的另一个子字符串

Question

I'm running through some practice problems, one of which is to take two Strings and determine if one is a substring of the other. I wrote my first solution:

public static boolean isSubstring(String s1, String s2){
    String longer = s1.length() > s2.length() ? s1 : s2;
    String shorter = s1.length() < s2.length() ? s1 : s2;
    String substring;

    for(int i = 0; i < longer.length() && i + shorter.length() <= longer.length(); i++){
        substring = longer.substring(i, i + shorter.length());
        if(substring.equals(shorter))
          return true;
    }
    return false;
}

And then I remembered that Java has a contains method for String class, and the solution is trivial at that point. :

public static boolean isSubstringUsingContains(String s1, String s2){
  String longer = s1.length() > s2.length() ? s1 : s2;
  String shorter = s1.length() < s2.length() ? s1 : s2;
  return longer.contains(shorter);

}

Since I'm practicing and I'm not very good at recursion, I thought I should try to solve this recursively, and I have not been able to do so correctly. How can I solve this with recursion, and are there any pros/cons for using recursion here as opposed to the above solutions. Here is my failed attempt at a recursive solution for this problem:

 public static boolean isSubstringRecursive(String s1, String s2,int i){
  if(s1.length() == 0 || s2.length() == 0)
   return false;

  String longer = s1.length() > s2.length() ? s1 : s2;
  String shorter = s1.length() < s2.length() ? s1 : s2;

  if(longer.equals(shorter))
     return true;

  return isSubstringRecursive(longer.substring(i,i + shorter.length()),shorter,i + 1);


}

EDIT

Test Cases: String A = "Batman" String B = "atm" RESULT: True

String A = "Handstand" String B = "stand" RESULT: True

String A = "Hotsauce" String B = "ecu" RESULT: False

Answer 1

I am making minimal changes to your routine to make it work. see my comments in the code for explanation.

/* Adding an extra argument to store the longest value constantly across multiple recursions. */
public static boolean isSubstringRecursive(String longString, String s1, String s2,int i){

  if(s1.length() == 0 || s2.length() == 0)
   return false;

  String longer = s1.length() >= s2.length() ? s1 : s2;
  String shorter = s1.length() < s2.length() ? s1 : s2;

  /* set the longString in the first iteration only */
  if(i==0)longString=longer;

  if(longer.equals(shorter))
     return true;

  /* To prevent substring to go out of boounds */
  if(i+ shorter.length() > longString.length()) return false;

  /* Use longString for substring since it holds the originally long string */
  return isSubstringRecursive(longString, longString.substring(i,i + shorter.length()),shorter,i + 1); 

}

This code can be further optimized to a great extent. But I will leave that part to you for further work.

Note 1 : As you say, you can easily achieve this using the 'contains' method of the String class. However, in the solution that you have demonstrated for contains , you don't really have to check the string lengths. See the following:

return s1.contains(s2) || s2.contains(s1);

Note 2 : You can also use the indexOf of the String class, to do the same. See the following:

return (s1.indexOf(s2) != -1 || s2.indexOf(s1) != -1);

Long story short, there are so many easier options to achieve your objective that there is no need to go for recursion option.