The ith student started doing their homework at the time startTime[i] and finished it at time endTime[i].

Return the number of students doing their homework at time queryTime. More formally, return the number of students where queryTime lays in the interval [startTime[i], endTime[i]] inclusive.

Example 1:

Input: startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
Output: 1
Explanation: We have 3 students where:
The first student started doing homework at time 1 and finished at time 3 and wasn't doing anything at time 4.
The second student started doing homework at time 2 and finished at time 2 and also wasn't doing anything at time 4.
The third student started doing homework at time 3 and finished at time 7 and was the only student doing homework at time 4.

Example 2:

Input: startTime = [4], endTime = [4], queryTime = 4
Output: 1
Explanation: The only student was doing their homework at the queryTime.

Example 3:

Input: startTime = [4], endTime = [4], queryTime = 5
Output: 0

Example 4:

Input: startTime = [1,1,1,1], endTime = [1,3,2,4], queryTime = 7
Output: 0

Example 5:

Input: startTime = [9,8,7,6,5,4,3,2,1], endTime = [10,10,10,10,10,10,10,10,10], queryTime = 5
Output: 5

Constraints:

• startTime.length == endTime.length
• 1 <= startTime.length <= 100
• 1 <= startTime[i] <= endTime[i] <= 1000
• 1 <= queryTime <= 1000

Solution: Brute Force

Time complexity: O(n)
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  int busyStudent(vector<int>& startTime, vector<int>& endTime, int queryTime) {
    int ans = 0;
    for (int i = 0; i < startTime.size(); ++i)
      if (startTime[i] <= queryTime && queryTime <= endTime[i]) ++ans;
    return ans;
  }
};

# Author: Huahua
class Solution:
  def busyStudent(self, startTime: List[int], endTime: List[int], queryTime: int) -> int:
    return sum(s <= queryTime <= e for s, e in zip(startTime, endTime))

The post 花花酱 LeetCode 1450. Number of Students Doing Homework at a Given Time appeared first on Huahua's Tech Road.

1. recordTweet(string tweetName, int time)

• Stores the tweetName at the recorded time (in seconds).

2. getTweetCountsPerFrequency(string freq, string tweetName, int startTime, int endTime)

• Returns the total number of occurrences for the given tweetName per minute, hour, or day (depending on freq) starting from the startTime (in seconds) and ending at the endTime (in seconds).
• freq is always minute, hour or day, representing the time interval to get the total number of occurrences for the given tweetName.
• The first time interval always starts from the startTime, so the time intervals are [startTime, startTime + delta*1>,  [startTime + delta*1, startTime + delta*2>, [startTime + delta*2, startTime + delta*3>, ... , [startTime + delta*i, min(startTime + delta*(i+1), endTime + 1)> for some non-negative number i and delta (which depends on freq).  

Example:

Input
["TweetCounts","recordTweet","recordTweet","recordTweet","getTweetCountsPerFrequency","getTweetCountsPerFrequency","recordTweet","getTweetCountsPerFrequency"]
[[],["tweet3",0],["tweet3",60],["tweet3",10],["minute","tweet3",0,59],["minute","tweet3",0,60],["tweet3",120],["hour","tweet3",0,210]]

Output
[null,null,null,null,[2]
[2,1],null,[4]]

Explanation
TweetCounts tweetCounts = new TweetCounts();
tweetCounts.recordTweet("tweet3", 0);
tweetCounts.recordTweet("tweet3", 60);
tweetCounts.recordTweet("tweet3", 10);                             // All tweets correspond to "tweet3" with recorded times at 0, 10 and 60.
tweetCounts.getTweetCountsPerFrequency("minute", "tweet3", 0, 59); // return [2]. The frequency is per minute (60 seconds), so there is one interval of time: 1) [0, 60> - > 2 tweets.
tweetCounts.getTweetCountsPerFrequency("minute", "tweet3", 0, 60); // return [2, 1]. The frequency is per minute (60 seconds), so there are two intervals of time: 1) [0, 60> - > 2 tweets, and 2) [60,61> - > 1 tweet.
tweetCounts.recordTweet("tweet3", 120);                            // All tweets correspond to "tweet3" with recorded times at 0, 10, 60 and 120.
tweetCounts.getTweetCountsPerFrequency("hour", "tweet3", 0, 210);  // return [4]. The frequency is per hour (3600 seconds), so there is one interval of time: 1) [0, 211> - > 4 tweets.

Constraints:

• There will be at most 10000 operations considering both recordTweet and getTweetCountsPerFrequency.
• 0 <= time, startTime, endTime <= 10^9
  

Solution: Hashtable + binary search

Time complexity:
Record: O(logn)
getCount: O(logn + |entries|)

Space complexity: O(n)

// Author: Huahua
class TweetCounts {
public:
  TweetCounts() {
    m_.clear();
  }

  void recordTweet(string tweetName, int time) {
    m_[tweetName].insert(time);
  }

  vector<int> getTweetCountsPerFrequency(string freq, string tweetName, int startTime, int endTime) {
    auto tit = m_.find(tweetName);
    if (tit == m_.end()) return {};
    const set<int>& s = tit->second;
    int delta = 1;
    if (freq == "minute") delta = 60;
    else if (freq == "hour") delta = 60 * 60;
    else if (freq == "day") delta = 60 * 60 * 24;
    int slots = (endTime - startTime + delta - 1) / delta;
    vector<int> ans(slots);
    for (int i = startTime; i <= endTime; i += delta) {
      auto it1 = s.lower_bound(i);
      auto it2 = s.lower_bound(min(i + delta, endTime + 1));
      ans.push_back(distance(it1, it2)); // O(|entries|)    
    }
    return ans;
  }
private:
  unordered_map<string, set<int>> m_;
};

The post 花花酱 LeetCode 1348. Tweet Counts Per Frequency appeared first on Huahua's Tech Road.

We remove the intersections between any interval in intervals and the interval toBeRemoved.

Return a sorted list of intervals after all such removals.

Example 1:

Input: intervals = [[0,2],[3,4],[5,7]], toBeRemoved = [1,6]
Output: [[0,1],[6,7]]

Example 2:

Input: intervals = [[0,5]], toBeRemoved = [2,3]
Output: [[0,2],[3,5]]

Constraints:

• 1 <= intervals.length <= 10^4
• -10^9 <= intervals[i][0] < intervals[i][1] <= 10^9

Solution: Geometry

Time complexity: O(n)
Space complexity: O(n)

// Author: Huahua
class Solution {
public:
  vector<vector<int>> removeInterval(vector<vector<int>>& intervals, vector<int>& r) {
    vector<vector<int>> ans;
    for (const auto& i : intervals)
      // Does not intersect
      if (i[1] <= r[0] || i[0] >= r[1])
        ans.push_back(i);
      else {
        // i starts first
        if (i[0] < r[0]) 
          ans.push_back({i[0], r[0]});
        // i ends later
        if (i[1] > r[1])
          ans.push_back({r[1], i[1]});        
      }
    return ans;
  }
};

The post 花花酱 LeetCode 1272. Remove Interval appeared first on Huahua's Tech Road.

Return the intersection of these two interval lists.

(Formally, a closed interval [a, b] (with a <= b) denotes the set of real numbers x with a <= x <= b.  The intersection of two closed intervals is a set of real numbers that is either empty, or can be represented as a closed interval.  For example, the intersection of [1, 3] and [2, 4] is [2, 3].)

Example 1:

Input: A = [[0,2],[5,10],[13,23],[24,25]], B = [[1,5],[8,12],[15,24],[25,26]]
Output: [[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]
Reminder: The inputs and the desired output are lists of Interval objects, and not arrays or lists.

Note:

1. 0 <= A.length < 1000
2. 0 <= B.length < 1000
3. 0 <= A[i].start, A[i].end, B[i].start, B[i].end < 10^9

Solution: Two pointers

Time complexity: O(m + n)
Space complexity: O(1)

// Author: Huahua, running time: 36 ms, 925.7 KB
class Solution {
public:
  vector<Interval> intervalIntersection(vector<Interval>& A, vector<Interval>& B) {
    size_t i = 0;
    size_t j = 0;
    vector<Interval> ans;
    while (i < A.size() && j < B.size()) {
      const int s = max(A[i].start, B[j].start);
      const int e = min(A[i].end, B[j].end);
      if (s <= e) ans.emplace_back(s, e);
      if (A[i].end < B[j].end)
        ++i;
      else
        ++j;
    }
    return ans;
  }
};

# Author: Huahua, running time: 96 ms, 7.6 MB
class Solution:
  def intervalIntersection(self, A: 'List[Interval]', B: 'List[Interval]') -> 'List[Interval]':
    i, j, ans = 0, 0, []
    while i < len(A) and j < len(B):
      s = max(A[i].start, B[j].start)
      e = min(A[i].end, B[j].end)
      if s <= e:
        ans.append(Interval(s, e))
      if A[i].end < B[j].end:
        i += 1
      else:
        j += 1
    return ans

The post 花花酱 LeetCode 986. Interval List Intersections appeared first on Huahua's Tech Road.

题目大意：给你每个员工的日历，让你找出所有员工都有空的时间段。

Problem:

We are given a list schedule of employees, which represents the working time for each employee.

Each employee has a list of non-overlapping Intervals, and these intervals are in sorted order.

Return the list of finite intervals representing common, positive-length free time for all employees, also in sorted order.

Example 1:

Input: schedule = [[[1,2],[5,6]],[[1,3]],[[4,10]]]
Output: [[3,4]]
Explanation:
There are a total of three employees, and all common
free time intervals would be [-inf, 1], [3, 4], [10, inf].
We discard any intervals that contain inf as they aren't finite.

Example 2:

Input: schedule = [[[1,3],[6,7]],[[2,4]],[[2,5],[9,12]]]
Output: [[5,6],[7,9]]

(Even though we are representing Intervals in the form [x, y], the objects inside are Intervals, not lists or arrays. For example, schedule[0][0].start = 1, schedule[0][0].end = 2, and schedule[0][0][0] is not defined.)

Also, we wouldn’t include intervals like [5, 5] in our answer, as they have zero length.

Note:

1. schedule and schedule[i] are lists with lengths in range [1, 50].
2. 0 <= schedule[i].start < schedule[i].end <= 10^8.

Idea:

Merge Intervals (virtually)

Solution:

C++

Time complexity: O(nlogn)

Space complexity: O(n)

n is the total number of intervals, n <= 2500

// Author: Huahua
// Running time: 81 ms
class Solution {
public:
    vector<Interval> employeeFreeTime(vector<vector<Interval>>& schedule) {
      vector<Interval> all;
      for (const auto intervals : schedule)
        all.insert(all.end(), intervals.begin(), intervals.end());
      std::sort(all.begin(), all.end(), 
                [](const Interval& a, const Interval& b){
                  return a.start < b.start;
                });
      vector<Interval> ans;
      int end = all.front().end;
      for (const Interval& busy : all) {
        if (busy.start > end) 
          ans.emplace_back(end, busy.start);  
        end = max(end, busy.end);
      }
      return ans;
    }
};

Related Problems:

• [解题报告] LeetCode 56. Merge Intervals
• [解题报告] LeetCode 57. Insert Interval
• [解题报告] LeetCode 729. My Calendar – 花花酱
• [解题报告] LeetCode 731. My Calendar II – 花花酱
• 花花酱 LeetCode 732. My Calendar III

The post 花花酱 LeetCode 759. Employee Free Time appeared first on Huahua's Tech Road.

Problem:

Solution:

C++

// Author: Huahua
// Runtime: 16 ms
class Solution {
public:
    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
        auto it = intervals.begin();
        while (it != intervals.end() && newInterval.start > it->start) ++it;
        intervals.insert(it, newInterval);
        
        // Merge intervals without sorting
        vector<Interval> ans;        
        for (const auto& interval : intervals) {
            if (ans.empty() || interval.start > ans.back().end) {
                ans.push_back(interval);
            } else {
                ans.back().end = max(ans.back().end, interval.end);
            }
        }
        
        return ans;
    }
};

Python

"""
Author: Huahua
Runtime: 78 ms
"""
class Solution(object):
    def insert(self, intervals, newInterval):
        
        index = len(intervals)
        for i in range(len(intervals)):
            if newInterval.start < intervals[i].start:
                index = i
                break
        
        intervals.insert(index, newInterval)
        
        ans = []
        for interval in intervals:
            if not ans or interval.start > ans[-1].end:
                ans.append(interval)
            else:
                ans[-1].end = max(ans[-1].end, interval.end)
        return ans

Solution 2:

C++

// Author: Huahua
// Runtime: 13 ms
class Solution {
public:
    vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {
        vector<Interval> l;
        vector<Interval> r;
        int start = newInterval.start;
        int end = newInterval.end;
        for (const Interval& interval : intervals) {
            if (interval.end < start)
                l.push_back(interval);
            else if (interval.start > end)
                r.push_back(interval);
            else {
                start = min(start, interval.start);
                end = max(end, interval.end);
            }                
        }
        
        vector<Interval> ans(std::move(l));
        ans.emplace_back(start, end);
        ans.insert(ans.end(), r.begin(), r.end());
        return ans;
    }
};

Python

"""
Author: Huahua
Runtime: 68 ms
"""
class Solution(object):
    def insert(self, intervals, newInterval):
        start, end = newInterval.start, newInterval.end
        l, r = [], []        
        for interval in intervals:
            if interval.end < start: l += interval, 
            elif interval.start > end: r += interval,
            else: 
                start = min(start, interval.start)
                end = max(end, interval.end)
        return l + [Interval(start, end)] + r

Related problems:

• [解题报告] LeetCode 56. Merge Intervals
• [解题报告] LeetCode 218. The Skyline Problem

The post 花花酱 LeetCode 57. Insert Interval appeared first on Huahua's Tech Road.

Problem:

Given a collection of intervals, merge all overlapping intervals.

For example,
Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

Idea:

Sweep line

Solution:

C++

// Author: Huahua
// Runtime: 12 ms
class Solution {
public:
    vector<Interval> merge(vector<Interval>& intervals) {
        if (intervals.empty()) return {};
        
        std::sort(intervals.begin(), intervals.end(), 
                  [](const Interval& a, const Interval& b){
                        return a.start < b.start;
                    });
        
        vector<Interval> ans;        
        for (const auto& interval : intervals) {
            if (ans.empty() || interval.start > ans.back().end) {
                ans.push_back(interval);
            } else {
                ans.back().end = max(ans.back().end, interval.end);
            }
        }
        
        return ans;
    }
};

Python

"""
Author: Huahua
Runtime: 69 ms
"""
class Solution(object):
    def merge(self, intervals):
        ans = []
        for interval in sorted(intervals, key=lambda x: x.start):
            if not ans or interval.start > ans[-1].end:
                ans.append(interval)
            else:
                ans[-1].end = max(ans[-1].end, interval.end)
        return ans

Related Problems:

• [解题报告] LeetCode 57. Insert Interval
• [解题报告] LeetCode 218. The Skyline Problem

The post 花花酱 LeetCode 56. Merge Intervals appeared first on Huahua's Tech Road.