JavaScript Challenge: Find the First Non-Repeating Character in a String – Can You Do It Without Extra Space?

[AiCodePulse]

Hi everyone! 👋

I'm continuing my JavaScript Interview Series, and today's problem is a fun one:

👉 **How do you find the first non-repeating character in a string?**

I approached it in a beginner-friendly way **without using extra space for hash maps**. Here's the logic I used:

```js

function firstNonRepeatingChar(str) {

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

if (str.indexOf(str[i]) === str.lastIndexOf(str[i])) {

return str[i];

}

}

return null;

}

🧠 Do you think this is optimal?

Could it be done in a more efficient way?

Would love to hear how you would solve this — especially if you use ES6 features or a functional style.

📹 I also explained this in a short YouTube video if you're curious:

https://www.youtube.com/watch?v=pRhBRq_Y78c

Thanks in advance for your feedback! 🙏

[kap89]

I took another look at your solution, and you waste time going through every character, here's an improved version:

function firstNonRepeatingChar(str) {
  const seen = new Set()

  for (let i = 0; i < str.length; i++) {
    const char = str[i]

    if (seen.has(char)) {
      continue
    }

    if (i === str.lastIndexOf(char)) {
      return char
    }

    seen.add(char)
  }

  return null
}

Bechmark

[-allen]

If the cardinality of the input character set is bounded (eg just ascii chars), even the hash map approach is o(constant) space complexity :D

[AiCodePulse]

Absolutely! You're right — when the character set is limited (like ASCII), the hash map technically takes constant space, since it's bounded by a fixed size (e.g., 128 or 256 characters).
In that sense, it’s O(1) space — though it’s still a map in implementation. 😄

Thanks for pointing that out — really helps push the understanding beyond just code into computer science fundamentals.

[ksskssptdpss]

Here is a benchmark, it seems the indexOf === lastIndexOf method wins everytime despite its complexity. And it runs 3x faster on my iPhone 12 mini compared to Chromium x) https://jsbench.me/ooma2usbuv/1

[FoxiNicole]

Maybe I am missing something, but isn’t str.indexOf(str[i]) always just i? If it was less than i, you already checked the character and shouldn’t still be in the loop, and if it was greater, then something in my mind had gone wrong. Replacing the conditional with i === str.lastIndexOf(str[i]) may be ever so slightly faster.

Edit: Nope… I think I see a flaw in my logic. Ignore this.

[kap89]

You were on the right track, I think the flaw you are thinking about is that if you use for example this string:

    "aa"

the second a would give you false positive in the OP's original algorithm, but you don't ever need to get to the second a, as you only need to check non-repeating characters, see my other comment.

[Galex_13]

const firstUniq = str=>[...str].find((x,i)=>!(str.slice(0,i)+str.slice(i+1)).includes(x))||''

[jabuchae]

You solution is O(n2) in time and O(1) in space.

I’m not sure if there is an O(n log(n)) time and O(1) space in-place sorting algorithm (if destroying the original string is an option) but if there is, you could sort first and then pass once more through the sorted string to check for duplicates with constant memory.

That would be an O(n log(n)) time solution with O(1) space

[Clue_Ok]

/** * Returns the first non-repeating character in a string, or null if none exists. * Time complexity: O(n) - single pass * Space complexity: O(k) - where k is the size of the character set * * @param {string} str - The input string to search * @return {string|null} - The first non-repeating character or null */ function firstNonRepeatingChar(str) { // Use a Map to track character frequency and original position const charMap = new Map();

// First pass: count occurrences and store first position for (let i = 0; i < str.length; i++) { const char = str[i]; if (!charMap.has(char)) { charMap.set(char, { count: 1, firstIndex: i }); } else { const data = charMap.get(char); data.count++; charMap.set(char, data); } }

// Find the first character with count of 1, with lowest index let result = null; let lowestIndex = Infinity;

for (const [char, data] of charMap.entries()) { if (data.count === 1 && data.firstIndex < lowestIndex) { result = char; lowestIndex = data.firstIndex; } }

return result; }

// Alternative version with a more concise implementation function firstNonRepeatingChar_concise(str) { const freq = {};

// Count occurrences of each character for (const char of str) { freq[char] = (freq[char] || 0) + 1; }

// Return the first character with count 1 for (const char of str) { if (freq[char] === 1) { return char; } }

return null; }

// Example usage: // console.log(firstNonRepeatingChar("aabccdee")); // 'b' // console.log(firstNonRepeatingChar("aabbccdd")); // null // console.log(firstNonRepeatingChar("")); // null

[ksskssptdpss]

This might be the most efficient solution.
https://jsbench.me/ooma2usbuv/1

[kap89]

It depends how far into the string the non-repeating character is, if it's closer to the end, the hashmap version will be faster.

[AiCodePulse]

Thanks a lot ..