Wsrtjtyk

If you're looking for the first occurrence of a letter that only occurs once, I would use another data structure to keep track of how many times each letter has been seen. This would let you do it with an O(n) rather than an O(n²) solution, except that n in this case is the larger of the difference between the smallest and largest character code or the length of the string and so not directly comparable.

Note: an earlier version of this used for-in - which in practice turns out to be incredibly slow. I've updated it to use the character codes as indexes to keep the look up as fast as possible. What we really need is a hash table but given the small values of N and the small, relative speed up, it's probably not worth it for this problem. In fact, you should prefer @Guffa's solution. I'm including mine only because I ended up learning a lot from it.

function firstNonRepeatedCharacter(string) {

   var counts = {};

   var i, minCode = 999999, maxCode = -1;

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

        var letter = string.charAt(i);

        var letterCode = string.charCodeAt(i);

       if (letterCode < minCode) {

           minCode = letterCode;

       }

       if (letterCode > maxCode) {

           maxCode = letterCode;

       }

        var count = counts[letterCode];

        if (count) {

           count.count = count.count + 1;

        }

        else {

            counts[letterCode] = { letter: letter, count: 1, index: i };

        }

   }



    var smallestIndex = string.length;

    for (i = minCode; i <= maxCode; ++i) {

       var count = counts[i];

       if (count && count.count === 1 && count.index < smallestIndex) {

          smallestIndex = count.index;

       }

   }



    return smallestIndex < string.length ? string.charAt(smallestIndex) : '';

}

See fiddle at http://jsfiddle.net/b2dE4/

Also a (slightly different than the comments) performance test at http://jsperf.com/24793051/2

var firstNonRepeatedCharacter = function(string) {

  var chars = string.split('');

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

    if (chars.filter(function(j) { 

                        return j == string.charAt(i); 

               }).length == 1) return string.charAt(i);

  }

};

So we create an array of all the characters, by splitting on anything.

Then, we loop through each character, and we filter the array we created, so we'll get an array of only those characters. If the length is ever 1, we know we have a non-repeated character.

Fiddle: http://jsfiddle.net/2FpZF/

First of all, start your loop at 1, not 0. There is no point in checking the first character to see if its repeating, obviously it can't be.

Now, within your loop, you have someString[i] and someString[i - 1]. They are the current and previous characters.

if someString[i] === someString[i - 1] then the characters are repeating, if someString[i] !== someString[i - 1] then they are not repeating, so you return someString[i]

I won't write the whole thing out for you, but hopefully the thought process behind this will help

 function FirstNotRepeatedChar(str) {

 var arr = str.split('');

 var result = '';

 var ctr = 0; 

  for (var x = 0; x < arr.length; x++) {

   ctr = 0;

  for (var y = 0; y < arr.length; y++) {

  if (arr[x] === arr[y]) {

    ctr+= 1;

    }

   }



if (ctr < 2) {

  result = arr[x];

  break;

  }

}

return result;

}

console.log(FirstNotRepeatedChar('asif shaik'));

Two further possibilities, using ECMA5 array methods. Will return undefined if none exist.

Javascript

function firstNonRepeatedCharacter(string) {

    return string.split('').filter(function (character, index, obj) {

        return obj.indexOf(character) === obj.lastIndexOf(character);

    }).shift();

}



console.log(firstNonRepeatedCharacter('aabcbd'));

On jsFiddle

Or if you want a bit better performance, especially on longer strings.

Javascript

function firstNonRepeatedCharacter(string) {

    var first;



    string.split('').some(function (character, index, obj) {

        if(obj.indexOf(character) === obj.lastIndexOf(character)) {

            first = character;

            return true;

        }



        return false;

    });



    return first;

}



console.log(firstNonRepeatedCharacter('aabcbd'));

On jsFiddle

Fill an empty array with zeros, with same length as the string array, and tally up how many times they appear through the loop. Grab the first one in the tallied array with a value of 1.

function firstNotRepeatingCharacter(s) {

    const array = s.split("");

    let scores = new Array(array.length).fill(0);



    for (let char of array) {

        scores[array.indexOf(char)]++;

    }



    const singleChar = array[scores.indexOf(1)];

    return singleChar ? singleChar : "_"

}

Here's an O(n) solution with 2 ES6 Sets, one tracking all characters that have appeared and one tracking only chars that have appeared once. This solution takes advantage of the insertion order preserved by Set.

const firstNonRepeating = str => {

  const set = new Set();

  const finalSet = new Set();

  str.split('').forEach(char => {

    if (set.has(char)) finalSet.delete(char);

    else {

      set.add(char);

      finalSet.add(char);

    }

  })

  const iter = finalSet.values();

  return iter.next().value;

}

I came accross this while facing similar problem. Let me add my 2 lines.
What I did is a similar to the Guffa's answer. But using both indexOf method and lastIndexOf.

My mehod:

function nonRepeated(str) {

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

      let j = str.charAt(i)

      if (str.indexOf(j) == str.lastIndexOf(j)) {

        return j;

      }

   }

   return null;

}



nonRepeated("aabcbd"); //c

Simply, indexOf() gets first occurrence of a character & lastIndexOf() gets the last occurrence. So when the first occurrence is also == the last occurence, it means there's just one the character.

You can iterate through each character to find() the first letter that returns a single match(). This will result in the first non-repeated character in the given string:

const first_nonrepeated_character = string => [...string].find(e => string.match(new RegExp(e, 'g')).length === 1);

const string = 'aabcbd';



console.log(first_nonrepeated_character(string)); // c

let arr = [10, 5, 3, 4, 3, 5, 6];

outer:for(let i=0;i<arr.length;i++){

    for(let j=0;j<arr.length;j++){

        if(arr[i]===arr[j+1]){

            console.log(arr[i]);

            break outer;

        }

    }

}





//or else you may try this way...

function firstDuplicate(arr) {

    let findFirst = new Set()

    for (element of arr)

        if (findFirst.has(element ))

            return element 

        else

            findFirst.add(element )

}

solution: map characters into an object

To begin, an empty object is initialized to be a count. Each char of the count is assigned as each letter from the input string.

If the letter doesn't already exist in the count, then the letter is assigned a value of 1. Otherwise, if the letter already exists, increase the count of its occurrence by 1.

After looping through each letter in the input string and assigning each letter to a key-value pair in the count, the next step is to loop through each property (key-value pair) in the count.

While looping through the properties in the count, the first property equal to 1 is the first non-repeating character in the input string.

The expected and actual output from invoking firstNonRepeatedCharacter(someString) is c.

var firstNonRepeatedCharacter = function(string) {

  var count = {};

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

    var letter = string[i];

    if (!count[letter]) {

      count[letter] = 1;

    } else {

      count[letter]++;

    }

  }



  for (var letter in count) {

    if (count[letter] === 1) {

      return letter;

    }

  }

  return null;

}



var someString = 'aabcbd';

console.log(firstNonRepeatedCharacter(someString));