Welcome to Subscribe On Youtube

635. Design Log Storage System


You are given several logs, where each log contains a unique ID and timestamp. Timestamp is a string that has the following format: Year:Month:Day:Hour:Minute:Second, for example, 2017:01:01:23:59:59. All domains are zero-padded decimal numbers.

Implement the LogSystem class:

  • LogSystem() Initializes the LogSystem object.
  • void put(int id, string timestamp) Stores the given log (id, timestamp) in your storage system.
  • int[] retrieve(string start, string end, string granularity) Returns the IDs of the logs whose timestamps are within the range from start to end inclusive. start and end all have the same format as timestamp, and granularity means how precise the range should be (i.e. to the exact Day, Minute, etc.). For example, start = "2017:01:01:23:59:59", end = "2017:01:02:23:59:59", and granularity = "Day" means that we need to find the logs within the inclusive range from Jan. 1st 2017 to Jan. 2nd 2017, and the Hour, Minute, and Second for each log entry can be ignored.


Example 1:

["LogSystem", "put", "put", "put", "retrieve", "retrieve"]
[[], [1, "2017:01:01:23:59:59"], [2, "2017:01:01:22:59:59"], [3, "2016:01:01:00:00:00"], ["2016:01:01:01:01:01", "2017:01:01:23:00:00", "Year"], ["2016:01:01:01:01:01", "2017:01:01:23:00:00", "Hour"]]
[null, null, null, null, [3, 2, 1], [2, 1]]

LogSystem logSystem = new LogSystem();
logSystem.put(1, "2017:01:01:23:59:59");
logSystem.put(2, "2017:01:01:22:59:59");
logSystem.put(3, "2016:01:01:00:00:00");

// return [3,2,1], because you need to return all logs between 2016 and 2017.
logSystem.retrieve("2016:01:01:01:01:01", "2017:01:01:23:00:00", "Year");

// return [2,1], because you need to return all logs between Jan. 1, 2016 01:XX:XX and Jan. 1, 2017 23:XX:XX.
// Log 3 is not returned because Jan. 1, 2016 00:00:00 comes before the start of the range.
logSystem.retrieve("2016:01:01:01:01:01", "2017:01:01:23:00:00", "Hour");



  • 1 <= id <= 500
  • 2000 <= Year <= 2017
  • 1 <= Month <= 12
  • 1 <= Day <= 31
  • 0 <= Hour <= 23
  • 0 <= Minute, Second <= 59
  • granularity is one of the values ["Year", "Month", "Day", "Hour", "Minute", "Second"].
  • At most 500 calls will be made to put and retrieve.



  • self.logs: A list that stores log entries, where each log entry is a tuple consisting of an id (integer) and a timestamp (string in the format YYYY:MM:DD:hh:mm:ss).
  • self.d: A dictionary mapping granularity names ("Year", "Month", "Day", "Hour", "Minute", "Second") to the index positions in the timestamp string that correspond to the end of each granularity level. These indices help in slicing timestamps up to the required granularity.



  • Initializes the log system. It sets up the logs list to store the log entries and the d dictionary to map each granularity to its respective slice index in the timestamp strings.

put(self, id: int, timestamp: str) -> None

  • Adds a log entry to the system. It appends a tuple containing the id and timestamp to the logs list. The id is an integer identifier for the log, and timestamp is a string representing when the log entry was made.

retrieve(self, start: str, end: str, granularity: str) -> List[int]

  • Retrieves all log ids with timestamps that fall within the range from start to end, inclusive, at the specified granularity.
  • The method uses the d dictionary to find the slice index i corresponding to the given granularity. This index determines how much of the timestamp strings should be considered for comparison.
  • It then iterates over all stored logs, comparing the sliced timestamps (ts[:i]) against the sliced start and end boundaries.
  • If a log’s timestamp falls within the range, the log’s id is included in the result list.

Example Usage:

obj = LogSystem()
obj.put(1, "2017:01:01:23:59:59")
obj.put(2, "2017:01:02:23:59:59")

# Retrieve logs within the entire year of 2017
logs = obj.retrieve("2017:01:01:00:00:00", "2017:12:31:23:59:59", "Year")
print(logs)  # Output: [1, 2]

# Retrieve logs from January 1, 2017
logs = obj.retrieve("2017:01:01:00:00:00", "2017:01:01:23:59:59", "Day")
print(logs)  # Output: [1]

Improve efficiency on retrival

Using a sorted data structure to store the log entries can indeed make retrieval operations more efficient, especially when dealing with a large number of logs. Python’s bisect module can be used for efficient insertion and searching in a sorted list, but it only works well for immutable elements and doesn’t directly support key-based sorting or retrieval.

For a scenario that benefits from sorted data and key-based operations, a better approach might be to use a TreeMap in languages like Java, which Python can mimic with the sortedcontainers module’s SortedDict. This data structure maintains elements in sorted order and supports efficient insertion, deletion, and range query operations.


  • Storage: Instead of a list, self.logs is now a SortedDict, where each key is a timestamp, and the value is a list of IDs that share the same timestamp. This allows the log system to efficiently manage and query logs based on timestamps.
  • Insertion (put method): Inserts logs into the SortedDict based on their timestamp. If multiple logs have the same timestamp, they’re appended to the list at that timestamp key.
  • Retrieval (retrieve method): To retrieve logs within a specified range and granularity, the method first adjusts the start and end according to the granularity. It then iterates over the timestamp keys within the specified range using SortedDict’s irange method, which efficiently finds the keys within the given range. The method accumulates the IDs of the logs that fall within the adjusted start and end range.


  • Efficiency: By maintaining the logs in a sorted order, the retrieve method becomes more efficient, especially for range queries, as it avoids scanning logs that fall outside the desired timestamp range.
  • Flexibility: The use of SortedDict allows for efficient queries not only based on exact timestamp matches but also for range-based retrievals, making the system more versatile.

This approach optimizes the retrieval operation by leveraging the sorted nature of the logs, which is particularly beneficial as the number of logs grows.

irange() in SortedDict

irange() is a method associated with the SortedDict object from the sortedcontainers module in Python, not part of Python’s standard library. The sortedcontainers module provides SortedDict, SortedSet, and SortedList collections that maintain their elements in sorted order. The irange() method of a SortedDict object is particularly useful for iterating over a range of keys in sorted order.

Here’s how you can use the irange() method with a SortedDict:

Installation of sortedcontainers

First, ensure you have the sortedcontainers module installed. If not, you can install it using pip:

pip install sortedcontainers

Example Usage of irange()

from sortedcontainers import SortedDict

# Creating a SortedDict object
sd = SortedDict({'apple': 2, 'banana': 3, 'cherry': 5, 'date': 7, 'elderberry': 11})

# Iterating over a range of keys using irange()
# This will include the start key 'banana' and exclude the stop key 'elderberry'
for key in sd.irange('banana', 'elderberry', inclusive=(True, False)):
    print(f"{key}: {sd[key]}")


banana: 3
cherry: 5
date: 7


  • SortedDict: A dictionary that maintains its keys in sorted order, which is useful for efficiently performing range queries and maintaining sorted data.

  • irange(start_key, stop_key, inclusive=(True, True)): Iterates over the keys of the SortedDict starting with start_key and ending with stop_key. The inclusive parameter is a tuple indicating whether the start and stop keys should be included in the range. By default, both are set to True, meaning both start_key and stop_key are included. In the example above, inclusive=(True, False) means that the range includes banana but excludes elderberry.

irange() is valuable for scenarios where you need to iterate over a subset of keys within a certain range in a dictionary that’s maintained in sorted order. This method combines the convenience of dictionary key-value access with the efficiency of sorted data structures for range queries.

  • class LogSystem {
        private List<Log> logs = new ArrayList<>();
        private Map<String, Integer> d = new HashMap<>();
        public LogSystem() {
            d.put("Year", 4);
            d.put("Month", 7);
            d.put("Day", 10);
            d.put("Hour", 13);
            d.put("Minute", 16);
            d.put("Second", 19);
        public void put(int id, String timestamp) {
            logs.add(new Log(id, timestamp));
        public List<Integer> retrieve(String start, String end, String granularity) {
            List<Integer> ans = new ArrayList<>();
            int i = d.get(granularity);
            String s = start.substring(0, i);
            String e = end.substring(0, i);
            for (var log : logs) {
                String t = log.ts.substring(0, i);
                if (s.compareTo(t) <= 0 && t.compareTo(e) <= 0) {
            return ans;
    class Log {
        int id;
        String ts;
        Log(int id, String ts) {
            this.id = id;
            this.ts = ts;
     * Your LogSystem object will be instantiated and called as such:
     * LogSystem obj = new LogSystem();
     * obj.put(id,timestamp);
     * List<Integer> param_2 = obj.retrieve(start,end,granularity);
  • class LogSystem {
        LogSystem() {
            d["Year"] = 4;
            d["Month"] = 7;
            d["Day"] = 10;
            d["Hour"] = 13;
            d["Minute"] = 16;
            d["Second"] = 19;
        void put(int id, string timestamp) {
            logs.push_back({id, timestamp});
        vector<int> retrieve(string start, string end, string granularity) {
            vector<int> ans;
            int i = d[granularity];
            auto s = start.substr(0, i);
            auto e = end.substr(0, i);
            for (auto& [id, ts] : logs) {
                auto t = ts.substr(0, i);
                if (s <= t && t <= e) {
            return ans;
        vector<pair<int, string>> logs;
        unordered_map<string, int> d;
     * Your LogSystem object will be instantiated and called as such:
     * LogSystem* obj = new LogSystem();
     * obj->put(id,timestamp);
     * vector<int> param_2 = obj->retrieve(start,end,granularity);
  • class LogSystem:
        def __init__(self):
            self.logs = []
            self.d = {
                "Year": 4,
                "Month": 7,
                "Day": 10,
                "Hour": 13,
                "Minute": 16,
                "Second": 19,
        def put(self, id: int, timestamp: str) -> None:
            self.logs.append((id, timestamp))
        def retrieve(self, start: str, end: str, granularity: str) -> List[int]:
            i = self.d[granularity]
            return [id for id, ts in self.logs if start[:i] <= ts[:i] <= end[:i]]
    # Your LogSystem object will be instantiated and called as such:
    # obj = LogSystem()
    # obj.put(id,timestamp)
    # param_2 = obj.retrieve(start,end,granularity)
    # pip install sortedcontainers
    from sortedcontainers import SortedDict
    # optimized, sorted
    class LogSystem:
        def __init__(self):
            self.logs = SortedDict()
        def put(self, id: int, timestamp: str) -> None:
            if timestamp not in self.logs:
                self.logs[timestamp] = []
        def retrieve(self, start: str, end: str, granularity: str) -> List[int]:
            index = {
                "Year": 4,
                "Month": 7,
                "Day": 10,
                "Hour": 13,
                "Minute": 16,
                "Second": 19,
            start = start[:index[granularity]]
            end = end[:index[granularity]]
            # Adjust end to ensure it captures the correct range for the granularity
            end = end[:index[granularity]] + "9" * (19 - index[granularity])
            result = []
            # Using irange to efficiently iterate over the range of timestamps
            # By default, both are set to True for inclusive{}
            #   eg: sd.irange('banana', 'elderberry', inclusive=(True, True))
            for timestamp in self.logs.irange(start, end):
                if timestamp[:index[granularity]] > end:
            return result
  • type LogSystem struct {
    	logs []pair
    	d    map[string]int
    func Constructor() LogSystem {
    	d := map[string]int{
    		"Year":   4,
    		"Month":  7,
    		"Day":    10,
    		"Hour":   13,
    		"Minute": 16,
    		"Second": 19,
    	return LogSystem{[]pair{}, d}
    func (this *LogSystem) Put(id int, timestamp string) {
    	this.logs = append(this.logs, pair{id, timestamp})
    func (this *LogSystem) Retrieve(start string, end string, granularity string) (ans []int) {
    	i := this.d[granularity]
    	s, e := start[:i], end[:i]
    	for _, log := range this.logs {
    		t := log.ts[:i]
    		if s <= t && t <= e {
    			ans = append(ans, log.id)
    type pair struct {
    	id int
    	ts string
     * Your LogSystem object will be instantiated and called as such:
     * obj := Constructor();
     * obj.Put(id,timestamp);
     * param_2 := obj.Retrieve(start,end,granularity);

All Problems

All Solutions