Full Question — IP Request Validation System You ...

Your rate-limit logic is basically right. The likely hidden-test failure is in the wildcard matcher, so I’m checking its exact * = one or more characters behavior and edge cases rather than changing the 5-second window blindly.

I found the likely reason you’re getting 13/15. Your rate-limiting logic is correct; the issue is almost certainly the semantics of *.

The publicly posted versions of this UBS OA problem specify that * matches zero or more characters, not one or more. (LeetCode)

Bug in your matcher

Your current transition:

cpp
if (p[j - 1] == '*') {
    if (i > 0)
        dp[i][j] = dp[i - 1][j] || dp[i - 1][j - 1];
}

forces * to consume at least one character.

For * = zero or more characters, you need:

cpp
dp[i][j] = dp[i][j - 1] || (i > 0 && dp[i - 1][j]);

The two cases are:

text
dp[i][j - 1]  -> '*' matches zero characters
dp[i - 1][j]  -> '*' consumes one more character

So use this:

cpp
bool match(const string& s, const string& p) {
    int n = s.size(), m = p.size();

    vector<vector<bool>> dp(n + 1, vector<bool>(m + 1, false));
    dp[0][0] = true;

    for (int j = 1; j <= m; j++) {
        if (p[j - 1] == '*')
            dp[0][j] = dp[0][j - 1];
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= m; j++) {
            if (p[j - 1] == '*') {
                // zero chars OR one/more chars
                dp[i][j] = dp[i][j - 1] || dp[i - 1][j];
            }
            else if (s[i - 1] == p[j - 1]) {
                dp[i][j] = dp[i - 1][j - 1];
            }
        }
    }

    return dp[n][m];
}

Your validateRequests() can otherwise stay essentially unchanged:

cpp
vector<int> validateRequests(
    vector<string> blacklisted_ips,
    vector<string> requests
) {
    unordered_map<string, deque<int>> mp;
    vector<int> ans;

    for (int i = 0; i < requests.size(); i++) {
        const string& ip = requests[i];
        bool blocked = false;

        // Rule 1: blacklist
        for (const string& p : blacklisted_ips) {
            if (match(ip, p)) {
                blocked = true;
                break;
            }
        }

        // Rule 2: rate limiting
        if (!blocked) {
            auto& q = mp[ip];

            // Requests exactly 5 seconds old are NOT counted.
            while (!q.empty() && q.front() <= i - 5)
                q.pop_front();

            if (q.size() >= 2) {
                blocked = true;
            } else {
                // Only store UNBLOCKED requests.
                q.push_back(i);
            }
        }

        ans.push_back(blocked ? 1 : 0);
    }

    return ans;
}

Your 5-second logic is correct

This part:

cpp
while (!q.empty() && q.front() <= i - 5)
    q.pop_front();

is correct.

At time 7 (i = 6 zero-based):

text
i - 5 = 1

so the request at zero-based index 1 (time 2) gets removed, while the request at index 2 (time 3) remains.

And you're correctly not inserting blocked requests:

cpp
if (q.size() >= 2)
    blocked = true;
else
    q.push_back(i);

That's exactly why the blocked request at time 5 doesn't affect time 7.

One more thing: your pasted sample is inconsistent

You have:

text
blacklist:
12.*

request:
12.13.5.255

Under either “one or more” or “zero or more” wildcard semantics, 12.* matches 12.13.5.255, so that request should be blocked. Thus the sample output you pasted cannot simultaneously be correct with the stated wildcard rules; there's likely a transcription error in that sample.

For the 13/15 issue, however, I'd submit the zero-or-more * version above. That's the semantics found in the available versions of this exact UBS validation problem. (LeetCode)