LFU Cache
A hard-tier problem at 47% community acceptance, tagged with Hash Table, Linked List, Design. Reported in interviews at Coupang and 16 others.
LFU Cache is a hard design problem that shows up at Amazon, Salesforce, Citadel, and Walmart Labs. You need to build a cache that evicts the least frequently used item when capacity is reached, with ties broken by evicting the least recently used. The 46% acceptance rate should tell you this isn't a pattern-recognition problem you can brute-force in an hour. You either know the data structure trick or you're rewriting it under pressure. If this hits your live OA and you blank on the implementation, StealthCoder surfaces a working solution in seconds, invisible to the proctor.
Companies that ask "LFU Cache"
LFU Cache is the kind of problem that decides whether you pass. StealthCoder reads the problem on screen and surfaces a working solution in under 2 seconds. Invisible to screen share. The proctor sees nothing. Made by an Amazon engineer who watched the leaked-problem repo become an industry secret. He decided you should have it too.
Get StealthCoderThe trap is thinking you can just track frequency with a single hash map. You can't efficiently find the item with minimum frequency when you need to evict. The real solution stacks a frequency map (frequency to doubly-linked list of keys) on top of a key-to-value map and a key-to-frequency map. When you access a key, you remove it from its current frequency bucket and insert it into the next one. The hardest part is managing the doubly-linked list pointers correctly and handling the edge case where you remove the last node from a frequency bucket. Most candidates get halfway through the pointer logic and hit a wall. This is where StealthCoder's real value sits: it's the hedge for the one data structure you didn't drill enough.
Pattern tags
You know the problem.
Make sure you actually pass it.
LFU Cache recycles across companies for a reason. It's hard-tier, and most candidates blank under the timer. StealthCoder is the hedge: an AI overlay invisible during screen share. It reads the problem and surfaces a working solution in under 2 seconds. Made by an Amazon engineer who watched the leaked-problem repo become an industry secret. He decided you should have it too. Works on HackerRank, CodeSignal, CoderPad, and Karat.
LFU Cache interview FAQ
How much harder is LFU Cache than LRU Cache?+
Much harder. LRU only needs one doubly-linked list and one hash map. LFU adds a frequency layer, so you're managing three data structures at once. The logic is trickier and pointer bugs are more subtle. If you haven't built LFU before, expect to spend 20-30 minutes on the implementation alone.
Do I really need to use a doubly-linked list?+
Yes. You need O(1) deletion and insertion. A singly-linked list forces you to search for the previous node, which kills your time complexity. A doubly-linked list lets you remove and reinsert a node in constant time, which is non-negotiable for this problem.
Is LFU Cache still asked at top companies?+
Yes. It appears in reports from Amazon, Walmart Labs, Salesforce, Citadel, and others. It's a genuine design problem, not a trend. If you're interviewing at a company that cares about system design chops, prepare for it.
What's the most common mistake?+
Forgetting to handle the case where you remove a node from a frequency bucket and that bucket becomes empty. You also need to track the minimum frequency separately and update it when you evict. Without that, you're searching all buckets on every eviction, which tanks performance.
How does LFU Cache relate to the other topics?+
Hash Table gives you O(1) lookups. Doubly-Linked List gives you O(1) removal and insertion. The Design part is gluing them together to satisfy all the constraints: get, put, and eviction all in O(1) time. You can't solve this well without understanding all three.
Want the actual problem statement? View "LFU Cache" on LeetCode →