LeetCode //2622. Cache With Time Limit (Day 14 of LC JavaScript Challenge)

2622. Cache With Time Limit

Write a class that allows getting and setting key-value pairs, however a time until expiration is associated with each key.

The class has three public methods:

set(key, value, duration): accepts an integer key, an integer value, and a duration in milliseconds. Once the duration has elapsed, the key should be inaccessible. The method should return true if the same un-expired key already exists and false otherwise. Both the value and duration should be overwritten if the key already exists.

get(key): if an un-expired key exists, it should return the associated value. Otherwise it should return -1.

count(): returns the count of un-expired keys.

 

Example 1:

Input:
[“TimeLimitedCache”, “set”, “get”, “count”, “get”]
[[], [1, 42, 100], [1], [], [1]]
[0, 0, 50, 50, 150]
Output: [null, false, 42, 1, -1]
Explanation:
At t=0, the cache is constructed.
At t=0, a key-value pair (1: 42) is added with a time limit of 100ms. The value doesn’t exist so false is returned.
At t=50, key=1 is requested and the value of 42 is returned.
At t=50, count() is called and there is one active key in the cache.
At t=100, key=1 expires.
At t=150, get(1) is called but -1 is returned because the cache is empty.

Example 2:

Input:
[“TimeLimitedCache”, “set”, “set”, “get”, “get”, “get”, “count”]
[[], [1, 42, 50], [1, 50, 100], [1], [1], [1], []]
[0, 0, 40, 50, 120, 200, 250]
Output: [null, false, true, 50, 50, -1]
Explanation:
At t=0, the cache is constructed.
At t=0, a key-value pair (1: 42) is added with a time limit of 50ms. The value doesn’t exist so false is returned.
At t=40, a key-value pair (1: 50) is added with a time limit of 100ms. A non-expired value already existed so true is returned and the old value was overwritten.
At t=50, get(1) is called which returned 50.
At t=120, get(1) is called which returned 50.
At t=140, key=1 expires.
At t=200, get(1) is called but the cache is empty so -1 is returned.
At t=250, count() returns 0 because the cache is empty.

Constraints:

• $0<=key<=10^9$
• $0<=value<=10^9$
• 0 <= duration <= 1000
• total method calls will not exceed 100

From: LeetCode
Link: 2622. Cache With Time Limit

---

Solution:

Ideas：

• The TimeLimitedCache class is a JavaScript class that allows getting and setting key-value pairs, however a time until expiration is associated with each key.

• The class has three public methods:

• set(key, value, duration): accepts an integer key, an integer value, and a duration in milliseconds. Once the duration has elapsed, the key should be inaccessible. The method should return true if the same un-expired key already exists and false otherwise. Both the value and duration should be overwritten if the key already exists.

• get(key): if an un-expired key exists, it should return the associated value. Otherwise it should return -1.

• count(): returns the count of un-expired keys.

• The set() method works by first checking if the key already exists in the cache. If it does, the value and duration are overwritten and true is returned. If the key does not exist, the key-value pair is added to the cache and false is returned.

• The get() method works by first checking if the key exists in the cache. If it does, the value is returned. If the key does not exist, -1 is returned.

• The count() method works by iterating over the keys in the cache and counting the number of keys that are not expired.

Here are some additional details about the code:

• The TimeLimitedCache class uses a JavaScript object to store the key-value pairs. The object is indexed by the key, and each key has a value and an expiration date.

• The set() method uses the Date.now() method to get the current time. The expiration date is then set to the current time plus the duration.

• The get() method uses the Date.now() method to get the current time. The value is returned if the key exists and the expiration date is greater than the current time. Otherwise, -1 is returned.

• The count() method iterates over the keys in the cache and counts the number of keys that are not expired.

Code:

var TimeLimitedCache = function() {
  this.data = {};
};

/** 
 * @param {number} key
 * @param {number} value
 * @param {number} time until expiration in ms
 * @return {boolean} if un-expired key already existed
 */
TimeLimitedCache.prototype.set = function(key, value, duration) {
  var now = Date.now();
  var expiredAt = now + duration;

  if (this.data[key] && this.data[key].expiredAt > now) {
    // The key already exists and is not expired.
    this.data[key].value = value;
    this.data[key].expiredAt = expiredAt;
    return true;
  } else {
    // The key does not exist or is expired.
    this.data[key] = {
      value: value,
      expiredAt: expiredAt
    };
    return false;
  }
};

/** 
 * @param {number} key
 * @return {number} value associated with key
 */
TimeLimitedCache.prototype.get = function(key) {
  var now = Date.now();
  var value;

  if (this.data[key] && this.data[key].expiredAt > now) {
    value = this.data[key].value;
  } else {
    value = -1;
  }

  return value;
};

/** 
 * @return {number} count of non-expired keys
 */
TimeLimitedCache.prototype.count = function() {
  var count = 0;

  for (var key in this.data) {
    if (this.data.hasOwnProperty(key) && this.data[key].expiredAt > Date.now()) {
      count++;
    }
  }

  return count;
};

/**
 * Your TimeLimitedCache object will be instantiated and called as such:
 * var obj = new TimeLimitedCache()
 * obj.set(1, 42, 1000); // false
 * obj.get(1) // 42
 * obj.count() // 1
 */