# Solving Leetcode Interviews in Seconds with AI: Number of Adjacent Elements With the Same Color


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2672" 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 integer n representing an array colors of length n where all elements are set to 0's meaning uncolored. You are also given a 2D integer array queries where queries[i] = [indexi, colori]. For the ith query:  Set colors[indexi] to colori. Count adjacent pairs in colors set to the same color (regardless of colori).  Return an array answer of the same length as queries where answer[i] is the answer to the ith query.   Example 1:  Input: n = 4, queries = [[0,2],[1,2],[3,1],[1,1],[2,1]] Output: [0,1,1,0,2] Explanation:  Initially array colors = [0,0,0,0], where 0 denotes uncolored elements of the array. After the 1st query colors = [2,0,0,0]. The count of adjacent pairs with the same color is 0. After the 2nd query colors = [2,2,0,0]. The count of adjacent pairs with the same color is 1. After the 3rd query colors = [2,2,0,1]. The count of adjacent pairs with the same color is 1. After the 4th query colors = [2,1,0,1]. The count of adjacent pairs with the same color is 0. After the 5th query colors = [2,1,1,1]. The count of adjacent pairs with the same color is 2.   Example 2:  Input: n = 1, queries = [[0,100000]] Output: [0] Explanation: After the 1st query colors = [100000]. The count of adjacent pairs with the same color is 0.    Constraints:  1 <= n <= 105 1 <= queries.length <= 105 queries[i].length == 2 0 <= indexi <= n - 1 1 <=  colori <= 105  

	# Explanation
	Here's the breakdown of the approach, complexity, and the Python code:

*   **High-level approach:**
    *   Initialize the `colors` array with 0s.
    *   Iterate through the `queries`. For each query, update the color at the given index.
    *   After each update, calculate the number of adjacent pairs with the same color by iterating through the `colors` array.

*   **Complexity:**
    *   Runtime Complexity: O(n*q) where n is the length of the `colors` array, and q is the length of the `queries` array.
    *   Storage Complexity: O(n)

	
	# Code
	```python
	def count_adjacent_pairs(n: int, queries: list[list[int]]) -> list[int]:
    """
    Calculates the number of adjacent pairs with the same color after each query.

    Args:
        n: The length of the colors array.
        queries: A list of queries, where each query is a list of [index, color].

    Returns:
        A list of integers, where each integer is the number of adjacent pairs with the same color after the corresponding query.
    """

    colors = [0] * n
    answer = []

    for index, color in queries:
        colors[index] = color
        count = 0
        for i in range(n - 1):
            if colors[i] == colors[i + 1] and colors[i] != 0:
                count += 1
        answer.append(count)

    return answer
	```