Sponsored
Sponsored
The key to this approach is analyzing each bit position of the numbers. We need to ensure that at each bit position i, (a[i] OR b[i]) matches c[i].
If c[i] is 0, both a[i] and b[i] must be 0. This may require flipping if either a[i] or b[i] is 1.
If c[i] is 1, we need at least one of a[i] or b[i] to be 1. If both are 0, we need one flip.
By iterating through each binary bit, we can count the necessary flips.
Time Complexity: O(1), since the number of bits is constant and we iterate a fixed number of times.
Space Complexity: O(1), as we use a constant amount of space.
1function minFlips(a, b, c) {
2 let flips = 0;
3 for (let i = 0; i < 32; i++) {
4 let bitA = (a >> i) & 1;
5 let bitB = (b >> i) & 1;
6 let bitC = (c >> i) & 1;
7 if (bitC === 0) {
8 flips += bitA + bitB;
9 } else {
10 flips += ((bitA | bitB) === 0) ? 1 : 0;
11 }
12 }
13 return flips;
14}
15
16console.log(minFlips(2, 6, 5));This JavaScript solution follows a similar pattern as other solutions, making use of bitwise operations and bit checks to determine the necessary bit flips on numbers a and b.
This alternative approach uses masks and logical reduction to simplify determining the minimum flips. Instead of checking each bit individually, create a mask that highlights the bits where a OR b does not match the bits of c.
For c's zeroed bits, count additions for every 1 found in corresponding bits in a or b.
For c's one bits, ensure at least one 1 is present in the corresponding a or b position. Adjust flips accordingly.
Time Complexity: O(1), consistently iterating fixed bits.
Space Complexity: O(1), as it uses primitive operations.
JavaScript follows a strategy of iterative bit examination and reduction through while loops, ensuring each loop evaluates a fixed number of positions for consistent flip calculation.