3514. Number of Unique XOR Triplets II

class Solution {
    public int uniqueXorTriplets(int[] nums) {
        final int MAX = 2048;

        boolean[][] dp = new boolean[4][MAX];
        dp[0][0] = true;

        for (int x : nums) {
            boolean[][] next = new boolean[4][MAX];

            for (int k = 0; k <= 3; k++) {
                System.arraycopy(dp[k], 0, next[k], 0, MAX);
            }

            // Use the current index up to 3 times (i <= j <= k allows repeats)
            for (int t = 0; t < 3; t++) {
                for (int k = 2; k >= 0; k--) {
                    for (int v = 0; v < MAX; v++) {
                        if (next[k][v]) {
                            next[k + 1][v ^ x] = true;
                        }
                    }
                }
            }

            dp = next;
        }

        int ans = 0;
        for (boolean ok : dp[3]) {
            if (ok) ans++;
        }

        return ans;
    }
}

class Solution:
    def uniqueXorTriplets(self, nums):
        MAX = 2048

        dp = [[False] * MAX for _ in range(4)]
        dp[0][0] = True

        for x in nums:
            nxt = [row[:] for row in dp]

            # Use current index up to 3 times (i <= j <= k allows repeats)
            for _ in range(3):
                for k in range(2, -1, -1):
                    for v in range(MAX):
                        if nxt[k][v]:
                            nxt[k + 1][v ^ x] = True

            dp = nxt

        return sum(dp[3])

class Solution {
public:
    int uniqueXorTriplets(vector<int>& nums) {
        const int MAX = 2048;

        vector<vector<bool>> dp(4, vector<bool>(MAX, false));
        dp[0][0] = true;

        for (int x : nums) {
            auto nxt = dp;

            // Use current index up to 3 times (i <= j <= k allows repeats)
            for (int t = 0; t < 3; t++) {
                for (int k = 2; k >= 0; k--) {
                    for (int v = 0; v < MAX; v++) {
                        if (nxt[k][v]) {
                            nxt[k + 1][v ^ x] = true;
                        }
                    }
                }
            }

            dp = move(nxt);
        }

        int ans = 0;
        for (bool ok : dp[3]) {
            if (ok) ans++;
        }

        return ans;
    }
};

var uniqueXorTriplets = function(nums) {
    const MAX = 2048;

    let dp = Array.from({ length: 4 }, () => Array(MAX).fill(false));
    dp[0][0] = true;

    for (const x of nums) {
        let next = dp.map(row => [...row]);

        // Use current index up to 3 times (i <= j <= k allows repeats)
        for (let t = 0; t < 3; t++) {
            for (let k = 2; k >= 0; k--) {
                for (let v = 0; v < MAX; v++) {
                    if (next[k][v]) {
                        next[k + 1][v ^ x] = true;
                    }
                }
            }
        }

        dp = next;
    }

    let ans = 0;
    for (const ok of dp[3]) {
        if (ok) ans++;
    }

    return ans;
};