Caching and result reuse in Agentic AI - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to store the result in cache after computation.

Agentic AI

cache['result'] = [1](data)

Drag options to blanks, or click blank then click option'

Aprocess_data

Bload_data

Cclear_cache

Dreset_data

Attempts:

3 left

💡 Hint

Common Mistakes

Using a function that does not compute the result, like loading or clearing data.

The function process_data computes the result which we want to cache for reuse.

2fill in blank

medium

Complete the code to check if the result is already cached before computing.

Agentic AI

if 'result' not in cache:
    cache['result'] = [1](input_data)

Drag options to blanks, or click blank then click option'

Areset_result

Bclear_cache

Cload_cache

Dcompute_result

Attempts:

3 left

💡 Hint

Common Mistakes

Calling functions that clear or reset cache instead of computing the result.

We only compute the result if it is not already in the cache, so we call compute_result.

3fill in blank

hard

Fix the error in the code to reuse cached results properly.

Agentic AI

def get_result(data):
    if [1] in cache:
        return cache['result']
    cache['result'] = compute(data)
    return cache['result']

Drag options to blanks, or click blank then click option'

A'result'

Bresult

C'cache'

Ddata

Attempts:

3 left

💡 Hint

Common Mistakes

Checking for a variable instead of a string key in the dictionary.

The key to check in the cache dictionary must be a string, so it should be 'result'.

4fill in blank

hard

Fill both blanks to create a cache dictionary that stores results only if input is new.

Agentic AI

def cached_compute(input):
    if input [1] cache:
        return cache[input]
    cache[input] = [2](input)
    return cache[input]

Drag options to blanks, or click blank then click option'

Anot in

Bin

Ccompute_result

Dclear_cache

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'in' instead of 'not in' causes recomputation to be skipped incorrectly.

Calling a function that clears cache instead of computing result.

We check if the input is not in cache to avoid recomputation, then compute and store the result.

5fill in blank

hard

Fill all three blanks to implement a caching mechanism with a function and cache dictionary.

Agentic AI

cache = {}

def [1](x):
    if x [2] cache:
        return cache[x]
    cache[x] = [3](x)
    return cache[x]

Drag options to blanks, or click blank then click option'

Aget_cached_result

Bnot in

Cexpensive_calculation

Dclear_cache

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'in' instead of 'not in' causes wrong caching behavior.

Using a function that clears cache instead of computing result.

The function get_cached_result checks if x is not in cache, then calls expensive_calculation to compute and store the result.

Practice

1.

What is the main benefit of caching in AI tasks?

easy

A. It saves time by reusing previous results.

B. It increases the size of the dataset.

C. It makes the model more complex.

D. It reduces the accuracy of predictions.

Solution

1. Step 1: Understand caching purpose

   Caching stores results from previous computations to avoid repeating the same work.

2. Step 2: Identify the benefit

   Reusing cached results saves time and speeds up AI tasks.

3. Final Answer:

   It saves time by reusing previous results. -> Option A

4. Quick Check:

   Caching benefit = Saves time [OK]

Hint: Caching means saving results to avoid repeat work [OK]

Common Mistakes:

• Thinking caching increases dataset size
• Believing caching reduces accuracy
• Confusing caching with model complexity

2.

Which Python code snippet correctly checks if a result is cached before computing?

cache = {}
key = 'input1'
# What to do next?

easy

A. if cache.has_key(key):
result = cache[key]
else:
result = compute()
cache[key] = result

B. if key in cache:
result = cache[key]
else:
result = compute()
cache[key] = result

C. if key not in cache:
result = cache[key]
else:
result = compute()
cache[key] = result

D. if cache[key]:
result = cache[key]
else:
result = compute()
cache[key] = result

Solution

1. Step 1: Check Python dictionary membership

   Use 'if key in cache' to check if key exists in dictionary.

2. Step 2: Use correct syntax to assign or compute

   If key exists, get cached result; else compute and save it.

3. Final Answer:

   if key in cache: result = cache[key] else: result = compute() cache[key] = result -> Option B

4. Quick Check:

   Python dict membership uses 'in' keyword [OK]

Hint: Use 'if key in dict' to check cache presence [OK]

Common Mistakes:

• Using deprecated has_key() method
• Checking 'if cache[key]' without key check
• Reversing condition logic

3.

What will be the output of this code?

cache = {}
def compute(x):
    print(f"Computing {x}")
    return x * 2

inputs = [1, 2, 1]
results = []
for i in inputs:
    if i in cache:
        results.append(cache[i])
    else:
        val = compute(i)
        cache[i] = val
        results.append(val)
print(results)

medium

A. [1, 2, 1]

B. [2, 4, 4]

C. [2, 2, 2]

D. [2, 4, 2]

Solution

1. Step 1: Trace the loop and caching behavior

   For input 1: not cached, compute(1)=2, cache[1]=2, results=[2]. For input 2: not cached, compute(2)=4, cache[2]=4, results=[2, 4]. For input 1 again: cached, results append cache[1]=2, results=[2, 4, 2].

2. Step 2: Confirm final results list

   The final printed list is [2, 4, 2].

3. Final Answer:

   [2, 4, 2] -> Option D

4. Quick Check:

   Cache reuse returns previous result [OK]

Hint: Cached inputs skip compute, reuse stored value [OK]

Common Mistakes:

• Assuming compute runs for repeated input
• Mixing up cached values
• Ignoring print output side effect

4.

Find the error in this caching code and select the fix:

cache = {}
def get_result(x):
    if x in cache:
        return cache[x]
    result = compute(x)
    return result

medium

A. Remove the cache dictionary entirely.

B. Change 'if x in cache' to 'if x not in cache'.

C. Add 'cache[x] = result' before returning result.

D. Return 'cache[x]' without checking if key exists.

Solution

1. Step 1: Identify missing cache update

   The function returns computed result but never saves it to cache, so caching fails.

2. Step 2: Fix by saving result in cache

   Insert 'cache[x] = result' before returning to store computed value.

3. Final Answer:

   Add 'cache[x] = result' before returning result. -> Option C

4. Quick Check:

   Cache must store new results [OK]

Hint: Always save new results to cache before returning [OK]

Common Mistakes:

• Forgetting to update cache after compute
• Reversing cache check condition
• Ignoring cache and recomputing every time

5.

You want to speed up an AI agent that processes user queries by caching results. Which strategy best balances memory use and speed?

• A. Cache all results forever.
• B. Cache only recent results with a size limit.
• C. Never cache, always compute fresh results.
• D. Cache results but never check before computing.

hard

A. Cache only recent results with a size limit.

B. Cache all results forever.

C. Never cache, always compute fresh results.

D. Cache results but never check before computing.

Solution

1. Step 1: Understand caching trade-offs

   Caching all results forever uses unlimited memory, which is impractical.

2. Step 2: Choose a balanced caching strategy

   Limiting cache size to recent results saves memory and keeps speed benefits.

3. Final Answer:

   Cache only recent results with a size limit. -> Option A

4. Quick Check:

   Limited cache balances memory and speed [OK]

Hint: Limit cache size to keep memory use reasonable [OK]

Common Mistakes:

• Caching everything without limit
• Not checking cache before computing
• Skipping caching entirely