Speeding Up Calculations with Memoization (Caching)

In this lesson you will learn how to speed up calculations with memoization in Swift, so the same work is not repeated. This is for anyone searching for "Swift memoization how to use".

Memoization stores a result once it has been computed and returns it straight from storage the next time the same input arrives. Picture being asked the same question repeatedly and simply repeating the answer you remembered.

The sample code stores computed results in the cache dictionary, and each time slowSquare() runs it checks whether the answer is already known with if let cached = cache[n]. On the second call with the same input you see "Retrieved from cache" and the actual calculation is skipped.

A common stumbling block for beginners is judging when caching is worth it. The heavier the computation the bigger the payoff, while introducing it for lightweight work can cost more in cache management than it saves.

In real-world development, recursive calculations and cached API responses in particular show a speed-up you can feel, making this a familiar idea in performance work.

📖 Reference code

var cache: [Int: Int] = [:]

func slowSquare(_ n: Int) -> Int {
    if let cached = cache[n] {
        print("Retrieved from cache: \(n)")
        return cached
    }
    print("Calculating: \(n)")
    let result = n * n
    cache[n] = result
    return result
}

print(slowSquare(5))
print(slowSquare(5))

✍️ Your code

Type your code, then press "Run"

🧪 This site can't compile or run Swift directly, so it checks on the spot whether what you typed matches the reference code (scoring happens entirely in your browser — nothing is sent anywhere).