What is memoization and how is it implemented in different programming languages?

What is memoization and why is it useful?

Memoization is an optimization technique that stores the results of expensive function calls and returns the cached result when the same inputs occur again. It's useful for improving performance, especially in recursive algorithms.

Can you show me how memoization is implemented in Python?

Sure! In Python, you can use a dictionary to store results. Here's a simple example:

memo = {}

def fib(n):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fib(n-1) + fib(n-2)
    return memo[n]

How about in JavaScript?

In JavaScript, you can use a closure to achieve memoization. Here's an example:

function memoize(fn) {
    const cache = {};
    return function(...args) {
        const key = JSON.stringify(args);
        if (cache[key]) {
            return cache[key];
        }
        const result = fn(...args);
        cache[key] = result;
        return result;
    };
}

const fib = memoize(function(n) {
    if (n <= 1) return n;
    return fib(n - 1) + fib(n - 2);
});

What about in Java?

In Java, you can use a HashMap to store the results. Here's a simple implementation:

import java.util.HashMap;

public class Fibonacci {
    private static HashMap<Integer, Integer> memo = new HashMap<>();

    public static int fib(int n) {
        if (memo.containsKey(n)) {
            return memo.get(n);
        }
        if (n <= 1) return n;
        int result = fib(n - 1) + fib(n - 2);
        memo.put(n, result);
        return result;
    }
}