# Python每日一练(20230331) 阶乘后的零、无重复最长子串、LRU缓存机制

## 1. 阶乘后的零

• 0 <= n <= 10^4

https://edu.csdn.net/practice/24289744

class Solution:
def trailingZeroes(self, n: int) -> int:
zero_count = 0
current_multiple = 5
while n >= current_multiple:
zero_count += n // current_multiple
current_multiple *= 5
return zero_count
# %%
s = Solution()
print(s.trailingZeroes(5))
print(s.trailingZeroes(100))

1

24

class Solution:
def trailingZeroes(self, n: int) -> int:
count = 0
while n > 0:
count += n // 5
n //= 5
return count

## 2. 无重复字符的最长子串

• 0 <= s.length <= 5 * 10^4
• s 由英文字母、数字、符号和空格组成

https://edu.csdn.net/practice/24289745

class Solution:
def lengthOfLongestSubstring(self, s: str) -> int:
i = 0
j = 0
m = 0
hset = {}
while j < len(s):
char = s[j]
index = hset.get(char)
if index is not None and index > i:
i = index
m = m if m > j - i + 1 else j - i + 1
hset[char] = j + 1
j += 1
return m
# %%
s = Solution()
print(s.lengthOfLongestSubstring('abcabcbb'))
print(s.lengthOfLongestSubstring('pwwkew'))

3

3

## 3. LRU 缓存机制

• LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
• int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1
• void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最久未使用的数据值，从而为新的数据值留出空间。

["LRUCache", "put", "put", "get", "put", "get", "put", "get", "get", "get"]

[[2], [1, 1], [2, 2], [1], [3, 3], [2], [4, 4], [1], [3], [4]]

[null, null, null, 1, null, -1, null, -1, 3, 4]

LRUCache lRUCache = new LRUCache(2);

lRUCache.put(1, 1); // 缓存是 {1=1}

lRUCache.put(2, 2); // 缓存是 {1=1, 2=2}

lRUCache.get(1); // 返回 1

lRUCache.put(3, 3); // 该操作会使得关键字 2 作废，缓存是 {1=1, 3=3}

lRUCache.get(2); // 返回 -1 (未找到)

lRUCache.put(4, 4); // 该操作会使得关键字 1 作废，缓存是 {4=4, 3=3}

lRUCache.get(1); // 返回 -1 (未找到)

lRUCache.get(3); // 返回 3

lRUCache.get(4); // 返回 4

• 1 <= capacity <= 3000
• 0 <= key <= 10000
• 0 <= value <= 10^5
• 最多调用 2 * 10^5getput

https://edu.csdn.net/practice/24289743

class LRUCache:
def __init__(self, capacity):
"""
:type capacity: int
"""
self.maxlength = capacity
self.array = {}
self.array_list = []
def get(self, key):
"""
:type key: int
:rtype: int
"""
value = self.array.get(key)
if value is not None and self.array_list[0] is not key:
index = self.array_list.index(key)
self.array_list.pop(index)
self.array_list.insert(0, key)
value = value if value is not None else -1
return value
def put(self, key, value):
"""
:type key: int
:type value: int
:rtype: void
"""
if self.array.get(key) is not None:
index = self.array_list.index(key)
self.array.pop(key)
self.array_list.pop(index)
if len(self.array_list) >= self.maxlength:
key_t = self.array_list.pop(self.maxlength - 1)
self.array.pop(key_t)
self.array[key] = value
self.array_list.insert(0, key)
#%%
lRUCache = LRUCache(2)
lRUCache.put(1, 1)
lRUCache.put(2, 2)
val = lRUCache.get(1)
print(val)
lRUCache.put(3, 3)
val = lRUCache.get(2)
print(val)
lRUCache.put(4, 4)
val = lRUCache.get(1)
print(val)
val = lRUCache.get(3)
print(val)
val = lRUCache.get(4)
print(val)

1

-1

-1

3

4

## 🌟 每日一练刷题专栏 🌟

👍 点赞，你的认可是我坚持的动力！

🌟 收藏，你的青睐是我努力的方向！

|
14天前
|

MySQL是关系型DB，依赖预定义的表格结构，适合结构化数据和复杂查询，但扩展性有限。NoSQL提供灵活的非结构化数据存储（如JSON），无统一查询语言，但能横向扩展，适用于大规模、高并发场景。选择取决于应用需求和扩展策略。
109 1
|
16天前
|

10 2
|
1月前
|

【2月更文挑战第19天】【2月更文挑战第57篇】如何确保Python的内存管理机制能够有效地工作？
22 1
|
1月前
|

【2月更文挑战第19天】【2月更文挑战第55篇】谈谈你对 Python 的内存管理机制的理解。
44 1
|
2月前
|

Python优化机制：常量折叠
Python优化机制：常量折叠
20 0
|
2月前
|

14 0
|
1月前
|
Python

18 0
|
29天前
|

Python阶乘计算
Python阶乘计算
14 1
|
30天前
|

75 1
|
1月前
|

Python计算阶乘
Python计算阶乘
11 0