Write a function to find the first non-repeated character in a string

The runtime of the 1st solution you posted is not O(n²). You are just traversing the string twice, which makes it O(2n) => O(n).

After playing a lot with jsperf and having to admit that the regex solution is actually faster, which annoys me.

• Your first approach is far superior than your second approach (O(2n) -> O(n^2)) as per Venu

• you should cache string.length, looking up the value of a property slows things down

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

• You can assign More than one and One time with a ternary, also you should cache string[i] and not look it up 3 times:

  charCount[c] = charCount[c] ? 'More Than One' : 'One Time';
  

• You do not need var j, just use i again

• You used string[i] everywhere else, your return statement should be return string[i];

• repeater is a terrible name if you are planning to return a non-repeater ;)

• from a design perspective, I would return '' instead of 'Everything is repeated', because really, '' aka nothing is repeating

On the whole I think your code is fine, I am not sure ( besides the magical regex ) how it could be done much faster. You need something to track the character count and I am not sure how you can avoid the second loop.

I'm proposing a solution that in some cases can be better than your first algorithm, but not always - it mostly depends on the input string. I think that on average they have similar performance.

The idea is to use a regex to search and replace with an empty string all occurrences of the first character. If the resulting string has length equal to the length at the previous iteration minus 1, then that character is not repeated. The search is case insensitive

The advantage of this code is that it's more compact and readable, plus it immediately breaks as soon as a non repeating character is found.

var repeater = function(string) {
    var result = false;

    while (string) {
        var len = string.length;
        var char = string[0];
        var regex = new RegExp(char, "gi");
        string = string.replace(regex, "");
        if (string.length == len - 1) {
            result = char;
            break;
        }
    }
    return result;
}

Update: I ran a few benchmarks, and on average it takes less than your first algorithm (using code runner and node.js). This is the benchmarking code:

var start = Date.now();

for (var count = 0; count < 10000; ++count) {
    repeater('toTal');
    repeater('teEter');
    repeater('erttreert');
    repeater('repeaterqetyhgerdfcvvgfnk');
}

var end = Date.now();

console.log("\nTime: " + (end - start) + "ms");

and the results are around 60ms for my algorithm, 110-120ms for yours.

This solution has an upper bound of O(n^2) and an lower bound of O(n). It has a good average performance for short strings and strings with many repeated characters.

function repeater(string)
{
  if(string.length==0)
    return false;

  var char = string.charAt(0);
  if(string.lastIndexOf(char) == 0)
    return char;

  for(var i = 1; i < string.length-1; ++i)
  {
    char = string.charAt(i);
    if(string.lastIndexOf(char)==i && string.indexOf(char)==i)
      return char;
  }

  char = string.charAt(string.length-1);
  if(string.indexOf(char)==string.length-1)
    return char;

  return false;
}