Welcome to Subscribe On Youtube

1604. Alert Using Same Key-Card Three or More Times in a One Hour Period

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 <= 105
• keyName.length == keyTime.length
• keyTime[i] is in the format "HH:MM".
• [keyName[i], keyTime[i]] is unique.
• 1 <= keyName[i].length <= 10
• keyName[i] contains only lowercase English letters.

Solutions

• Java
• C++
• Python
• Go
• TypeScript

• 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;
      }
  }
  

• 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;
      }
  };
  

• 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
  
  

• 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
  }
  

• 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;
  }
  
  

All Problems

All Solutions