Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit 957336b

Browse files
feat: add solutions to lc problem: No.2220 (#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 -->
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+
}
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)

AltStyle によって変換されたページ (->オリジナル) /