AI solution for JavaScript Coding Question on BFE.dev
87. longest substring with unique characters

One possible solution in JavaScript:

function longestUniqueSubstr(str) {
  let maxLength = 0;
  let maxSubstr = "";
  let currSubstr = "";
  let seenChars = {};

  for (let i = 0; i < str.length; i++) {
    let char = str[i];
    if (!seenChars[char]) {
      seenChars[char] = true;
      currSubstr += char;
      if (currSubstr.length > maxLength) {
        maxLength = currSubstr.length;
        maxSubstr = currSubstr;
      }
    } else {
      let prevOccurrence = str.lastIndexOf(char, i - 1);
      currSubstr = str.slice(prevOccurrence + 1, i + 1);
      seenChars = {};
      for (let j = prevOccurrence + 1; j <= i; j++) {
        seenChars[str[j]] = true;
      }
    }
  }
  return maxSubstr;
}

This solution uses two pointers, i and prevOccurrence, and a sliding window to track the current substring with no repeated characters. It also uses an object seenChars to keep track of the characters seen so far, and updates it when a repeated character is encountered. If a repeated character is found, the sliding window is reset to the substring starting from the last occurrence of that character, and the characters seen so far are updated accordingly.

The time complexity of this solution is O(n), where n is the length of the input string, since we need to iterate through the string at most twice (once for the outer loop, and once for the inner loop starting from prevOccurrence). The space complexity is O(k), where k is the size of the character set, since we use an object to store the seen characters. In practice, the space complexity is likely to be smaller, since the character set is typically much smaller than the length of the input string.

There are alternative solutions that use different data structures, such as a Set or a Map, to track the seen characters. However, the basic sliding window approach should be similar, and the time and space complexity should also be O(n) and O(k) respectively.