Skip to content

Commit 95d0209

Browse files
YangFongYangFong
committed
feat: add solutions to lc problems: No.0217, 1356
- No.0217.Contains Duplicate - No.1356.Sort Integers by The Number of 1 Bits
1 parent ab7e4b7 commit 95d0209

File tree

9 files changed

+239
-94
lines changed

9 files changed

+239
-94
lines changed

‎solution/0200-0299/0217.Contains Duplicate/README.md

+55-25
Original file line numberDiff line numberDiff line change
@@ -161,25 +161,6 @@ func containsDuplicate(nums []int) bool {
161161
}
162162
```
163163

164-
### **TypeScript**
165-
166-
```ts
167-
function containsDuplicate(nums: number[]): boolean {
168-
let unique: Set<number> = new Set(nums);
169-
return unique.size != nums.length;
170-
}
171-
```
172-
173-
### **C#**
174-
175-
```cs
176-
public class Solution {
177-
public bool ContainsDuplicate(int[] nums) {
178-
return nums.Distinct().Count() < nums.Length;
179-
}
180-
}
181-
```
182-
183164
### **JavaScript**
184165

185166
```js
@@ -192,17 +173,29 @@ var containsDuplicate = function (nums) {
192173
};
193174
```
194175

195-
### **Rust**
176+
### **TypeScript**
196177

197-
```rust
198-
use std::collections::HashSet;
199-
impl Solution {
200-
pub fn contains_duplicate(nums: Vec<i32>) -> bool {
201-
nums.iter().collect::<HashSet<&i32>>().len() != nums.len()
178+
```ts
179+
function containsDuplicate(nums: number[]): boolean {
180+
nums.sort((a, b) => a - b);
181+
const n = nums.length;
182+
for (let i = 1; i < n; i++) {
183+
if (nums[i - 1] === nums[i]) {
184+
return true;
185+
}
202186
}
187+
return false;
203188
}
204189
```
205190

191+
```ts
192+
function containsDuplicate(nums: number[]): boolean {
193+
return new Set<number>(nums).size !== nums.length;
194+
}
195+
```
196+
197+
### **Rust**
198+
206199
```rust
207200
impl Solution {
208201
pub fn contains_duplicate(mut nums: Vec<i32>) -> bool {
@@ -218,6 +211,43 @@ impl Solution {
218211
}
219212
```
220213

214+
```rust
215+
use std::collections::HashSet;
216+
impl Solution {
217+
pub fn contains_duplicate(nums: Vec<i32>) -> bool {
218+
nums.iter().collect::<HashSet<&i32>>().len() != nums.len()
219+
}
220+
}
221+
```
222+
223+
### **C**
224+
225+
```c
226+
int cmp(const void *a, const void *b) {
227+
return *(int *) a - *(int *) b;
228+
}
229+
230+
bool containsDuplicate(int *nums, int numsSize) {
231+
qsort(nums, numsSize, sizeof(int), cmp);
232+
for (int i = 1; i < numsSize; i++) {
233+
if (nums[i - 1] == nums[i]) {
234+
return 1;
235+
}
236+
}
237+
return 0;
238+
}
239+
```
240+
241+
### **C#**
242+
243+
```cs
244+
public class Solution {
245+
public bool ContainsDuplicate(int[] nums) {
246+
return nums.Distinct().Count() < nums.Length;
247+
}
248+
}
249+
```
250+
221251
### **...**
222252

223253
```

‎solution/0200-0299/0217.Contains Duplicate/README_EN.md

+55-25
Original file line numberDiff line numberDiff line change
@@ -127,25 +127,6 @@ func containsDuplicate(nums []int) bool {
127127
}
128128
```
129129

130-
### **TypeScript**
131-
132-
```ts
133-
function containsDuplicate(nums: number[]): boolean {
134-
let unique: Set<number> = new Set(nums);
135-
return unique.size != nums.length;
136-
}
137-
```
138-
139-
### **C#**
140-
141-
```cs
142-
public class Solution {
143-
public bool ContainsDuplicate(int[] nums) {
144-
return nums.Distinct().Count() < nums.Length;
145-
}
146-
}
147-
```
148-
149130
### **JavaScript**
150131

151132
```js
@@ -158,17 +139,29 @@ var containsDuplicate = function (nums) {
158139
};
159140
```
160141

161-
### **Rust**
142+
### **TypeScript**
162143

163-
```rust
164-
use std::collections::HashSet;
165-
impl Solution {
166-
pub fn contains_duplicate(nums: Vec<i32>) -> bool {
167-
nums.iter().collect::<HashSet<&i32>>().len() != nums.len()
144+
```ts
145+
function containsDuplicate(nums: number[]): boolean {
146+
nums.sort((a, b) => a - b);
147+
const n = nums.length;
148+
for (let i = 1; i < n; i++) {
149+
if (nums[i - 1] === nums[i]) {
150+
return true;
151+
}
168152
}
153+
return false;
169154
}
170155
```
171156

157+
```ts
158+
function containsDuplicate(nums: number[]): boolean {
159+
return new Set<number>(nums).size !== nums.length;
160+
}
161+
```
162+
163+
### **Rust**
164+
172165
```rust
173166
impl Solution {
174167
pub fn contains_duplicate(mut nums: Vec<i32>) -> bool {
@@ -184,6 +177,43 @@ impl Solution {
184177
}
185178
```
186179

180+
```rust
181+
use std::collections::HashSet;
182+
impl Solution {
183+
pub fn contains_duplicate(nums: Vec<i32>) -> bool {
184+
nums.iter().collect::<HashSet<&i32>>().len() != nums.len()
185+
}
186+
}
187+
```
188+
189+
### **C**
190+
191+
```c
192+
int cmp(const void *a, const void *b) {
193+
return *(int *) a - *(int *) b;
194+
}
195+
196+
bool containsDuplicate(int *nums, int numsSize) {
197+
qsort(nums, numsSize, sizeof(int), cmp);
198+
for (int i = 1; i < numsSize; i++) {
199+
if (nums[i - 1] == nums[i]) {
200+
return 1;
201+
}
202+
}
203+
return 0;
204+
}
205+
```
206+
207+
### **C#**
208+
209+
```cs
210+
public class Solution {
211+
public bool ContainsDuplicate(int[] nums) {
212+
return nums.Distinct().Count() < nums.Length;
213+
}
214+
}
215+
```
216+
187217
### **...**
188218

189219
```

‎solution/0200-0299/0217.Contains Duplicate/Solution.c

+13
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,13 @@
1+
int cmp(const void *a, const void *b) {
2+
return *(int *) a - *(int *) b;
3+
}
4+
5+
bool containsDuplicate(int *nums, int numsSize) {
6+
qsort(nums, numsSize, sizeof(int), cmp);
7+
for (int i = 1; i < numsSize; i++) {
8+
if (nums[i - 1] == nums[i]) {
9+
return 1;
10+
}
11+
}
12+
return 0;
13+
}

‎solution/0200-0299/0217.Contains Duplicate/Solution.ts

+1-2
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
11
function containsDuplicate(nums: number[]): boolean {
2-
let unique: Set<number> = new Set(nums);
3-
return unique.size != nums.length;
2+
return new Set<number>(nums).size !== nums.length;
43
}

‎solution/1300-1399/1356.Sort Integers by The Number of 1 Bits/README.md

+40-14
Original file line numberDiff line numberDiff line change
@@ -100,21 +100,15 @@ class Solution {
100100

101101
```ts
102102
function sortByBits(arr: number[]): number[] {
103-
const countOnes = (num: number) => {
104-
let count = 0;
105-
while (num !== 0) {
106-
num &= num - 1;
107-
count++;
108-
}
109-
return count;
110-
};
111-
return arr.sort((a, b) => {
112-
let res = countOnes(a) - countOnes(b);
113-
if (res === 0) {
114-
return a - b;
103+
const countOnes = (n: number) => {
104+
let res = 0;
105+
while (n) {
106+
n &= n - 1;
107+
res++;
115108
}
116109
return res;
117-
});
110+
};
111+
return arr.sort((a, b) => countOnes(a) - countOnes(b) || a - b);
118112
}
119113
```
120114

@@ -123,7 +117,7 @@ function sortByBits(arr: number[]): number[] {
123117
```rust
124118
impl Solution {
125119
pub fn sort_by_bits(mut arr: Vec<i32>) -> Vec<i32> {
126-
arr.sort_unstable_by(|a, b| {
120+
arr.sort_by(|a, b| {
127121
let res = a.count_ones().cmp(&b.count_ones());
128122
if res == std::cmp::Ordering::Equal {
129123
return a.cmp(&b);
@@ -135,6 +129,38 @@ impl Solution {
135129
}
136130
```
137131

132+
### **C**
133+
134+
```c
135+
/**
136+
* Note: The returned array must be malloced, assume caller calls free().
137+
*/
138+
int countOnes(int n) {
139+
int res = 0;
140+
while (n) {
141+
n &= n - 1;
142+
res++;
143+
}
144+
return res;
145+
}
146+
147+
int cmp(const void *_a, const void *_b) {
148+
int a = *(int *) _a;
149+
int b = *(int *) _b;
150+
int res = countOnes(a) - countOnes(b);
151+
if (res == 0) {
152+
return a - b;
153+
}
154+
return res;
155+
}
156+
157+
int *sortByBits(int *arr, int arrSize, int *returnSize) {
158+
qsort(arr, arrSize, sizeof(int), cmp);
159+
*returnSize = arrSize;
160+
return arr;
161+
}
162+
```
163+
138164
### **...**
139165
140166
```

‎solution/1300-1399/1356.Sort Integers by The Number of 1 Bits/README_EN.md

+40-14
Original file line numberDiff line numberDiff line change
@@ -72,21 +72,15 @@ class Solution {
7272

7373
```ts
7474
function sortByBits(arr: number[]): number[] {
75-
const countOnes = (num: number) => {
76-
let count = 0;
77-
while (num !== 0) {
78-
num &= num - 1;
79-
count++;
80-
}
81-
return count;
82-
};
83-
return arr.sort((a, b) => {
84-
let res = countOnes(a) - countOnes(b);
85-
if (res === 0) {
86-
return a - b;
75+
const countOnes = (n: number) => {
76+
let res = 0;
77+
while (n) {
78+
n &= n - 1;
79+
res++;
8780
}
8881
return res;
89-
});
82+
};
83+
return arr.sort((a, b) => countOnes(a) - countOnes(b) || a - b);
9084
}
9185
```
9286

@@ -95,7 +89,7 @@ function sortByBits(arr: number[]): number[] {
9589
```rust
9690
impl Solution {
9791
pub fn sort_by_bits(mut arr: Vec<i32>) -> Vec<i32> {
98-
arr.sort_unstable_by(|a, b| {
92+
arr.sort_by(|a, b| {
9993
let res = a.count_ones().cmp(&b.count_ones());
10094
if res == std::cmp::Ordering::Equal {
10195
return a.cmp(&b);
@@ -107,6 +101,38 @@ impl Solution {
107101
}
108102
```
109103

104+
### **C**
105+
106+
```c
107+
/**
108+
* Note: The returned array must be malloced, assume caller calls free().
109+
*/
110+
int countOnes(int n) {
111+
int res = 0;
112+
while (n) {
113+
n &= n - 1;
114+
res++;
115+
}
116+
return res;
117+
}
118+
119+
int cmp(const void *_a, const void *_b) {
120+
int a = *(int *) _a;
121+
int b = *(int *) _b;
122+
int res = countOnes(a) - countOnes(b);
123+
if (res == 0) {
124+
return a - b;
125+
}
126+
return res;
127+
}
128+
129+
int *sortByBits(int *arr, int arrSize, int *returnSize) {
130+
qsort(arr, arrSize, sizeof(int), cmp);
131+
*returnSize = arrSize;
132+
return arr;
133+
}
134+
```
135+
110136
### **...**
111137
112138
```

0 commit comments

Comments
 (0)