def containsNearbyAlmostDuplicate(self, nums: List[int], k: int,
t: int) -> bool:
n = len(nums)
if n == 0 or k <= 0 or t < 0: return False
d = OrderedDict()
for i, e in enumerate(nums):
pool = [num[0] for num in d.keys()]
pool.sort()
print(f"Keys are: {' '.join(map(str, pool))}")
l_b = bisect.bisect_left(pool, e)
print(f"Foud lower bound {l_b} for e={e} at i={i}")
if l_b < len(pool) and pool[l_b] <= e + t: return True
u_b = bisect.bisect_right(pool, e - t - 1)
print(f"Foud upper bound {u_b} for e={e - t - 1} at i={i}")
if u_b < len(pool) and pool[u_b] >= e - t and pool[u_b] <= e:
return True
if len(d) == k:
d.popitem(last=False)
d[(e, i)] = i
return False
class LRUCache:
def __init__(self, capacity):
self.cache = OrderedDict()
self.capacity = capacity
def get(self, key):
if key in self.cache:
self.cache.move_to_end(key)
return self.cache.get(key, -1)
def put(self, key, value):
if key in self.cache:
self.cache.move_to_end(key)
else:
if len(self.cache) >= self.capacity:
self.cache.popitem(last=False)
self.cache[key] = value
def rob(self, nums: List[int]) -> int:
if not nums:
return 0
if len(nums) <= 2:
return max(nums)
dp = OrderedDict()
dp[0], dp[1] = nums[0], max(nums[0], nums[1])
for i in range(2, len(nums)):
dp[i] = max(dp[i - 1], dp[i - 2] + nums[i])
return dp.popitem()[1]
class ISBNCache:
def __init__(self, size):
self.cache = OrderedDict()
self.size = size
# O(1)
def lookup(self, isbn):
if isbn in self.cache:
self.cache.move_to_end(isbn)
return self.cache[isbn]
return -1
# O(1)
def insert(self, isbn, price):
if isbn in self.cache:
del self.cache[isbn]
self.cache[isbn] = price
if len(self.cache) > self.size:
self.cache.popitem(last=False) # Remove least recent isbn
# O(1)
def remove(self, isbn):
return self.cache.pop(isbn, None) is not None
def lengthOfLongestSubstring(self, s: str) -> int:
substring = OrderedDict()
max_length = 0
for char in s:
if char in substring:
popped = ''
while popped != char:
popped = substring.popitem(False)
substring[char] = True
substring_length = len(substring)
if substring_length > max_length:
max_length = substring_length
return max_length
class LRUCacheStrategy(MemoryCacheStrategy[K, V]):
"""strategy which enforces a size limit with LRU"""
__slots__ = ("storage", "lock", "max_entries")
storage: OrderedDict[K, V]
lock: Lock # OrderedDict is not thread safe
max_entries: int
def __init__(self, max_entries: int) -> None:
self.storage = OrderedDict()
self.lock = Lock()
self.max_entries = max_entries
def __eq__(self, other: object) -> bool:
if isinstance(other, LRUCacheStrategy):
return self.storage == other.storage \
and self.max_entries == other.max_entries
return NotImplemented
def __getitem__(self, key: K) -> V:
"""get a value, setting it as the most recently used one"""
with self.lock:
self.storage.move_to_end(
key, last=False) # higher index = longer time since last use
return self.storage[key]
def __setitem__(self, key: K, value: V) -> None:
"""set a value, removing old ones if necessary"""
with self.lock:
if key not in self.storage and len(
self.storage) == self.max_entries:
self.storage.popitem(
) # make space for new entry by removing the last element
self.storage[key] = value
def __delitem__(self, key: K) -> None:
"""remove a value"""
with self.lock:
del self.storage[key]
def __iter__(self) -> Iterator[K]:
return iter(self.storage)
def __len__(self) -> int:
return len(self.storage)
def __contains__(self, key: object) -> bool:
return key in self.storage
def keys(self) -> KeysView[K]:
return self.storage.keys()
def values(self) -> ValuesView[V]:
return self.storage.values()
def items(self) -> ItemsView[K, V]:
return self.storage.items()
def peek(self, key: K) -> V:
"""get the value of key without triggering side effects like changing its priority"""
with self.lock:
return self.storage[key]
@overload
def pop(self, key: K) -> V:
...
@overload
def pop(self, key: K, default: Union[V, T] = ...) -> Union[V, T]:
...
def pop(self,
key: K,
default: Union[V,
T] = POP_SENTINEL) -> Union[V, T]: # type: ignore
"""remove a value and return it"""
with self.lock:
if default is POP_SENTINEL:
return self.storage.pop(key)
return self.storage.pop(key, default)
def popitem(self) -> Tuple[K, V]:
"""remove the least recently used key-value pair and return it"""
with self.lock:
return self.storage.popitem()
def clear(self) -> None:
"""remove all values"""
with self.lock:
self.storage.clear()
