2351-第一个出现两次的字母

Raphael Liu Lv10
  2023-09-13 00:47:26 2023-09-13 00:47:26 Created   2023-09-13 16:06:32 2023-09-13 16:06:32 Updated    

给你一个由小写英文字母组成的字符串 s ，请你找出并返回第一个出现 两次 的字母。

注意：

  • 如果 a 的 第二次 出现比 b 的 第二次 出现在字符串中的位置更靠前，则认为字母 a 在字母 b 之前出现两次。
  • s 包含至少一个出现两次的字母。

示例 1：

**输入：** s = "abccbaacz"
**输出：** "c"
**解释：**
字母 'a' 在下标 0 、5 和 6 处出现。
字母 'b' 在下标 1 和 4 处出现。
字母 'c' 在下标 2 、3 和 7 处出现。
字母 'z' 在下标 8 处出现。
字母 'c' 是第一个出现两次的字母，因为在所有字母中，'c' 第二次出现的下标是最小的。

示例 2：

**输入：** s = "abcdd"
**输出：** "d"
**解释：**
只有字母 'd' 出现两次，所以返回 'd' 。

提示：

  • 2 <= s.length <= 100
  • s 由小写英文字母组成
  • s 包含至少一个重复字母

方法一：哈希表

思路与算法

我们可以使用一个哈希表记录每个字母是否出现过。

具体地，我们对字符串 s 进行一次遍历。当遍历到字母 c 时，如果哈希表中包含 c，我们返回 c 作为答案即可；否则，我们将 c 加入哈希表。

代码

[sol1-C++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
public:
    char repeatedCharacter(string s) {
        unordered_set<char> seen;
        for (char ch: s) {
            if (seen.count(ch)) {
                return ch;
            }
            seen.insert(ch);
        }
        // impossible
        return ' ';
    }
};
[sol1-Java]
1
2
3
4
5
6
7
8
9
10
11
12
13
class Solution {
    public char repeatedCharacter(String s) {
        Set<Character> seen = new HashSet<Character>();
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            if (!seen.add(ch)) {
                return ch;
            }
        }
        // impossible
        return ' ';
    }
}
[sol1-C#]
1
2
3
4
5
6
7
8
9
10
11
12
public class Solution {
    public char RepeatedCharacter(string s) {
        ISet<char> seen = new HashSet<char>();
        foreach (char ch in s) {
            if (!seen.Add(ch)) {
                return ch;
            }
        }
        // impossible
        return ' ';
    }
}
[sol1-Python3]
1
2
3
4
5
6
7
class Solution:
    def repeatedCharacter(self, s: str) -> str:
        seen = set()
        for ch in s:
            if ch in seen:
                return ch
            seen.add(ch)
[sol1-C]
1
2
3
4
5
6
7
8
9
10
11
char repeatedCharacter(char * s) {
    int seen[26];
    memset(seen, 0, sizeof(seen));
    for (int i = 0; s[i] != '\0'; i++) {
        if (seen[s[i] - 'a'] > 0) {
            return s[i];
        }
        seen[s[i] - 'a'] = 1;
    }
    return ' ';
}
[sol1-JavaScript]
1
2
3
4
5
6
7
8
9
10
11
12
var repeatedCharacter = function(s) {
    const seen = new Set();
    for (let i = 0; i < s.length; i++) {
        const ch = s[i];
        if (seen.has(ch)) {
            return ch;
        }
        seen.add(ch);
    }
    // impossible
    return ' ';
};
[sol1-Golang]
1
2
3
4
5
6
7
8
9
10
func repeatedCharacter(s string) byte {
	seen := map[rune]bool{}
	for _, c := range s {
		if seen[c] {
			return byte(c)
		}
		seen[c] = true
	}
	return 0 // impossible
}

复杂度分析

  • 时间复杂度：O(n)，其中 n 是字符串 s 的长度。

  • 空间复杂度：O(|\Sigma|)，其中 \Sigma 是字符集，在本题中字符串只包含小写字母，因此 |\Sigma|=26。即为哈希表需要使用的空间。

方法二：状态压缩

思路与算法

注意到字符集的大小为 26，因此我们可以使用一个 32 位的二进制数 seen 完美地存储哈希表。如果 seen 的第 i~(0 \leq i < 26) 位是 1，说明第 i 个小写字母已经出现过。

具体地，我们对字符串 s 进行一次遍历。当遍历到字母 c 时，记它是第 i 个字母，seen 的第 i~(0 \leq i < 26) 位是 1，我们返回 c 作为答案即可；否则，我们将 seen 的第 i 位置为 1。

代码

[sol2-C++]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
public:
    char repeatedCharacter(string s) {
        int seen = 0;
        for (char ch: s) {
            int x = ch - 'a';
            if (seen & (1 << x)) {
                return ch;
            }
            seen |= (1 << x);
        }
        // impossible
        return ' ';
    }
};
[sol2-Java]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class Solution {
    public char repeatedCharacter(String s) {
        int seen = 0;
        for (int i = 0; i < s.length(); i++) {
            char ch = s.charAt(i);
            int x = ch - 'a';
            if ((seen & (1 << x)) != 0) {
                return ch;
            }
            seen |= (1 << x);
        }
        // impossible
        return ' ';
    }
}
[sol2-C#]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Solution {
    public char RepeatedCharacter(string s) {
        int seen = 0;
        foreach (char ch in s) {
            int x = ch - 'a';
            if ((seen & (1 << x)) != 0) {
                return ch;
            }
            seen |= (1 << x);
        }
        // impossible
        return ' ';
    }
}
[sol2-Python3]
1
2
3
4
5
6
7
8
class Solution:
    def repeatedCharacter(self, s: str) -> str:
        seen = 0
        for ch in s:
            x = ord(ch) - ord("a")
            if seen & (1 << x):
                return ch
            seen |= (1 << x)
[sol2-C]
1
2
3
4
5
6
7
8
9
10
11
12
char repeatedCharacter(char * s) {
    int seen = 0;
    for (int i = 0; s[i] != '\0'; i++) {
        int x = s[i] - 'a';
        if (seen & (1 << x)) {
            return s[i];
        }
        seen |= (1 << x);
    }
    // impossible
    return ' ';
}
[sol2-JavaScript]
1
2
3
4
5
6
7
8
9
10
11
12
13
var repeatedCharacter = function(s) {
    let seen = 0;
    for (let i = 0; i < s.length; i++) {
        const ch = s[i];
        const x = ch.charCodeAt() - 'a'.charCodeAt();
        if ((seen & (1 << x)) !== 0) {
            return ch;
        }
        seen |= (1 << x);
    }
    // impossible
    return ' ';
};
[sol2-Golang]
1
2
3
4
5
6
7
8
9
10
func repeatedCharacter(s string) byte {
	seen := 0
	for _, c := range s {
		if seen>>(c-'a')&1 > 0 {
			return byte(c)
		}
		seen |= 1 << (c - 'a')
	}
	return 0 // impossible
}

复杂度分析

  • 时间复杂度：O(n)，其中 n 是字符串 s 的长度。

  • 空间复杂度：O(1)。

 Comments
On this page
2351-第一个出现两次的字母