# Solving Leetcode Interviews in Seconds with AI: Most Frequent Number Following Key In an Array


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2190" 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 integer array nums. You are also given an integer key, which is present in nums. For every unique integer target in nums, count the number of times target immediately follows an occurrence of key in nums. In other words, count the number of indices i such that:  0 <= i <= nums.length - 2, nums[i] == key and, nums[i + 1] == target.  Return the target with the maximum count. The test cases will be generated such that the target with maximum count is unique.   Example 1:  Input: nums = [1,100,200,1,100], key = 1 Output: 100 Explanation: For target = 100, there are 2 occurrences at indices 1 and 4 which follow an occurrence of key. No other integers follow an occurrence of key, so we return 100.  Example 2:  Input: nums = [2,2,2,2,3], key = 2 Output: 2 Explanation: For target = 2, there are 3 occurrences at indices 1, 2, and 3 which follow an occurrence of key. For target = 3, there is only one occurrence at index 4 which follows an occurrence of key. target = 2 has the maximum number of occurrences following an occurrence of key, so we return 2.    Constraints:  2 <= nums.length <= 1000 1 <= nums[i] <= 1000 The test cases will be generated such that the answer is unique.  

	# Explanation
	Here's the solution to the problem:

*   **High-level approach:**
    *   Iterate through the `nums` array, checking for occurrences of `key`.
    *   When `key` is found, increment the count for the subsequent element (`target`) in a dictionary (or hash map).
    *   Find the target with the maximum count and return it.

*   **Complexity:**
    *   Runtime: O(n), where n is the length of the `nums` array.
    *   Storage: O(k), where k is the number of unique elements in `nums` that immediately follow an occurence of `key`. In the worst case scenario, this could be O(n).

	
	# Code
	```python
	def mostFrequent(nums: list[int], key: int) -> int:
    """
    Finds the target with the maximum count of occurrences immediately following the key in the nums array.
    """

    counts = {}
    for i in range(len(nums) - 1):
        if nums[i] == key:
            target = nums[i + 1]
            counts[target] = counts.get(target, 0) + 1

    max_count = 0
    most_frequent_target = -1

    for target, count in counts.items():
        if count > max_count:
            max_count = count
            most_frequent_target = target

    return most_frequent_target
	```