Alert Using Same Key-Card Three or More Times in a One Hour Period solution and explanation

from collections import defaultdict

def alertNames(keyName, keyTime):
    def getMinutes(t):
        h, m = map(int, t.split(':'))
        return h * 60 + m

    access = defaultdict(list)

    for name, time in zip(keyName, keyTime):
        access[name].append(getMinutes(time))

    alerted = []

    for name, times in access.items():
        times.sort()
        for i in range(len(times) - 2):
            if times[i + 2] - times[i] <= 60:
                alerted.append(name)
                break

    return sorted(alerted)

import java.util.*;

class Solution {
    public List<String> alertNames(String[] keyName, String[] keyTime) {
        Map<String, List<Integer>> accessMap = new HashMap<>();

        for (int i = 0; i < keyName.length; i++) {
            String name = keyName[i];
            String time = keyTime[i];
            int minutes = Integer.parseInt(time.substring(0, 2)) * 60 + Integer.parseInt(time.substring(3));
            accessMap.computeIfAbsent(name, k -> new ArrayList<>()).add(minutes);
        }

        List<String> alerted = new ArrayList<>();
        for (String name : accessMap.keySet()) {
            List<Integer> times = accessMap.get(name);
            Collections.sort(times);

            for (int i = 0; i < times.size() - 2; i++) {
                if (times.get(i + 2) - times.get(i) <= 60) {
                    alerted.add(name);
                    break;
                }
            }
        }

        Collections.sort(alerted);
        return alerted;
    }
}

#include <vector>
#include <string>
#include <unordered_map>
#include <algorithm>

using namespace std;

vector<string> alertNames(vector<string>& keyName, vector<string>& keyTime) {
    unordered_map<string, vector<int>> timesMap;
    
    for (int i = 0; i < keyName.size(); ++i) {
        string time = keyTime[i];
        int minutes = stoi(time.substr(0, 2)) * 60 + stoi(time.substr(3, 2));
        timesMap[keyName[i]].push_back(minutes);
    }
    
    vector<string> result;
    for (auto& [name, times] : timesMap) {
        sort(times.begin(), times.end());
        for (int i = 0; i + 2 < times.size(); ++i) {
            if (times[i + 2] - times[i] <= 60) {
                result.push_back(name);
                break;
            }
        }
    }
    
    sort(result.begin(), result.end());
    return result;
}

var alertNames = function(keyName, keyTime) {
    const accessMap = {};

    const convertToMinutes = (time) => {
        const [hour, minute] = time.split(':').map(Number);
        return hour * 60 + minute;
    };

    keyName.forEach((name, i) => {
        if (!accessMap[name]) accessMap[name] = [];
        accessMap[name].push(convertToMinutes(keyTime[i]));
    });

    const result = [];
    Object.keys(accessMap).forEach(name => {
        const times = accessMap[name].sort((a, b) => a - b);
        const heap = [];
        for (const time of times) {
            heap.push(time);
            if (heap.length > 3) heap.shift(); // Maintain heap size up to 3
            if (heap.length === 3 && (heap[2] - heap[0]) <= 60) {
                result.push(name);
                break;
            }
        }
    });

    return result.sort();
};

using System;
using System.Collections.Generic;

public class Solution {
    public IList<string> AlertNames(string[] keyName, string[] keyTime) {
        var accessMap = new Dictionary<string, List<int>>();

        int ConvertTimeToMinutes(string time) {
            var parts = time.Split(':');
            return int.Parse(parts[0]) * 60 + int.Parse(parts[1]);
        }

        for (int i = 0; i < keyName.Length; i++) {
            if (!accessMap.ContainsKey(keyName[i]))
                accessMap[keyName[i]] = new List<int>();
            accessMap[keyName[i]].Add(ConvertTimeToMinutes(keyTime[i]));
        }

        List<string> alerted = new List<string>();

        foreach (var entry in accessMap) {
            string name = entry.Key;
            List<int> times = entry.Value;
            times.Sort();

            for (int i = 0; i < times.Count - 2; i++) {
                if (times[i + 2] - times[i] <= 60) {
                    alerted.Add(name);
                    break;
                }
            }
        }

        alerted.Sort();
        return alerted;
    }
}

function alertNames(keyName: string[], keyTime: string[]): string[] {
    const d: { [name: string]: number[] } = {};
    for (let i = 0; i < keyName.length; ++i) {
        const name = keyName[i];
        const t = keyTime[i];
        const minutes = +t.slice(0, 2) * 60 + +t.slice(3);
        if (d[name] === undefined) {
            d[name] = [];
        }
        d[name].push(minutes);
    }
    const ans: string[] = [];
    for (const name in d) {
        if (d.hasOwnProperty(name)) {
            const ts = d[name];
            if (ts.length > 2) {
                ts.sort((a, b) => a - b);
                for (let i = 0; i < ts.length - 2; ++i) {
                    if (ts[i + 2] - ts[i] <= 60) {
                        ans.push(name);
                        break;
                    }
                }
            }
        }
    }
    ans.sort();
    return ans;
}

func alertNames(keyName []string, keyTime []string) (ans []string) {
	d := map[string][]int{}
	for i, name := range keyName {
		var a, b int
		fmt.Sscanf(keyTime[i], "%d:%d", &a, &b)
		t := a*60 + b
		d[name] = append(d[name], t)
	}
	for name, ts := range d {
		n := len(ts)
		if n > 2 {
			sort.Ints(ts)
			for i := 0; i < n-2; i++ {
				if ts[i+2]-ts[i] <= 60 {
					ans = append(ans, name)
					break
				}
			}
		}
	}
	sort.Strings(ans)
	return
}