Application logs are used in analysis of interacti...

Below is one acceptable Java solution. In this solution, we process the logs by storing each user’s sign‐in and sign‐out timestamps in separate maps. Then, we iterate through the sign‐in entries, and if the corresponding sign‐out exists and the time difference is less than or equal to maxSpan, we add that user id (converted to an integer so that sorting is done numerically) to the result list. Finally, we sort the list and convert the integers back to strings.

Below is the complete code:

java
import java.util.*;

public class LogProcessor {

    public static List<String> processLogs(String[] logs, int maxSpan) {
        // Map to store the sign-in time for each user.
        Map<String, Integer> signInMap = new HashMap<>();
        // Map to store the sign-out time for each user.
        Map<String, Integer> signOutMap = new HashMap<>();
        
        // Process each log entry.
        for (String log : logs) {
            // Split the log entry by space.
            String[] parts = log.split(" ");
            String userId = parts[0];
            int timestamp = Integer.parseInt(parts[1]);
            String action = parts[2];
            
            if (action.equals("sign-in")) {
                signInMap.put(userId, timestamp);
            } else if (action.equals("sign-out")) {
                signOutMap.put(userId, timestamp);
            }
        }
        
        // List to store valid user IDs (as integers for numeric sorting).
        List<Integer> validUsers = new ArrayList<>();
        // Check each user who has signed in.
        for (String userId : signInMap.keySet()) {
            if (signOutMap.containsKey(userId)) {
                int signInTime = signInMap.get(userId);
                int signOutTime = signOutMap.get(userId);
                if (signOutTime - signInTime <= maxSpan) {
                    validUsers.add(Integer.parseInt(userId));
                }
            }
        }
        
        // Sort numerically.
        Collections.sort(validUsers);
        
        // Convert the user IDs back to strings.
        List<String> result = new ArrayList<>();
        for (int id : validUsers) {
            result.add(String.valueOf(id));
        }
        
        return result;
    }
    
    // For testing purposes.
    public static void main(String[] args) {
        String[] logs = {
            "30 99 sign-in", 
            "30 105 sign-out", 
            "12 100 sign-in", 
            "20 80 sign-in", 
            "12 120 sign-out", 
            "20 101 sign-out", 
            "21 110 sign-in"
        };
        int maxSpan = 20;
        
        List<String> validUsers = processLogs(logs, maxSpan);
        System.out.println(validUsers);  // Expected output: ["12", "30"]
    }
}

Explanation

1. Parsing the Logs:
   Each log entry is split using split(" ") into userId, timestamp, and action. We then parse the timestamp from a string to an integer.

2. Storing the Timestamps:
   We use two maps: one for sign-in times and one for sign-out times. This ensures that even if the logs are unsorted, we correctly associate the sign-in and sign-out events for each user.

3. Determining Valid Users:
   We iterate through all users that have a sign-in event. For each, we check if there is a corresponding sign-out and if the difference (signOutTime - signInTime) is within the allowed maxSpan.

4. Sorting Numerically:
   Since user IDs are strings but need to be sorted numerically, we convert them to integers, sort them, and then convert back to strings.

5. Testing:
   The main method includes a test with the example provided. When run, it prints the expected output ["12", "30"].

This solution meets the problem requirements and handles the logs even when they are not in chronological order.