Employee Time Tracking Analysis

Many organizations track employee work hours to manage payroll, project costing, and resource allocation. This challenge requires you to analyze a dataset of employee time entries and calculate the total time each employee has spent working. This is a common task in time management and project management systems.

Problem Description

You are given a dataset representing employee time entries. Each entry contains an employee ID, a start time, and an end time. Your task is to calculate the total time spent working by each employee. The total time should be calculated in minutes.

What needs to be achieved:

• Process a list of time entries.
• Group the entries by employee ID.
• Calculate the duration of each entry in minutes.
• Sum the durations for each employee to determine their total working time.
• Return a data structure (e.g., a dictionary/map/hash table) where keys are employee IDs and values are their total working time in minutes.

Key Requirements:

• Input data will be provided as a list of tuples/arrays/objects. Each element in the list represents a time entry.
• Start and end times will be represented in a consistent format (e.g., "YYYY-MM-DD HH:MM:SS" or Unix timestamps). Assume the format is consistent throughout the input.
• The calculation must accurately account for durations that span across days.
• The output should be a clear and easily interpretable representation of the results.

Expected Behavior:

The function/program should take the list of time entries as input and return a dictionary/map/hash table where the keys are employee IDs and the values are the total time spent working by that employee in minutes.

Edge Cases to Consider:

• Empty input list: Should return an empty dictionary/map/hash table.
• Time entries with the same start and end time: Should contribute 0 minutes to the employee's total time.
• End time before start time: Consider this an invalid entry and ignore it (or handle it according to specific requirements - clarify this if needed).
• Large datasets: Consider efficiency and potential performance bottlenecks.

Examples

Example 1:

Input: [
    (101, "2023-10-26 09:00:00", "2023-10-26 10:30:00"),
    (102, "2023-10-26 10:00:00", "2023-10-26 12:00:00"),
    (101, "2023-10-26 14:00:00", "2023-10-26 15:00:00"),
    (102, "2023-10-27 08:00:00", "2023-10-27 09:00:00")
]
Output: {101: 210, 102: 240}
Explanation: Employee 101 worked for 90 minutes on 2023-10-26 and 60 minutes on 2023-10-26, totaling 150 minutes. Employee 102 worked for 120 minutes on 2023-10-26 and 60 minutes on 2023-10-27, totaling 180 minutes.

Example 2:

Input: []
Output: {}
Explanation: The input list is empty, so the output is an empty dictionary.

Example 3: (Edge Case - End time before start time)

Input: [
    (101, "2023-10-26 11:00:00", "2023-10-26 09:00:00")
]
Output: {}
Explanation: The entry is invalid (end time before start time), so it's ignored, and the output is an empty dictionary.

Constraints

• The number of time entries can range from 0 to 10,000.
• Start and end times will be in a consistent string format (e.g., "YYYY-MM-DD HH:MM:SS").
• Employee IDs will be integers.
• The time difference between start and end times for any single entry will be no more than 24 hours.
• The solution should have a time complexity of O(n), where n is the number of time entries.

Notes

• You will need to parse the date/time strings into a format that allows for time difference calculations. Consider using a built-in date/time library for your chosen language.
• Focus on clarity and readability in your code.
• Consider how to handle potential errors or invalid input gracefully.
• Think about how to efficiently group the time entries by employee ID. A dictionary/hash table is generally a good choice for this.
• The specific data structure for representing the input and output can be adapted to your chosen language. The key is to clearly define the format.