CODEWITHSUNDEEP
javaalgorithm
Chander Shivdasani
Chander Shivdasani

Reputation: 10121

Common Substring of two strings

This particular interview-question stumped me:

Given two Strings S1 and S2. Find the longest Substring which is a Prefix of S1 and suffix of S2.

Through Google, I came across the following solution, but didnt quite understand what it was doing. 

public String findLongestSubstring(String s1, String s2) {
        List<Integer> occurs = new ArrayList<>();
        for (int i = 0; i < s1.length(); i++) {
            if (s1.charAt(i) == s2.charAt(s2.length()-1)) {
                occurs.add(i);
            }
        }

        Collections.reverse(occurs);

        for(int index : occurs) {
            boolean equals = true;
            for(int i = index; i >= 0; i--) {
                if (s1.charAt(index-i) != s2.charAt(s2.length() - i - 1)) {
                    equals = false;
                    break;
                }
            }
            if(equals) {
                return s1.substring(0,index+1);
            }
        }

        return null;
    }

My questions:

  1. How does this solution work?
    • And how do you get to discovering this solution?
  2. Is there a more intuitive / easier solution?

Upvotes: 2

Views: 11742

Answers (4)

trank
trank

Reputation: 1012

I converted the @TheMorph's answer to javascript. Hope this helps js developer

if (typeof String.prototype.endsWith !== 'function') {
    String.prototype.endsWith = function(suffix) {
        return this.indexOf(suffix, this.length - suffix.length) !== -1;
    };
}

function findLongestPrefixSuffix(s2, s1) {

   for( var i = Math.min(s1.length, s2.length); ; i--) {
      if(s2.endsWith(s1.substring(0, i))) {
         return s1.substring(0, i);
      }
   }    
}

console.log(findLongestPrefixSuffix('abc', 'bcd')); // result: 'bc'

Upvotes: 0

Dacav
Dacav

Reputation: 14078

Apache commons lang3, StringUtils.getCommonPrefix()

Java is really bad in providing useful stuff via stdlib. On the plus side there's almost always some reasonable tool from Apache.

Upvotes: 3

TheMorph
TheMorph

Reputation: 572

Part 2 of your question

Here is a shorter variant:

public String findLongestPrefixSuffix(String s1, String s2) {

   for( int i = Math.min(s1.length(), s2.length()); ; i--) {
      if(s2.endsWith(s1.substring(0, i))) {
         return s1.substring(0, i);
      }
   }    
}

I am using Math.min to find the length of the shortest String, as I don't need to and cannot compare more than that.

someString.substring(x,y) returns you the String you get when reading someString beginning from character x and stopping at character y. I go backwards from the biggest possible substring (s1 or s2) to the smallest possible substring, the empty string. This way the first time my condition is true it will be biggest possible substring the fulfills it.

If you prefer you can go the other way round, but you have to introduce a variable saving the length of the longest found substring fulfilling the condition so far:

public static String findLongestPrefixSuffix(String s1, String s2) {

   if (s1.equals(s2)) { // this part is optional and will 
      return s1;        // speed things up if s1 is equal to s2
   }                    //

   int max = 0;
   for (int i = 0; i < Math.min(s1.length(), s2.length()); i++) {
      if (s2.endsWith(s1.substring(0, i))) {
         max = i;
      }
   }
   return s1.substring(0, max);
}

For the record: You could start with i = 1 in the latter example for a tiny bit of extra performance. On top of this you can use i to specify how long the suffix has at least to be you want to get. ;) If you writ Math.min(s1.length(), s2.length()) - x you can use x to specify how long the found substring may be at most. Both of these things are possible with the first solution, too, but the min length is a bit more involving. ;)

Part 1 of your question

In the part above the Collections.reverse the author of the code searches for all positions in s1 where the last letter of s2 is and saves this position.

What follows is essentially what my algorithm does, the difference is, that he doesn't check every substring but only those that end with the last letter of s2.

This is some sort of optimization to speed things up. If speed is not that important my naive implementation should suffice. ;)

Upvotes: 5

janos
janos

Reputation: 124648

Where did you find that solution? Was it written by a credible, well-respected coder? If you're not sure of that, then it might not be worth reading it. One could write really complex and inefficient code to accomplish something really simple, and it will not be worth understanding the algorithm.

Rather than trying to understand somebody else's solution, it might be easier to come up with it on your own. I think you understand the problem much better that way, and the logic becomes your own. Over time and practice the thought process will start to come more naturally. Practice makes perfect.

Anyway, I put a more simple implementation in Python here (spoiler alert!). I suggest you first figure out the solution on your own, and compare it to mine later.

Upvotes: 3

Related Questions