Skip to content

Commit 17f5f79

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1128
No.1128.Number of Equivalent Domino Pairs
1 parent 23fa248 commit 17f5f79

File tree

6 files changed

+197
-11
lines changed

6 files changed

+197
-11
lines changed

‎solution/1100-1199/1128.Number of Equivalent Domino Pairs/README.md

+76-1
Original file line numberDiff line numberDiff line change
@@ -42,15 +42,90 @@
4242
<!-- 这里可写当前语言的特殊实现逻辑 -->
4343

4444
```python
45-
45+
class Solution:
46+
def numEquivDominoPairs(self, dominoes: List[List[int]]) -> int:
47+
counter = Counter()
48+
ans = 0
49+
for a, b in dominoes:
50+
v = a * 10 + b if a > b else b * 10 + a
51+
ans += counter[v]
52+
counter[v] += 1
53+
return ans
4654
```
4755

4856
### **Java**
4957

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

5260
```java
61+
class Solution {
62+
public int numEquivDominoPairs(int[][] dominoes) {
63+
int ans = 0;
64+
int[] counter = new int[100];
65+
for (int[] d : dominoes) {
66+
int v = d[0] > d[1] ? d[0] * 10 + d[1] : d[1] * 10 + d[0];
67+
ans += counter[v];
68+
++counter[v];
69+
}
70+
return ans;
71+
}
72+
}
73+
```
74+
75+
```java
76+
class Solution {
77+
public int numEquivDominoPairs(int[][] dominoes) {
78+
int[] counter = new int[100];
79+
for (int[] d : dominoes) {
80+
int v = d[0] > d[1] ? d[0] * 10 + d[1] : d[1] * 10 + d[0];
81+
++counter[v];
82+
}
83+
int ans = 0;
84+
for (int c : counter) {
85+
ans += c * (c - 1) / 2;
86+
}
87+
return ans;
88+
}
89+
}
90+
```
91+
92+
### **C++**
93+
94+
```cpp
95+
class Solution {
96+
public:
97+
int numEquivDominoPairs(vector<vector<int>>& dominoes) {
98+
vector<int> counter(100);
99+
int ans = 0;
100+
for (auto& d : dominoes)
101+
{
102+
int v = d[0] > d[1] ? d[0] * 10 + d[1] : d[1] * 10 + d[0];
103+
ans += counter[v];
104+
++counter[v];
105+
}
106+
return ans;
107+
}
108+
};
109+
```
53110
111+
### **Go**
112+
113+
```go
114+
func numEquivDominoPairs(dominoes [][]int) int {
115+
counter := make([]int, 100)
116+
for _, d := range dominoes {
117+
if d[1] < d[0] {
118+
d[0], d[1] = d[1], d[0]
119+
}
120+
v := d[0]*10 + d[1]
121+
counter[v]++
122+
}
123+
ans := 0
124+
for _, c := range counter {
125+
ans += c * (c - 1) / 2
126+
}
127+
return ans
128+
}
54129
```
55130

56131
### **...**

‎solution/1100-1199/1128.Number of Equivalent Domino Pairs/README_EN.md

+76-1
Original file line numberDiff line numberDiff line change
@@ -34,13 +34,88 @@
3434
### **Python3**
3535

3636
```python
37-
37+
class Solution:
38+
def numEquivDominoPairs(self, dominoes: List[List[int]]) -> int:
39+
counter = Counter()
40+
ans = 0
41+
for a, b in dominoes:
42+
v = a * 10 + b if a > b else b * 10 + a
43+
ans += counter[v]
44+
counter[v] += 1
45+
return ans
3846
```
3947

4048
### **Java**
4149

4250
```java
51+
class Solution {
52+
public int numEquivDominoPairs(int[][] dominoes) {
53+
int ans = 0;
54+
int[] counter = new int[100];
55+
for (int[] d : dominoes) {
56+
int v = d[0] > d[1] ? d[0] * 10 + d[1] : d[1] * 10 + d[0];
57+
ans += counter[v];
58+
++counter[v];
59+
}
60+
return ans;
61+
}
62+
}
63+
```
64+
65+
```java
66+
class Solution {
67+
public int numEquivDominoPairs(int[][] dominoes) {
68+
int[] counter = new int[100];
69+
for (int[] d : dominoes) {
70+
int v = d[0] > d[1] ? d[0] * 10 + d[1] : d[1] * 10 + d[0];
71+
++counter[v];
72+
}
73+
int ans = 0;
74+
for (int c : counter) {
75+
ans += c * (c - 1) / 2;
76+
}
77+
return ans;
78+
}
79+
}
80+
```
81+
82+
### **C++**
83+
84+
```cpp
85+
class Solution {
86+
public:
87+
int numEquivDominoPairs(vector<vector<int>>& dominoes) {
88+
vector<int> counter(100);
89+
int ans = 0;
90+
for (auto& d : dominoes)
91+
{
92+
int v = d[0] > d[1] ? d[0] * 10 + d[1] : d[1] * 10 + d[0];
93+
ans += counter[v];
94+
++counter[v];
95+
}
96+
return ans;
97+
}
98+
};
99+
```
43100
101+
### **Go**
102+
103+
```go
104+
func numEquivDominoPairs(dominoes [][]int) int {
105+
counter := make([]int, 100)
106+
for _, d := range dominoes {
107+
if d[1] < d[0] {
108+
d[0], d[1] = d[1], d[0]
109+
}
110+
v := d[0]*10 + d[1]
111+
counter[v]++
112+
}
113+
ans := 0
114+
for _, c := range counter {
115+
ans += c * (c - 1) / 2
116+
}
117+
return ans
118+
}
44119
```
45120

46121
### **...**

‎solution/1100-1199/1128.Number of Equivalent Domino Pairs/Solution.cpp

+14
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,14 @@
1+
class Solution {
2+
public:
3+
int numEquivDominoPairs(vector<vector<int>>& dominoes) {
4+
vector<int> counter(100);
5+
int ans = 0;
6+
for (auto& d : dominoes)
7+
{
8+
int v = d[0] > d[1] ? d[0] * 10 + d[1] : d[1] * 10 + d[0];
9+
ans += counter[v];
10+
++counter[v];
11+
}
12+
return ans;
13+
}
14+
};

‎solution/1100-1199/1128.Number of Equivalent Domino Pairs/Solution.go

+15
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,15 @@
1+
func numEquivDominoPairs(dominoes [][]int) int {
2+
counter := make([]int, 100)
3+
for _, d := range dominoes {
4+
if d[1] < d[0] {
5+
d[0], d[1] = d[1], d[0]
6+
}
7+
v := d[0]*10 + d[1]
8+
counter[v]++
9+
}
10+
ans := 0
11+
for _, c := range counter {
12+
ans += c * (c - 1) / 2
13+
}
14+
return ans
15+
}

‎solution/1100-1199/1128.Number of Equivalent Domino Pairs/Solution.java

+7-9
Original file line numberDiff line numberDiff line change
@@ -1,14 +1,12 @@
11
class Solution {
22
public int numEquivDominoPairs(int[][] dominoes) {
3-
Map<Integer, Integer> map = new HashMap<>();
3+
int ans = 0;
4+
int[] counter = new int[100];
45
for (int[] d : dominoes) {
5-
int x = d[0] < d[1] ? d[0] * 10 + d[1] : d[1] * 10 + d[0];
6-
map.put(x, map.getOrDefault(x, 0) + 1);
6+
int v = d[0] > d[1] ? d[0] * 10 + d[1] : d[1] * 10 + d[0];
7+
ans += counter[v];
8+
++counter[v];
79
}
8-
int res = 0;
9-
for (int v : map.values()) {
10-
res += v * (v - 1) / 2;
11-
}
12-
return res;
10+
return ans;
1311
}
14-
}
12+
}

‎solution/1100-1199/1128.Number of Equivalent Domino Pairs/Solution.py

+9
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,9 @@
1+
class Solution:
2+
def numEquivDominoPairs(self, dominoes: List[List[int]]) -> int:
3+
counter = Counter()
4+
ans = 0
5+
for a, b in dominoes:
6+
v = a * 10 + b if a > b else b * 10 + a
7+
ans += counter[v]
8+
counter[v] += 1
9+
return ans

0 commit comments

Comments
 (0)