Longest Uploaded Prefix

Longest Uploaded Prefix - Problem

Hash Table Binary Search Union Find Design Binary Indexed Tree Segment Tree Heap (Priority Queue) Ordered Set Medium

You are given a stream of n videos, each represented by a distinct number from 1 to n that you need to upload to a server. You need to implement a data structure that calculates the length of the longest uploaded prefix at various points in the upload process.

We consider i to be an uploaded prefix if all videos in the range 1 to i (inclusive) have been uploaded to the server. The longest uploaded prefix is the maximum value of i that satisfies this definition.

Implement the LUPrefix class:

LUPrefix(int n) Initializes the object for a stream of n videos.
void upload(int video) Uploads video to the server.
int longest() Returns the length of the longest uploaded prefix defined above.

Input & Output

Example 1 — Basic Operation Sequence

$ Input: operations = [["LUPrefix",4],["upload",3],["longest"],["upload",1],["longest"],["upload",2],["longest"]]

› Output: [null,null,0,null,1,null,3]

💡 Note: Initialize with n=4. Upload 3: longest prefix is 0 (video 1 missing). Upload 1: prefix is 1. Upload 2: now videos 1,2,3 are consecutive, so prefix is 3.

Example 2 — Sequential Uploads

$ Input: operations = [["LUPrefix",3],["upload",1],["longest"],["upload",2],["longest"],["upload",3],["longest"]]

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

💡 Note: Upload in order 1,2,3. Each upload extends the prefix: 1→1, 2→2, 3→3.

Example 3 — Reverse Order

$ Input: operations = [["LUPrefix",2],["upload",2],["longest"],["upload",1],["longest"]]

› Output: [null,null,0,null,2]

💡 Note: Upload 2 first: prefix is 0 (video 1 missing). Upload 1: now both 1,2 are uploaded, prefix becomes 2.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ video ≤ n
All values of video are distinct
At most 2 × 10⁵ calls will be made to upload and longest

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 20 f Meta 15

The key insight is to maintain the current prefix length and extend it efficiently when consecutive videos become available. The optimized approach uses a boolean array to track uploads and maintains the current prefix length, extending it in O(1) amortized time per upload. Time: O(n) total for all operations, Space: O(n) for the boolean array.

Common Approaches

✓ Greedy

⏱️ Time: N/A Space: N/A

Monotonic Stack

⏱️ Time: N/A Space: N/A

Boolean Array with Prefix Tracking

⏱️ Time: O(n) Space: O(n)

Use a boolean array to mark uploaded videos and keep track of the current prefix length. When a video is uploaded, extend the prefix if possible by checking consecutive videos.

Brute Force with Set Check

⏱️ Time: O(n) Space: O(n)

Use a hash set to store uploaded videos. For each longest() query, iterate from 1 to n checking if each video exists in the set until we find a gap.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int solution(int* arr, int n) {
    if (n == 0) {
        return 0;
    }
    
    int* sortedArr = malloc(n * sizeof(int));
    memcpy(sortedArr, arr, n * sizeof(int));
    qsort(sortedArr, n, sizeof(int), compare);
    
    int chunks = 0;
    
    for (int i = 0; i < n; i++) {
        // Check if we can make a cut after position i
        // Sort both prefixes and compare
        int* leftPrefix = malloc((i + 1) * sizeof(int));
        int* expectedPrefix = malloc((i + 1) * sizeof(int));
        
        memcpy(leftPrefix, arr, (i + 1) * sizeof(int));
        memcpy(expectedPrefix, sortedArr, (i + 1) * sizeof(int));
        
        qsort(leftPrefix, i + 1, sizeof(int), compare);
        
        // Compare sorted prefixes
        int match = 1;
        for (int j = 0; j <= i; j++) {
            if (leftPrefix[j] != expectedPrefix[j]) {
                match = 0;
                break;
            }
        }
        
        if (match) {
            chunks++;
        }
        
        free(leftPrefix);
        free(expectedPrefix);
    }
    
    free(sortedArr);
    return chunks;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse JSON array
    int arr[1000];
    int n = 0;
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != '\n') {
            arr[n++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(arr, n);
    printf("%d\n", result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~25 min Avg. Time

450 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