Memoization Cache Simulator

Problem Context

One of the most common React performance optimizations is memoization — avoiding redundant computations by caching results. This is the core idea behind React.memo, useMemo, and useCallback. In this problem, you'll implement the underlying cache mechanism that powers these hooks.

You are given a series of function calls, each identified by a function name and a list of arguments. Your task is to simulate a memoization cache that:

• Returns a cached result if the same function with the same arguments was called before.
• Computes and stores the result if it's a new call.
• Supports a cache invalidation operation that clears all cached results for a specific function.

Each function, when called with arguments [a, b, c, ...], returns the sum of all arguments as its computed value.

Input/Output Format

Input: A list of operations, where each operation is one of:

• ["call", funcName, [args]] — call the function with given arguments
• ["invalidate", funcName] — clear cached results for funcName

Output: A list of results for each "call" operation:

• Return the computed/cached result (sum of args)
• Append "(cached)" if the result was retrieved from cache, or "(computed)" if freshly calculated.

Examples

Example 1

Input:

operations = [
  ["call", "add", [1, 2]],
  ["call", "add", [1, 2]],
  ["call", "add", [3, 4]]
]

Output: ["3 (computed)", "3 (cached)", "7 (computed)"]

Explanation: The first call to add(1,2) computes 1+2=3. The second call hits the cache. The third call with different args computes 3+4=7.

Example 2

Input:

operations = [
  ["call", "sum", [5, 10]],
  ["invalidate", "sum"],
  ["call", "sum", [5, 10]]
]

Output: ["15 (computed)", "15 (computed)"]

Explanation: After invalidation, the cache for sum is cleared, forcing recomputation.

Example 3

Input:

operations = [
  ["call", "fn", []],
  ["call", "fn", []]
]

Output: ["0 (computed)", "0 (cached)"]

Explanation: Empty args sum to 0. Second call is cached.