Instead of using an array to store results, you can opt for a map that keeps track of the last index for each character encountered. This allows you to optimize the loop by jumping back to one after the last index of a repeated character and continuing the search from there. By doing so, you avoid simply restarting from the current position which may not work in certain scenarios like in the case of 'dvdf':

Here is the modified code incorporating the use of a map:

function lengthOfLongestSubstring(check) {
  var letters = check.split("");
  var max = 0;
  var result = new Map();
  var start = 0;
  
  for (var i = 0; i < letters.length; i++) {
    if (!result.has(letters[i])) {
      result.set(letters[i], i);
    } else {
      i = result.get(letters[i]);
      result.clear();
    }
    
    if (max < result.size) {
      max = result.size;
    }
  }
  return max;
}

// Example:
console.log(lengthOfLongestSubstring("dvdf")); // 3

In order to solve this problem, we can implement a solution using the concept of Sliding Window along with a HashMap.

const findLengthOfLongestSubstring = (str) => {
  if (!str.length || typeof str !== 'string') return 0;

  if (str.length === 1) return 1;
  
  let charMap = {};
  let longestSubstringLength = 0;
  let start = 0;
  
  for (let i = 0; i < str.length; i++) {
    if (charMap[str[i]] !== undefined && charMap[str[i]] >= start) {
      start = charMap[str[i]] + 1;
    }
    
    charMap[str[i]] = i;
    longestSubstringLength = Math.max(longestSubstringLength, (i - start + 1));
  }

  return longestSubstringLength;
}

After some brainstorming, I came up with a simpler approach:

function findLongestSubstr(input) {
    let start = 0;
    let maxLength = 0;
    let seenChars = new Set();

    for (let end = 0; end < input.length; end++) {
        while (seenChars.has(input[end])) {
            seenChars.delete(input[start]);
            start += 1;
        }
        seenChars.add(input[end]);
        maxLength = Math.max(maxLength, end - start + 1);
    }

    console.log(seenChars);
    return maxLength;
}

console.log(findLongestSubstr('abcaabcad')); //4

On the date of January 7th, 2021, this particular Leetcode problem was featured as the question of the day. Initially, my approach closely resembled the chosen solution. While the performance was acceptable, I decided to delve into the answer solution documentation out of curiosity. After studying examples exclusively in Java and Python, I opted to rewrite my code using the sliding window technique. This change yielded a slightly more efficient outcome - with an execution time of 144ms as opposed to the original 160ms, along with a reduced memory footprint of 42mb compared to the initial 44.9mb:

function lengthOfLongestSubstring(s: string): number {
    let stringLength = s.length;
    let maxLength = 0;
    const charMap = new Map();
    let pos = 0;

    for (let i = 0; i < stringLength; i++) {
        if (charMap.has(s[i])) {
            pos = Math.max(charMap.get(s[i]), pos);
        }

        maxLength = Math.max(maxLength, i - pos + 1);
        charMap.set(s[i], i + 1);
    }
    return maxLength;
}

console.log(lengthOfLongestSubstring("dvdf"));

Give this a try:

function findLongestNonRepeatingSubstring (inputString) {
  const charMap = new Map();
  let maxLength = 0;
  let leftIndex = 0;
  
  for (let rightIndex = 0; rightIndex < inputString.length; rightIndex++) {
    const currentChar = inputString[rightIndex];
    
    if (charMap.get(currentChar) >= leftIndex) {
      leftIndex = charMap.get(currentChar) + 1;
    } else {
      maxLength = Math.max(maxLength, rightIndex - leftIndex + 1);
    }
    
    charMap.set(currentChar, rightIndex);
  }
  
  return maxLength;
}

It is important to note that resetting the variable "i" to "i - 1" may not be the correct approach in this scenario. Another loop inside the for loop might be necessary. Consider the following example code snippet (please verify the index carefully).

function findLongestDistinctSubstring(input){
    var characters = input.split("");
    var maxLength = 0;
    
    for (var i = 0; i < characters.length; i++) {
        var uniqueChars = [];
        var j = i;
        
        for(;j < characters.length; j++) {
            if (uniqueChars.indexOf(characters[j]) === -1) {
                uniqueChars.push(characters[j]);
            } else {
                break;
            }        
        }
        
        if(j - i > maxLength) {
            maxLength = j - i;
        }
    }
    
    return maxLength;
}

A useful strategy to tackle this issue is by employing the sliding window pattern.

function findMaxLength(str) {
  let maxLength = 0;
  let maxSubstr = "";
  let seenChars = {};
  let startIndex = 0;
  let nextIndex = 0;

  while (nextIndex < str.length) {
    // Extract current character from string
    let character = str[nextIndex];

    // Check if character already exists in map
    if (seenChars[character]) {
      // Determine whether start index exceeds last index of current character
      startIndex = Math.max(startIndex, seenChars[character]);
    }

    // Compare lengths of new substring and previous substrings
    if (maxLength < nextIndex - startIndex + 1) {
      maxLength = nextIndex - startIndex + 1;
      // Capture slice of longer substring
      maxSubstr = str.slice(startIndex, nextIndex + 1);
    }
    // Update index of current character
    seenChars[character] = nextIndex + 1;
    // Move to the next character
    nextIndex++;
  }

  console.log(str, "->", maxSubstr, "->", maxLength);
  return maxLength;
}

findMaxLength("dvdfvev");
findMaxLength("hello");
findMaxLength("1212312344");

Discovering the Longest Unique Substring with Map Method

let inputString = "aaabcbdeaf";
let startingIndex = 0;
let charMap = new Map();
let maxSubStringLength = 0;
let longestSubstring = '';

for(nextCharIndex=0; nextCharIndex< inputString.length ; nextCharIndex++){
if(charMap.has(inputString[nextCharIndex])){
  charMap.set(inputString[nextCharIndex],charMap.get(inputString[nextCharIndex])+1);
  startingIndex = Math.max(startingIndex,charMap.get(inputString[nextCharIndex]));
}
if(maxSubStringLength < nextCharIndex-startingIndex+1){
  maxSubStringLength = nextCharIndex-startingIndex+1;
  longestSubstring = inputString.slice(startingIndex,nextCharIndex+1);
}
 charMap.set(inputString[nextCharIndex],nextCharIndex);
}
console.log(longestSubstring);

If you're looking for a solution, here is one way to approach it:

function findLongestSubstring(str) {
  const substrings = []
  const strLength = str.length
  const addSubstring = (value) => {
    if (value !== '') {
      if (substrings.length > 0) {
        if (substrings.indexOf(value) === -1) {
          substrings.push(value)
        }
      } else {
        substrings.push(value)
      }
    }
  }
  addSubstring(str)
  for (const [index, value] of str.split('').entries()) {
    let length = strLength
    let substringStr = str
    const indexOffset = str.indexOf(value)
    addSubstring(value)
    while (length > indexOffset) {
      addSubstring(substringStr.slice(index-1, length + 1))
      length = --length
    }
    substringStr = str.slice(index, strLength)
  }
  substrings.sort()
  return substrings.pop()
}

console.log(findLongestSubstring('banana'))
console.log(findLongestSubstring('fgjashore'))
console.log(findLongestSubstring('xyzabcd'))

Discover the maximum length of a unique substring without relying on MAP(). Utilize simple slice() instead. This same technique can also be applied to find the longest unique string.

Just swap out "return max => return str"

const sampleString = "dvdf";;

var getLongestUniqueSubstring = function() {
if(sampleString.length == 1) return 1;
if(sampleString.length == 0) return 0;

let max = 0,i =  0, str = "";

while(i < sampleString.length){
    const index = str.indexOf(sampleString.charAt(i));
    if(index > -1) {
        // s = "fiterm".slice(1,4) => ite
        str = str.slice(index + 1, sampleString.length);
    }
    str += sampleString.charAt(i);
    max = Math.max(str.length, max);
    i++;
}
  return max;
};

Find the longest substring without repeating characters:

function findLongestUniqueSubstring(inputString) {
    if(inputString.length < 2) {
        return inputString.length;
    }
    
    let longestLength = 1;
    let currentSubstr = '';
    
    for(let i = 0; i < inputString.length; i++) {
        if(currentSubstr.includes(inputString.charAt(i))) {
           let firstIndex = currentSubstr.indexOf(inputString.charAt(i));
            currentSubstr = currentSubstr.substring(firstIndex + 1, currentSubstr.length);   

        }
          currentSubstr += inputString.charAt(i);
          longestLength = Math.max(currentSubstr.length, longestLength);
    }
     
    return longestLength;
};

Utilizing the reduce function for a concise solution.

const findUniqueSubstring = str => [...str].reduce((prev, current) => ( prev.includes(current) ? (prev += current, prev.substr(prev.indexOf(current)+1)) : prev += current),'');
console.log(findUniqueSubstring('abacdbef').length);

function findLongestUniqueSubstring(input: string): number {
  const charArray = input.split("");
  let longestLength = 0;
  const uniqueSet: Set<string> = new Set();
  
  for (let index = 0; index < charArray.length; index++) {
    uniqueSet.add(charArray[index]);
    let tryIndex = index + 1;
    
    while (charArray[tryIndex] && !uniqueSet.has(charArray[tryIndex])) {
      uniqueSet.add(charArray[tryIndex]);
      tryIndex++;
    }
    
    if (uniqueSet.size > longestLength) {
      longestLength = uniqueSet.size;
    }
    
    uniqueSet.clear();
  }

  return longestLength;
}

After thinking about it for a while, I decided to share my approach because I believe it offers an innovative way to solve this problem. Instead of using if/else blocks, I utilized the substring.indexOf() method to search for matching string characters in an array and remove indexes up to, and including, the match (+1). If no match is found, indexOf() returns -1 which, when added to +1, results in a .splice(0,0) operation that does nothing. The final Math check takes into consideration the addition of the last character in the loop to determine the higher outcome.

const findSubstring = input => {
let substring = [];
let maxLength = 0;
for (let i = 0; i < input.length; i++) {
    maxLength = Math.max(substring.length, maxLength);
    substring.splice(0, substring.indexOf(input[i]) + 1);
    substring.push(input[i]);
}
maxLength = Math.max(substring.length, maxLength);
return maxLength;
}

employs the concept of a sliding window

function findLongestDistinctSubstring(inputString) {
  var characters = inputString.split("");
  var substring = "";
  var result = [];
  var length = 0;
  let maxLength = 0;

  for (var index = 0; index < characters.length; index++) {
    const pos = result.indexOf(characters[index]);
    if (pos === -1) {
      result.push(characters[index]);
      length += 1;
    } else if (characters[index]) {
      result = result.splice(pos + 1);
      length = result.length + 1;
      result.push(characters[index]);
    }
    maxLength = length > maxLength ? length : maxLength;
  }
  return maxLength;
}

console.log(findLongestDistinctSubstring("example"));

Sliding Window Algorithm with O(n) Time Complexity

• To implement this algorithm, you can utilize either a hash table or a Map data structure.

1. Iterate through each character in the string.
2. Maintain a dictionary to keep track of unique characters encountered.
3. If a character already exists in the dictionary, update the count and reset the dictionary. Update the longest substring length accordingly.
4. Restart from the index after the first occurrence of the repeated character.

var lengthOfLongestSubstring = function(s) {
    if(s.length<2) return s.length;
    let longest = 0;
    let count=0;
    let hash={}
    for (let i = 0; i < s.length; i++) {
       //If char exist in hash
        if(hash[s[i]]!=undefined){
            i=hash[s[i]];
            hash={}
            longest = Math.max(longest, count);
            count = 0;
        }else{
            hash[s[i]]=i
            count = count+1;
        }
        
    }
    return Math.max(longest, count);
};

console.log(lengthOfLongestSubstring("abcabcbb"))
console.log(lengthOfLongestSubstring("au"))

Give this a try:

function checkLongestSubstring(str) {
    let longest = "";
    for (let i = 0; i < str.length; i++) {
        if (longest.includes(str[i])) {
            return longest.length
        } else {
            longest += str[i];
        }
    }
    return longest.length;
}

console.log(checkLongestSubstring("abcabcbb"));
console.log(checkLongestSubstring("bbbbb"));
console.log(checkLongestSubstring("abcdef"));
console.log(checkLongestSubstring(""));

// ZXKJKKLPPXTVBVSQW -> JKLP

const findLongestUniqueSubstring = (str) => {
  let uniqueString = str;
  const pattern = /(\w+)\1+/g;
  const matches = [...str.matchAll(pattern)].map((p) => p[1]);
  if (matches.length > 0) {
    uniqueString = uniqueString.replace(pattern, '_');
    let strArray = uniqueString.split('_');
    let longestUniqueSubstr = strArray.reduce((a, b) =>
      a.length > b.length ? a : b
    );
    for (let i = 0; i < matches.length; i++) {
      let long1 = `${matches[i]}${longestUniqueSubstr}`;
      let long2 = `${longestUniqueSubstr}${matches[i]}`;
      if (str.indexOf(long1) > -1) {
        return long1;
      } else if (str.indexOf(long2) > -1) {
        return long2;
      }
    }
    return '';
  }
  return '';
};
const runTestCases = (func, result) =>
  func == result ? 'test passed' : `test failed. expected results : ${result}`;

console.log(findLongestUniqueSubstring('ZXKKIOQPGTAYNSCF'));

console.log(
  runTestCases(
    findLongestUniqueSubstring('ABXFGHIKCDDDEFGHI'),
    'ABXFGHIKCD'
  )
);
console.log(
  runTestCases(findLongestUniqueSubstring('AJAGOPPQE'), 'AGOPPQE')
);

the issue arises with the input string "pwwkew"

function checkLengthOfLongestSubstring(input) {
    let result = "";
    for (let i = 0; i < input.length; i++) {
        if (result.includes(input[i])) {
            return result.length
        } else {
            result += input[i];
        }
    }
    return result.length;
}

console.log(checkLengthOfLongestSubstring("abcabcbb"));
console.log(checkLengthOfLongestSubstring("bbbbb"));
console.log(checkLengthOfLongestSubstring("abcdef"));
console.log(checkLengthOfLongestSubstring(""));

Finding the Longest Substring Without Repeating Characters - using our own logic

// defining an input string
let strInput = "pwwkew";

// initialize result with the first character of input string
let result = strInput[0];
let isRepeated;

// function to check if a character exists in the result substring
let doesCharExistInResult = (result, strInput) => {
    for(let index = result.length-1; index >= 0; index--){
        if(result[index] == strInput){
            return true;
        }
    }
}

let findLongestSubstringWithoutRepeats = (strInput) => {
    for(let pos = 1; pos < strInput.length; pos++){
        if(result[0] != strInput[pos]){
            if(result.length == 1){
                result += strInput[pos]
            }
            else {
                isRepeated = doesCharExistInResult(result, strInput[pos]);
                if(isRepeated != true) {
                    result += strInput[pos]

                }
            }
        }
    }
    return result;
};

console.log(findLongestSubstringWithoutRepeats(strInput));