Last Visited Integers - Practice Coding Problems

Last Visited Integers - Problem

Array Simulation Easy

🔍 Track the Last Visited Integers

Imagine you're building a smart browsing history that tracks positive integers you've seen. When you encounter a special -1 token, you need to look back at your history to find specific previously visited integers.

Here's how it works:

🔢 When you see a positive integer, add it to the front of your history (most recent first)
❓ When you see a -1, count how many consecutive -1s you've seen (including this one) - call this k
📋 If k ≤ history_length, return the k-th element from your history
🚫 If k > history_length, return -1 (not enough history)

Goal: Return an array containing the results for each -1 encountered.

Example: [1, 2, -1, -1, 3, -1, -1, -1]
History builds: [1] → [2, 1] → first -1 (k=1) returns 2 → second -1 (k=2) returns 1 → add 3: [3, 2, 1] → continue...

Input & Output

example_1.py — Basic Case

$ Input: [1, 2, -1, -1, 3, -1, -1, -1]

› Output: [2, 1, 3, 3, -1]

💡 Note: Process: 1→seen=[1], 2→seen=[2,1], -1(k=1)→result=[2], -1(k=2)→result=[2,1], 3→seen=[3,2,1],count=0, -1(k=1)→result=[2,1,3], -1(k=2)→result=[2,1,3,3], -1(k=3)→seen only has 3 elements, so result=[2,1,3,3,-1]

example_2.py — Only Positive

$ Input: [1, 2, 3, 4]

› Output: []

💡 Note: No -1 encountered, so result array remains empty. The seen array builds up as [4,3,2,1] but no queries are made.

example_3.py — Edge Case

$ Input: [-1, -1, -1]

› Output: [-1, -1, -1]

💡 Note: No positive integers seen, so seen array is empty. All three -1s result in -1 since k > len(seen) for each query.

Constraints

1 ≤ nums.length ≤ 100
nums[i] == -1 or 1 ≤ nums[i] ≤ 100
All positive integers are distinct
The array will contain at least one -1 or one positive integer

Visualization

Tap to expand

Understanding the Visualization

Book Return

When a book is returned (positive integer), place it on top of the stack

Query Request

When someone asks for a book (-1), increment the request counter

Stack Lookup

Look k positions down from the top of the stack

Reset on Return

Counter resets to 0 when a new book is returned

Key Takeaway

🎯 Key Insight: Track consecutive -1s with a simple counter that resets when positive integers appear. This eliminates the need to scan backwards through the array each time!

Asked in

a Amazon 35 G Google 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a single pass with a consecutive counter. Maintain a seen array (most recent first) and track consecutive -1s with a counter that resets on positive integers. For each -1, increment the counter and use it to index into the seen array. Time: O(n²) due to front insertion, Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Optimal Single Pass with Counter	O(n²)	O(n)	Track consecutive -1 count and reset when seeing positive integers
Brute Force (Linear Search)	O(n²)	O(n)	Track history and search linearly for each query

Optimal Single Pass with Counter — Algorithm Steps

Initialize seen list, result list, and consecutive_count = 0
Iterate through nums array once
For positive integers: prepend to seen, reset consecutive_count = 0
For -1: increment consecutive_count, use it as k
Access k-th element from seen or append -1 if out of bounds

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with empty seen array and consecutive_count = 0

Process Elements

For positive: add to front, reset count. For -1: increment count

Query History

Use consecutive_count as index into seen array

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int* lastVisitedIntegers(int* nums, int numsSize, int* returnSize) {
    int* seen = (int*)malloc(numsSize * sizeof(int));
    int* result = (int*)malloc(numsSize * sizeof(int));
    int seenSize = 0;
    int consecutiveCount = 0;
    *returnSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        if (nums[i] > 0) {
            // Add positive integer to front of seen
            memmove(seen + 1, seen, seenSize * sizeof(int));
            seen[0] = nums[i];
            seenSize++;
            consecutiveCount = 0; // Reset count
        } else { // nums[i] == -1
            consecutiveCount++;
            
            // Get consecutiveCount-th element from seen (1-indexed)
            if (consecutiveCount <= seenSize) {
                result[*returnSize] = seen[consecutiveCount - 1];
            } else {
                result[*returnSize] = -1;
            }
            (*returnSize)++;
        }
    }
    
    free(seen);
    return result;
}

int main() {
    int nums[1000];
    int count = 0;
    int num;
    
    while (scanf("%d", &num) == 1) {
        nums[count++] = num;
        if (getchar() == '\n') break;
    }
    
    int returnSize;
    int* result = lastVisitedIntegers(nums, count, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

O(n) for iteration, but insert at front of seen list takes O(n) in worst case, making overall O(n²)

⚠ Quadratic Growth

Space Complexity

O(n)

Space for seen list and result list

⚡ Linearithmic Space

28.0K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

🔍 Track the Last Visited Integers

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Optimal Single Pass with Counter — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler