Skip to content

Commit 58c37f6

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0954
No.0954.Array of Doubled Pairs
1 parent b1e9be9 commit 58c37f6

File tree

6 files changed

+251
-2
lines changed

6 files changed

+251
-2
lines changed

‎solution/0900-0999/0954.Array of Doubled Pairs/README.md

Lines changed: 88 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -46,22 +46,109 @@
4646

4747
<!-- 这里可写通用的实现逻辑 -->
4848

49+
**方法一：哈希表 + 排序**
50+
4951
<!-- tabs:start -->
5052

5153
### **Python3**
5254

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

5557
```python
56-
58+
class Solution:
59+
def canReorderDoubled(self, arr: List[int]) -> bool:
60+
freq = Counter(arr)
61+
if freq[0] & 1:
62+
return False
63+
for x in sorted(freq, key=abs):
64+
if freq[x << 1] < freq[x]:
65+
return False
66+
freq[x << 1] -= freq[x]
67+
return True
5768
```
5869

5970
### **Java**
6071

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

6374
```java
75+
class Solution {
76+
public boolean canReorderDoubled(int[] arr) {
77+
Map<Integer, Integer> freq = new HashMap<>();
78+
for (int v : arr) {
79+
freq.put(v, freq.getOrDefault(v, 0) + 1);
80+
}
81+
if ((freq.getOrDefault(0, 0) & 1) != 0) {
82+
return false;
83+
}
84+
List<Integer> keys = new ArrayList<>(freq.keySet());
85+
keys.sort(Comparator.comparingInt(Math::abs));
86+
for (int k : keys) {
87+
if (freq.getOrDefault(k << 1, 0) < freq.get(k)) {
88+
return false;
89+
}
90+
freq.put(k << 1, freq.getOrDefault(k << 1, 0) - freq.get(k));
91+
}
92+
return true;
93+
}
94+
}
95+
```
96+
97+
### **C++**
98+
99+
```cpp
100+
class Solution {
101+
public:
102+
bool canReorderDoubled(vector<int>& arr) {
103+
unordered_map<int, int> freq;
104+
for (int& v : arr) ++freq[v];
105+
if (freq[0] & 1) return false;
106+
vector<int> keys;
107+
for (auto& [k, _] : freq) keys.push_back(k);
108+
sort(keys.begin(), keys.end(), [](int a, int b) { return abs(a) < abs(b); });
109+
for (int& k : keys)
110+
{
111+
if (freq[k * 2] < freq[k]) return false;
112+
freq[k * 2] -= freq[k];
113+
}
114+
return true;
115+
}
116+
};
117+
```
64118
119+
### **Go**
120+
121+
```go
122+
func canReorderDoubled(arr []int) bool {
123+
freq := make(map[int]int)
124+
for _, v := range arr {
125+
freq[v]++
126+
}
127+
if freq[0]%2 != 0 {
128+
return false
129+
}
130+
var keys []int
131+
for k := range freq {
132+
keys = append(keys, k)
133+
}
134+
sort.Slice(keys, func(i, j int) bool {
135+
return abs(keys[i]) < abs(keys[j])
136+
})
137+
for _, k := range keys {
138+
if freq[k*2] < freq[k] {
139+
return false
140+
}
141+
freq[k*2] -= freq[k]
142+
}
143+
return true
144+
}
145+
146+
func abs(x int) int {
147+
if x < 0 {
148+
return -x
149+
}
150+
return x
151+
}
65152
```
66153

67154
### **...**

‎solution/0900-0999/0954.Array of Doubled Pairs/README_EN.md

Lines changed: 86 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -45,13 +45,98 @@
4545
### **Python3**
4646

4747
```python
48-
48+
class Solution:
49+
def canReorderDoubled(self, arr: List[int]) -> bool:
50+
freq = Counter(arr)
51+
if freq[0] & 1:
52+
return False
53+
for x in sorted(freq, key=abs):
54+
if freq[x << 1] < freq[x]:
55+
return False
56+
freq[x << 1] -= freq[x]
57+
return True
4958
```
5059

5160
### **Java**
5261

5362
```java
63+
class Solution {
64+
public boolean canReorderDoubled(int[] arr) {
65+
Map<Integer, Integer> freq = new HashMap<>();
66+
for (int v : arr) {
67+
freq.put(v, freq.getOrDefault(v, 0) + 1);
68+
}
69+
if ((freq.getOrDefault(0, 0) & 1) != 0) {
70+
return false;
71+
}
72+
List<Integer> keys = new ArrayList<>(freq.keySet());
73+
keys.sort(Comparator.comparingInt(Math::abs));
74+
for (int k : keys) {
75+
if (freq.getOrDefault(k << 1, 0) < freq.get(k)) {
76+
return false;
77+
}
78+
freq.put(k << 1, freq.getOrDefault(k << 1, 0) - freq.get(k));
79+
}
80+
return true;
81+
}
82+
}
83+
```
84+
85+
### **C++**
86+
87+
```cpp
88+
class Solution {
89+
public:
90+
bool canReorderDoubled(vector<int>& arr) {
91+
unordered_map<int, int> freq;
92+
for (int& v : arr) ++freq[v];
93+
if (freq[0] & 1) return false;
94+
vector<int> keys;
95+
for (auto& [k, _] : freq) keys.push_back(k);
96+
sort(keys.begin(), keys.end(), [](int a, int b) { return abs(a) < abs(b); });
97+
for (int& k : keys)
98+
{
99+
if (freq[k * 2] < freq[k]) return false;
100+
freq[k * 2] -= freq[k];
101+
}
102+
return true;
103+
}
104+
};
105+
```
54106
107+
### **Go**
108+
109+
```go
110+
func canReorderDoubled(arr []int) bool {
111+
freq := make(map[int]int)
112+
for _, v := range arr {
113+
freq[v]++
114+
}
115+
if freq[0]%2 != 0 {
116+
return false
117+
}
118+
var keys []int
119+
for k := range freq {
120+
keys = append(keys, k)
121+
}
122+
sort.Slice(keys, func(i, j int) bool {
123+
return abs(keys[i]) < abs(keys[j])
124+
})
125+
for _, k := range keys {
126+
if freq[k*2] < freq[k] {
127+
return false
128+
}
129+
freq[k*2] -= freq[k]
130+
}
131+
return true
132+
}
133+
134+
func abs(x int) int {
135+
if x < 0 {
136+
return -x
137+
}
138+
return x
139+
}
55140
```
56141

57142
### **...**

‎solution/0900-0999/0954.Array of Doubled Pairs/Solution.cpp

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,17 @@
1+
class Solution {
2+
public:
3+
bool canReorderDoubled(vector<int>& arr) {
4+
unordered_map<int, int> freq;
5+
for (int& v : arr) ++freq[v];
6+
if (freq[0] & 1) return false;
7+
vector<int> keys;
8+
for (auto& [k, _] : freq) keys.push_back(k);
9+
sort(keys.begin(), keys.end(), [](int a, int b) { return abs(a) < abs(b); });
10+
for (int& k : keys)
11+
{
12+
if (freq[k * 2] < freq[k]) return false;
13+
freq[k * 2] -= freq[k];
14+
}
15+
return true;
16+
}
17+
};

‎solution/0900-0999/0954.Array of Doubled Pairs/Solution.go

Lines changed: 30 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,30 @@
1+
func canReorderDoubled(arr []int) bool {
2+
freq := make(map[int]int)
3+
for _, v := range arr {
4+
freq[v]++
5+
}
6+
if freq[0]%2 != 0 {
7+
return false
8+
}
9+
var keys []int
10+
for k := range freq {
11+
keys = append(keys, k)
12+
}
13+
sort.Slice(keys, func(i, j int) bool {
14+
return abs(keys[i]) < abs(keys[j])
15+
})
16+
for _, k := range keys {
17+
if freq[k*2] < freq[k] {
18+
return false
19+
}
20+
freq[k*2] -= freq[k]
21+
}
22+
return true
23+
}
24+
25+
func abs(x int) int {
26+
if x < 0 {
27+
return -x
28+
}
29+
return x
30+
}

‎solution/0900-0999/0954.Array of Doubled Pairs/Solution.java

Lines changed: 20 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,20 @@
1+
class Solution {
2+
public boolean canReorderDoubled(int[] arr) {
3+
Map<Integer, Integer> freq = new HashMap<>();
4+
for (int v : arr) {
5+
freq.put(v, freq.getOrDefault(v, 0) + 1);
6+
}
7+
if ((freq.getOrDefault(0, 0) & 1) != 0) {
8+
return false;
9+
}
10+
List<Integer> keys = new ArrayList<>(freq.keySet());
11+
keys.sort(Comparator.comparingInt(Math::abs));
12+
for (int k : keys) {
13+
if (freq.getOrDefault(k << 1, 0) < freq.get(k)) {
14+
return false;
15+
}
16+
freq.put(k << 1, freq.getOrDefault(k << 1, 0) - freq.get(k));
17+
}
18+
return true;
19+
}
20+
}

‎solution/0900-0999/0954.Array of Doubled Pairs/Solution.py

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
class Solution:
2+
def canReorderDoubled(self, arr: List[int]) -> bool:
3+
freq = Counter(arr)
4+
if freq[0] & 1:
5+
return False
6+
for x in sorted(freq, key=abs):
7+
if freq[x << 1] < freq[x]:
8+
return False
9+
freq[x << 1] -= freq[x]
10+
return True

0 commit comments

Comments
 (0)