Skip to content

Commit d79ba26

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.1481
No.1481.Least Number of Unique Integers after K Removals
1 parent aaeeb0a commit d79ba26

File tree

10 files changed

+247
-18
lines changed

10 files changed

+247
-18
lines changed

‎README.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -23,7 +23,7 @@
2323
- Netlify: https://lc.netlify.app
2424
- GitHub Pages: https://doocs.github.io/leetcode
2525

26-
## LeetCode 全解
26+
## 算法全解
2727

2828
- [LeetCode](/solution/README.md)
2929
- [LeetCode 《剑指 Offer（第 2 版）》](/lcof/README.md)

‎solution/1300-1399/1366.Rank Teams by Votes/README.md

+2-5
Original file line numberDiff line numberDiff line change
@@ -176,11 +176,8 @@ func rankTeams(votes []string) string {
176176
sort.Slice(ans, func(i, j int) bool {
177177
v1, v2 := counter[ans[i]], counter[ans[j]]
178178
for i := range v1 {
179-
if v1[i] > v2[i] {
180-
return true
181-
}
182-
if v1[i] < v2[i] {
183-
return false
179+
if v1[i] != v2[i] {
180+
return v1[i] > v2[i]
184181
}
185182
}
186183
return ans[i] < ans[j]

‎solution/1300-1399/1366.Rank Teams by Votes/README_EN.md

+2-5
Original file line numberDiff line numberDiff line change
@@ -164,11 +164,8 @@ func rankTeams(votes []string) string {
164164
sort.Slice(ans, func(i, j int) bool {
165165
v1, v2 := counter[ans[i]], counter[ans[j]]
166166
for i := range v1 {
167-
if v1[i] > v2[i] {
168-
return true
169-
}
170-
if v1[i] < v2[i] {
171-
return false
167+
if v1[i] != v2[i] {
168+
return v1[i] > v2[i]
172169
}
173170
}
174171
return ans[i] < ans[j]

‎solution/1300-1399/1366.Rank Teams by Votes/Solution.go

+2-5
Original file line numberDiff line numberDiff line change
@@ -13,11 +13,8 @@ func rankTeams(votes []string) string {
1313
sort.Slice(ans, func(i, j int) bool {
1414
v1, v2 := counter[ans[i]], counter[ans[j]]
1515
for i := range v1 {
16-
if v1[i] > v2[i] {
17-
return true
18-
}
19-
if v1[i] < v2[i] {
20-
return false
16+
if v1[i] != v2[i] {
17+
return v1[i] > v2[i]
2118
}
2219
}
2320
return ans[i] < ans[j]

‎solution/1400-1499/1481.Least Number of Unique Integers after K Removals/README.md

+83-1
Original file line numberDiff line numberDiff line change
@@ -47,15 +47,97 @@
4747
<!-- 这里可写当前语言的特殊实现逻辑 -->
4848

4949
```python
50-
50+
class Solution:
51+
def findLeastNumOfUniqueInts(self, arr: List[int], k: int) -> int:
52+
counter = Counter(arr)
53+
t = sorted(counter.items(), key=lambda x: x[1])
54+
for v, cnt in t:
55+
if k >= cnt:
56+
k -= cnt
57+
counter.pop(v)
58+
else:
59+
break
60+
return len(counter)
5161
```
5262

5363
### **Java**
5464

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

5767
```java
68+
class Solution {
69+
public int findLeastNumOfUniqueInts(int[] arr, int k) {
70+
Map<Integer, Integer> counter = new HashMap<>();
71+
for (int v : arr) {
72+
counter.put(v, counter.getOrDefault(v, 0) + 1);
73+
}
74+
List<Map.Entry<Integer, Integer>> t = new ArrayList<>(counter.entrySet());
75+
Collections.sort(t, Comparator.comparingInt(Map.Entry::getValue));
76+
for (Map.Entry<Integer, Integer> e : t) {
77+
int v = e.getKey();
78+
int cnt = e.getValue();
79+
if (k >= cnt) {
80+
k -= cnt;
81+
counter.remove(v);
82+
} else {
83+
break;
84+
}
85+
}
86+
return counter.size();
87+
}
88+
}
89+
```
90+
91+
### **C++**
92+
93+
```cpp
94+
class Solution {
95+
public:
96+
int findLeastNumOfUniqueInts(vector<int>& arr, int k) {
97+
unordered_map<int, int> counter;
98+
for (int v : arr) ++counter[v];
99+
vector<pair<int, int>> t(counter.begin(), counter.end());
100+
sort(t.begin(), t.end(), [](const auto& a, const auto& b) {return a.second < b.second;});
101+
for (auto [v, cnt] : t)
102+
{
103+
if (k >= cnt)
104+
{
105+
k -= cnt;
106+
counter.erase(v);
107+
}
108+
else break;
109+
}
110+
return counter.size();
111+
}
112+
};
113+
```
58114
115+
### **Go**
116+
117+
```go
118+
func findLeastNumOfUniqueInts(arr []int, k int) int {
119+
counter := make(map[int]int)
120+
for _, v := range arr {
121+
counter[v]++
122+
}
123+
var t [][]int
124+
for v, cnt := range counter {
125+
t = append(t, []int{v, cnt})
126+
}
127+
sort.Slice(t, func(i, j int) bool {
128+
return t[i][1] < t[j][1]
129+
})
130+
for _, e := range t {
131+
v, cnt := e[0], e[1]
132+
if k >= cnt {
133+
k -= cnt
134+
delete(counter, v)
135+
} else {
136+
break
137+
}
138+
}
139+
return len(counter)
140+
}
59141
```
60142

61143
### **...**

‎solution/1400-1499/1481.Least Number of Unique Integers after K Removals/README_EN.md

+83-1
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,95 @@
5151
### **Python3**
5252

5353
```python
54-
54+
class Solution:
55+
def findLeastNumOfUniqueInts(self, arr: List[int], k: int) -> int:
56+
counter = Counter(arr)
57+
t = sorted(counter.items(), key=lambda x: x[1])
58+
for v, cnt in t:
59+
if k >= cnt:
60+
k -= cnt
61+
counter.pop(v)
62+
else:
63+
break
64+
return len(counter)
5565
```
5666

5767
### **Java**
5868

5969
```java
70+
class Solution {
71+
public int findLeastNumOfUniqueInts(int[] arr, int k) {
72+
Map<Integer, Integer> counter = new HashMap<>();
73+
for (int v : arr) {
74+
counter.put(v, counter.getOrDefault(v, 0) + 1);
75+
}
76+
List<Map.Entry<Integer, Integer>> t = new ArrayList<>(counter.entrySet());
77+
Collections.sort(t, Comparator.comparingInt(Map.Entry::getValue));
78+
for (Map.Entry<Integer, Integer> e : t) {
79+
int v = e.getKey();
80+
int cnt = e.getValue();
81+
if (k >= cnt) {
82+
k -= cnt;
83+
counter.remove(v);
84+
} else {
85+
break;
86+
}
87+
}
88+
return counter.size();
89+
}
90+
}
91+
```
92+
93+
### **C++**
94+
95+
```cpp
96+
class Solution {
97+
public:
98+
int findLeastNumOfUniqueInts(vector<int>& arr, int k) {
99+
unordered_map<int, int> counter;
100+
for (int v : arr) ++counter[v];
101+
vector<pair<int, int>> t(counter.begin(), counter.end());
102+
sort(t.begin(), t.end(), [](const auto& a, const auto& b) {return a.second < b.second;});
103+
for (auto [v, cnt] : t)
104+
{
105+
if (k >= cnt)
106+
{
107+
k -= cnt;
108+
counter.erase(v);
109+
}
110+
else break;
111+
}
112+
return counter.size();
113+
}
114+
};
115+
```
60116
117+
### **Go**
118+
119+
```go
120+
func findLeastNumOfUniqueInts(arr []int, k int) int {
121+
counter := make(map[int]int)
122+
for _, v := range arr {
123+
counter[v]++
124+
}
125+
var t [][]int
126+
for v, cnt := range counter {
127+
t = append(t, []int{v, cnt})
128+
}
129+
sort.Slice(t, func(i, j int) bool {
130+
return t[i][1] < t[j][1]
131+
})
132+
for _, e := range t {
133+
v, cnt := e[0], e[1]
134+
if k >= cnt {
135+
k -= cnt
136+
delete(counter, v)
137+
} else {
138+
break
139+
}
140+
}
141+
return len(counter)
142+
}
61143
```
62144

63145
### **...**

‎solution/1400-1499/1481.Least Number of Unique Integers after K Removals/Solution.cpp

+19
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,19 @@
1+
class Solution {
2+
public:
3+
int findLeastNumOfUniqueInts(vector<int>& arr, int k) {
4+
unordered_map<int, int> counter;
5+
for (int v : arr) ++counter[v];
6+
vector<pair<int, int>> t(counter.begin(), counter.end());
7+
sort(t.begin(), t.end(), [](const auto& a, const auto& b) {return a.second < b.second;});
8+
for (auto [v, cnt] : t)
9+
{
10+
if (k >= cnt)
11+
{
12+
k -= cnt;
13+
counter.erase(v);
14+
}
15+
else break;
16+
}
17+
return counter.size();
18+
}
19+
};

‎solution/1400-1499/1481.Least Number of Unique Integers after K Removals/Solution.go

+23
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,23 @@
1+
func findLeastNumOfUniqueInts(arr []int, k int) int {
2+
counter := make(map[int]int)
3+
for _, v := range arr {
4+
counter[v]++
5+
}
6+
var t [][]int
7+
for v, cnt := range counter {
8+
t = append(t, []int{v, cnt})
9+
}
10+
sort.Slice(t, func(i, j int) bool {
11+
return t[i][1] < t[j][1]
12+
})
13+
for _, e := range t {
14+
v, cnt := e[0], e[1]
15+
if k >= cnt {
16+
k -= cnt
17+
delete(counter, v)
18+
} else {
19+
break
20+
}
21+
}
22+
return len(counter)
23+
}

‎solution/1400-1499/1481.Least Number of Unique Integers after K Removals/Solution.java

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
class Solution {
2+
public int findLeastNumOfUniqueInts(int[] arr, int k) {
3+
Map<Integer, Integer> counter = new HashMap<>();
4+
for (int v : arr) {
5+
counter.put(v, counter.getOrDefault(v, 0) + 1);
6+
}
7+
List<Map.Entry<Integer, Integer>> t = new ArrayList<>(counter.entrySet());
8+
Collections.sort(t, Comparator.comparingInt(Map.Entry::getValue));
9+
for (Map.Entry<Integer, Integer> e : t) {
10+
int v = e.getKey();
11+
int cnt = e.getValue();
12+
if (k >= cnt) {
13+
k -= cnt;
14+
counter.remove(v);
15+
} else {
16+
break;
17+
}
18+
}
19+
return counter.size();
20+
}
21+
}

‎solution/1400-1499/1481.Least Number of Unique Integers after K Removals/Solution.py

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
class Solution:
2+
def findLeastNumOfUniqueInts(self, arr: List[int], k: int) -> int:
3+
counter = Counter(arr)
4+
t = sorted(counter.items(), key=lambda x: x[1])
5+
for v, cnt in t:
6+
if k >= cnt:
7+
k -= cnt
8+
counter.pop(v)
9+
else:
10+
break
11+
return len(counter)

0 commit comments

Comments
 (0)