#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#define MAX_PROCESSES 10000
#define MAX_MACHINES 1000

typedef struct {
    int machine_id;
    int process_id;
    char activity_type[10];
    double timestamp;
} Activity;

typedef struct {
    int machine_id;
    double start_time;
} ProcessInfo;

typedef struct {
    char key[50];
    ProcessInfo info;
} ProcessMapEntry;

int hash_func(char* key, int size) {
    int hash = 0;
    for (int i = 0; key[i]; i++) {
        hash = hash * 31 + key[i];
    }
    return abs(hash) % size;
}

ProcessInfo* find_process(ProcessMapEntry* map, int size, char* key) {
    int index = hash_func(key, size);
    while (map[index].key[0] != '\0') {
        if (strcmp(map[index].key, key) == 0) {
            return &map[index].info;
        }
        index = (index + 1) % size;
    }
    return NULL;
}

void insert_process(ProcessMapEntry* map, int size, char* key, ProcessInfo info) {
    int index = hash_func(key, size);
    while (map[index].key[0] != '\0') {
        index = (index + 1) % size;
    }
    strcpy(map[index].key, key);
    map[index].info = info;
}

typedef struct {
    int machine_id;
    double processing_time;
} Result;

Result* solution(Activity* activities, int size, int* result_size) {
    ProcessMapEntry process_map[MAX_PROCESSES] = {0};
    
    double processing_times[MAX_PROCESSES];
    int machine_ids[MAX_PROCESSES];
    int processing_count = 0;
    
    // Single pass through activities
    for (int i = 0; i < size; i++) {
        char key[50];
        sprintf(key, "%d_%d", activities[i].machine_id, activities[i].process_id);
        
        if (strcmp(activities[i].activity_type, "start") == 0) {
            ProcessInfo info = {activities[i].machine_id, activities[i].timestamp};
            insert_process(process_map, MAX_PROCESSES, key, info);
        } else { // end
            ProcessInfo* info = find_process(process_map, MAX_PROCESSES, key);
            if (info != NULL) {
                double processing_time = activities[i].timestamp - info->start_time;
                processing_times[processing_count] = processing_time;
                machine_ids[processing_count] = info->machine_id;
                processing_count++;
            }
        }
    }
    
    // Group by machine and calculate averages
    double machine_time_sums[MAX_MACHINES] = {0};
    int machine_counts[MAX_MACHINES] = {0};
    int unique_machines[MAX_MACHINES];
    int machine_count = 0;
    
    for (int i = 0; i < processing_count; i++) {
        int machine_id = machine_ids[i];
        int machine_index = -1;
        
        for (int j = 0; j < machine_count; j++) {
            if (unique_machines[j] == machine_id) {
                machine_index = j;
                break;
            }
        }
        
        if (machine_index == -1) {
            machine_index = machine_count;
            unique_machines[machine_count++] = machine_id;
        }
        
        machine_time_sums[machine_index] += processing_times[i];
        machine_counts[machine_index]++;
    }
    
    Result* results = malloc(machine_count * sizeof(Result));
    *result_size = machine_count;
    
    for (int i = 0; i < machine_count; i++) {
        double average = machine_time_sums[i] / machine_counts[i];
        results[i].machine_id = unique_machines[i];
        results[i].processing_time = round(average * 1000.0) / 1000.0;
    }
    
    return results;
}