Skip to content

Commit 957336b

Browse files
yanglbmeyanglbme
authored
feat: add solutions to lc problem: No.2220 (doocs#3977)
No.2220.Minimum Bit Flips to Convert Number
1 parent 426b9e9 commit 957336b

File tree

12 files changed

+132
-199
lines changed

12 files changed

+132
-199
lines changed

‎solution/2200-2299/2220.Minimum Bit Flips to Convert Number/README.md‎

Lines changed: 46 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -69,7 +69,11 @@ tags:
6969

7070
<!-- solution:start -->
7171

72-
### 方法一
72+
### 方法一：位运算
73+
74+
根据题目描述，我们只需要计算 $\textit{start} \oplus \textit{goal}$ 的二进制表示中有多少个 1 即可。
75+
76+
时间复杂度 $O(\log n)$，其中 $n$ 是题目中整数的大小。空间复杂度 $O(1)$。
7377

7478
<!-- tabs:start -->
7579

@@ -78,26 +82,15 @@ tags:
7882
```python
7983
class Solution:
8084
def minBitFlips(self, start: int, goal: int) -> int:
81-
t = start ^ goal
82-
ans = 0
83-
while t:
84-
ans += t & 1
85-
t >>= 1
86-
return ans
85+
return (start ^ goal).bit_count()
8786
```
8887

8988
#### Java
9089

9190
```java
9291
class Solution {
9392
public int minBitFlips(int start, int goal) {
94-
int t = start ^ goal;
95-
int ans = 0;
96-
while (t != 0) {
97-
ans += t & 1;
98-
t >>= 1;
99-
}
100-
return ans;
93+
return Integer.bitCount(start ^ goal);
10194
}
10295
}
10396
```
@@ -108,13 +101,7 @@ class Solution {
108101
class Solution {
109102
public:
110103
int minBitFlips(int start, int goal) {
111-
int t = start ^ goal;
112-
int ans = 0;
113-
while (t) {
114-
ans += t & 1;
115-
t >>= 1;
116-
}
117-
return ans;
104+
return __builtin_popcount(start ^ goal);
118105
}
119106
};
120107
```
@@ -123,27 +110,24 @@ public:
123110
124111
```go
125112
func minBitFlips(start int, goal int) int {
126-
t := start ^ goal
127-
ans := 0
128-
for t != 0 {
129-
ans += t & 1
130-
t >>= 1
131-
}
132-
return ans
113+
return bits.OnesCount(uint(start ^ goal))
133114
}
134115
```
135116

136117
#### TypeScript
137118

138119
```ts
139120
function minBitFlips(start: number, goal: number): number {
140-
let tmp = start ^ goal;
141-
let ans = 0;
142-
while (tmp !== 0) {
143-
ans += tmp & 1;
144-
tmp >>= 1;
145-
}
146-
return ans;
121+
return bitCount(start ^ goal);
122+
}
123+
124+
function bitCount(i: number): number {
125+
i = i - ((i >>> 1) & 0x55555555);
126+
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
127+
i = (i + (i >>> 4)) & 0x0f0f0f0f;
128+
i = i + (i >>> 8);
129+
i = i + (i >>> 16);
130+
return i & 0x3f;
147131
}
148132
```
149133

@@ -152,26 +136,42 @@ function minBitFlips(start: number, goal: number): number {
152136
```rust
153137
impl Solution {
154138
pub fn min_bit_flips(start: i32, goal: i32) -> i32 {
155-
let mut tmp = start ^ goal;
156-
let mut ans = 0;
157-
while tmp != 0 {
158-
ans += tmp & 1;
159-
tmp >>= 1;
160-
}
161-
ans
139+
(start ^ goal).count_ones() as i32
162140
}
163141
}
164142
```
165143

144+
#### JavaScript
145+
146+
```js
147+
/**
148+
* @param {number} start
149+
* @param {number} goal
150+
* @return {number}
151+
*/
152+
var minBitFlips = function (start, goal) {
153+
return bitCount(start ^ goal);
154+
};
155+
156+
function bitCount(i) {
157+
i = i - ((i >>> 1) & 0x55555555);
158+
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
159+
i = (i + (i >>> 4)) & 0x0f0f0f0f;
160+
i = i + (i >>> 8);
161+
i = i + (i >>> 16);
162+
return i & 0x3f;
163+
}
164+
```
165+
166166
#### C
167167

168168
```c
169169
int minBitFlips(int start, int goal) {
170-
int tmp = start ^ goal;
170+
int x = start ^ goal;
171171
int ans = 0;
172-
while (tmp) {
173-
ans += tmp & 1;
174-
tmp >>= 1;
172+
while (x) {
173+
ans += (x & 1);
174+
x >>= 1;
175175
}
176176
return ans;
177177
}
@@ -181,30 +181,4 @@ int minBitFlips(int start, int goal) {
181181
182182
<!-- solution:end -->
183183
184-
<!-- solution:start -->
185-
186-
### Solution 2
187-
188-
<!-- tabs:start -->
189-
190-
#### TypeScript
191-
192-
```ts
193-
function minBitFlips(start: number, goal: number): number {
194-
return (start ^ goal).toString(2).replace(/0/g, '').length;
195-
}
196-
```
197-
198-
#### JavaScript
199-
200-
```js
201-
function minBitFlips(start, goal) {
202-
return (start ^ goal).toString(2).replace(/0/g, '').length;
203-
}
204-
```
205-
206-
<!-- tabs:end -->
207-
208-
<!-- solution:end -->
209-
210184
<!-- problem:end -->

‎solution/2200-2299/2220.Minimum Bit Flips to Convert Number/README_EN.md‎

Lines changed: 46 additions & 72 deletions
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,11 @@ It can be shown we cannot convert 3 to 4 in less than 3 steps. Hence, we return
6666

6767
<!-- solution:start -->
6868

69-
### Solution 1
69+
### Solution 1: Bit Manipulation
70+
71+
According to the problem description, we only need to count the number of 1s in the binary representation of $\textit{start} \oplus \textit{goal}$.
72+
73+
The time complexity is $O(\log n)$, where $n$ is the size of the integers in the problem. The space complexity is $O(1)$.
7074

7175
<!-- tabs:start -->
7276

@@ -75,26 +79,15 @@ It can be shown we cannot convert 3 to 4 in less than 3 steps. Hence, we return
7579
```python
7680
class Solution:
7781
def minBitFlips(self, start: int, goal: int) -> int:
78-
t = start ^ goal
79-
ans = 0
80-
while t:
81-
ans += t & 1
82-
t >>= 1
83-
return ans
82+
return (start ^ goal).bit_count()
8483
```
8584

8685
#### Java
8786

8887
```java
8988
class Solution {
9089
public int minBitFlips(int start, int goal) {
91-
int t = start ^ goal;
92-
int ans = 0;
93-
while (t != 0) {
94-
ans += t & 1;
95-
t >>= 1;
96-
}
97-
return ans;
90+
return Integer.bitCount(start ^ goal);
9891
}
9992
}
10093
```
@@ -105,13 +98,7 @@ class Solution {
10598
class Solution {
10699
public:
107100
int minBitFlips(int start, int goal) {
108-
int t = start ^ goal;
109-
int ans = 0;
110-
while (t) {
111-
ans += t & 1;
112-
t >>= 1;
113-
}
114-
return ans;
101+
return __builtin_popcount(start ^ goal);
115102
}
116103
};
117104
```
@@ -120,27 +107,24 @@ public:
120107
121108
```go
122109
func minBitFlips(start int, goal int) int {
123-
t := start ^ goal
124-
ans := 0
125-
for t != 0 {
126-
ans += t & 1
127-
t >>= 1
128-
}
129-
return ans
110+
return bits.OnesCount(uint(start ^ goal))
130111
}
131112
```
132113

133114
#### TypeScript
134115

135116
```ts
136117
function minBitFlips(start: number, goal: number): number {
137-
let tmp = start ^ goal;
138-
let ans = 0;
139-
while (tmp !== 0) {
140-
ans += tmp & 1;
141-
tmp >>= 1;
142-
}
143-
return ans;
118+
return bitCount(start ^ goal);
119+
}
120+
121+
function bitCount(i: number): number {
122+
i = i - ((i >>> 1) & 0x55555555);
123+
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
124+
i = (i + (i >>> 4)) & 0x0f0f0f0f;
125+
i = i + (i >>> 8);
126+
i = i + (i >>> 16);
127+
return i & 0x3f;
144128
}
145129
```
146130

@@ -149,26 +133,42 @@ function minBitFlips(start: number, goal: number): number {
149133
```rust
150134
impl Solution {
151135
pub fn min_bit_flips(start: i32, goal: i32) -> i32 {
152-
let mut tmp = start ^ goal;
153-
let mut ans = 0;
154-
while tmp != 0 {
155-
ans += tmp & 1;
156-
tmp >>= 1;
157-
}
158-
ans
136+
(start ^ goal).count_ones() as i32
159137
}
160138
}
161139
```
162140

141+
#### JavaScript
142+
143+
```js
144+
/**
145+
* @param {number} start
146+
* @param {number} goal
147+
* @return {number}
148+
*/
149+
var minBitFlips = function (start, goal) {
150+
return bitCount(start ^ goal);
151+
};
152+
153+
function bitCount(i) {
154+
i = i - ((i >>> 1) & 0x55555555);
155+
i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
156+
i = (i + (i >>> 4)) & 0x0f0f0f0f;
157+
i = i + (i >>> 8);
158+
i = i + (i >>> 16);
159+
return i & 0x3f;
160+
}
161+
```
162+
163163
#### C
164164

165165
```c
166166
int minBitFlips(int start, int goal) {
167-
int tmp = start ^ goal;
167+
int x = start ^ goal;
168168
int ans = 0;
169-
while (tmp) {
170-
ans += tmp & 1;
171-
tmp >>= 1;
169+
while (x) {
170+
ans += (x & 1);
171+
x >>= 1;
172172
}
173173
return ans;
174174
}
@@ -178,30 +178,4 @@ int minBitFlips(int start, int goal) {
178178
179179
<!-- solution:end -->
180180
181-
<!-- solution:start -->
182-
183-
### Solution 2
184-
185-
<!-- tabs:start -->
186-
187-
#### TypeScript
188-
189-
```ts
190-
function minBitFlips(start: number, goal: number): number {
191-
return (start ^ goal).toString(2).replace(/0/g, '').length;
192-
}
193-
```
194-
195-
#### JavaScript
196-
197-
```js
198-
function minBitFlips(start, goal) {
199-
return (start ^ goal).toString(2).replace(/0/g, '').length;
200-
}
201-
```
202-
203-
<!-- tabs:end -->
204-
205-
<!-- solution:end -->
206-
207181
<!-- problem:end -->

‎solution/2200-2299/2220.Minimum Bit Flips to Convert Number/Solution.c‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1,9 +1,9 @@
11
int minBitFlips(int start, int goal) {
2-
int tmp = start ^ goal;
2+
int x = start ^ goal;
33
int ans = 0;
4-
while (tmp) {
5-
ans += tmp & 1;
6-
tmp >>= 1;
4+
while (x) {
5+
ans += (x & 1);
6+
x >>= 1;
77
}
88
return ans;
9-
}
9+
}

‎solution/2200-2299/2220.Minimum Bit Flips to Convert Number/Solution.cpp‎

Lines changed: 2 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1,12 +1,6 @@
11
class Solution {
22
public:
33
int minBitFlips(int start, int goal) {
4-
int t = start ^ goal;
5-
int ans = 0;
6-
while (t) {
7-
ans += t & 1;
8-
t >>= 1;
9-
}
10-
return ans;
4+
return __builtin_popcount(start ^ goal);
115
}
12-
};
6+
};

0 commit comments

Comments
 (0)