# Solving Leetcode Interviews in Seconds with AI: Replace Elements in an Array


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2295" 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 a 0-indexed array nums that consists of n distinct positive integers. Apply m operations to this array, where in the ith operation you replace the number operations[i][0] with operations[i][1]. It is guaranteed that in the ith operation:  operations[i][0] exists in nums. operations[i][1] does not exist in nums.  Return the array obtained after applying all the operations.   Example 1:  Input: nums = [1,2,4,6], operations = [[1,3],[4,7],[6,1]] Output: [3,2,7,1] Explanation: We perform the following operations on nums: - Replace the number 1 with 3. nums becomes [3,2,4,6]. - Replace the number 4 with 7. nums becomes [3,2,7,6]. - Replace the number 6 with 1. nums becomes [3,2,7,1]. We return the final array [3,2,7,1].  Example 2:  Input: nums = [1,2], operations = [[1,3],[2,1],[3,2]] Output: [2,1] Explanation: We perform the following operations to nums: - Replace the number 1 with 3. nums becomes [3,2]. - Replace the number 2 with 1. nums becomes [3,1]. - Replace the number 3 with 2. nums becomes [2,1]. We return the array [2,1].    Constraints:  n == nums.length m == operations.length 1 <= n, m <= 105 All the values of nums are distinct. operations[i].length == 2 1 <= nums[i], operations[i][0], operations[i][1] <= 106 operations[i][0] will exist in nums when applying the ith operation. operations[i][1] will not exist in nums when applying the ith operation.  

	# Explanation
	Here's the solution to the problem, with explanations:

*   **High-Level Approach:**
    *   Use a dictionary (hash map) to store the index of each number in the `nums` array. This allows for O(1) lookup of the index of a number.
    *   Iterate through the `operations` array. For each operation, find the index of `operations[i][0]` in `nums` using the dictionary. Then, replace `nums[index]` with `operations[i][1]`. Update the dictionary to reflect the new value and its index.
*   **Complexity:**
    *   Runtime Complexity: O(n + m), where n is the length of `nums` and m is the length of `operations`.
    *   Storage Complexity: O(n), where n is the length of `nums` (for the dictionary).

	
	# Code
	```python
	def array_operations(nums, operations):
    """
    Applies a series of replacement operations on an array.

    Args:
        nums (list[int]): The input array of distinct positive integers.
        operations (list[list[int]]): A list of operations, where each operation is a list [old_value, new_value].

    Returns:
        list[int]: The modified array after applying all operations.
    """

    num_index_map = {num: i for i, num in enumerate(nums)}

    for old_value, new_value in operations:
        index = num_index_map[old_value]
        nums[index] = new_value
        num_index_map[new_value] = index
        del num_index_map[old_value]

    return nums
	```