# Solving Leetcode Interviews in Seconds with AI: Special Array II


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "3152" 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
	> An array is considered special if every pair of its adjacent elements contains two numbers with different parity. You are given an array of integer nums and a 2D integer matrix queries, where for queries[i] = [fromi, toi] your task is to check that subarray nums[fromi..toi] is special or not. Return an array of booleans answer such that answer[i] is true if nums[fromi..toi] is special.   Example 1:  Input: nums = [3,4,1,2,6], queries = [[0,4]] Output: [false] Explanation: The subarray is [3,4,1,2,6]. 2 and 6 are both even.  Example 2:  Input: nums = [4,3,1,6], queries = [[0,2],[2,3]] Output: [false,true] Explanation:  The subarray is [4,3,1]. 3 and 1 are both odd. So the answer to this query is false. The subarray is [1,6]. There is only one pair: (1,6) and it contains numbers with different parity. So the answer to this query is true.     Constraints:  1 <= nums.length <= 105 1 <= nums[i] <= 105 1 <= queries.length <= 105 queries[i].length == 2 0 <= queries[i][0] <= queries[i][1] <= nums.length - 1  

	# Explanation
	Here's the solution:

*   **Precompute Parity:** Create an array to store the parity (0 for even, 1 for odd) of each number in `nums`.
*   **Check Subarrays:** For each query, iterate through the specified subarray using the parity array and check if adjacent elements have different parities.
*   **Early Exit:** If any adjacent pair has the same parity, the subarray is not special, so return `False` immediately.

*   **Runtime Complexity:** O(N + Q * K), where N is the length of `nums`, Q is the number of queries, and K is the maximum length of a subarray in the queries.
*   **Storage Complexity:** O(N)

	
	# Code
	```python
	def solve():
    nums = [int(x) for x in input().split(",")]
    queries_str = input()
    queries_list = queries_str.strip("[]").split("],[")
    queries = []
    for q in queries_list:
        queries.append([int(x) for x in q.split(",")])

    def is_special(subarray):
        if len(subarray) < 2:
            return True
        for i in range(len(subarray) - 1):
            if subarray[i] % 2 == subarray[i+1] % 2:
                return False
        return True

    result = []
    for query in queries:
        from_index = query[0]
        to_index = query[1]
        sub_array = nums[from_index:to_index + 1]
        result.append(is_special(sub_array))

    print(result)

#Get input and process based on the prompt format

solve()
	```