thảo luận Leetcode mỗi ngày

    public int missingNumber(int[] nums) {
        int sum = 0;
        int total = nums.length;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            total += i;
        }
        return total - sum;
    }

class Solution:
    def rangeBitwiseAnd(self, left: int, right: int) -> int:
        res = 0
        for bit_index in range(32, -1, -1):
            bit = 1 << bit_index
            if (bit & left) == (bit & right):
                res += (bit & left)
            else:
                break
        return res

class Solution:
    def rangeBitwiseAnd(self, left: int, right: int) -> int:
        shift = 0
        while left < right:
            left = left >> 1
            right = right >> 1
            shift += 1
        return left << shift

class Solution {
    public int rangeBitwiseAnd(int left, int right) {
        if (left == right){
            return left;
        }
        int c = 0;
        //long c = left & right;
        while (left != right){
            left >>= 1;
            right >>= 1;
            c++;
        }
        return left<<c;
    }
}

public static int rangeBitwiseAnd(int left, int right) {
    int count = 0;
    while (left < right) {
        left >>= 1;
        right >>= 1;
        count++;
    }
    return left << count;
}

function rangeBitwiseAnd(left: number, right: number): number {
    let shift = 0;
    while (left < right) {
        left >>= 1;
        right >>=1;
        shift++;
    }
    return left << shift
};

class Solution:
    def rangeBitwiseAnd(self, left: int, right: int) -> int:
        leftBinary = format(left, "031b")
        rightBinary = format(right, "031b")
        result = ""
        for i in range(31):
            if leftBinary[i] == rightBinary[i]:
                result += leftBinary[i]
            else:
                break
        if len(result) == 0:
            return 0
        numberResult = int(result, 2)
        if numberResult == 0:
            return 0
        return numberResult << (31 - len(result))

class Solution {
    public static int rangeBitwiseAnd(int left, int right) {
        int count = 0;
        while (left < right) {
            left >>= 1;
            right >>= 1;
            count++;
        }
        return left << count;
    }
  
}

    int rangeBitwiseAnd(int left, int right) {
        int ret = left;     
        for (long step = 1, i = step + left; i <= right; i += step){
            ret &= i;
            if (ret == 0) return 0;
            while ((ret & step) == 0) step <<= 1;
            if (i + step > right) return ret & right;
        }
        return ret;
    }

class Solution {
    public int rangeBitwiseAnd(int left, int right) {
        while (right != 0 && right > left){
            right = right & (right - 1);
        }
        return right;
    }
}

var rangeBitwiseAnd = function(left, right) {
    if (right === 0) {
        return 0;
    }
    let t = 1 << Math.trunc(Math.log2(right)), ans = 0;
    while (t && (t & left) === (t & right)) {
        ans |= t & left;
        t >>= 1;
    }
    return ans;
};

public class Solution
{
    public int RangeBitwiseAnd(int left, int right)
    {
        int diff = right - left;
        if (diff == 0)
        {
            return left;
        }
        int result = 0;
        int leftCopy = left;
        int i = 0;
        int twoPow = 1;
        while (leftCopy > 0)
        {
            twoPow *= 2;
            int startBit = leftCopy % 2;
            int endBit = 0;
            if (startBit == 0)
            {
                endBit = 0;
                leftCopy >>= 1;
                i++;
                continue;
            }

            int order = left % twoPow;
            endBit = order + diff < twoPow ? 1 : 0;
            if (i == 30)
            {
                result += TwoPow(30);
            }
            else
            {
                result += endBit * (twoPow / 2);
            }

            leftCopy >>= 1;
            i++;
        }

        return result;
    }

    private int TwoPow(int p)
    {
        int result = 1;
        for (int i = 0; i < p; i++)
        {
            result *= 2;
        }

        return result;
    }
}

class Solution {
    public static int rangeBitwiseAnd(int left, int right) {
        int ans = 0;
        while (left != right) {
            left >>= 1;
            right >>= 1;
            ans++;
        }
        return left << ans;
    }
}