Description#
LeetCode company workers use key-cards to unlock office doors. Each time a worker uses their key-card, the security system saves the worker's name and the time when it was used. The system emits an alert if any worker uses the key-card three or more times in a one-hour period.
You are given a list of strings keyName and keyTime where [keyName[i], keyTime[i]] corresponds to a person's name and the time when their key-card was used in a single day.
Access times are given in the 24-hour time format "HH:MM", such as "23:51" and "09:49".
Return a list of unique worker names who received an alert for frequent keycard use. Sort the names in ascending order alphabetically.
Notice that "10:00" - "11:00" is considered to be within a one-hour period, while "22:51" - "23:52" is not considered to be within a one-hour period.
Example 1:
Input: keyName = ["daniel","daniel","daniel","luis","luis","luis","luis"], keyTime = ["10:00","10:40","11:00","09:00","11:00","13:00","15:00"]
Output: ["daniel"]
Explanation: "daniel" used the keycard 3 times in a one-hour period ("10:00","10:40", "11:00").
Example 2:
Input: keyName = ["alice","alice","alice","bob","bob","bob","bob"], keyTime = ["12:01","12:00","18:00","21:00","21:20","21:30","23:00"]
Output: ["bob"]
Explanation: "bob" used the keycard 3 times in a one-hour period ("21:00","21:20", "21:30").
Constraints:
1 <= keyName.length, keyTime.length <= 105keyName.length == keyTime.lengthkeyTime[i] is in the format "HH:MM".[keyName[i], keyTime[i]] is unique.1 <= keyName[i].length <= 10keyName[i] contains only lowercase English letters.
Solutions#
Solution 1#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| class Solution:
def alertNames(self, keyName: List[str], keyTime: List[str]) -> List[str]:
d = defaultdict(list)
for name, t in zip(keyName, keyTime):
t = int(t[:2]) * 60 + int(t[3:])
d[name].append(t)
ans = []
for name, ts in d.items():
if (n := len(ts)) > 2:
ts.sort()
for i in range(n - 2):
if ts[i + 2] - ts[i] <= 60:
ans.append(name)
break
ans.sort()
return ans
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| class Solution {
public List<String> alertNames(String[] keyName, String[] keyTime) {
Map<String, List<Integer>> d = new HashMap<>();
for (int i = 0; i < keyName.length; ++i) {
String name = keyName[i];
String time = keyTime[i];
int t
= Integer.parseInt(time.substring(0, 2)) * 60 + Integer.parseInt(time.substring(3));
d.computeIfAbsent(name, k -> new ArrayList<>()).add(t);
}
List<String> ans = new ArrayList<>();
for (var e : d.entrySet()) {
var ts = e.getValue();
int n = ts.size();
if (n > 2) {
Collections.sort(ts);
for (int i = 0; i < n - 2; ++i) {
if (ts.get(i + 2) - ts.get(i) <= 60) {
ans.add(e.getKey());
break;
}
}
}
}
Collections.sort(ans);
return ans;
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
| class Solution {
public:
vector<string> alertNames(vector<string>& keyName, vector<string>& keyTime) {
unordered_map<string, vector<int>> d;
for (int i = 0; i < keyName.size(); ++i) {
auto name = keyName[i];
auto time = keyTime[i];
int a, b;
sscanf(time.c_str(), "%d:%d", &a, &b);
int t = a * 60 + b;
d[name].emplace_back(t);
}
vector<string> ans;
for (auto& [name, ts] : d) {
int n = ts.size();
if (n > 2) {
sort(ts.begin(), ts.end());
for (int i = 0; i < n - 2; ++i) {
if (ts[i + 2] - ts[i] <= 60) {
ans.emplace_back(name);
break;
}
}
}
}
sort(ans.begin(), ans.end());
return ans;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| 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
}
|
