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

class Solution:
    def getMaximumXor(self, nums: List[int], maximumBit: int) -> List[int]:
        n = len(nums)
        xOr = 0
        for num in nums:
            xOr = xOr ^ num
     
        maxK = 2**maximumBit
        ans = []
        for i in range(n - 1, -1, -1):
            current = 0
            currentK = maxK
            for j in range(32, -1, -1):
                if xOr >> j & 1 == 0 and 1 << j < currentK:
                    currentK -= 1 << j
                    current |= 1 << j

            ans.append(current)
            xOr ^= nums[i]
        return ans

class Solution:
    def getMaximumXor(self, nums: List[int], maximumBit: int) -> List[int]:
        n = len(nums)
        xOr = 0
        for num in nums:
            xOr = xOr ^ num
      
        maxK = (1 << maximumBit) - 1
        ans = [0]*n
        for i in range(n - 1, -1, -1):
            ans[n - i - 1] = maxK ^ xOr
            xOr ^= nums[i]
          
        return ans

vector<int> Solution::getMaximumXor(vector<int>& nums, int maximumBit) {
    int n = 0;
    for (int i = 0; i < nums.size(); ++i) {
        n ^= nums[i];
    }
    vector<int> ans;
    ans.reserve(nums.size());
    int maximized = (1 << maximumBit) - 1;
    for (int i = nums.size() - 1; i >= 0; --i) {
        ans.push_back(n ^ maximized);
        n ^= nums[i];
    }
    return ans;
}

class Solution {
    public int[] getMaximumXor(int[] nums, int maximumBit) {
        int n = nums.length;
        int[] ans = new int[n];
        int[] res = new int[n];
        int max = (1 << maximumBit) - 1;
        for (int i = 0; i < n; i++) {
            if (i == 0) ans[i] = nums[i];
            else ans[i] = ans[i - 1] ^ nums[i];
        }
        for (int i = ans.length - 1; i >= 0 ; i--) {
            ans[i] ^= max;
        }
        for (int i = ans.length - 1; i >= 0 ; i--) {
            res[n - 1 - i] = ans[i];
        }
        return res;
    }
}

var getMaximumXor = function(nums, maximumBit) {
    const m = (1 << maximumBit) - 1;
    for (let i = 1; i < nums.length; i++) {
        nums[i] ^= nums[i-1];
    }
    return nums.map(n => n ^ m).reverse();
};

class Solution {
public:
    vector<int> getMaximumXor(vector<int>& nums, int maximumBit) {
        
        vector<int> count(20, 0);
        int n = nums.size();

        for (int i = 0; i < n; i++) {
            for (int j = 0; j < 20; j++) {
                if ((nums[i] & (1 << j)) != 0) {
                    count[j]++;
                }
            }
        }

        vector<int> ans;
        int lastElement = n - 1;

        for (int i = 0; i < n; i++) {
            int tmp = 0;
            for (int j = maximumBit - 1; j >= 0; j--) {
                if (count[j] % 2 != 1) tmp += powerOf(j);
            }
            ans.push_back(tmp);
            for (int j = 0; j < 20; j++) {
                if ((nums[lastElement] & (1 << j)) != 0) {
                    count[j]--;
                }
            }
            lastElement--;
        }

        return ans;
    }

    int powerOf(int order) {
        int ans = 1;
        for (int i = 1; i <= order; i++) {
            ans *= 2;
        }
        return ans;
    }
};

function getMaximumXor(nums: number[], b: number): number[] {
    const n = nums.length;
    const res = new Array(n)
    let cur = (1 << b) - 1;
    for (let i = 0; i < n; i++) cur^= nums[i], res[n - 1 - i] = cur
    return res;
}

class Solution {
public:
    vector<int> getMaximumXor(vector<int>& nums, int maximumBit) {
        vector<int> vec(nums.size());
        vec[0] = nums[0];
        for (int i = 1; i < nums.size(); i++) vec[i] = vec[i-1] ^ nums[i];
        vector<int> ans;
        for (int i = nums.size() - 1; i >= 0; i--) {
            int t = 0;
            for (int j = 0; j < maximumBit; j++) {
                if (((vec[i] >> j) & 1) == 0) t += pow(2, j);
            }
            ans.push_back(t);
        }
        return ans;
    }
};

class Solution {
    public int[] getMaximumXor(int[] nums, int maximumBit) {
        int n =nums.length;
        int[] res = new int[n];
        int prefix =0;
        int max = (int)Math.pow(2,maximumBit)-1;

        for(int i =0; i < n ;i++){
            prefix  = prefix^nums[i];
            int k=0;
            int bits = Integer.bitCount(prefix);
            res[n-1-i] = prefix>>(bits-maximumBit>=0?bits-maximumBit:0) ^ max;
        }

        return res;
    }
}

class Solution {
    public int[] getMaximumXor(int[] nums, int maximumBit) {
        int n = nums.length;
        int[] ans = new int[n];
        int max = (1 << maximumBit) - 1;
        for (int i = 0; i < n; i++) {
            if (i == 0) ans[i] = nums[i];
            else ans[i] = ans[i - 1] ^ nums[i];
        }
        for (int i = 0; i < n; i++) {
            ans[i] ^= max;
        }
        for (int i = 0; i < n / 2; i++) {
            int tmp = ans[i];
            ans[i] = ans[n - 1 - i];
            ans[n - 1 - i] = tmp;
        }
        return ans;
    }
}

class Solution {
public:
    vector<int> getMaximumXor(vector<int>& nums, int maximumBit) {
        int max_num = (1 << maximumBit) - 1;
        int n = nums.size();
        int r = nums.size();
        vector<int> result(n);

        int xor_sum = 0;
        for (const int &num : nums) {
            xor_sum ^= num;
            result[--r] = max_num ^ xor_sum;
        }
        return result;
    }
};