Find longest substring without repeating characters

Question

Given a string S of length N find longest substring without repeating characters.

Example:

Input:

Answer 1

1. You are going to need a start and an end locator(/pointer) for the string and an array where you store information for each character: did it occour at least once?

2. Start at the beginning of the string, both locators point to the start of the string.

3. Move the end locator to the right till you find a repetition (or reach the end of the string). For each processed character, store it in the array. When stopped store the position if this is the largest substring. Also remember the repeated character.

4. Now do the same thing with the start locator, when processing each character, remove its flags from the array. Move the locator till you find the earlier occurrence of the repeated character.

5. Go back to step 3 if you haven't reached the end of string.

Overall: O(N)

Answer 2

import java.util.HashSet;

public class SubString {
    public static String subString(String input){

        HashSet<Character> set = new HashSet<Character>();

        String longestOverAll = "";
        String longestTillNow = "";

        for (int i = 0; i < input.length(); i++) {
            char c = input.charAt(i);

            if (set.contains(c)) {
                longestTillNow = "";
                set.clear();
            }
            longestTillNow += c;
            set.add(c);
            if (longestTillNow.length() > longestOverAll.length()) {
                longestOverAll = longestTillNow;
            }
        }

        return longestOverAll;
    }

    public static void main(String[] args) {
        String input = "substringfindout";
        System.out.println(subString(input));
    }
}

Answer 3

Another O(n) JavaScript solution. It does not alter strings during the looping; it just keeps track of the offset and length of the longest sub string so far:

function longest(str) {
    var hash = {}, start, end, bestStart, best;
    start = end = bestStart = best = 0;
    while (end < str.length) {
        while (hash[str[end]]) hash[str[start++]] = 0;
        hash[str[end]] = 1;
        if (++end - start > best) bestStart = start, best = end - start;
    }
    return str.substr(bestStart, best);
}
 
// I/O for snippet
document.querySelector('input').addEventListener('input', function () {
    document.querySelector('span').textContent = longest(this.value);
});

Enter word:<input><br>
Longest: <span></span>

Answer 4

def max_substring(string):
   last_substring = ''
   max_substring  = ''
   for x in string:
       k = find_index(x,last_substring)
       last_substring = last_substring[(k+1):]+x
       if len(last_substring) > len(max_substring):
               max_substring  = last_substring        
   return max_substring

def find_index(x, lst):
   k = 0
   while k <len(lst):
      if lst[k] == x:
         return k
      k +=1
   return -1

Answer 5

Tested and working. For easy understanding, I suppose there's a drawer to put the letters.

Function:

    public int lengthOfLongestSubstring(String s) {
        int maxlen = 0;
        int start = 0;
        int end = 0;
        HashSet<Character> drawer = new HashSet<Character>(); 
        for (int i=0; i<s.length(); i++) {
            char ch = s.charAt(i);
            if (drawer.contains(ch)) {
                //search for ch between start and end
                while (s.charAt(start)!=ch) {
                    //drop letter from drawer
                    drawer.remove(s.charAt(start));
                    start++;
                }
                //Do not remove from drawer actual char (it's the new recently found)
                start++;
                end++;
            }
            else {
                drawer.add(ch);
                end++;
                int _maxlen = end-start;
                if (_maxlen>maxlen) {
                    maxlen=_maxlen;
                }
            }
        }
        return maxlen;
    }

Answer 6

simple python snippet l=length p=position maxl=maxlength maxp=maxposition