Question

Formatted question description: https://leetcode.ca/all/387.html

Given a string s, find the first non-repeating character in it and return its index. If it does not exist, return -1.

Example 1:

Input: s = "leetcode"
Output: 0


Example 2:

Input: s = "loveleetcode"
Output: 2


Example 3:

Input: s = "aabb"
Output: -1


Constraints:

• 1 <= s.length <= 105
• s consists of only lowercase English letters.

Algorithm

The hash table builds a mapping between each character and its number of occurrences, and then traverses the string in order, finds the first character with a number of occurrences of 1, and returns its position.

Code

• 
public class First_Unique_Character_in_a_String {

public static void main (String[] args) {
First_Unique_Character_in_a_String out = new First_Unique_Character_in_a_String();
Solution s = out.new Solution();

System.out.println(s.firstUniqChar("loveleetcode"));
}

class Solution {
public int firstUniqChar(String s) {

if (s == null || s.length() == 0) {
return -1;
}

// unique[i] meaning index i has no duplicate
int[] count = new int[256];

for (char each: s.toCharArray()) {
count[each] += 1;
}

for (int i = 0; i < s.length(); i++) {
if (count[s.charAt(i)] == 1) {
return i;
}
}

return -1;
}
}
}

############

class Solution {
public int firstUniqChar(String s) {
int[] cnt = new int[26];
int n = s.length();
for (int i = 0; i < n; ++i) {
++cnt[s.charAt(i) - 'a'];
}
for (int i = 0; i < n; ++i) {
if (cnt[s.charAt(i) - 'a'] == 1) {
return i;
}
}
return -1;
}
}

• // OJ: https://leetcode.com/problems/first-unique-character-in-a-string/
// Time: O(S)
// Space: O(1)
class Solution {
public:
int firstUniqChar(string s) {
int cnt[26] = {0};
for (char c : s) cnt[c - 'a']++;
for (int i = 0; i < s.size(); ++i) {
if (cnt[s[i] - 'a'] == 1) return i;
}
return -1;
}
};

• class Solution:
def firstUniqChar(self, s: str) -> int:
counter = Counter(s)
for i, c in enumerate(s):
if counter[c] == 1:
return i
return -1

############

class Solution(object):
def firstUniqChar(self, s):
"""
:type s: str
:rtype: int
"""
letters = [0] * 26
for c in s:
ci = ord(c) - ord('a')
letters[ci] += 1
for i in range(0, len(s)):
ci = ord(s[i]) - ord('a')
if letters[ci] == 1:
return i
return -1


• func firstUniqChar(s string) int {
cnt := [26]int{}
for _, c := range s {
cnt[c-'a']++
}
for i, c := range s {
if cnt[c-'a'] == 1 {
return i
}
}
return -1
}

• function firstUniqChar(s: string): number {
const cnt = new Array(26).fill(0);
for (const c of s) {
cnt[c.charCodeAt(0) - 97]++;
}
for (let i = 0; i < s.length; i++) {
if (cnt[s.charCodeAt(i) - 97] === 1) {
return i;
}
}
return -1;
}


• /**
* @param {string} s
* @return {number}
*/
var firstUniqChar = function (s) {
const cnt = new Array(26).fill(0);
for (const c of s) {
++cnt[c.charCodeAt() - 'a'.charCodeAt()];
}
for (let i = 0; i < s.length; ++i) {
if (cnt[s[i].charCodeAt() - 'a'.charCodeAt()] === 1) {
return i;
}
}
return -1;
};


• class Solution {
/**
* @param String $s * @return Integer */ function firstUniqChar($s) {
for ($i = 0;$i < strlen($s);$i++) {
$hashtable[$s[$i]]++; } for ($i = 0; $i < strlen($s); $i++) { if ($hashtable[$s[$i]] == 1) {
return \$i;
}
}
return -1;
}
}