1class Solution {
2    /**
3     * Computes the sum of all "good" integers within a bounded range around n.
4     * An integer x is considered "good" if it shares no common set bits with n,
5     * i.e. (n & x) == 0.
6     *
7     * @param n the reference number used for both range computation and bit check
8     * @param k the range radius used to derive the inclusive search bounds
9     * @return  the accumulated sum of every good integer in [start, end]
10     */
11    public int sumOfGoodIntegers(int n, int k) {
12        // Running total of all good integers found.
13        int sum = 0;
14
15        // Lower bound of the search range, clamped to a minimum of 1.
16        int start = Math.max(1, n - k);
17
18        // Upper bound of the search range (inclusive).
19        int end = n + k;
20
21        // Iterate over every candidate value in the inclusive range [start, end].
22        for (int x = start; x <= end; x++) {
23            // x is "good" only when it has no overlapping set bits with n.
24            if ((n & x) == 0) {
25                sum += x;
26            }
27        }
28
29        return sum;
30    }
31}
32

1class Solution {
2public:
3    int sumOfGoodIntegers(int n, int k) {
4        // Accumulator for the sum of all "good" integers found in the range.
5        int sum = 0;
6
7        // Define the lower bound of the search range.
8        // We never go below 1, hence the use of max(1, ...).
9        int rangeStart = max(1, n - k);
10
11        // Define the upper bound of the search range.
12        int rangeEnd = n + k;
13
14        // Iterate over every integer within the inclusive range [rangeStart, rangeEnd].
15        for (int candidate = rangeStart; candidate <= rangeEnd; ++candidate) {
16            // A candidate is considered "good" when it shares no set bits with n,
17            // i.e. the bitwise AND of n and candidate equals 0.
18            if ((n & candidate) == 0) {
19                // Add the qualifying candidate to the running total.
20                sum += candidate;
21            }
22        }
23
24        // Return the total sum of all good integers.
25        return sum;
26    }
27};
28

1/**
2 * Computes the sum of all "good" integers within a range determined by n and k.
3 *
4 * An integer x is considered "good" if it lies within the inclusive range
5 * [max(1, n - k), n + k] and shares no common set bits with n
6 * (i.e. the bitwise AND of n and x equals 0).
7 *
8 * @param n - The base integer used for range calculation and the bitwise check.
9 * @param k - The offset that defines the width of the search range around n.
10 * @returns The sum of every integer in the range that satisfies the bitwise condition.
11 */
12function sumOfGoodIntegers(n: number, k: number): number {
13    // Accumulator for the running total of all qualifying integers.
14    let answer = 0;
15
16    // Lower bound of the search range; clamped to at least 1 so we never go below 1.
17    const start = Math.max(1, n - k);
18
19    // Upper bound of the search range.
20    const end = n + k;
21
22    // Iterate over every candidate integer in the inclusive range [start, end].
23    for (let x = start; x <= end; x++) {
24        // A candidate qualifies only if it has no bits in common with n.
25        if ((n & x) === 0) {
26            answer += x;
27        }
28    }
29
30    return answer;
31}
32