# Solving Leetcode Interviews in Seconds with AI: Last Visited Integers


	# Introduction
	In this blog post, we will explore how to solve the LeetCode problem "2899" 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
	> Given an integer array nums where nums[i] is either a positive integer or -1. We need to find for each -1 the respective positive integer, which we call the last visited integer. To achieve this goal, let's define two empty arrays: seen and ans. Start iterating from the beginning of the array nums.  If a positive integer is encountered, prepend it to the front of seen. If -1 is encountered, let k be the number of consecutive -1s seen so far (including the current -1), 	 If k is less than or equal to the length of seen, append the k-th element of seen to ans. If k is strictly greater than the length of seen, append -1 to ans.    Return the array ans.   Example 1:  Input: nums = [1,2,-1,-1,-1] Output: [2,1,-1] Explanation: Start with seen = [] and ans = [].  Process nums[0]: The first element in nums is 1. We prepend it to the front of seen. Now, seen == [1]. Process nums[1]: The next element is 2. We prepend it to the front of seen. Now, seen == [2, 1]. Process nums[2]: The next element is -1. This is the first occurrence of -1, so k == 1. We look for the first element in seen. We append 2 to ans. Now, ans == [2]. Process nums[3]: Another -1. This is the second consecutive -1, so k == 2. The second element in seen is 1, so we append 1 to ans. Now, ans == [2, 1]. Process nums[4]: Another -1, the third in a row, making k = 3. However, seen only has two elements ([2, 1]). Since k is greater than the number of elements in seen, we append -1 to ans. Finally, ans == [2, 1, -1].   Example 2:  Input: nums = [1,-1,2,-1,-1] Output: [1,2,1] Explanation: Start with seen = [] and ans = [].  Process nums[0]: The first element in nums is 1. We prepend it to the front of seen. Now, seen == [1]. Process nums[1]: The next element is -1. This is the first occurrence of -1, so k == 1. We look for the first element in seen, which is 1. Append 1 to ans. Now, ans == [1]. Process nums[2]: The next element is 2. Prepend this to the front of seen. Now, seen == [2, 1]. Process nums[3]: The next element is -1. This -1 is not consecutive to the first -1 since 2 was in between. Thus, k resets to 1. The first element in seen is 2, so append 2 to ans. Now, ans == [1, 2]. Process nums[4]: Another -1. This is consecutive to the previous -1, so k == 2. The second element in seen is 1, append 1 to ans. Finally, ans == [1, 2, 1].     Constraints:  1 <= nums.length <= 100 nums[i] == -1 or 1 <= nums[i] <= 100  

	# Explanation
	Here's a breakdown of the solution:

*   **Simulate the Process:** The code directly implements the described algorithm, maintaining the `seen` and `ans` arrays as specified in the problem description.
*   **Track Consecutive -1s:** The code counts consecutive -1's to determine the index to access in the `seen` array. It resets this counter when a non -1 value is encountered.
*   **Handle Out-of-Bounds Access:** The code verifies that the calculated index for `seen` array access is within bounds, and if not, appends -1 to the `ans` array.

*   **Runtime Complexity:** O(n), where n is the length of the input array.
*   **Storage Complexity:** O(n), in the worst case, all elements could be positive, leading to `seen` potentially holding all elements.

	
	# Code
	```python
	def solve():
    nums = [1,2,-1,-1,-1]
    #nums = [1,-1,2,-1,-1]
    #nums = [1,2,3,-1,5,-1]

    seen = []
    ans = []
    k = 0

    for num in nums:
        if num > 0:
            seen.insert(0, num)
            k = 0 # Reset counter when positive num appears
        else:
            k += 1
            if k <= len(seen):
                ans.append(seen[k-1])
            else:
                ans.append(-1)

    print(ans)
    return ans

def find_last_visited(nums):
    seen = []
    ans = []
    k = 0

    for num in nums:
        if num > 0:
            seen.insert(0, num)
            k = 0  # Reset counter when a positive number appears
        else:
            k += 1
            if k <= len(seen):
                ans.append(seen[k - 1])
            else:
                ans.append(-1)

    return ans
	```