LeetCode #387 First Unique Character in a String 字串中第一個唯一的字元

public class Solution {
    public int FirstUniqChar(string s) {
        Dictionary<char,int> dict =   new Dictionary<char,int>();
        HashSet<char> hSet = new HashSet<char>();
        
        for(int i = 0; i<s.Length;i++)
        {
            char c = s[i];
            
            if(hSet.Contains(c))
            {
                continue;
            }
                
            
            if (!dict.ContainsKey(c))
            {
                dict.Add(c, i);
            }
            else
            {
                dict.Remove(c);
                hSet.Add(c);
            }
        }
        
        if(dict.Count == 0)
        {
            return -1;
        }
        
         return dict.MinBy(k => k.Value).Value;
    }
}

public class Solution {
    public int FirstUniqChar(string s) {
        
        int min = Int32.MaxValue;
        
        for (char c = 'a'; c <= 'z'; c++)
        {
            int tmp = s.IndexOf(c);
            if(tmp!=-1 && tmp == s.LastIndexOf(c))
            {
                min = tmp<min ? tmp : min;
            }
        } 
        min = min == Int32.MaxValue ? -1 : min;
            
        return min;
    }
}

class Solution {
    public int firstUniqChar(String s) {
        Map<Character, Integer> dict = new HashMap<Character, Integer>();
        HashSet<Character> hSet  = new HashSet<Character>();
        
        for(int i = 0; i<s.length();i++)
        {
            char c = s.charAt(i);
            
            if(hSet.contains(c))
            {
                continue;
            } 
            
            if (!dict.containsKey(c))
            {
                dict.put(c, i);
            }
            else
            {
                dict.remove(c);
                hSet.add(c);
            }
        }
        
        if(dict.size() == 0)
        {
            return -1;
        }
        
        int min = Integer.MAX_VALUE;
        
        for (Integer value : dict.values()) {
            min = value<min ? value : min;
        }
        
        return min;
    }
}

class Solution {
    public int firstUniqChar(String s) {
        int min = Integer.MAX_VALUE;
        
        for (char c = 'a'; c <= 'z'; c++)
        {
            int tmp = s.indexOf(c);
            if(tmp!=-1 && tmp == s.lastIndexOf(c))
            {
                min = tmp<min ? tmp : min;
            }
        } 
        min = min == Integer.MAX_VALUE ? -1 : min;
            
        return min;
    }
}

from string import ascii_lowercase as alc

class Solution:
    def firstUniqChar(self, s: str) -> int:
        
        m = math.pow(10,5);     #min
        
        for c in alc:
            try:
                tmp = s.index(c)
                tmp2 = s.rindex(c)
            except: 
                continue;
                
            if tmp == tmp2:
                m = tmp if tmp<m else m
                
        return -1 if m == math.pow(10,5) else m

/**
 * @param {string} s
 * @return {number}
 */
var firstUniqChar = function(s) {
    var min = 10**5;
    for (var i = 97; i <= 122; i++) {
        var c = String.fromCharCode(i);
        
        var tmp = s.indexOf(c);
        if(tmp!=-1 && tmp == s.lastIndexOf(c))
        {
            min = tmp<min ? tmp : min;
        }
    }
    
    min = min == 10**5 ? -1 : min;
    return min;
};