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


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3315" 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] <= 109 nums[i] is a prime number.  

	# Explanation
	Here's the solution to the problem:

*   **Key Idea:** The core idea is to recognize the bit pattern characteristic of prime numbers that satisfy the `ans[i] OR (ans[i] + 1) == nums[i]` condition. Specifically, `nums[i]` can be expressed as the OR of two consecutive numbers `ans[i]` and `ans[i] + 1` only if `nums[i]` has the form `2^k - 1` is not prime (except for 3 which is 2^2 -1). If `nums[i]` is of the form `2^k -1` then the answer is `nums[i]/2 -1`. Otherwise, `ans[i]` is `nums[i] - (nums[i] & -nums[i]) -1`. Another way of saying is, find the rightmost set bit in `nums[i]`. That bit indicates the number we have to subtract from `nums[i]` so that we get the number `ans[i]` where `ans[i] OR ans[i]+1 == nums[i]`.

*   **Prime Check (Optimization):** Because the input consists of prime numbers, special handling can be done to optimize. If prime number is of the form `2^k - 1`, we check if we can find a valid answer as described above, if not, the answer is `-1`. The bit manipulation to find the rightmost set bit can be optimized and done efficiently.

*   **Edge Cases:** Handles cases where no suitable `ans[i]` can be found, returning `-1`. Specifically, if `nums[i]` is 2, no solution exists.

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

	
	# Code
	```python
	def construct_array(nums):
    ans = []
    for num in nums:
        if num == 2:
            ans.append(-1)
            continue

        val = num - (num & -num)
        ans.append(val)

    return ans
	```