Question

I was asked this question in a phone interview for summer internship, and tried to come up with a n*m complexity solution (although it wasn’t accurate too) in Java.

I have a function that takes 2 strings, suppose “common” and “cmn”. It should return True based on the fact that ‘c’, ‘m’, ‘n’ are occurring in the same order in “common”. But if the arguments were “common” and “omn”, it would return False because even though they are occurring in the same order, but ‘m’ is also appearing after ‘o’ (which fails the pattern match condition)

I have worked over it using Hashmaps, and Ascii arrays, but didn’t get a convincing solution yet! From what I have read till now, can it be related to Boyer-Moore, or Levenshtein Distance algorithms?

Hoping for respite at stackoverflow! 🙂

Edit: Some of the answers talk about reducing the word length, or creating a hashset. But per my understanding, this question cannot be done with hashsets because occurrence/repetition of each character in first string has its own significance. PASS conditions- “con”, “cmn”, “cm”, “cn”, “mn”, “on”, “co”. FAIL conditions that may seem otherwise– “com”, “omn”, “mon”, “om”. These are FALSE/FAIL because “o” is occurring before as well as after “m”. Another example- “google”, “ole” would PASS, but “google”, “gol” would fail because “o” is also appearing before “g”!

Answer 1

I think it’s quite simple. Run through the pattern and fore every character get the index of it’s last occurence in the string. The index must always increase, otherwise return false.
So in pseudocode:

index = -1
foreach c in pattern
    checkindex = string.lastIndexOf(c)
    if checkindex == -1                   //not found
        return false
    if checkindex < index
        return false
    if string.firstIndexOf(c) < index     //characters in the wrong order
        return false
    index = checkindex
return true

Edit: you could further improve the code by passing index as the starting index to the lastIndexOf method. Then you would’t have to compare checkindex with index and the algorithm would be faster.

Updated: Fixed a bug in the algorithm. Additional condition added to consider the order of the letters in the pattern.