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

public class Solution {
    public int[] GetMaximumXor(int[] nums, int maximumBit) {
        var result = new int[nums.Length];
        var maxK = (int)Math.Pow(2, maximumBit) - 1;
        result[nums.Length - 1] = nums[0];
        for (int i = 1; i < nums.Length; i++)
        {
            result[nums.Length - 1 - i] = result[nums.Length - i] ^ nums[i];
        }

        for (int i = 0; i < nums.Length; i++)
        {
            result[i] ^= maxK;
        }

        return result;
    }
}

class Solution
{

    /**
     * @param Integer[] $nums
     * @param Integer $maximumBit
     * @return Integer[]
     */
    function getMaximumXor($nums, $maximumBit)
    {
        $max = (2 ** $maximumBit) - 1;
        $output = [];
        for ($i = 0; $i < count($nums); $i++) {
            $value = $max ^ $nums[$i];
            $output[] = $value;
            $max = $value;
        }
        return array_reverse($output);
    }
}

class Solution {
public:
    vector<int> getMaximumXor(vector<int>& nums, int maximumBit) {
        auto maxs = vector<int>(); maxs.reserve(nums.size());
        auto xorall = accumulate(nums.begin(), nums.end(), ((1 << maximumBit) - 1), [](int a, int b) { return a ^ b; });
        for_each(nums.rbegin(), nums.rend(), [&](int num) { maxs.emplace_back(xorall); xorall = xorall ^ num; });
        return maxs;
    }
};

class Solution {
    public int[] getMaximumXor(int[] nums, int maximumBit) {
        int max = (1 << maximumBit) - 1;
        int[] result = new int[nums.length];
        int[] xorlist = new int[nums.length];
        xorlist[0] = nums[0];
        for(int i = 1;i<nums.length;i++){
            xorlist[i] = xorlist[i - 1] ^ nums[i];
        }

        for(int i = xorlist.length - 1;i>=0;i--){
            result[xorlist.length - i  - 1] =  max ^ xorlist[i];
        }

        return result;
    }
}

class Solution {
    private boolean find(TreeNode n, int val, StringBuilder sb) {
        if (n.val == val)
            return true;
        if (n.left != null && find(n.left, val, sb))
            sb.append("L");
        else if (n.right != null && find(n.right, val, sb))
            sb.append("R");
        return sb.length() > 0;
    }

    public String getDirections(TreeNode root, int startValue, int destValue) {
        StringBuilder s = new StringBuilder(), d = new StringBuilder();
        find(root, startValue, s);
        find(root, destValue, d);
        int i = 0, max_i = Math.min(d.length(), s.length());
        while (i < max_i && s.charAt(s.length() - i - 1) == d.charAt(d.length() - i - 1))
            ++i;
        return "U".repeat(s.length() - i) + d.reverse().toString().substring(i);
    }
}

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

        return result

class Solution:
    def minEnd(self, n: int, x: int) -> int:
        firstElement = x
        n -= 1
        bits = 0
        for i in range(64):
            if firstElement >> i & 1 == 0:
                if n >> bits & 1 == 1:
                    firstElement |= 1 << i

                bits += 1

        return firstElement

class Solution:
    def minEnd(self, n: int, x: int) -> int:
        result, pos = x, 0
        n -= 1
        while n > 0:
            mask = n & 1
            while result & (1 << pos) > 0:
                pos += 1
            result = result ^ (mask << pos)
            pos += 1
            n >>= 1
        return result

var minEnd = function (n, x) {
    const k = (n - 1).toString(2).split('');
    return Number.parseInt(
        x.toString(2)
            .padStart(52, '0')
            .split('')
            .reverse()
            .map(it => it === '1' ? it : k.pop() ?? '0')
            .reverse()
            .join(''),
        2
    );
};

class Solution {
    public long minEnd(int n, int x) {
        if (n == 1)
            return x;
        long res = x;
        int len = 1;
        long N = n-1;
        long X = x;
        while (N >> len > 0) {
            len++;
        }
    
        int i=0;
        for(int j=0 ;j<len;j++){
            while(((X>>i)&1)!=0){
                i++;     
            }
            res |= ((N >> j) & 1) << i;
            i++;
        }

        return res;
    }
}

class Solution {
public:
    long long minEnd(int n, int x) {
        int max = n - 1;
        int i = 0;
        long long res = x;
        while (max != 0) {
            while (res & (1ULL<<i)) i++;
            if (max & 1) {
                res |= (1ULL<<i);
            }
            i++;
            max >>= 1;
        }
        return res;
    }
};

class Solution {
    public long minEnd(int n, int x) {
        long res = 0;
        long[] binX = new long[64];
        long[] binN = new long[64];
        long X = x;
        long N = n - 1;
        for (int i = 0; i < 64; i++) {
            binX[i] = (X >> i) & 1;
            binN[i] = (N >> i) & 1;
        }
        for (int i = 0, j = 0; i < 64; i++) {
            while (i < 64 && binX[i] != 0) {
                i++;
            }
            binX[i] = binN[j];
            j++;
        }
        for (int i = 0; i < 64; i++) {
            if (binX[i] == 1) {
                res += (1l << i);
            }
        }
        return res;
    }
}

class Solution:
    def minEnd(self, n: int, x: int) -> int:
        n -= 1
        res = 0

        for i in range(45): # loop 45 bits of final result
            curr = x & 1 # get last bit of x
            x >>= 1
            if not curr and n:
                curr = n & 1 # replace last bit of x with bit of n
                n >>= 1
            res += curr * 1 << i # get base 10 of final result

            if not n and not x: # break loop if no more replace or end of x
                break
            
        return res

public long minEnd(int n, int x) {
        int k = n-1;
        long res = 0;
        int rank = 0;
        int len = Integer.toBinaryString(x).length();
        while(k>0 || len>0){
            if((x&1)==0){
                res+=(long) (k&1)<<rank;
                k>>=1;
            }else
                res+=1<<rank;
            rank++;
            len--;
            x>>=1;
        }
        return res;
    }