# Solving Leetcode Interviews in Seconds with AI: Maximum Xor Product


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2939" using AI. LeetCode is a popular platform for preparing for coding interviews, and with the help of AI tools like [Chatmagic](https://www.chatmagic.app), we can generate solutions quickly and efficiently - helping you pass the interviews and get the job offer without having to study for months.

	# Problem Statement
	> Given three integers a, b, and n, return the maximum value of (a XOR x) * (b XOR x) where 0 <= x < 2n. Since the answer may be too large, return it modulo 109 + 7. Note that XOR is the bitwise XOR operation.   Example 1:  Input: a = 12, b = 5, n = 4 Output: 98 Explanation: For x = 2, (a XOR x) = 14 and (b XOR x) = 7. Hence, (a XOR x) * (b XOR x) = 98.  It can be shown that 98 is the maximum value of (a XOR x) * (b XOR x) for all 0 <= x < 2n.  Example 2:  Input: a = 6, b = 7 , n = 5 Output: 930 Explanation: For x = 25, (a XOR x) = 31 and (b XOR x) = 30. Hence, (a XOR x) * (b XOR x) = 930. It can be shown that 930 is the maximum value of (a XOR x) * (b XOR x) for all 0 <= x < 2n. Example 3:  Input: a = 1, b = 6, n = 3 Output: 12 Explanation: For x = 5, (a XOR x) = 4 and (b XOR x) = 3. Hence, (a XOR x) * (b XOR x) = 12. It can be shown that 12 is the maximum value of (a XOR x) * (b XOR x) for all 0 <= x < 2n.    Constraints:  0 <= a, b < 250 0 <= n <= 50  

	# Explanation
	Here's a breakdown of the solution strategy, followed by the code:

*   **Maximize Individual XORs:** The core idea is to maximize `(a XOR x)` and `(b XOR x)` independently as much as possible within the constraint `0 <= x < 2^n`. We iterate through the bits from the most significant bit (n-1) down to 0.

*   **Greedy Bit Setting:** For each bit position, we check if setting the corresponding bit in `x` would cause `a` and `b` to have different bits at that position after the XOR operation. If they are the same originally, setting the bit in `x` makes them different, which generally leads to a larger result.  If they are different, we don't set the bit, as keeping them different could result in a smaller product.

*   **Modulo Arithmetic:** The problem requires taking the modulo at the end due to the potentially large result.

*   **Runtime & Storage Complexity:** O(n) time complexity, O(1) space complexity.

	
	# Code
	```python
	def solve():
    a, b, n = map(int, input().split())
    
    x = 0
    for i in range(n - 1, -1, -1):
        bit_mask = 1 << i
        
        if (a & bit_mask) != (b & bit_mask):
            continue
        else:
            x |= bit_mask
            
    result = (a ^ x) * (b ^ x)
    return result % (10**9 + 7)

print(solve())
	```