Skip to content

Commit 62e248f

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problem: No.0090
No.0090.Subsets II
1 parent b13b1d1 commit 62e248f

File tree

9 files changed

+358
-15
lines changed

9 files changed

+358
-15
lines changed

‎solution/0000-0099/0090.Subsets II/README.md‎

Lines changed: 125 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -133,11 +133,11 @@ class Solution {
133133
class Solution {
134134
public:
135135
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
136-
sort(nums.begin(), nums.end());
136+
ranges::sort(nums);
137137
vector<vector<int>> ans;
138138
vector<int> t;
139139
int n = nums.size();
140-
function<void(int)> dfs = [&](int i) {
140+
auto dfs = [&](this auto&& dfs, int i) {
141141
if (i >= n) {
142142
ans.push_back(t);
143143
return;
@@ -160,7 +160,7 @@ public:
160160
161161
```go
162162
func subsetsWithDup(nums []int) (ans [][]int) {
163-
sort.Ints(nums)
163+
slices.Sort(nums)
164164
n := len(nums)
165165
t := []int{}
166166
var dfs func(int)
@@ -239,6 +239,67 @@ impl Solution {
239239
}
240240
```
241241

242+
#### JavaScript
243+
244+
```js
245+
/**
246+
* @param {number[]} nums
247+
* @return {number[][]}
248+
*/
249+
var subsetsWithDup = function (nums) {
250+
nums.sort((a, b) => a - b);
251+
const n = nums.length;
252+
const t = [];
253+
const ans = [];
254+
const dfs = i => {
255+
if (i >= n) {
256+
ans.push([...t]);
257+
return;
258+
}
259+
t.push(nums[i]);
260+
dfs(i + 1);
261+
t.pop();
262+
while (i + 1 < n && nums[i] === nums[i + 1]) {
263+
i++;
264+
}
265+
dfs(i + 1);
266+
};
267+
dfs(0);
268+
return ans;
269+
};
270+
```
271+
272+
#### C#
273+
274+
```cs
275+
public class Solution {
276+
private IList<IList<int>> ans = new List<IList<int>>();
277+
private IList<int> t = new List<int>();
278+
private int[] nums;
279+
280+
public IList<IList<int>> SubsetsWithDup(int[] nums) {
281+
Array.Sort(nums);
282+
this.nums = nums;
283+
Dfs(0);
284+
return ans;
285+
}
286+
287+
private void Dfs(int i) {
288+
if (i >= nums.Length) {
289+
ans.Add(new List<int>(t));
290+
return;
291+
}
292+
t.Add(nums[i]);
293+
Dfs(i + 1);
294+
t.RemoveAt(t.Count - 1);
295+
while (i + 1 < nums.Length && nums[i + 1] == nums[i]) {
296+
++i;
297+
}
298+
Dfs(i + 1);
299+
}
300+
}
301+
```
302+
242303
<!-- tabs:end -->
243304

244305
<!-- solution:end -->
@@ -314,7 +375,7 @@ class Solution {
314375
class Solution {
315376
public:
316377
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
317-
sort(nums.begin(), nums.end());
378+
ranges::sort(nums);
318379
int n = nums.size();
319380
vector<vector<int>> ans;
320381
for (int mask = 0; mask < 1 << n; ++mask) {
@@ -421,6 +482,66 @@ impl Solution {
421482
}
422483
```
423484

485+
#### JavaScript
486+
487+
```js
488+
/**
489+
* @param {number[]} nums
490+
* @return {number[][]}
491+
*/
492+
var subsetsWithDup = function (nums) {
493+
nums.sort((a, b) => a - b);
494+
const n = nums.length;
495+
const ans = [];
496+
for (let mask = 0; mask < 1 << n; ++mask) {
497+
const t = [];
498+
let ok = true;
499+
for (let i = 0; i < n; ++i) {
500+
if (((mask >> i) & 1) === 1) {
501+
if (i && ((mask >> (i - 1)) & 1) === 0 && nums[i] === nums[i - 1]) {
502+
ok = false;
503+
break;
504+
}
505+
t.push(nums[i]);
506+
}
507+
}
508+
if (ok) {
509+
ans.push(t);
510+
}
511+
}
512+
return ans;
513+
};
514+
```
515+
516+
#### C#
517+
518+
```cs
519+
public class Solution {
520+
public IList<IList<int>> SubsetsWithDup(int[] nums) {
521+
Array.Sort(nums);
522+
int n = nums.Length;
523+
IList<IList<int>> ans = new List<IList<int>>();
524+
for (int mask = 0; mask < 1 << n; ++mask) {
525+
IList<int> t = new List<int>();
526+
bool ok = true;
527+
for (int i = 0; i < n; ++i) {
528+
if ((mask >> i & 1) == 1) {
529+
if (i > 0 && (mask >> (i - 1) & 1) == 0 && nums[i] == nums[i - 1]) {
530+
ok = false;
531+
break;
532+
}
533+
t.Add(nums[i]);
534+
}
535+
}
536+
if (ok) {
537+
ans.Add(t);
538+
}
539+
}
540+
return ans;
541+
}
542+
}
543+
```
544+
424545
<!-- tabs:end -->
425546

426547
<!-- solution:end -->

‎solution/0000-0099/0090.Subsets II/README_EN.md‎

Lines changed: 125 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -120,11 +120,11 @@ class Solution {
120120
class Solution {
121121
public:
122122
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
123-
sort(nums.begin(), nums.end());
123+
ranges::sort(nums);
124124
vector<vector<int>> ans;
125125
vector<int> t;
126126
int n = nums.size();
127-
function<void(int)> dfs = [&](int i) {
127+
auto dfs = [&](this auto&& dfs, int i) {
128128
if (i >= n) {
129129
ans.push_back(t);
130130
return;
@@ -147,7 +147,7 @@ public:
147147
148148
```go
149149
func subsetsWithDup(nums []int) (ans [][]int) {
150-
sort.Ints(nums)
150+
slices.Sort(nums)
151151
n := len(nums)
152152
t := []int{}
153153
var dfs func(int)
@@ -226,6 +226,67 @@ impl Solution {
226226
}
227227
```
228228

229+
#### JavaScript
230+
231+
```js
232+
/**
233+
* @param {number[]} nums
234+
* @return {number[][]}
235+
*/
236+
var subsetsWithDup = function (nums) {
237+
nums.sort((a, b) => a - b);
238+
const n = nums.length;
239+
const t = [];
240+
const ans = [];
241+
const dfs = i => {
242+
if (i >= n) {
243+
ans.push([...t]);
244+
return;
245+
}
246+
t.push(nums[i]);
247+
dfs(i + 1);
248+
t.pop();
249+
while (i + 1 < n && nums[i] === nums[i + 1]) {
250+
i++;
251+
}
252+
dfs(i + 1);
253+
};
254+
dfs(0);
255+
return ans;
256+
};
257+
```
258+
259+
#### C#
260+
261+
```cs
262+
public class Solution {
263+
private IList<IList<int>> ans = new List<IList<int>>();
264+
private IList<int> t = new List<int>();
265+
private int[] nums;
266+
267+
public IList<IList<int>> SubsetsWithDup(int[] nums) {
268+
Array.Sort(nums);
269+
this.nums = nums;
270+
Dfs(0);
271+
return ans;
272+
}
273+
274+
private void Dfs(int i) {
275+
if (i >= nums.Length) {
276+
ans.Add(new List<int>(t));
277+
return;
278+
}
279+
t.Add(nums[i]);
280+
Dfs(i + 1);
281+
t.RemoveAt(t.Count - 1);
282+
while (i + 1 < nums.Length && nums[i + 1] == nums[i]) {
283+
++i;
284+
}
285+
Dfs(i + 1);
286+
}
287+
}
288+
```
289+
229290
<!-- tabs:end -->
230291

231292
<!-- solution:end -->
@@ -301,7 +362,7 @@ class Solution {
301362
class Solution {
302363
public:
303364
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
304-
sort(nums.begin(), nums.end());
365+
ranges::sort(nums);
305366
int n = nums.size();
306367
vector<vector<int>> ans;
307368
for (int mask = 0; mask < 1 << n; ++mask) {
@@ -408,6 +469,66 @@ impl Solution {
408469
}
409470
```
410471

472+
#### JavaScript
473+
474+
```js
475+
/**
476+
* @param {number[]} nums
477+
* @return {number[][]}
478+
*/
479+
var subsetsWithDup = function (nums) {
480+
nums.sort((a, b) => a - b);
481+
const n = nums.length;
482+
const ans = [];
483+
for (let mask = 0; mask < 1 << n; ++mask) {
484+
const t = [];
485+
let ok = true;
486+
for (let i = 0; i < n; ++i) {
487+
if (((mask >> i) & 1) === 1) {
488+
if (i && ((mask >> (i - 1)) & 1) === 0 && nums[i] === nums[i - 1]) {
489+
ok = false;
490+
break;
491+
}
492+
t.push(nums[i]);
493+
}
494+
}
495+
if (ok) {
496+
ans.push(t);
497+
}
498+
}
499+
return ans;
500+
};
501+
```
502+
503+
#### C#
504+
505+
```cs
506+
public class Solution {
507+
public IList<IList<int>> SubsetsWithDup(int[] nums) {
508+
Array.Sort(nums);
509+
int n = nums.Length;
510+
IList<IList<int>> ans = new List<IList<int>>();
511+
for (int mask = 0; mask < 1 << n; ++mask) {
512+
IList<int> t = new List<int>();
513+
bool ok = true;
514+
for (int i = 0; i < n; ++i) {
515+
if ((mask >> i & 1) == 1) {
516+
if (i > 0 && (mask >> (i - 1) & 1) == 0 && nums[i] == nums[i - 1]) {
517+
ok = false;
518+
break;
519+
}
520+
t.Add(nums[i]);
521+
}
522+
}
523+
if (ok) {
524+
ans.Add(t);
525+
}
526+
}
527+
return ans;
528+
}
529+
}
530+
```
531+
411532
<!-- tabs:end -->
412533

413534
<!-- solution:end -->

‎solution/0000-0099/0090.Subsets II/Solution.cpp‎

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,11 +1,11 @@
11
class Solution {
22
public:
33
vector<vector<int>> subsetsWithDup(vector<int>& nums) {
4-
sort(nums.begin(), nums.end());
4+
ranges::sort(nums);
55
vector<vector<int>> ans;
66
vector<int> t;
77
int n = nums.size();
8-
function<void(int)> dfs = [&](int i) {
8+
auto dfs = [&](this auto&& dfs, int i) {
99
if (i >= n) {
1010
ans.push_back(t);
1111
return;
@@ -21,4 +21,4 @@ class Solution {
2121
dfs(0);
2222
return ans;
2323
}
24-
};
24+
};

‎solution/0000-0099/0090.Subsets II/Solution.cs‎

Lines changed: 26 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,26 @@
1+
public class Solution {
2+
private IList<IList<int>> ans = new List<IList<int>>();
3+
private IList<int> t = new List<int>();
4+
private int[] nums;
5+
6+
public IList<IList<int>> SubsetsWithDup(int[] nums) {
7+
Array.Sort(nums);
8+
this.nums = nums;
9+
Dfs(0);
10+
return ans;
11+
}
12+
13+
private void Dfs(int i) {
14+
if (i >= nums.Length) {
15+
ans.Add(new List<int>(t));
16+
return;
17+
}
18+
t.Add(nums[i]);
19+
Dfs(i + 1);
20+
t.RemoveAt(t.Count - 1);
21+
while (i + 1 < nums.Length && nums[i + 1] == nums[i]) {
22+
++i;
23+
}
24+
Dfs(i + 1);
25+
}
26+
}

‎solution/0000-0099/0090.Subsets II/Solution.go‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
func subsetsWithDup(nums []int) (ans [][]int) {
2-
sort.Ints(nums)
2+
slices.Sort(nums)
33
n := len(nums)
44
t := []int{}
55
var dfs func(int)
@@ -18,4 +18,4 @@ func subsetsWithDup(nums []int) (ans [][]int) {
1818
}
1919
dfs(0)
2020
return
21-
}
21+
}

0 commit comments

Comments
 (0)