Program to find the Length of the longest substring without repeating characters in Golang

Given a string, print the longest substring without repeating characters in Golang. For example, the longest substrings without repeating characters for “ABDEFGABEF” are “BDEFGA”.

Examples:

Input : GEEKSFORGEEKS
Output : 
Substring: EKSFORG
Length: 7

Input : ABDEFGABEF
Output : 
Substring: BDEFGA
Length: 6

The idea is to traverse the string and for each already visited character store its last occurrence in an array pos of integers(we will update the indexes in the array based on the ASCII values of the characters of the string). The variable st stores starting point of current substring, maxlen stores length of maximum length substring, and start stores starting index of maximum length substring.

While traversing the string, check whether the current character is already present in the string by checking out the array pos. If it is not present, then store the current character’s index in the array with value as the current index. If it is already present in the array, this means the current character could repeat in the current substring. For this, check if the previous occurrence of character is before or after the starting point st of the current substring. If it is before st, then only update the value in array. If it is after st, then find the length of current substring currlen as i-st, where i is current index.

Compare currlen with maxlen. If maxlen is less than currlen, then update maxlen as currlen and start as st. After complete traversal of string, the required longest substring without repeating characters is from s[start] to s[start+maxlen-1].

filter_none

edit
close

play_arrow

link
brightness_4
code

// Golang program to find the length of the
// longest substring without repeating
// characters
  
package main
  
import "fmt"
  
func longest_substring(s string, n int) string {
  
    var i int
      
    // starting point of
    // current substring.
    st := 0    
      
    // length of current substring.  
    currlen := 0 
      
    // maximum length substring 
    // without repeating  characters
    maxlen := 0  
  
    // starting index of 
    // maximum length substring.
    start := 0
  
    // this array works as the hash table
    // -1 indicates that element is not
    // present before else any value 
    // indicates its previous index
    pos := make([]int, 125)
  
    for i = 0; i < 125; i++ {
  
        pos[i] = -1
    }
  
    // storing the index
    // of first character
    pos[s[0]] = 0
  
    for i = 1; i < n; i++ {
  
        // If this character is not present in array,
        // then this is first occurrence of this
        // character, store this in array.
        if pos[s[i]] == -1 {
            pos[s[i]] = i
        } else {
          
            // If this character is present in hash then
            // this character has previous occurrence,
            // check if that occurrence is before or after
            // starting point of current substring.
            if pos[s[i]] >= st {
  
                // find length of current substring and
                // update maxlen and start accordingly.
                currlen = i - st
                if maxlen < currlen {
  
                    maxlen = currlen
                    start = st
                }
                // Next substring will start after the last
                // occurrence of current character to avoid
                // its repetition.
  
                st = pos[s[i]] + 1
  
            }
            // Update last occurrence of
            // current character.
            pos[s[i]] = i
        }
  
    }
    // Compare length of last substring 
    // with maxlen and update maxlen 
    // and start accordingly.
    if maxlen < i-st {
  
        maxlen = i - st
        start = st
    }
      
    // the required string
    ans := ""
  
    // extracting the string from 
    // [start] to [start+maxlen]
    for i = start; i < start+maxlen; i++ {
        ans += string(s[i])
    }
  
    return ans
  
}
  
func main() {
  
    var s string = "GEEKSFORGEEKS"
    var n int = len(s)
  
    // calling the function to 
    // get the required answer.
    var newString = longest_substring(s, n)
      
    // finding the length of the string
    var length int = len(newString)
  
    fmt.Println("Longest substring is: ", newString)
    fmt.Println("Length of the string: ", length)
  
}

chevron_right


Output:

Longest substring is:  EKSFORG
Length of the string:  7

Note: Instead of using the array, we can also use a map of string to int.




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.


Article Tags :

Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.