Untitled

import java.io.*;
import java.util.*;
import java.util.regex.*;
import java.util.stream.Collectors;

class Result {

    /*
     * Complete the 'validateRequests' function below.
     *
     * The function is expected to return an INTEGER_ARRAY.
     * The function accepts following parameters:
     *  1. STRING_ARRAY blacklisted_ips
     *  2. STRING_ARRAY requests
     */

    public static List<Integer> validateRequests(List<String> blacklisted_ips, List<String> requests) {
        // Precompile the regex patterns for blacklist IPs
        List<Pattern> patterns = blacklisted_ips.stream()
                .map(ip -> ip.replace("*", ".*")) // Convert wildcard to regex
                .map(Pattern::compile)
                .collect(Collectors.toList());

        // Map to keep track of the timestamps of the requests (for rate limiting)
        Map<String, Deque<Integer>> ipTimestamps = new HashMap<>();

        // List to store the result for each request
        List<Integer> results = new ArrayList<>();

        for (int i = 0; i < requests.size(); i++) {
            String requestIP = requests.get(i);
            boolean isBlocked = false;

            // Check against blacklist
            for (Pattern pattern : patterns) {
                if (pattern.matcher(requestIP).matches()) {
                    isBlocked = true;
                    break;
                }
            }

            // Check rate limit only if not already blocked by blacklist
            if (!isBlocked) {
                ipTimestamps.putIfAbsent(requestIP, new ArrayDeque<>());
                Deque<Integer> timestamps = ipTimestamps.get(requestIP);

                // Remove timestamps outside the 5-second sliding window
                while (!timestamps.isEmpty() && i - timestamps.peek() >= 5) {
                    timestamps.poll();
                }

                // Check if the rate limit is exceeded
                if (timestamps.size() >= 2) {
                    isBlocked = true;
                } else {
                    // If not blocked, record the current timestamp
                    timestamps.offer(i);
                }
            }

            // Add the result for the current request
            results.add(isBlocked ? 1 : 0);
        }

        return results;
    }
}

public class Solution {
    public static void main(String[] args) throws IOException {
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

        int blacklisted_ipsCount = Integer.parseInt(bufferedReader.readLine().trim());
        List<String> blacklisted_ips = new ArrayList<>();

        for (int i = 0; i < blacklisted_ipsCount; i++) {
            String blacklisted_ipsItem = bufferedReader.readLine();
            blacklisted_ips.add(blacklisted_ipsItem);
        }

        int requestsCount = Integer.parseInt(bufferedReader.readLine().trim());
        List<String> requests = new ArrayList<>();

        for (int i = 0; i < requestsCount; i++) {
            String requestsItem = bufferedReader.readLine();
            requests.add(requestsItem);
        }

        List<Integer> result = Result.validateRequests(blacklisted_ips, requests);

        for (int i = 0; i < result.size(); i++) {
            System.out.println(result.get(i));
        }

        bufferedReader.close();
    }
}