在一个字符串(0<=字符串长度<=10000，全部只由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）。(从0开始计数)

你可以使用Python的内置模块collections中的Counter来解决这个问题。Counter可以快速统计字符串中每个字符出现的次数。然后，再次遍历字符串，找到第一个出现次数为1的字符，返回其位置。

下面是一个示例代码：

from collections import Counter

def find_first_unique_char(s):
    char_count = Counter(s)
    
    # 找到第一个出现次数为1的字符
    for i in range(len(s)):
        if char_count[s[i]] == 1:
            return i
    
    return -1

# 测试
s = "abccba"
print(find_first_unique_char(s))  # 输出 2

s = "abcabc"
print(find_first_unique_char(s))  # 输出 -1

在这个示例中，我们首先使用Counter统计字符串`s`中每个字符的出现次数，并保存在字典`char_count`中。然后，我们再次遍历字符串`s`，找到第一个出现次数为1的字符，并返回其位置。如果没有找到满足条件的字符，则返回-1。

注意：该解法时间复杂度为O(n)，其中n为字符串的长度。

相关问题

在一个字符串(0<=字符串长度<=10000，全部由字母组成)中找到第一个只出现一次的字符,并返回它的位置, 如果没有则返回 -1（需要区分大小写）。怎么编写python程序

可以使用Python的字典来解决这个问题。首先，我们可以遍历字符串中的每个字符，并将其作为字典的键，出现的次数作为字典的值。然后，再次遍历字符串，找到第一个出现次数为1的字符，返回其位置。

下面是一个示例代码：

def find_first_unique_char(s):
    char_count = {}
    
    # 计算每个字符出现的次数
    for char in s:
        if char in char_count:
            char_count[char] += 1
        else:
            char_count[char] = 1
    
    # 找到第一个出现次数为1的字符
    for i in range(len(s)):
        if char_count[s[i]] == 1:
            return i
    
    return -1

# 测试
s = "abccba"
print(find_first_unique_char(s))  # 输出 2

s = "abcabc"
print(find_first_unique_char(s))  # 输出 -1

在这个示例中，我们首先创建了一个空字典`char_count`来存储每个字符的出现次数。然后，我们遍历字符串`s`中的每个字符，如果字符已经在字典中，则将其对应的值加1；否则，在字典中创建该字符，并将其对应的值设为1。接下来，我们再次遍历字符串`s`，找到第一个出现次数为1的字符，并返回其位置。如果没有找到满足条件的字符，则返回-1。

注意：该解法时间复杂度为O(n)，其中n为字符串的长度。

小码妹有一个长度为 n 的字符串 s 和一个大小为 m 的字符集 现在小码妹希望通过对字符串 s 增加或删去字符，使得 s 变为一个回文串 但是增加或删去不同字符需要花费的代价不同 小码妹希望花费最少的代价达成目标，于是她想寻求你的帮助 输入格式:第一行两个正整数 m和n，分别表示字符集大小和s的长度; 第二行为字符串 s; 接下来 m 行，每行由一个字符 c(数据保证字符c唯一)和两个整数 x,y 组成，之间用空格隔开，表示在 s字符串增加字符 c 需要 x的代价，删去字符 c 需要y 的代价。 输出格式:输出一个整数，表示将 s变为回文串需要的最小代价。 样例 输入:3 4 abcba a 1009 1100 b 350 700 c200 800 输出:900 测试数据保证 1<=m<=26，1<=n <= 2000，1<=x,y <= 10000 且字符集为小写英文字母的子集

def getMinCost(s, m, n, c, x, y):
    dp = [[0] * n for _ in range(n)]
    
    for length in range(2, n+1):
        for i in range(n - length + 1):
            j = i + length - 1
            if s[i] == s[j]:
                dp[i][j] = dp[i+1][j-1]
            else:
                add_cost = x[ord(s[i]) - ord('a')] + dp[i+1][j]
                remove_cost = y[ord(s[j]) - ord('a')] + dp[i][j-1]
                dp[i][j] = min(add_cost, remove_cost)
    
    return dp[0][n-1]

# 输入
m, n = map(int, input().split())
s = input()

c = []
x = []
y = []
for _ in range(m):
    char, cost1, cost2 = input().split()
    c.append(char)
    x.append(int(cost1))
    y.append(int(cost2))

# 输出
print(getMinCost(s, m, n, c, x, y))

这段代码使用了动态规划的思想。定义一个二维数组dp，其中dp[i][j]表示将字符串s的子串s[i...j]变为回文串所需要的最小代价。初始化时，所有dp[i][i]都为0，表示单个字符本身就是回文串。

然后，通过遍历子串的长度和起始位置来计算dp[i][j]。如果s[i]和s[j]相等，则dp[i][j]等于dp[i+1][j-1]，因为只需要将两边的子串变为回文串即可。

如果s[i]和s[j]不相等，则需要选择增加或删除字符来使其相等。假设c是s[i]或s[j]中的一个字符，那么增加字符c的代价是x[ord(c) - ord('a')]，删除字符c的代价是y[ord(c) - ord('a')]。因此，dp[i][j]等于x[ord(s[i]) - ord('a')] + dp[i+1][j]和y[ord(s[j]) - ord('a')] + dp[i][j-1]中的较小值。

最后，返回dp[0][n-1]，即整个字符串s变为回文串所需要的最小代价。

注意：在Python中，字符串是以'\n'结尾的字符数组，可以直接使用input函数读取字符串。另外，ord函数可以将字符转换为对应的ASCII码。