Skip to content

Commit 922c34c

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.0822 (doocs#1369)
No.0822.Card Flipping Game
1 parent 35a53ef commit 922c34c

File tree

6 files changed

+195
-108
lines changed

6 files changed

+195
-108
lines changed

‎solution/0800-0899/0822.Card Flipping Game/README.md

+75-39
Original file line numberDiff line numberDiff line change
@@ -42,7 +42,15 @@
4242

4343
**方法一：哈希表**
4444

45-
对于位置 i，若 `fronts[i]` 与 `backs[i]` 元素相同，则一定不满足条件。找其他出现在 fronts 或 backs 中的元素的最小值即可。
45+
我们注意到，对于位置 $i$，若 $fronts[i]$ 与 $backs[i]$ 元素相同，则一定不满足条件。
46+
47+
因此，我们先找出正面与背面相同的元素，记录在哈希表 $s$ 中。
48+
49+
接下来，遍历正面与背面的元素，若元素 $x$ 不在哈希表 $s$ 中，则更新答案的最小值。
50+
51+
最后，若找到一个满足条件的元素，返回答案，否则返回 $0$。
52+
53+
时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是数组的长度。
4654

4755
<!-- tabs:start -->
4856

@@ -53,12 +61,8 @@
5361
```python
5462
class Solution:
5563
def flipgame(self, fronts: List[int], backs: List[int]) -> int:
56-
same = {a for a, b in zip(fronts, backs) if a == b}
57-
ans = 9999
58-
for x in chain(fronts, backs):
59-
if x not in same:
60-
ans = min(ans, x)
61-
return ans % 9999
64+
s = {a for a, b in zip(fronts, backs) if a == b}
65+
return min((x for x in chain(fronts, backs) if x not in s), default=0)
6266
```
6367

6468
### **Java**
@@ -99,16 +103,22 @@ public:
99103
int flipgame(vector<int>& fronts, vector<int>& backs) {
100104
unordered_set<int> s;
101105
int n = fronts.size();
102-
for (int i = 0; i < n; ++i)
103-
if (fronts[i] == backs[i])
106+
for (int i = 0; i < n; ++i) {
107+
if (fronts[i] == backs[i]) {
104108
s.insert(fronts[i]);
109+
}
110+
}
105111
int ans = 9999;
106-
for (int& v : fronts)
107-
if (!s.count(v))
112+
for (int& v : fronts) {
113+
if (!s.count(v)) {
108114
ans = min(ans, v);
109-
for (int& v : backs)
110-
if (!s.count(v))
115+
}
116+
}
117+
for (int& v : backs) {
118+
if (!s.count(v)) {
111119
ans = min(ans, v);
120+
}
121+
}
112122
return ans % 9999;
113123
}
114124
};
@@ -118,20 +128,20 @@ public:
118128
119129
```go
120130
func flipgame(fronts []int, backs []int) int {
121-
s := map[int]bool{}
122-
for i, v := range fronts {
123-
if v == backs[i] {
124-
s[v] = true
131+
s := map[int]struct{}{}
132+
for i, a := range fronts {
133+
if a == backs[i] {
134+
s[a] = struct{}{}
125135
}
126136
}
127137
ans := 9999
128138
for _, v := range fronts {
129-
if !s[v] {
139+
if _, ok := s[v]; !ok {
130140
ans = min(ans, v)
131141
}
132142
}
133143
for _, v := range backs {
134-
if !s[v] {
144+
if _, ok := s[v]; !ok {
135145
ans = min(ans, v)
136146
}
137147
}
@@ -150,26 +160,52 @@ func min(a, b int) int {
150160

151161
```ts
152162
function flipgame(fronts: number[], backs: number[]): number {
153-
const s: Set<number> = new Set();
154-
const n = fronts.length;
155-
for (let i = 0; i < n; ++i) {
156-
if (fronts[i] === backs[i]) {
157-
s.add(fronts[i]);
158-
}
159-
}
160-
let ans = 9999;
161-
for (const v of fronts) {
162-
if (!s.has(v)) {
163-
ans = Math.min(ans, v);
164-
}
165-
}
166-
for (const v of backs) {
167-
if (!s.has(v)) {
168-
ans = Math.min(ans, v);
169-
}
170-
}
171-
return ans % 9999;
172-
};
163+
const s: Set<number> = new Set();
164+
const n = fronts.length;
165+
for (let i = 0; i < n; ++i) {
166+
if (fronts[i] === backs[i]) {
167+
s.add(fronts[i]);
168+
}
169+
}
170+
let ans = 9999;
171+
for (const v of fronts) {
172+
if (!s.has(v)) {
173+
ans = Math.min(ans, v);
174+
}
175+
}
176+
for (const v of backs) {
177+
if (!s.has(v)) {
178+
ans = Math.min(ans, v);
179+
}
180+
}
181+
return ans % 9999;
182+
}
183+
```
184+
185+
### **C#**
186+
187+
```cs
188+
public class Solution {
189+
public int Flipgame(int[] fronts, int[] backs) {
190+
var s = new HashSet<int>();
191+
int n = fronts.Length;
192+
for (int i = 0; i < n; ++i) {
193+
if (fronts[i] == backs[i]) {
194+
s.Add(fronts[i]);
195+
}
196+
}
197+
int ans = 9999;
198+
for (int i = 0; i < n; ++i) {
199+
if (!s.Contains(fronts[i])) {
200+
ans = Math.Min(ans, fronts[i]);
201+
}
202+
if (!s.Contains(backs[i])) {
203+
ans = Math.Min(ans, backs[i]);
204+
}
205+
}
206+
return ans % 9999;
207+
}
208+
}
173209
```
174210

175211
### **...**

‎solution/0800-0899/0822.Card Flipping Game/README_EN.md

+66-38
Original file line numberDiff line numberDiff line change
@@ -49,12 +49,8 @@ There are no good integers no matter how we flip the cards, so we return 0.
4949
```python
5050
class Solution:
5151
def flipgame(self, fronts: List[int], backs: List[int]) -> int:
52-
same = {a for a, b in zip(fronts, backs) if a == b}
53-
ans = 9999
54-
for x in chain(fronts, backs):
55-
if x not in same:
56-
ans = min(ans, x)
57-
return ans % 9999
52+
s = {a for a, b in zip(fronts, backs) if a == b}
53+
return min((x for x in chain(fronts, backs) if x not in s), default=0)
5854
```
5955

6056
### **Java**
@@ -93,16 +89,22 @@ public:
9389
int flipgame(vector<int>& fronts, vector<int>& backs) {
9490
unordered_set<int> s;
9591
int n = fronts.size();
96-
for (int i = 0; i < n; ++i)
97-
if (fronts[i] == backs[i])
92+
for (int i = 0; i < n; ++i) {
93+
if (fronts[i] == backs[i]) {
9894
s.insert(fronts[i]);
95+
}
96+
}
9997
int ans = 9999;
100-
for (int& v : fronts)
101-
if (!s.count(v))
98+
for (int& v : fronts) {
99+
if (!s.count(v)) {
102100
ans = min(ans, v);
103-
for (int& v : backs)
104-
if (!s.count(v))
101+
}
102+
}
103+
for (int& v : backs) {
104+
if (!s.count(v)) {
105105
ans = min(ans, v);
106+
}
107+
}
106108
return ans % 9999;
107109
}
108110
};
@@ -112,20 +114,20 @@ public:
112114
113115
```go
114116
func flipgame(fronts []int, backs []int) int {
115-
s := map[int]bool{}
116-
for i, v := range fronts {
117-
if v == backs[i] {
118-
s[v] = true
117+
s := map[int]struct{}{}
118+
for i, a := range fronts {
119+
if a == backs[i] {
120+
s[a] = struct{}{}
119121
}
120122
}
121123
ans := 9999
122124
for _, v := range fronts {
123-
if !s[v] {
125+
if _, ok := s[v]; !ok {
124126
ans = min(ans, v)
125127
}
126128
}
127129
for _, v := range backs {
128-
if !s[v] {
130+
if _, ok := s[v]; !ok {
129131
ans = min(ans, v)
130132
}
131133
}
@@ -144,26 +146,52 @@ func min(a, b int) int {
144146

145147
```ts
146148
function flipgame(fronts: number[], backs: number[]): number {
147-
const s: Set<number> = new Set();
148-
const n = fronts.length;
149-
for (let i = 0; i < n; ++i) {
150-
if (fronts[i] === backs[i]) {
151-
s.add(fronts[i]);
152-
}
153-
}
154-
let ans = 9999;
155-
for (const v of fronts) {
156-
if (!s.has(v)) {
157-
ans = Math.min(ans, v);
158-
}
159-
}
160-
for (const v of backs) {
161-
if (!s.has(v)) {
162-
ans = Math.min(ans, v);
163-
}
164-
}
165-
return ans % 9999;
166-
};
149+
const s: Set<number> = new Set();
150+
const n = fronts.length;
151+
for (let i = 0; i < n; ++i) {
152+
if (fronts[i] === backs[i]) {
153+
s.add(fronts[i]);
154+
}
155+
}
156+
let ans = 9999;
157+
for (const v of fronts) {
158+
if (!s.has(v)) {
159+
ans = Math.min(ans, v);
160+
}
161+
}
162+
for (const v of backs) {
163+
if (!s.has(v)) {
164+
ans = Math.min(ans, v);
165+
}
166+
}
167+
return ans % 9999;
168+
}
169+
```
170+
171+
### **C#**
172+
173+
```cs
174+
public class Solution {
175+
public int Flipgame(int[] fronts, int[] backs) {
176+
var s = new HashSet<int>();
177+
int n = fronts.Length;
178+
for (int i = 0; i < n; ++i) {
179+
if (fronts[i] == backs[i]) {
180+
s.Add(fronts[i]);
181+
}
182+
}
183+
int ans = 9999;
184+
for (int i = 0; i < n; ++i) {
185+
if (!s.Contains(fronts[i])) {
186+
ans = Math.Min(ans, fronts[i]);
187+
}
188+
if (!s.Contains(backs[i])) {
189+
ans = Math.Min(ans, backs[i]);
190+
}
191+
}
192+
return ans % 9999;
193+
}
194+
}
167195
```
168196

169197
### **...**

‎solution/0800-0899/0822.Card Flipping Game/Solution.cpp

+23-17
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,24 @@
1-
class Solution {
2-
public:
3-
int flipgame(vector<int>& fronts, vector<int>& backs) {
4-
unordered_set<int> s;
5-
int n = fronts.size();
6-
for (int i = 0; i < n; ++i)
7-
if (fronts[i] == backs[i])
8-
s.insert(fronts[i]);
9-
int ans = 9999;
10-
for (int& v : fronts)
11-
if (!s.count(v))
12-
ans = min(ans, v);
13-
for (int& v : backs)
14-
if (!s.count(v))
15-
ans = min(ans, v);
16-
return ans % 9999;
17-
}
1+
class Solution {
2+
public:
3+
int flipgame(vector<int>& fronts, vector<int>& backs) {
4+
unordered_set<int> s;
5+
int n = fronts.size();
6+
for (int i = 0; i < n; ++i) {
7+
if (fronts[i] == backs[i]) {
8+
s.insert(fronts[i]);
9+
}
10+
}
11+
int ans = 9999;
12+
for (int& v : fronts) {
13+
if (!s.count(v)) {
14+
ans = min(ans, v);
15+
}
16+
}
17+
for (int& v : backs) {
18+
if (!s.count(v)) {
19+
ans = min(ans, v);
20+
}
21+
}
22+
return ans % 9999;
23+
}
1824
};

‎solution/0800-0899/0822.Card Flipping Game/Solution.cs

+21
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
public class Solution {
2+
public int Flipgame(int[] fronts, int[] backs) {
3+
var s = new HashSet<int>();
4+
int n = fronts.Length;
5+
for (int i = 0; i < n; ++i) {
6+
if (fronts[i] == backs[i]) {
7+
s.Add(fronts[i]);
8+
}
9+
}
10+
int ans = 9999;
11+
for (int i = 0; i < n; ++i) {
12+
if (!s.Contains(fronts[i])) {
13+
ans = Math.Min(ans, fronts[i]);
14+
}
15+
if (!s.Contains(backs[i])) {
16+
ans = Math.Min(ans, backs[i]);
17+
}
18+
}
19+
return ans % 9999;
20+
}
21+
}

‎solution/0800-0899/0822.Card Flipping Game/Solution.go

+6-6
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,18 @@
11
func flipgame(fronts []int, backs []int) int {
2-
s := map[int]bool{}
3-
for i, v := range fronts {
4-
if v == backs[i] {
5-
s[v] = true
2+
s := map[int]struct{}{}
3+
for i, a := range fronts {
4+
if a == backs[i] {
5+
s[a] = struct{}{}
66
}
77
}
88
ans := 9999
99
for _, v := range fronts {
10-
if !s[v] {
10+
if _, ok := s[v]; !ok {
1111
ans = min(ans, v)
1212
}
1313
}
1414
for _, v := range backs {
15-
if !s[v] {
15+
if _, ok := s[v]; !ok {
1616
ans = min(ans, v)
1717
}
1818
}

0 commit comments

Comments
 (0)