Description#
Given a string s, you can transform every letter individually to be lowercase or uppercase to create another string.
Return a list of all possible strings we could create. Return the output in any order.
Example 1:
Input: s = "a1b2"
Output: ["a1b2","a1B2","A1b2","A1B2"]
Example 2:
Input: s = "3z4"
Output: ["3z4","3Z4"]
Constraints:
1 <= s.length <= 12s consists of lowercase English letters, uppercase English letters, and digits.
Solutions#
Solution 1#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| class Solution:
def letterCasePermutation(self, s: str) -> List[str]:
def dfs(i):
if i >= len(s):
ans.append(''.join(t))
return
dfs(i + 1)
if t[i].isalpha():
t[i] = chr(ord(t[i]) ^ 32)
dfs(i + 1)
t = list(s)
ans = []
dfs(0)
return ans
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| class Solution {
private List<String> ans = new ArrayList<>();
private char[] t;
public List<String> letterCasePermutation(String s) {
t = s.toCharArray();
dfs(0);
return ans;
}
private void dfs(int i) {
if (i >= t.length) {
ans.add(String.valueOf(t));
return;
}
dfs(i + 1);
if (t[i] >= 'A') {
t[i] ^= 32;
dfs(i + 1);
}
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| class Solution {
public:
vector<string> letterCasePermutation(string s) {
vector<string> ans;
function<void(int)> dfs = [&](int i) {
if (i >= s.size()) {
ans.emplace_back(s);
return;
}
dfs(i + 1);
if (s[i] >= 'A') {
s[i] ^= 32;
dfs(i + 1);
}
};
dfs(0);
return ans;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| func letterCasePermutation(s string) (ans []string) {
t := []byte(s)
var dfs func(int)
dfs = func(i int) {
if i >= len(t) {
ans = append(ans, string(t))
return
}
dfs(i + 1)
if t[i] >= 'A' {
t[i] ^= 32
dfs(i + 1)
}
}
dfs(0)
return ans
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| function letterCasePermutation(s: string): string[] {
const n = s.length;
const cs = [...s];
const res = [];
const dfs = (i: number) => {
if (i === n) {
res.push(cs.join(''));
return;
}
dfs(i + 1);
if (cs[i] >= 'A') {
cs[i] = String.fromCharCode(cs[i].charCodeAt(0) ^ 32);
dfs(i + 1);
}
};
dfs(0);
return res;
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
| impl Solution {
fn dfs(i: usize, cs: &mut Vec<char>, res: &mut Vec<String>) {
if i == cs.len() {
res.push(cs.iter().collect());
return;
}
Self::dfs(i + 1, cs, res);
if cs[i] >= 'A' {
cs[i] = char::from((cs[i] as u8) ^ 32);
Self::dfs(i + 1, cs, res);
}
}
pub fn letter_case_permutation(s: String) -> Vec<String> {
let mut res = Vec::new();
let mut cs = s.chars().collect::<Vec<char>>();
Self::dfs(0, &mut cs, &mut res);
res
}
}
|
Solution 2#
1
2
3
4
5
6
7
8
9
10
11
12
13
| class Solution:
def letterCasePermutation(self, s: str) -> List[str]:
ans = []
n = sum(c.isalpha() for c in s)
for i in range(1 << n):
j, t = 0, []
for c in s:
if c.isalpha():
c = c.lower() if (i >> j) & 1 else c.upper()
j += 1
t.append(c)
ans.append(''.join(t))
return ans
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| class Solution {
public List<String> letterCasePermutation(String s) {
int n = 0;
for (int i = 0; i < s.length(); ++i) {
if (s.charAt(i) >= 'A') {
++n;
}
}
List<String> ans = new ArrayList<>();
for (int i = 0; i < 1 << n; ++i) {
int j = 0;
StringBuilder t = new StringBuilder();
for (int k = 0; k < s.length(); ++k) {
char x = s.charAt(k);
if (x >= 'A') {
x = ((i >> j) & 1) == 1 ? Character.toLowerCase(x) : Character.toUpperCase(x);
++j;
}
t.append(x);
}
ans.add(t.toString());
}
return ans;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| class Solution {
public:
vector<string> letterCasePermutation(string s) {
int n = 0;
for (char c : s)
if (isalpha(c)) ++n;
vector<string> ans;
for (int i = 0; i < 1 << n; ++i) {
int j = 0;
string t;
for (char c : s) {
if (isalpha(c)) {
c = (i >> j & 1) ? tolower(c) : toupper(c);
++j;
}
t += c;
}
ans.emplace_back(t);
}
return ans;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
| func letterCasePermutation(s string) (ans []string) {
n := 0
for _, c := range s {
if c >= 'A' {
n++
}
}
for i := 0; i < 1<<n; i++ {
j := 0
t := []rune{}
for _, c := range s {
if c >= 'A' {
if ((i >> j) & 1) == 1 {
c = unicode.ToLower(c)
} else {
c = unicode.ToUpper(c)
}
j++
}
t = append(t, c)
}
ans = append(ans, string(t))
}
return ans
}
|
