Get, Set, Clear ith Bit — Editorial

Opening the reading…

Intuitionone mask gives all three answers

Bit position i is 1-based, but a shift count is 0-based. Therefore the bit at position i is reached by shifting 1 left by i - 1 places. This creates a mask with exactly one 1: the target bit is 1 in the mask, and every other bit is 0.

Once the mask exists, each operation follows from what AND and OR preserve. AND with the mask leaves the target bit isolated, OR with the mask forces the target bit to 1, and AND with the complemented mask forces the target bit to 0. The original num remains unchanged because every expression creates a result rather than modifying num.

Approachtranslate the 1-based position before touching the bits

Create mask as 1 shifted left by i - 1 positions, because shifting by i would target the next bit and every result would be off by one.

Read num & mask to keep only the requested bit, then convert the result to exactly 0 or 1 because the AND result itself is either 0 or the mask value.

Compute num | mask to set the bit, because OR with a 1 always produces 1 at that position while leaving every other position unchanged.

Compute num & ~mask to clear the bit, because the complemented mask has 0 at the target position and 1 everywhere else.

Store the three values in the required order: current bit, set value, then clear value, because the operations are independent and must describe the same original num.

Use 64-bit values for the mask and results, because shifting to position 32 produces 2147483648, which does not fit in a signed 32-bit int.

Complexitythe input has a fixed number of bit operations

MEASURE	BOUND	WHY
Time	O(1)	The solution performs a fixed number of shifts, bitwise operations, and assignments, regardless of the numeric value of num or the selected position.
Space	O(1) extra	Only the mask and three scalar results are stored. The returned array is required output and is excluded from the extra-space bound.

The input contains one number and one bit position; no additional size parameter is needed.

Annotated solutionC++ · direct mask construction · complete judge-ready implementation

CPPBuild one 64-bit mask, apply the three bitwise operations, and return the results in order.

#include <vector>
using namespace std;

class Solution {
public:
    vector<long long> bitManipulation(long long num, int i) {
        long long mask = 1LL << (i - 1);
        long long current = (num & mask) ? 1LL : 0LL;
        long long setValue = num | mask;
        long long clearValue = num & ~mask;
        return vector<long long>{current, setValue, clearValue};
    }
};

The expression 1LL is important before the shift: it makes the mask a 64-bit value from the start. The ternary expression is also intentional. num & mask tells you whether the bit is present, but when the bit is set it returns the mask itself, such as 4 for position 3; the required first answer is 1, so the expression converts any nonzero result to 1.