Skip to content

Commit 1048eef

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problems: No.3042,3045 (#2350)
* No.3042.Count Prefix and Suffix Pairs I * No.3045.Count Prefix and Suffix Pairs II
1 parent 3c2e771 commit 1048eef

19 files changed

+892
-6
lines changed

‎solution/3000-3099/3042.Count Prefix and Suffix Pairs I/README.md

+175
Original file line numberDiff line numberDiff line change
@@ -67,19 +67,194 @@ i = 2 且 j = 3 ，因为 isPrefixAndSuffix("ma", "mama") 为 true 。
6767
<!-- tabs:start -->
6868

6969
```python
70+
class Solution:
71+
def countPrefixSuffixPairs(self, words: List[str]) -> int:
72+
ans = 0
73+
for i, s in enumerate(words):
74+
for t in words[i + 1 :]:
75+
ans += t.endswith(s) and t.startswith(s)
76+
return ans
77+
```
78+
79+
```java
80+
class Solution {
81+
public int countPrefixSuffixPairs(String[] words) {
82+
int ans = 0;
83+
int n = words.length;
84+
for (int i = 0; i < n; ++i) {
85+
String s = words[i];
86+
for (int j = i + 1; j < n; ++j) {
87+
String t = words[j];
88+
if (t.startsWith(s) && t.endsWith(s)) {
89+
++ans;
90+
}
91+
}
92+
}
93+
return ans;
94+
}
95+
}
96+
```
97+
98+
```cpp
99+
class Solution {
100+
public:
101+
int countPrefixSuffixPairs(vector<string>& words) {
102+
int ans = 0;
103+
int n = words.size();
104+
for (int i = 0; i < n; ++i) {
105+
string s = words[i];
106+
for (int j = i + 1; j < n; ++j) {
107+
string t = words[j];
108+
if (t.find(s) == 0 && t.rfind(s) == t.length() - s.length()) {
109+
++ans;
110+
}
111+
}
112+
}
113+
return ans;
114+
}
115+
};
116+
```
117+
118+
```go
119+
func countPrefixSuffixPairs(words []string) (ans int) {
120+
for i, s := range words {
121+
for _, t := range words[i+1:] {
122+
if strings.HasPrefix(t, s) && strings.HasSuffix(t, s) {
123+
ans++
124+
}
125+
}
126+
}
127+
return
128+
}
129+
```
130+
131+
```ts
132+
function countPrefixSuffixPairs(words: string[]): number {
133+
let ans = 0;
134+
for (let i = 0; i < words.length; ++i) {
135+
const s = words[i];
136+
for (const t of words.slice(i + 1)) {
137+
if (t.startsWith(s) && t.endsWith(s)) {
138+
++ans;
139+
}
140+
}
141+
}
142+
return ans;
143+
}
144+
```
145+
146+
<!-- tabs:end -->
147+
148+
### 方法二
149+
150+
<!-- tabs:start -->
70151

152+
```python
153+
class Node:
154+
__slots__ = ["children", "cnt"]
155+
156+
def __init__(self):
157+
self.children = {}
158+
self.cnt = 0
159+
160+
161+
class Solution:
162+
def countPrefixSuffixPairs(self, words: List[str]) -> int:
163+
ans = 0
164+
trie = Node()
165+
for s in words:
166+
node = trie
167+
for p in zip(s, reversed(s)):
168+
if p not in node.children:
169+
node.children[p] = Node()
170+
node = node.children[p]
171+
ans += node.cnt
172+
node.cnt += 1
173+
return ans
71174
```
72175

73176
```java
177+
class Node {
178+
Map<Integer, Node> children = new HashMap<>();
179+
int cnt;
180+
}
74181

182+
class Solution {
183+
public int countPrefixSuffixPairs(String[] words) {
184+
int ans = 0;
185+
Node trie = new Node();
186+
for (String s : words) {
187+
Node node = trie;
188+
int m = s.length();
189+
for (int i = 0; i < m; ++i) {
190+
int p = s.charAt(i) * 32 + s.charAt(m - i - 1);
191+
node.children.putIfAbsent(p, new Node());
192+
node = node.children.get(p);
193+
ans += node.cnt;
194+
}
195+
++node.cnt;
196+
}
197+
return ans;
198+
}
199+
}
75200
```
76201

77202
```cpp
203+
class Node {
204+
public:
205+
unordered_map<int, Node*> children;
206+
int cnt;
207+
208+
Node()
209+
: cnt(0) {}
210+
};
78211

212+
class Solution {
213+
public:
214+
int countPrefixSuffixPairs(vector<string>& words) {
215+
int ans = 0;
216+
Node* trie = new Node();
217+
for (const string& s : words) {
218+
Node* node = trie;
219+
int m = s.length();
220+
for (int i = 0; i < m; ++i) {
221+
int p = s[i] * 32 + s[m - i - 1];
222+
if (node->children.find(p) == node->children.end()) {
223+
node->children[p] = new Node();
224+
}
225+
node = node->children[p];
226+
ans += node->cnt;
227+
}
228+
++node->cnt;
229+
}
230+
return ans;
231+
}
232+
};
79233
```
80234
81235
```go
236+
type Node struct {
237+
children map[int]*Node
238+
cnt int
239+
}
82240
241+
func countPrefixSuffixPairs(words []string) (ans int) {
242+
trie := &Node{children: make(map[int]*Node)}
243+
for _, s := range words {
244+
node := trie
245+
m := len(s)
246+
for i := 0; i < m; i++ {
247+
p := int(s[i])*32 + int(s[m-i-1])
248+
if _, ok := node.children[p]; !ok {
249+
node.children[p] = &Node{children: make(map[int]*Node)}
250+
}
251+
node = node.children[p]
252+
ans += node.cnt
253+
}
254+
node.cnt++
255+
}
256+
return
257+
}
83258
```
84259

85260
<!-- tabs:end -->

‎solution/3000-3099/3042.Count Prefix and Suffix Pairs I/README_EN.md

+175
Original file line numberDiff line numberDiff line change
@@ -63,19 +63,194 @@ Therefore, the answer is 0.</pre>
6363
<!-- tabs:start -->
6464

6565
```python
66+
class Solution:
67+
def countPrefixSuffixPairs(self, words: List[str]) -> int:
68+
ans = 0
69+
for i, s in enumerate(words):
70+
for t in words[i + 1 :]:
71+
ans += t.endswith(s) and t.startswith(s)
72+
return ans
73+
```
74+
75+
```java
76+
class Solution {
77+
public int countPrefixSuffixPairs(String[] words) {
78+
int ans = 0;
79+
int n = words.length;
80+
for (int i = 0; i < n; ++i) {
81+
String s = words[i];
82+
for (int j = i + 1; j < n; ++j) {
83+
String t = words[j];
84+
if (t.startsWith(s) && t.endsWith(s)) {
85+
++ans;
86+
}
87+
}
88+
}
89+
return ans;
90+
}
91+
}
92+
```
93+
94+
```cpp
95+
class Solution {
96+
public:
97+
int countPrefixSuffixPairs(vector<string>& words) {
98+
int ans = 0;
99+
int n = words.size();
100+
for (int i = 0; i < n; ++i) {
101+
string s = words[i];
102+
for (int j = i + 1; j < n; ++j) {
103+
string t = words[j];
104+
if (t.find(s) == 0 && t.rfind(s) == t.length() - s.length()) {
105+
++ans;
106+
}
107+
}
108+
}
109+
return ans;
110+
}
111+
};
112+
```
113+
114+
```go
115+
func countPrefixSuffixPairs(words []string) (ans int) {
116+
for i, s := range words {
117+
for _, t := range words[i+1:] {
118+
if strings.HasPrefix(t, s) && strings.HasSuffix(t, s) {
119+
ans++
120+
}
121+
}
122+
}
123+
return
124+
}
125+
```
126+
127+
```ts
128+
function countPrefixSuffixPairs(words: string[]): number {
129+
let ans = 0;
130+
for (let i = 0; i < words.length; ++i) {
131+
const s = words[i];
132+
for (const t of words.slice(i + 1)) {
133+
if (t.startsWith(s) && t.endsWith(s)) {
134+
++ans;
135+
}
136+
}
137+
}
138+
return ans;
139+
}
140+
```
141+
142+
<!-- tabs:end -->
143+
144+
### Solution 2
145+
146+
<!-- tabs:start -->
66147

148+
```python
149+
class Node:
150+
__slots__ = ["children", "cnt"]
151+
152+
def __init__(self):
153+
self.children = {}
154+
self.cnt = 0
155+
156+
157+
class Solution:
158+
def countPrefixSuffixPairs(self, words: List[str]) -> int:
159+
ans = 0
160+
trie = Node()
161+
for s in words:
162+
node = trie
163+
for p in zip(s, reversed(s)):
164+
if p not in node.children:
165+
node.children[p] = Node()
166+
node = node.children[p]
167+
ans += node.cnt
168+
node.cnt += 1
169+
return ans
67170
```
68171

69172
```java
173+
class Node {
174+
Map<Integer, Node> children = new HashMap<>();
175+
int cnt;
176+
}
70177

178+
class Solution {
179+
public int countPrefixSuffixPairs(String[] words) {
180+
int ans = 0;
181+
Node trie = new Node();
182+
for (String s : words) {
183+
Node node = trie;
184+
int m = s.length();
185+
for (int i = 0; i < m; ++i) {
186+
int p = s.charAt(i) * 32 + s.charAt(m - i - 1);
187+
node.children.putIfAbsent(p, new Node());
188+
node = node.children.get(p);
189+
ans += node.cnt;
190+
}
191+
++node.cnt;
192+
}
193+
return ans;
194+
}
195+
}
71196
```
72197

73198
```cpp
199+
class Node {
200+
public:
201+
unordered_map<int, Node*> children;
202+
int cnt;
203+
204+
Node()
205+
: cnt(0) {}
206+
};
74207

208+
class Solution {
209+
public:
210+
int countPrefixSuffixPairs(vector<string>& words) {
211+
int ans = 0;
212+
Node* trie = new Node();
213+
for (const string& s : words) {
214+
Node* node = trie;
215+
int m = s.length();
216+
for (int i = 0; i < m; ++i) {
217+
int p = s[i] * 32 + s[m - i - 1];
218+
if (node->children.find(p) == node->children.end()) {
219+
node->children[p] = new Node();
220+
}
221+
node = node->children[p];
222+
ans += node->cnt;
223+
}
224+
++node->cnt;
225+
}
226+
return ans;
227+
}
228+
};
75229
```
76230
77231
```go
232+
type Node struct {
233+
children map[int]*Node
234+
cnt int
235+
}
78236
237+
func countPrefixSuffixPairs(words []string) (ans int) {
238+
trie := &Node{children: make(map[int]*Node)}
239+
for _, s := range words {
240+
node := trie
241+
m := len(s)
242+
for i := 0; i < m; i++ {
243+
p := int(s[i])*32 + int(s[m-i-1])
244+
if _, ok := node.children[p]; !ok {
245+
node.children[p] = &Node{children: make(map[int]*Node)}
246+
}
247+
node = node.children[p]
248+
ans += node.cnt
249+
}
250+
node.cnt++
251+
}
252+
return
253+
}
79254
```
80255

81256
<!-- tabs:end -->

0 commit comments

Comments
 (0)