Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 58c37f6

Browse files
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
### **...**
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+
};
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+
}
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+
}
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)

AltStyle によって変換されたページ (->オリジナル) /