Skip to content

Commit c8ba5fd

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1220
No.1220.Count Vowels Permutation
1 parent a28fec1 commit c8ba5fd

File tree

6 files changed

+250
-2
lines changed

6 files changed

+250
-2
lines changed

‎solution/1200-1299/1220.Count Vowels Permutation/README.md

+93-1
Original file line numberDiff line numberDiff line change
@@ -52,22 +52,114 @@
5252

5353
<!-- 这里可写通用的实现逻辑 -->
5454

55+
```bash
56+
a [e]
57+
e [a|i]
58+
i [a|e|o|u]
59+
o [i|u]
60+
u [a]
61+
62+
=>
63+
64+
[e|i|u] a
65+
[a|i] e
66+
[e|o] i
67+
[i] o
68+
[i|o] u
69+
```
70+
71+
设 `dp[i][j]` 表示当前长度为 i 且以字符 j 为结尾的字符串的数目，其中 j = {0,1,2,3,4} 分别代表元音字母 `a,e,i,o,u`。
72+
5573
<!-- tabs:start -->
5674

5775
### **Python3**
5876

5977
<!-- 这里可写当前语言的特殊实现逻辑 -->
6078

6179
```python
62-
80+
class Solution:
81+
def countVowelPermutation(self, n: int) -> int:
82+
dp = (1, 1, 1, 1, 1)
83+
MOD = 1000000007
84+
for _ in range(n - 1):
85+
dp = ((dp[1] + dp[2] + dp[4]) % MOD, (dp[0] + dp[2]) %
86+
MOD, (dp[1] + dp[3]) % MOD, dp[2], (dp[2] + dp[3]) % MOD)
87+
return sum(dp) % MOD
6388
```
6489

6590
### **Java**
6691

6792
<!-- 这里可写当前语言的特殊实现逻辑 -->
6893

6994
```java
95+
class Solution {
96+
private static final long MOD = (long) 1e9 + 7;
97+
98+
public int countVowelPermutation(int n) {
99+
long[] dp = new long[5];
100+
long[] t = new long[5];
101+
Arrays.fill(dp, 1);
102+
for (int i = 0; i < n - 1; ++i) {
103+
t[0] = (dp[1] + dp[2] + dp[4]) % MOD;
104+
t[1] = (dp[0] + dp[2]) % MOD;
105+
t[2] = (dp[1] + dp[3]) % MOD;
106+
t[3] = dp[2];
107+
t[4] = (dp[2] + dp[3]) % MOD;
108+
System.arraycopy(t, 0, dp, 0, 5);
109+
}
110+
long ans = 0;
111+
for (int i = 0; i < 5; ++i) {
112+
ans = (ans + dp[i]) % MOD;
113+
}
114+
return (int) ans;
115+
}
116+
}
117+
```
118+
119+
### **C++**
120+
121+
```cpp
122+
class Solution {
123+
public:
124+
int countVowelPermutation(int n) {
125+
using ll = long long;
126+
const ll mod = 1e9 + 7;
127+
vector<ll> dp(5, 1);
128+
vector<ll> t(5);
129+
for (int i = 0; i < n - 1; ++i) {
130+
t[0] = (dp[1] + dp[2] + dp[4]) % mod;
131+
t[1] = (dp[0] + dp[2]) % mod;
132+
t[2] = (dp[1] + dp[3]) % mod;
133+
t[3] = dp[2];
134+
t[4] = (dp[2] + dp[3]) % mod;
135+
dp = t;
136+
}
137+
return accumulate(dp.begin(), dp.end(), 0LL) % mod;
138+
}
139+
};
140+
```
70141
142+
### **Go**
143+
144+
```go
145+
func countVowelPermutation(n int) int {
146+
const mod int = 1e9 + 7
147+
dp := [5]int{1, 1, 1, 1, 1}
148+
for i := 0; i < n-1; i++ {
149+
dp = [5]int{
150+
(dp[1] + dp[2] + dp[4]) % mod,
151+
(dp[0] + dp[2]) % mod,
152+
(dp[1] + dp[3]) % mod,
153+
dp[2],
154+
(dp[2] + dp[3]) % mod,
155+
}
156+
}
157+
ans := 0
158+
for _, v := range dp {
159+
ans = (ans + v) % mod
160+
}
161+
return ans
162+
}
71163
```
72164

73165
### **...**

‎solution/1200-1299/1220.Count Vowels Permutation/README_EN.md

+91-1
Original file line numberDiff line numberDiff line change
@@ -49,18 +49,108 @@
4949

5050
## Solutions
5151

52+
```bash
53+
a [e]
54+
e [a|i]
55+
i [a|e|o|u]
56+
o [i|u]
57+
u [a]
58+
59+
=>
60+
61+
[e|i|u] a
62+
[a|i] e
63+
[e|o] i
64+
[i] o
65+
[i|o] u
66+
```
67+
5268
<!-- tabs:start -->
5369

5470
### **Python3**
5571

5672
```python
57-
73+
class Solution:
74+
def countVowelPermutation(self, n: int) -> int:
75+
dp = (1, 1, 1, 1, 1)
76+
MOD = 1000000007
77+
for _ in range(n - 1):
78+
dp = ((dp[1] + dp[2] + dp[4]) % MOD, (dp[0] + dp[2]) %
79+
MOD, (dp[1] + dp[3]) % MOD, dp[2], (dp[2] + dp[3]) % MOD)
80+
return sum(dp) % MOD
5881
```
5982

6083
### **Java**
6184

6285
```java
86+
class Solution {
87+
private static final long MOD = (long) 1e9 + 7;
88+
89+
public int countVowelPermutation(int n) {
90+
long[] dp = new long[5];
91+
long[] t = new long[5];
92+
Arrays.fill(dp, 1);
93+
for (int i = 0; i < n - 1; ++i) {
94+
t[0] = (dp[1] + dp[2] + dp[4]) % MOD;
95+
t[1] = (dp[0] + dp[2]) % MOD;
96+
t[2] = (dp[1] + dp[3]) % MOD;
97+
t[3] = dp[2];
98+
t[4] = (dp[2] + dp[3]) % MOD;
99+
System.arraycopy(t, 0, dp, 0, 5);
100+
}
101+
long ans = 0;
102+
for (int i = 0; i < 5; ++i) {
103+
ans = (ans + dp[i]) % MOD;
104+
}
105+
return (int) ans;
106+
}
107+
}
108+
```
109+
110+
### **C++**
111+
112+
```cpp
113+
class Solution {
114+
public:
115+
int countVowelPermutation(int n) {
116+
using ll = long long;
117+
const ll mod = 1e9 + 7;
118+
vector<ll> dp(5, 1);
119+
vector<ll> t(5);
120+
for (int i = 0; i < n - 1; ++i) {
121+
t[0] = (dp[1] + dp[2] + dp[4]) % mod;
122+
t[1] = (dp[0] + dp[2]) % mod;
123+
t[2] = (dp[1] + dp[3]) % mod;
124+
t[3] = dp[2];
125+
t[4] = (dp[2] + dp[3]) % mod;
126+
dp = t;
127+
}
128+
return accumulate(dp.begin(), dp.end(), 0LL) % mod;
129+
}
130+
};
131+
```
63132
133+
### **Go**
134+
135+
```go
136+
func countVowelPermutation(n int) int {
137+
const mod int = 1e9 + 7
138+
dp := [5]int{1, 1, 1, 1, 1}
139+
for i := 0; i < n-1; i++ {
140+
dp = [5]int{
141+
(dp[1] + dp[2] + dp[4]) % mod,
142+
(dp[0] + dp[2]) % mod,
143+
(dp[1] + dp[3]) % mod,
144+
dp[2],
145+
(dp[2] + dp[3]) % mod,
146+
}
147+
}
148+
ans := 0
149+
for _, v := range dp {
150+
ans = (ans + v) % mod
151+
}
152+
return ans
153+
}
64154
```
65155

66156
### **...**

‎solution/1200-1299/1220.Count Vowels Permutation/Solution.cpp

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
class Solution {
2+
public:
3+
int countVowelPermutation(int n) {
4+
using ll = long long;
5+
const ll mod = 1e9 + 7;
6+
vector<ll> dp(5, 1);
7+
vector<ll> t(5);
8+
for (int i = 0; i < n - 1; ++i) {
9+
t[0] = (dp[1] + dp[2] + dp[4]) % mod;
10+
t[1] = (dp[0] + dp[2]) % mod;
11+
t[2] = (dp[1] + dp[3]) % mod;
12+
t[3] = dp[2];
13+
t[4] = (dp[2] + dp[3]) % mod;
14+
dp = t;
15+
}
16+
return accumulate(dp.begin(), dp.end(), 0LL) % mod;
17+
}
18+
};

‎solution/1200-1299/1220.Count Vowels Permutation/Solution.go

+18
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,18 @@
1+
func countVowelPermutation(n int) int {
2+
const mod int = 1e9 + 7
3+
dp := [5]int{1, 1, 1, 1, 1}
4+
for i := 0; i < n-1; i++ {
5+
dp = [5]int{
6+
(dp[1] + dp[2] + dp[4]) % mod,
7+
(dp[0] + dp[2]) % mod,
8+
(dp[1] + dp[3]) % mod,
9+
dp[2],
10+
(dp[2] + dp[3]) % mod,
11+
}
12+
}
13+
ans := 0
14+
for _, v := range dp {
15+
ans = (ans + v) % mod
16+
}
17+
return ans
18+
}

‎solution/1200-1299/1220.Count Vowels Permutation/Solution.java

+22
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,22 @@
1+
class Solution {
2+
private static final long MOD = (long) 1e9 + 7;
3+
4+
public int countVowelPermutation(int n) {
5+
long[] dp = new long[5];
6+
long[] t = new long[5];
7+
Arrays.fill(dp, 1);
8+
for (int i = 0; i < n - 1; ++i) {
9+
t[0] = (dp[1] + dp[2] + dp[4]) % MOD;
10+
t[1] = (dp[0] + dp[2]) % MOD;
11+
t[2] = (dp[1] + dp[3]) % MOD;
12+
t[3] = dp[2];
13+
t[4] = (dp[2] + dp[3]) % MOD;
14+
System.arraycopy(t, 0, dp, 0, 5);
15+
}
16+
long ans = 0;
17+
for (int i = 0; i < 5; ++i) {
18+
ans = (ans + dp[i]) % MOD;
19+
}
20+
return (int) ans;
21+
}
22+
}

‎solution/1200-1299/1220.Count Vowels Permutation/Solution.py

+8
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
class Solution:
2+
def countVowelPermutation(self, n: int) -> int:
3+
dp = (1, 1, 1, 1, 1)
4+
MOD = 1000000007
5+
for _ in range(n - 1):
6+
dp = ((dp[1] + dp[2] + dp[4]) % MOD, (dp[0] + dp[2]) %
7+
MOD, (dp[1] + dp[3]) % MOD, dp[2], (dp[2] + dp[3]) % MOD)
8+
return sum(dp) % MOD

0 commit comments

Comments
 (0)