Design an image browsing app (a grid of photos you can open full screen): thumbnails, paging, caching, memory and offline.

Predict first

What do the sizes, the byte-budget cache and the prefetch ranges print?

final class CostCache {                                    // LRU cache with a byte budget, not an item count
    private(set) var order: [Int] = []                     // least recently used first
    private var sizes: [Int: Int] = [:]
    private(set) var used = 0
    let budget: Int
    init(budget: Int) { self.budget = budget }
    func get(_ id: Int) -> Bool { guard sizes[id] != nil else { return false }; touch(id); return true }
    func put(_ id: Int, bytes: Int) {
        if let old = sizes[id] { used -= old }
        sizes[id] = bytes; used += bytes; touch(id)
        while used > budget, let victim = order.first {      // evict until we fit again
            order.removeFirst(); used -= sizes.removeValue(forKey: victim)!
        }
    }
    private func touch(_ id: Int) { order.removeAll { $0 == id }; order.append(id) }
}
func prefetchRange(visible: ClosedRange<Int>, ahead: Int, count: Int) -> ClosedRange<Int> {
    visible.lowerBound...min(count - 1, visible.upperBound + ahead)
}
let decodedFull = 4000 * 3000 * 4                           // a 12 megapixel photo decoded to 4 bytes per pixel
let decodedThumb = 200 * 200 * 4
print("full photo:", decodedFull, "bytes, thumbnail:", decodedThumb, "bytes, ratio:", decodedFull / decodedThumb)
let cache = CostCache(budget: 100)
cache.put(1, bytes: 40); cache.put(2, bytes: 40)
print("hit 1:", cache.get(1), "used:", cache.used, "order:", cache.order)
cache.put(3, bytes: 40)                                      // over budget: the least recently used (2) goes
print("hit 2:", cache.get(2), "used:", cache.used, "order:", cache.order)
print("prefetch:", prefetchRange(visible: 10...14, ahead: 5, count: 100), prefetchRange(visible: 96...99, ahead: 5, count: 100))

• full photo: 48000000 bytes, thumbnail: 160000 bytes, ratio: 300 / hit 1: true used: 80 order: [2, 1] / hit 2: false used: 80 order: [1, 3] / prefetch: 10...19 96...99
• ratio: 30 / hit 2: true order: [1, 2, 3]
• prefetch: 10...14 96...104