1class Solution {
2    public String maximumXor(String s, String t) {
3        // Count occurrences of '0' and '1' in string t.
4        // digitCount[0] = number of '0' characters, digitCount[1] = number of '1' characters.
5        int[] digitCount = new int[2];
6        for (char c : t.toCharArray()) {
7            digitCount[c - '0']++;
8        }
9
10        // Build the result string that maximizes the XOR with s,
11        // using a greedy strategy: prefer producing a '1' bit whenever possible.
12        char[] result = new char[s.length()];
13        for (int i = 0; i < s.length(); i++) {
14            // Current bit from s at position i.
15            int currentBit = s.charAt(i) - '0';
16
17            // To get a XOR result of '1', we need the opposite bit (currentBit ^ 1).
18            if (digitCount[currentBit ^ 1] > 0) {
19                // Consume one opposite bit, producing a '1' in the XOR result.
20                digitCount[currentBit ^ 1]--;
21                result[i] = '1';
22            } else {
23                // No opposite bit available, so use the same bit, producing a '0'.
24                digitCount[currentBit]--;
25                result[i] = '0';
26            }
27        }
28
29        return new String(result);
30    }
31}
32

1class Solution {
2public:
3    string maximumXor(string s, string t) {
4        // Count the occurrences of '0' and '1' in string t.
5        // count[0] holds the number of '0' characters, count[1] holds the number of '1' characters.
6        int count[2]{};
7        for (char c : t) {
8            count[c - '0']++;
9        }
10
11        // Initialize the answer with all '0' characters, matching the length of s.
12        string ans(s.size(), '0');
13
14        // Greedily try to maximize each XOR bit from left to right.
15        for (int i = 0; i < static_cast<int>(s.size()); i++) {
16            int bit = s[i] - '0';
17
18            // To produce a '1' in the XOR result, we need a character from t
19            // that is the complement of the current bit (bit ^ 1).
20            if (count[bit ^ 1] > 0) {
21                // Consume one complementary character and set this position to '1'.
22                count[bit ^ 1]--;
23                ans[i] = '1';
24            } else {
25                // No complement available, so we must use the same bit,
26                // which yields '0' in the XOR result (already set by default).
27                count[bit]--;
28            }
29        }
30
31        return ans;
32    }
33};
34

1/**
2 * Maximizes the XOR result string by greedily pairing each bit of `s`
3 * with an opposite bit from `t` whenever one is available.
4 *
5 * @param s - The base binary string whose length defines the result length.
6 * @param t - The binary string providing the pool of bits to XOR against.
7 * @returns The lexicographically maximized XOR result as a binary string.
8 */
9function maximumXor(s: string, t: string): string {
10    // bitCount[0] tracks available '0' bits in t, bitCount[1] tracks '1' bits.
11    const bitCount: [number, number] = [0, 0];
12
13    // Tally how many of each bit value exist in t.
14    for (const char of t) {
15        bitCount[Number(char)]++;
16    }
17
18    // Initialize the result with all '0's; each position is the length of s.
19    const answer: string[] = new Array<string>(s.length).fill('0');
20
21    // For each bit in s, attempt to produce a '1' by using an opposite bit from t.
22    for (let i = 0; i < s.length; i++) {
23        const currentBit = Number(s[i]);
24        const oppositeBit = currentBit ^ 1;
25
26        if (bitCount[oppositeBit] > 0) {
27            // An opposite bit is available: XOR yields 1, so consume it.
28            bitCount[oppositeBit]--;
29            answer[i] = '1';
30        } else {
31            // No opposite bit left: must use the same bit, producing 0.
32            bitCount[currentBit]--;
33        }
34    }
35
36    // Combine individual bit characters into the final result string.
37    return answer.join('');
38}
39