2747. Count Zero Request Servers

/**
 * Problem: LeetCode 2747 - Count Zero Request Servers
 * Difficulty: Medium
 * Language: Java
 * Author: CodeByTushu
 */
import java.util.*;

class Solution {
    public int[] countServers(int n, int[][] logs, int x, int[] queries) {
        // Sort logs by timestamp ascending
        Arrays.sort(logs, (a, b) -> Integer.compare(a[1], b[1]));

        int qn = queries.length;
        Integer[] order = new Integer[qn];
        for (int i = 0; i < qn; i++) order[i] = i;
        Arrays.sort(order, (a, b) -> Integer.compare(queries[a], queries[b]));

        int[] cnt = new int[n + 1];
        int[] ans = new int[qn];
        int active = 0;
        int l = 0, r = 0;
        int m = logs.length;

        for (int idx : order) {
            int q = queries[idx];

            // Ingest logs with timestamp <= q
            while (r < m && logs[r][1] <= q) {
                if (cnt[logs[r][0]]++ == 0) active++;
                r++;
            }

            // Evict expired logs with timestamp < q - x
            while (l < r && logs[l][1] < q - x) {
                if (--cnt[logs[l][0]] == 0) active--;
                l++;
            }

            ans[idx] = n - active;
        }

        return ans;
    }
}

"""
Problem: LeetCode 2747 - Count Zero Request Servers
Difficulty: Medium
Language: Python (Python 3)
Author: CodeByTushu
"""

from typing import List

class Solution:
    def countServers(self, n: int, logs: List[List[int]], x: int, queries: List[int]) -> List[int]:
        # Sort logs by timestamp
        logs.sort(key=lambda item: item[1])
        
        qn = len(queries)
        order = sorted(range(qn), key=lambda i: queries[i])
        
        cnt = [0] * (n + 1)
        ans = [0] * qn
        active = 0
        l = 0
        r = 0
        m = len(logs)
        
        for idx in order:
            q = queries[idx]
            
            # Add logs with time <= q
            while r < m and logs[r][1] <= q:
                server = logs[r][0]
                if cnt[server] == 0:
                    active += 1
                cnt[server] += 1
                r += 1
                
            # Remove logs with time < q - x
            while l < r and logs[l][1] < q - x:
                server = logs[l][0]
                cnt[server] -= 1
                if cnt[server] == 0:
                    active -= 1
                l += 1
                
            ans[idx] = n - active
            
        return ans

/**
 * Problem: LeetCode 2747 - Count Zero Request Servers
 * Difficulty: Medium
 * Language: C++
 * Author: CodeByTushu
 */

#include <vector>
#include <algorithm>
#include <numeric>

using namespace std;

class Solution {
public:
    vector<int> countServers(int n, vector<vector<int>>& logs, int x, vector<int>& queries) {
        // Sort logs by timestamp
        sort(logs.begin(), logs.end(), [](const vector<int>& a, const vector<int>& b) {
            return a[1] < b[1];
        });

        int qn = queries.size();
        vector<int> order(qn);
        iota(order.begin(), order.end(), 0);
        sort(order.begin(), order.end(), [&](int a, int b) {
            return queries[a] < queries[b];
        });

        vector<int> cnt(n + 1, 0);
        vector<int> ans(qn, 0);
        int active = 0;
        int l = 0, r = 0;
        int m = logs.size();

        for (int idx : order) {
            int q = queries[idx];

            // Add logs with time <= q
            while (r < m && logs[r][1] <= q) {
                int server = logs[r][0];
                if (cnt[server]++ == 0) active++;
                r++;
            }

            // Remove logs with time < q - x
            while (l < r && logs[l][1] < q - x) {
                int server = logs[l][0];
                if (--cnt[server] == 0) active--;
                l++;
            }

            ans[idx] = n - active;
        }

        return ans;
    }
};

/**
 * Problem: LeetCode 2747 - Count Zero Request Servers
 * Difficulty: Medium
 * Language: JavaScript
 * Author: CodeByTushu
 */

/**
 * @param {number} n
 * @param {number[][]} logs
 * @param {number} x
 * @param {number[]} queries
 * @return {number[]}
 */
var countServers = function(n, logs, x, queries) {
    // Sort logs by timestamp ascending
    logs.sort((a, b) => a[1] - b[1]);

    const qn = queries.length;
    const order = Array.from({ length: qn }, (_, i) => i);
    order.sort((a, b) => queries[a] - queries[b]);

    const cnt = new Int32Array(n + 1);
    const ans = new Int32Array(qn);
    let active = 0;
    let l = 0, r = 0;
    const m = logs.length;

    for (let i = 0; i < qn; i++) {
        const idx = order[i];
        const q = queries[idx];

        // Add logs with time <= q
        while (r < m && logs[r][1] <= q) {
            const server = logs[r][0];
            if (cnt[server] === 0) active++;
            cnt[server]++;
            r++;
        }

        // Remove logs with time < q - x
        while (l < r && logs[l][1] < q - x) {
            const server = logs[l][0];
            cnt[server]--;
            if (cnt[server] === 0) active--;
            l++;
        }

        ans[idx] = n - active;
    }

    return Array.from(ans);
};