# 本题涉及到 Python 的一些语法知识
# Python常用内置函数、方法、技巧汇总
# https://og7kl7g6h8.feishu.cn/docx/AbbMdd4YHoGeQRxRGKJcJZs6nDb
class Solution:
    def firstUniqChar(self, s: str) -> int:
        # Counter 可以直接统计字符串、列表等可迭代对象的元素频率
        # s = "leetcode"
        # cnt = Counter({'e': 3, 'l': 1, 't': 1, 'c': 1, 'o': 1, 'd': 1})
        cnt = Counter(s)
        print(cnt)

        # 如果想在for循环中同时获得列表的索引 i 和元素值 v
        # 可以使用枚举内置函数 enumerate()
        for i, v in enumerate(s):
            # 如果找到了某个字符出现的频率为 1
            if cnt[v] == 1:
                # 返回它的下标即可
                return i

        # 如果不存在，则返回 -1 
        return -1

Java

class Solution {
    public int firstUniqChar(String s) {
        // 定义一个哈希表，用于统计字符串中每个字符的频率
        int[] cnt = new int[26];

        // 遍历字符串，记录每个字符的出现频率
        for (char c : s.toCharArray()) {
            cnt[c - 'a']++;
        }

        // 遍历字符串，找到第一个频率为 1 的字符，返回其下标
        for (int i = 0; i < s.length(); i++) {
            if (cnt[s.charAt(i) - 'a'] == 1) {
                return i;
            }
        }

        // 如果不存在频率为 1 的字符，返回 -1
        return -1;
    }
}

C++

class Solution {
public:
    int firstUniqChar(std::string s) {
        // 定义一个数组，用于统计字符串中每个字符的频率
        std::vector<int> cnt(26, 0);

        // 遍历字符串，记录每个字符的出现频率
        for (char c : s) {
            cnt[c - 'a']++;
        }

        // 遍历字符串，找到第一个频率为 1 的字符，返回其下标
        for (int i = 0; i < s.size(); i++) {
            if (cnt[s[i] - 'a'] == 1) {
                return i;
            }
        }

        // 如果不存在频率为 1 的字符，返回 -1
        return -1;
    }
};

C

int firstUniqChar(char *s) {
    // 定义一个数组，用于统计字符串中每个字符的频率
    int cnt[26] = {0};

    // 计算字符串的长度
    int len = strlen(s);

    // 遍历字符串，记录每个字符的出现频率
    for (int i = 0; i < len; i++) {
        cnt[s[i] - 'a']++;
    }

    // 遍历字符串，找到第一个频率为 1 的字符，返回其下标
    for (int i = 0; i < len; i++) {
        if (cnt[s[i] - 'a'] == 1) {
            return i;
        }
    }

    // 如果不存在频率为 1 的字符，返回 -1
    return -1;
}

Node JavaScript

/**
 * @param {string} s
 * @return {number}
 */
var firstUniqChar = function(s) {
    // 定义一个哈希表，用于统计字符串中每个字符的频率
    const cnt = new Array(26).fill(0);

    // 遍历字符串，记录每个字符的出现频率
    for (const c of s) {
        cnt[c.charCodeAt(0) - 'a'.charCodeAt(0)]++;
    }

    // 遍历字符串，找到第一个频率为 1 的字符，返回其下标
    for (let i = 0; i < s.length; i++) {
        if (cnt[s.charCodeAt(i) - 'a'.charCodeAt(0)] === 1) {
            return i;
        }
    }

    // 如果不存在频率为 1 的字符，返回 -1
    return -1;
};

Go

func firstUniqChar(s string) int {
    // 定义一个数组，用于统计字符串中每个字符的频率
    cnt := make([]int, 26)

    // 遍历字符串，记录每个字符的出现频率
    for _, c := range s {
        cnt[c-'a']++
    }

    // 遍历字符串，找到第一个频率为 1 的字符，返回其下标
    for i, c := range s {
        if cnt[c-'a'] == 1 {
            return i
        }
    }

    // 如果不存在频率为 1 的字符，返回 -1
    return -1
}