有时间限制的缓存

2622. 有时间限制的缓存

编写一个类，它允许获取和设置键-值对，并且每个键都有一个 过期时间 。

该类有三个公共方法：

set(key, value, duration) ：接收参数为整型键 key 、整型值 value 和以毫秒为单位的持续时间 duration 。一旦 duration 到期后，这个键就无法访问。如果相同的未过期键已经存在，该方法将返回 true ，否则返回 false 。如果该键已经存在，则它的值和持续时间都应该被覆盖。

get(key) ：如果存在一个未过期的键，它应该返回这个键相关的值。否则返回 -1 。

count() ：返回未过期键的总数。

示例 1：

输入： 
["TimeLimitedCache", "set", "get", "count", "get"]
[[], [1, 42, 100], [1], [], [1]]
[0, 0, 50, 50, 150]
输出： [null, false, 42, 1, -1]
解释：
在 t=0 时，缓存被构造。
在 t=0 时，添加一个键值对 (1: 42) ，过期时间为 100ms 。因为该值不存在，因此返回false。
在 t=50 时，请求 key=1 并返回值 42。
在 t=50 时，调用 count() ，缓存中有一个未过期的键。
在 t=100 时，key=1 到期。
在 t=150 时，调用 get(1) ，返回 -1，因为缓存是空的。

示例 2：

输入：
["TimeLimitedCache", "set", "set", "get", "get", "get", "count"]
[[], [1, 42, 50], [1, 50, 100], [1], [1], [1], []]
[0, 0, 40, 50, 120, 200, 250]
输出： [null, false, true, 50, 50, -1]
解释：
在 t=0 时，缓存被构造。
在 t=0 时，添加一个键值对 (1: 42) ，过期时间为 50ms。因为该值不存在，因此返回false。
当 t=40 时，添加一个键值对 (1: 50) ，过期时间为 100ms。因为一个未过期的键已经存在，返回 true 并覆盖这个键的旧值。
在 t=50 时，调用 get(1) ，返回 50。
在 t=120 时，调用 get(1) ，返回 50。
在 t=140 时，key=1 过期。
在 t=200 时，调用 get(1) ，但缓存为空，因此返回 -1。
在 t=250 时，count() 返回0 ，因为缓存是空的，没有未过期的键。

提示：

0 <= key <= 10⁹
0 <= value <= 10⁹
0 <= duration <= 1000
方法调用总数不会超过100

原站题解

去查看

上次编辑到这里，代码来自缓存点击恢复默认模板

javascript 解法, 执行用时: 60 ms, 内存消耗: 41.1 MB, 提交时间: 2023-04-17 15:46:38

var TimeLimitedCache = function() {
    this.map = new Map();
};

/** 
 * @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) {
    this._expire();
    const res = this.map.has(key);
    const now = Date.now()
    this.map.set(key, [value, now + duration]);
    return res;
};

/** 
 * @param {number} key
 * @return {number} value associated with key
 */
TimeLimitedCache.prototype.get = function(key) {
    this._expire();
    if ( !this.map.has(key)) return -1;
    return this.map.get(key)[0];
};

/** 
 * @return {number} count of non-expired keys
 */
TimeLimitedCache.prototype.count = function() {
    this._expire();
    return this.map.size;
};


TimeLimitedCache.prototype._expire = function() {
    const now = Date.now();
    this.map.forEach((value, key) => {
      if (value[1] <= now) this.map.delete(key);
    });
};

/**
 * 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
 */

typescript 解法, 执行用时: 64 ms, 内存消耗: 42.5 MB, 提交时间: 2023-04-17 15:35:55

class TimeLimitedCache {
    private readonly _cache: Map<number, [value: number, expired: number]> = new Map()

    set(key: number, value: number, duration: number): boolean {
        this._expire()
        const res = this._cache.has(key)
        const now = Date.now()
        this._cache.set(key, [value, now + duration])
        return res
    }

    get(key: number): number {
        this._expire()
        if (!this._cache.has(key)) return -1
        return this._cache.get(key)![0]
    }

    count(): number {
        this._expire()
        return this._cache.size
    }

    private _expire(): void {
        const now = Date.now()
        this._cache.forEach((value, key) => {
            if (value[1] <= now) this._cache.delete(key)
        })
    }
}

/**
 * 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
 */

上一题

下一题

详情