Vfrdtyky

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));

    }

}

You keep an array indicating the position at which a certain character occurred last. For convenience all characters occurred at position -1. You iterate on the string keeping a window, if a character is repeated in that window, you chop off the prefix that ends with the first occurrence of this character. Throughout, you maintain the longest length. Here's a python implementation:

def longest_unique_substr(S):

  # This should be replaced by an array (size = alphabet size).

  last_occurrence = {} 

  longest_len_so_far = 0

  longest_pos_so_far = 0

  curr_starting_pos = 0

  curr_length = 0



  for k, c in enumerate(S):

    l = last_occurrence.get(c, -1)

    # If no repetition within window, no problems.

    if l < curr_starting_pos: 

        curr_length += 1

    else:

        # Check if it is the longest so far

        if curr_length > longest_len_so_far: 

            longest_pos_so_far = curr_starting_pos

            longest_len_so_far = curr_length

        # Cut the prefix that has repetition

        curr_length -= l - curr_starting_pos

        curr_starting_pos = l + 1

    # In any case, update last_occurrence

    last_occurrence[c] = k



  # Maybe the longest substring is a suffix

  if curr_length > longest_len_so_far:

    longest_pos_so_far = curr_starting_pos

    longest_len_so_far = curr_length



  return S[longest_pos_so_far:longest_pos_so_far + longest_len_so_far]

EDITED:

following is an implementation of the concesus. It occured to me after my original publication. so as not to delete original, it is presented following:

public static String longestUniqueString(String S) {

    int start = 0, end = 0, length = 0;

    boolean bits = new boolean[256];

    int x = 0, y = 0;

    for (; x < S.length() && y < S.length() && length < S.length() - x; x++) {

        bits[S.charAt(x)] = true;

        for (y++; y < S.length() && !bits[S.charAt(y)]; y++) {

            bits[S.charAt(y)] = true;

        }

        if (length < y - x) {

            start = x;

            end = y;

            length = y - x;

        }

        while(y<S.length() && x<y && S.charAt(x) != S.charAt(y))

            bits[S.charAt(x++)]=false;

    }

    return S.substring(start, end);

}//

ORIGINAL POST:

Here is my two cents. Test strings included. boolean bits = new boolean[256] may be larger to encompass some larger charset.

public static String longestUniqueString(String S) {

    int start=0, end=0, length=0;

    boolean bits = new boolean[256];

    int x=0, y=0;

    for(;x<S.length() && y<S.length() && length < S.length()-x;x++) {

        Arrays.fill(bits, false);

        bits[S.charAt(x)]=true;

        for(y=x+1;y<S.length() && !bits[S.charAt(y)];y++) {

            bits[S.charAt(y)]=true;

        }           

        if(length<y-x) {

            start=x;

            end=y;

            length=y-x;

        }

    }

    return S.substring(start,end);

}//



public static void main(String... args) {

    String input = { { "" }, { "a" }, { "ab" }, { "aab" }, { "abb" },

            { "aabc" }, { "abbc" }, { "aabbccdefgbc" },

            { "abcdeafghicabcdefghijklmnop" },

            { "abcdeafghicabcdefghijklmnopqrabcdx" },

            { "zxxaabcdeafghicabcdefghijklmnopqrabcdx" },

            {"aaabcdefgaaa"}};

    for (String a : input) {

        System.out.format("%s  *** GIVES ***  {%s}%n", Arrays.toString(a),

                longestUniqueString(a[0]));

    }

}

Here is one more solution with only 2 string variables:

public static String getLongestNonRepeatingString(String inputStr){

    if(inputStr == null){

        return null;

    }



    String maxStr = "";

    String tempStr = "";

    for(int i=0; i < inputStr.length(); i++){

        // 1. if tempStr contains new character, then change tempStr  

        if(tempStr.contains("" + inputStr.charAt(i))){

            tempStr = tempStr.substring(tempStr.lastIndexOf(inputStr.charAt(i)) + 1);

        }

        // 2. add new character

        tempStr = tempStr + inputStr.charAt(i);

        // 3. replace maxStr with tempStr if tempStr is longer

        if(maxStr.length() < tempStr.length()){

            maxStr = tempStr;

        }

    }



    return maxStr;

}

Algorithm in JavaScript (w/ lots of comments)..

/**

 Given a string S find longest substring without repeating characters.

 Example:



 Input: "stackoverflow"

 Output: "stackoverfl"



 Input: "stackoverflowabcdefghijklmn"

 Output: "owabcdefghijklmn"

 */

function findLongestNonRepeatingSubStr(input) {

    var chars = input.split('');

    var currChar;

    var str = "";

    var longestStr = "";

    var hash = {};

    for (var i = 0; i < chars.length; i++) {

        currChar = chars[i];

        if (!hash[chars[i]]) { // if hash doesn't have the char,

            str += currChar; //add it to str

        hash[chars[i]] = {index:i};//store the index of the char

    } else {// if a duplicate char found..

        //store the current longest non-repeating chars. until now

        //In case of equal-length, <= right-most str, < will result in left most str

        if(longestStr.length <= str.length) {

            longestStr = str;

        }

        //Get the previous duplicate char's index

        var prevDupeIndex = hash[currChar].index;



        //Find all the chars AFTER previous duplicate char and current one

        var strFromPrevDupe = input.substring(prevDupeIndex + 1, i);

        //*NEW* longest string will be chars AFTER prevDupe till current char

        str = strFromPrevDupe + currChar;

        //console.log(str);

        //Also, Reset hash to letters AFTER duplicate letter till current char

        hash = {};

        for (var j = prevDupeIndex + 1; j <= i; j++) {

            hash[input.charAt(j)] = {index:j};

        }

    }

  }

  return longestStr.length > str.length ? longestStr : str;

}



//console.log("stackoverflow => " + findLongestNonRepeatingSubStr("stackoverflow"));      

//returns stackoverfl



//console.log("stackoverflowabcdefghijklmn => " + 

findLongestNonRepeatingSubStr("stackoverflowabcdefghijklmn")); //returns owabcdefghijklmn



//console.log("1230123450101 => " + findLongestNonRepeatingSubStr("1230123450101")); //    

returns 234501

We can consider all substrings one by one and check for each substring whether it contains all unique characters or not.
There will be n*(n+1)/2 substrings. Whether a substirng contains all unique characters or not can be checked in linear time by
scanning it from left to right and keeping a map of visited characters. Time complexity of this solution would be O(n^3).`

import java.util.ArrayList;

import java.util.Collections;

import java.util.HashMap;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;





public class LengthOfLongestSubstringWithOutRepeatingChar {

	public static void main(String args)

	{

	String s="stackoverflow";	

	//allSubString(s);

	System.out.println("result of find"+find(s));

	}

	public static String find(String s)

	{

		List<String> allSubsring=allSubString(s);

		Set<String> main =new LinkedHashSet<String>();

		for(String temp:allSubsring)

		{

			boolean a = false;

			for(int i=0;i<temp.length();i++)

			{ 

				for(int k=temp.length()-1;k>i;k--)

				{

					if(temp.charAt(k)==temp.charAt(i))

						a=true;

				}

			}

			if(!a)

			{

				main.add(temp);

			}

		}

		/*for(String x:main)

		{

		System.out.println(x);	

		}*/

		String res=null;

		int min=0,max=s.length();

		for(String temp:main)

		{

		if(temp.length()>min&&temp.length()<max)

		{

			min=temp.length();

			res=temp;

		}

		}

		System.out.println(min+"ha ha ha"+res+"he he he");

		return res;

		

	}

	//substrings left to right ban rahi hai



private static List<String> allSubString(String str) {

	List<String> all=new ArrayList<String>();

	int c=0;

	for (int i = 0; i < str.length(); i++) {

		for (int j = 0; j <= i; j++) {

			if (!all.contains(str.substring(j, i + 1)))

			{

				c++;

				all.add(str.substring(j, i + 1));

			}

		}

	}

	for(String temp:all)

	{

		System.out.println("substring :-"+temp);

	}

	System.out.println("count"+c);

	return all;

}

}

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

import java.util.ArrayList;

import java.util.HashSet;

import java.util.LinkedHashSet;

import java.util.List;

import java.util.Set;

import java.util.TreeMap;



public class LongestSubString2 {



    public static void main(String args) {

        String input = "stackoverflowabcdefghijklmn";

        List<String> allOutPuts = new ArrayList<String>();

        TreeMap<Integer, Set> map = new TreeMap<Integer, Set>();

        for (int k = 0; k < input.length(); k++) {

            String input1 = input.substring(k);

            String longestSubString = getLongestSubString(input1);

            allOutPuts.add(longestSubString);

        }



        for (String str : allOutPuts) {

            int strLen = str.length();

            if (map.containsKey(strLen)) {

                Set set2 = (HashSet) map.get(strLen);

                set2.add(str);

                map.put(strLen, set2);

            } else {

                Set set1 = new HashSet();

                set1.add(str);

                map.put(strLen, set1);

            }



        }

        System.out.println(map.lastKey());

        System.out.println(map.get(map.lastKey()));

    }



    private static void printArray(Object currentObjArr) {

        for (Object obj : currentObjArr) {

            char str = (char) obj;

            System.out.println(str);

        }



    }



    private static String getLongestSubString(String input) {



        Set<Character> set = new LinkedHashSet<Character>();

        String longestString = "";

        int len = input.length();

        for (int i = 0; i < len; i++) {

            char currentChar = input.charAt(i);

            boolean isCharAdded = set.add(currentChar);

            if (isCharAdded) {

                if (i == len - 1) {

                    String currentStr = getStringFromSet(set);



                    if (currentStr.length() > longestString.length()) {

                        longestString = currentStr;

                    }

                }

                continue;

            } else {

                String currentStr = getStringFromSet(set);



                if (currentStr.length() > longestString.length()) {

                    longestString = currentStr;

                }

                set = new LinkedHashSet<Character>(input.charAt(i));

            }



        }



        return longestString;

    }



    private static String getStringFromSet(Set<Character> set) {



        Object charArr = set.toArray();



        StringBuffer strBuff = new StringBuffer();

        for (Object obj : charArr) {

            strBuff.append(obj);



        }



        return strBuff.toString();

    }

}

This is my solution, and it was accepted by leetcode. However, after I saw the stats, I saw whole lot solutions has much faster result....meaning, my solution is around 600ms for all their test cases, and most of the js solutions are around 200 -300 ms bracket.. who can tell me why my solution is slowwww??

var lengthOfLongestSubstring = function(s) {

  var arr = s.split("");



  if (s.length === 0 || s.length === 1) {

    return s.length;

  }



  var head = 0,

    tail = 1;

  var str = arr[head];

  var maxL = 0;

  while (tail < arr.length) {

    if (str.indexOf(arr[tail]) == -1) {

      str += arr[tail];

      maxL = Math.max(maxL, str.length);

      tail++;

    } else {

      maxL = Math.max(maxL, str.length);

      head = head + str.indexOf(arr[tail]) + 1;

      str = arr[head];

      tail = head + 1;

    }

  }

  return maxL;

};

I am posting O(n^2) in python . I just want to know whether the technique mentioned by Karoly Horvath has any steps that are similar to existing search/sort algorithms ?

My code :

def main():

    test='stackoverflow'

    tempstr=''

    maxlen,index=0,0

    indexsubstring=''

    print 'Original string is =%snn' %test



    while(index!=len(test)):

        for char in test[index:]:

            if char not in tempstr:

                tempstr+=char

                if len(tempstr)> len(indexsubstring):

                   indexsubstring=tempstr

            elif (len(tempstr)>=maxlen):

                   maxlen=len(tempstr)

                   indexsubstring=tempstr

                   break

        tempstr=''

        print 'max substring length till iteration with starting index =%s is %s'%(test[index],indexsubstring)

        index+=1



if __name__=='__main__':

    main()

Simple and Easy

import java.util.Scanner;



public class longestsub {



    static Scanner sn = new Scanner(System.in);

    static String word = sn.nextLine();



    public static void main(String args) {

        System.out.println("The Length is " +check(word));

    }

    private static int check(String word) {

        String store="";

        for (int i = 0; i < word.length(); i++) {

            if (store.indexOf(word.charAt(i))<0) {

                store = store+word.charAt(i);

            }

        }

        System.out.println("Result word " +store);

        return store.length();

    }



}

Not quite optimized but simple answer in Python

def lengthOfLongestSubstring(s):

      temp,maxlen,newstart = {},0,0

      for i,x in enumerate(s):

            if x in temp:

                  newstart = max(newstart,s[:i].rfind(x)+1)

            else:

                  temp[x] = 1

            maxlen = max(maxlen, len(s[newstart:i + 1]))

      return maxlen

I think the costly affair is rfind which is why it's not quite optimized.

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

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;

}

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>

This is my solution. Hope it helps.

  function longestSubstringWithoutDuplication(str) {

      var max = 0;



      //if empty string

      if (str.length === 0){

        return 0;

      } else if (str.length === 1){ //case if the string's length is 1

        return 1;

      }



      //loop over all the chars in the strings

      var currentChar,

          map = {},

          counter = 0; //count the number of char in each substring without duplications

      for (var i=0; i< str.length ; i++){

        currentChar = str.charAt(i);



        //if the current char is not in the map

        if (map[currentChar]  == undefined){

          //push the currentChar to the map

              map[currentChar] = i;

              if (Object.keys(map).length > max){

                 max = Object.keys(map).length;

              }

        } else { //there is duplacation

          //update the max

          if (Object.keys(map).length > max){

            max = Object.keys(map).length;

          }

          counter = 0; //initilize the counter to count next substring

          i = map[currentChar]; //start from the duplicated char

          map = {}; // clean the map

        }

      }





     return max;

    }

here is my javascript and cpp implementations with great details: https://algorithm.pingzhang.io/String/longest_substring_without_repeating_characters.html

We want to find the longest substring without repeating characters. The first thing comes to my mind is that we need a hash table to store every character in a substring so that when a new character comes in, we can easily know whether this character is already in the substring or not. I call it as valueIdxHash. Then, a substring has a startIdx and endIdx. So we need a variable to keep track of the starting index of a substring and I call it as startIdx. Let's assume we are at index i and we already have a substring (startIdx, i - 1). Now, we want to check whether this substring can keep growing or not.

If the valueIdxHash contains str[i], it means it is a repeated character. But we still need to check whether this repeated character is in the substring (startIdx, i - 1). So we need to retrieve the index of str[i] that is appeared last time and then compare this index with startIdx.

• If startIdx is larger, it means the last appeared str[i] is outside of the substring. Thus the subtring can keep growing.


• If startIdx is smaller, it means the last appeared str[i] is within of the substring. Thus, the substring cannot grow any more. startIdx will be updated as valueIdxHash[str[i]] + 1 and the new substring (valueIdxHash[str[i]] + 1, i) has potential to keep growing.

If the valueIdxHash does not contain str[i], the substring can keep growing.

I modified my solution to "find the length of the longest substring without repeating characters".

        public string LengthOfLongestSubstring(string s) {

    var res = 0;

    var dict = new Dictionary<char, int>();

    var start = 0;



    for(int i =0; i< s.Length; i++)

    {

        if(dict.ContainsKey(s[i]))

        {

            start = Math.Max(start, dict[s[i]] + 1); //update start index

            dict[s[i]] = i;

        }

        else

        {

            dict.Add(s[i], i);

        }



        res = Math.Max(res, i - start + 1);  //track max length

    }

    return s.Substring(start,res);

}

import java.util.HashMap;

import java.util.HashSet;



public class SubString {

    public static String subString(String input) {



        String longesTillNOw = "";



        String longestOverAll = "";

        HashMap<Character,Integer> chars = new HashMap<>();

        char array=input.toCharArray();

        int start=0;

        for (int i = 0; i < array.length; i++) {

            char charactor = array[i];

            if (chars.containsKey(charactor) ) {

                start=chars.get(charactor)+1;

                i=start;

                chars.clear();

                longesTillNOw = "";

            } else {

                chars.put(charactor,i);

                longesTillNOw = longesTillNOw + charactor;

                if (longesTillNOw.length() > longestOverAll.length()) {

                    longestOverAll = longesTillNOw;

                }

            }

        }

        return longestOverAll;



    }



    public static void main(String args) {

        String input = "stackoverflowabcdefghijklmn";

        System.out.println(subString(input));

    }

}

Here are two ways to approach this problem in JavaScript.

A Brute Force approach is to loop through the string twice, checking every substring against every other substring and finding the maximum length where the substring is unique. We'll need two functions: one to check if a substring is unique and a second function to perform our double loop.

// O(n) time

const allUnique = str => {

  const set = [...new Set(str)];

  return (set.length == str.length) ? true: false;

}



// O(n^3) time, O(k) size where k is the size of the set

const lengthOfLongestSubstring = str => {

  let result = 0,

      maxResult = 0;

  for (let i=0; i<str.length-1; i++) {

    for (let j=i+1; j<str.length; j++) {

      if (allUnique(str.substring(i, j))) {

        result = str.substring(i, j).length;

        if (result > maxResult) {

          maxResult = result;

        }

      }

    }

  return maxResult;

  }

}

This has a time complexity of O(n^3) since we perform a double loop O(n^2) and then another loop on top of that O(n) for our unique function. The space is the size of our set which can be generalized to O(n) or more accurately O(k) where k is the size of the set.

A Greedy Approach is to loop through only once and keep track of the maximum unique substring length as we go. We can use either an array or a hash map, but I think the new .includes() array method is cool, so let's use that.

const lengthOfLongestSubstring = str => {

  let result = ,

      maxResult = 0;



  for (let i=0; i<str.length; i++) {

    if (!result.includes(str[i])) {

      result.push(str[i]);

    } else {

      maxResult = i;

    }

  }



  return maxResult;

}

This has a time complexity of O(n) and a space complexity of O(1).

This problem can be solved in O(n) time complexity.
Initialize three variables

1. Start (index pointing to the start of the non repeating substring, Initialize it as 0 ).


2. End (index pointing to the end of the non repeating substring, Initialize it as 0 )


3. Hasmap (Object containing the last visited index positions of characters. Ex : {'a':0, 'b':1} for string "ab")

Steps :
Iterate over the string and perform following actions.

1. If the current character is not present in hashmap (), add it as to
   hashmap, character as key and its index as value.


2. 
   

   If current character is present in hashmap, then

   
   
   

   a) Check whether the start index is less than or equal to the value present in the hashmap against the character (last index of same character earlier visited),

   
   
   

   b) it is less then assign start variables value as the hashmaps' value + 1 (last index of same character earlier visited + 1);

   
   
   

   c) Update hashmap by overriding the hashmap's current character's value as current index of character.

   
   
   

   d) Calculate the end-start as the longest substring value and update if it's greater than earlier longest non-repeating substring.

   
   

Following is the Javascript Solution for this problem.

var lengthOfLongestSubstring = function(s) {

    let length = s.length;

    let ans = 0;

    let start = 0,

        end = 0;

    let hashMap = {};



    for (var i = 0; i < length; i++) {



        if (!hashMap.hasOwnProperty(s[i])) {

            hashMap[s[i]] = i;

        } else {

            if (start <= hashMap[s[i]]) {

                start = hashMap[s[i]] + 1;

            }

            hashMap[s[i]] = i;

        }

        end++;

        ans = ans > (end - start) ? ans : (end - start);

    }

    return ans;

};

Question: Find the longest substring without repeating characters.
Example 1 :

    import java.util.LinkedHashMap;

    import java.util.Map;



    public class example1 {



        public static void main(String args) {

            String a = "abcabcbb";

               // output => 3

            System.out.println( lengthOfLongestSubstring(a));



        }



        private static int lengthOfLongestSubstring(String a) {

               if(a == null  || a.length() == 0) {return  0 ;}  

               int res = 0 ;

            Map<Character , Integer> map = new LinkedHashMap<>();

              for (int i = 0; i < a.length(); i++) {

                  char ch = a.charAt(i);

                if (!map.containsKey(ch)) {

       //If ch is not present in map, adding ch into map along with its position

                    map.put(ch, i);



                }else {

/*

If char ch is present in Map, reposition the cursor i to the position of ch and clear the Map.

*/ 

                    i = map.put(ch, i);// updation of index

                     map.clear();

                }//else



                res = Math.max(res, map.size());



            }







            return res;

        }



    }

if you want the longest string without the repeating characters as output then do this inside the for loop:

String res ="";// global

    int len = 0 ;//global

 if(len < map.size()) {

     len = map.size();

    res = map.keySet().toString();

 }

System.out.println("len -> " + len);

System.out.println("res => " + res);

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

can we use something like this .

def longestpalindrome(str1):

    arr1=list(str1)

    s=set(arr1)

    arr2=list(s)

    return len(arr2)







str1='abadef'

a=longestpalindrome(str1)

print(a)

if only length of the substring is to be returned

Algorithm:
1) Initialise an empty dictionary dct to check if any character already exists in the string.
2) cnt - to keep the count of substring without repeating characters.
3)l and r are the two pointers initialised to first index of the string.
4)loop through each char of the string.
5) If the character not present in the dct add itand increse the cnt.
6)If its already present then check if cnt is greater then resStrLen.
7)Remove the char from dct and shift the left pointer by 1 and decrease the count.
8)Repeat 5,6,7 till l,r greater or equal to length of the input string.
9)Have one more check at the end to handle cases like input string with non-repeating characters.

Here is the simple python program to Find longest substring without repeating characters

a="stackoverflow"

strLength = len(a)

dct={}

resStrLen=0

cnt=0

l=0

r=0

strb=l

stre=l

while(l<strLength and r<strLength):

    if a[l] in dct:

        if cnt>resStrLen:

            resStrLen=cnt

            strb=r

            stre=l

        dct.pop(a[r])

        cnt=cnt-1

        r+=1    

    else:

        cnt+=1

        dct[a[l]]=1

        l+=1



if cnt>resStrLen:

    resStrLen=cnt

    strb=r

    stre=l



print "Result String Length : "+str(resStrLen)

print "Result String : " + a[strb:stre]

The solution in C.

#include<stdio.h>

#include <string.h>



void longstr(char* a, int *start, int *last)

{

    *start = *last = 0;

    int visited[256];

    for (int i = 0; i < 256; i++)

    {

        visited[i] = -1;

    }

    int max_len = 0;

    int cur_len = 0;

    int prev_index;

    visited[a[0]] = 0;

    for (int i = 1; i < strlen(a); i++)

    {

        prev_index = visited[a[i]];

        if (prev_index == -1 || i - cur_len > prev_index)

        {

            cur_len++;

            *last = i;

        }

        else

        {

            if (max_len < cur_len)

            {

                *start = *last - cur_len;

                max_len = cur_len;

            }

            cur_len = i - prev_index;

        }

        visited[a[i]] = i;

    }

    if (max_len < cur_len)

    {

        *start = *last - cur_len;

        max_len = cur_len;

    }

}



int main()

{

    char str = "ABDEFGABEF";

    printf("The input string is %s n", str);

    int start, last;

    longstr(str, &start, &last);

    //printf("n %d  %d n", start, last);

    memmove(str, (str + start), last - start);

    str[last] = '';

    printf("the longest non-repeating character substring is %s", str);

    return 0;

}

private static string LongestSubstring(string word)

        {

            var set = new HashSet<char>();

            string longestOverAll = "";

            string longestTillNow = "";



            foreach (char c in word)

            {

                if (!set.Contains(c))

                {

                    longestTillNow += c;

                    set.Add(c);

                }

                else

                {

                    longestTillNow = string.Empty;

                }



                if (longestTillNow.Length > longestOverAll.Length)

                {

                    longestOverAll = longestTillNow;

                }

            }



            return longestOverAll;

        }

private static String LongestSubString(String word)

{

    char charArray = word.toCharArray();

    HashSet set = new HashSet();

    String longestOverAll = "";

    String longestTillNow = "";

    for (int i = 0; i < charArray.length; i++) {

        Character c = charArray[i];



        if (set.contains(c)) {

            longestTillNow = "";

            set.clear();

        }

        longestTillNow += c;

        set.add(c);

        if (longestTillNow.length() > longestOverAll.length())

        {

            longestOverAll = longestTillNow;



        }

    }



    return longestOverAll;

}