# Solving Leetcode Interviews in Seconds with AI: Construct the Minimum Bitwise Array I


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3314" 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
	> You are given an array nums consisting of n prime integers. You need to construct an array ans of length n, such that, for each index i, the bitwise OR of ans[i] and ans[i] + 1 is equal to nums[i], i.e. ans[i] OR (ans[i] + 1) == nums[i]. Additionally, you must minimize each value of ans[i] in the resulting array. If it is not possible to find such a value for ans[i] that satisfies the condition, then set ans[i] = -1.   Example 1:  Input: nums = [2,3,5,7] Output: [-1,1,4,3] Explanation:  For i = 0, as there is no value for ans[0] that satisfies ans[0] OR (ans[0] + 1) = 2, so ans[0] = -1. For i = 1, the smallest ans[1] that satisfies ans[1] OR (ans[1] + 1) = 3 is 1, because 1 OR (1 + 1) = 3. For i = 2, the smallest ans[2] that satisfies ans[2] OR (ans[2] + 1) = 5 is 4, because 4 OR (4 + 1) = 5. For i = 3, the smallest ans[3] that satisfies ans[3] OR (ans[3] + 1) = 7 is 3, because 3 OR (3 + 1) = 7.   Example 2:  Input: nums = [11,13,31] Output: [9,12,15] Explanation:  For i = 0, the smallest ans[0] that satisfies ans[0] OR (ans[0] + 1) = 11 is 9, because 9 OR (9 + 1) = 11. For i = 1, the smallest ans[1] that satisfies ans[1] OR (ans[1] + 1) = 13 is 12, because 12 OR (12 + 1) = 13. For i = 2, the smallest ans[2] that satisfies ans[2] OR (ans[2] + 1) = 31 is 15, because 15 OR (15 + 1) = 31.     Constraints:  1 <= nums.length <= 100 2 <= nums[i] <= 1000 nums[i] is a prime number.  

	# Explanation
	Here's the breakdown of the solution:

*   **Understanding the Bitwise OR Property:** The core idea is to recognize that `x OR (x + 1)` effectively sets the least significant 0-bit of `x` to 1. A prime number `p` can be expressed as `x OR (x+1)` only if `p` has a single contiguous block of 1s in its binary representation, starting from the least significant bit. If `p` doesn't have this form, no solution for `x` exists.

*   **Finding the Candidate:** If a solution *does* exist, then `x = p & (p + 1)`.  We can verify if `x OR (x+1)` is indeed equal to `p`. This `x` will always be the smallest value which satisfies the condition.

*   **Prime Check and Minimization:** We iterate through the `nums` array, calculating the candidate `ans[i]` as described above. We explicitly check the OR condition, assigning -1 if it fails.

*   **Runtime and Storage Complexity:**
    *   **Runtime Complexity:** O(n), where n is the length of the `nums` array.
    *   **Storage Complexity:** O(n) for the `ans` array.

	
	# Code
	```python
	def construct_array(nums):
    """
    Constructs an array ans such that ans[i] OR (ans[i] + 1) == nums[i],
    minimizing each ans[i].

    Args:
        nums: A list of prime integers.

    Returns:
        A list of integers representing the constructed array ans.
    """
    ans = []
    for num in nums:
        candidate = num & (num + 1)
        if (candidate | (candidate + 1)) == num:
            ans.append(candidate)
        else:
            ans.append(-1)
    return ans
	```