Count Zero Request Servers

Count Zero Request Servers - Problem

You are given an integer n denoting the total number of servers and a 2D 0-indexed integer array logs, where logs[i] = [server_id, time] denotes that the server with id server_id received a request at time time.

You are also given an integer x and a 0-indexed integer array queries.

Return a 0-indexed integer array arr of length queries.length where arr[i] represents the number of servers that did not receive any requests during the time interval [queries[i] - x, queries[i]].

Note that the time intervals are inclusive.

Input & Output

Example 1 — Basic Case

$ Input: n = 3, logs = [[1,3],[2,6],[1,5]], x = 5, queries = [10,11]

› Output: [1,2]

💡 Note: For query 10: window [5,10] contains logs [1,5] and [2,6], so servers {1,2} are active, leaving 1 server with zero requests. For query 11: window [6,11] contains only [2,6], so server {2} is active, leaving 2 servers with zero requests.

Example 2 — No Active Servers

$ Input: n = 2, logs = [[1,1],[2,2]], x = 1, queries = [5]

› Output: [2]

💡 Note: Query 5 with window [4,5] contains no logs, so all 2 servers have zero requests.

Example 3 — All Servers Active

$ Input: n = 3, logs = [[1,1],[2,2],[3,3]], x = 2, queries = [3]

› Output: [0]

💡 Note: Query 3 with window [1,3] contains all logs, so all 3 servers are active, leaving 0 servers with zero requests.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ logs.length ≤ 10⁵
1 ≤ queries.length ≤ 10⁵
logs[i].length == 2
1 ≤ logs[i][0] ≤ n
1 ≤ logs[i][1] ≤ 10⁶
1 ≤ x ≤ 10⁵
x + 1 ≤ queries[i] ≤ 10⁶

Visualization

Tap to expand

Asked in

a Amazon 25 G Google 18 M Microsoft 12 f Meta 8

The key insight is to efficiently find servers active in each time window [query-x, query]. The optimal approach sorts both logs by time and queries by value, then uses sliding window technique to process queries efficiently. Time: O(logs×log(logs) + queries×log(queries)), Space: O(logs + queries)

Common Approaches

✓ Optimized

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

Brute Force

⏱️ Time: O(queries × logs) Space: O(n)

For each query time interval, iterate through all logs to find which servers had requests. Count total servers minus active servers.

Sliding Window with Sorted Queries

⏱️ Time: O(logs×log(logs) + queries×log(queries) + logs + queries) Space: O(logs + queries)

Sort logs by time and queries with their indices. Use two pointers to maintain a sliding window of active logs for each query, avoiding redundant work.

Sort and Binary Search

⏱️ Time: O(logs×log(logs) + queries×logs) Space: O(logs + n)

Pre-sort all logs by timestamp, then for each query use binary search to efficiently find the range of logs within the time window.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int server_id;
    int time;
} Log;

void parseIntArray(const char* input, int* arr, int* size) {
    *size = 0;
    const char* p = input;
    
    while (*p) {
        while (*p && !isdigit(*p) && *p != '-') p++;
        if (*p == '\0') break;
        
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

void parseLogArray(const char* input, Log* logs, int* size) {
    *size = 0;
    const char* p = input;
    
    while (*p) {
        // Find opening bracket
        while (*p && *p != '[') p++;
        if (*p == '\0') break;
        p++; // skip '['
        
        // Parse server_id
        while (*p && !isdigit(*p) && *p != '-') p++;
        if (*p == '\0') break;
        logs[*size].server_id = (int)strtol(p, (char**)&p, 10);
        
        // Find comma
        while (*p && *p != ',') p++;
        if (*p == '\0') break;
        p++; // skip ','
        
        // Parse time
        while (*p && !isdigit(*p) && *p != '-') p++;
        if (*p == '\0') break;
        logs[*size].time = (int)strtol(p, (char**)&p, 10);
        
        (*size)++;
        
        // Find closing bracket
        while (*p && *p != ']') p++;
        if (*p) p++;
    }
}

void solution(int n, Log* logs, int log_count, int x, int* queries, int query_count, int* result) {
    for (int i = 0; i < query_count; i++) {
        int query = queries[i];
        int active_servers[1001] = {0}; // assuming server ids are <= 1000
        int start_time = query - x;
        int end_time = query;
        
        for (int j = 0; j < log_count; j++) {
            if (start_time <= logs[j].time && logs[j].time <= end_time) {
                active_servers[logs[j].server_id] = 1;
            }
        }
        
        int active_count = 0;
        for (int k = 1; k <= n; k++) {
            if (active_servers[k]) active_count++;
        }
        
        result[i] = n - active_count;
    }
}

int main() {
    char line[2000];
    
    // Read n
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    int n = atoi(line);
    
    // Read logs
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    Log logs[1000];
    int log_count;
    parseLogArray(line, logs, &log_count);
    
    // Read x
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    int x = atoi(line);
    
    // Read queries
    fgets(line, sizeof(line), stdin);
    line[strcspn(line, "\n")] = 0;
    int queries[1000];
    int query_count;
    parseIntArray(line, queries, &query_count);
    
    int result[1000];
    solution(n, logs, log_count, x, queries, query_count, result);
    
    printf("[");
    for (int i = 0; i < query_count; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

⚡ Linearithmic

Space Complexity

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

856 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