Welcome to Subscribe On Youtube

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;
        }
    }
    

All Problems

All Solutions