import numpy as np

# Define the parameters of the caching problem

N = 100    # number of end user devices

M = 10     # number of edge devices

C = 10000  # cache capacity of each edge device in bytes

F = np.random.randint(1, 10, size=(N, M))  # access frequency matrix

S = np.random.randint(100, 1000, size=N)  # content size array

# Define the heuristic algorithm to solve the caching optimization problem

def cache_heuristic(N, M, C, F, S):

    # Calculate the popularity score for each content

    P = np.sum(F, axis=0)

    # Sort the contents by their popularity scores

    sorted_contents = np.argsort(P)[::-1]

    # Initialize the cache of each edge device to be empty

    cache = np.zeros((M, C))

    # For each content in the sorted list, starting from the most popular content

    for j in sorted_contents:

        # Check if content j can fit in any of the edge devices' caches

        added_to_cache = False

        for k in range(M):

            if np.sum(cache[k]) + S[j] <= C:

                cache[k][np.argmax(cache[k] == 0)] = S[j] * F[:,j].sum()

                added_to_cache = True

                break

        # If content j cannot fit in any of the edge devices' caches, use LRU replacement policy

        if not added_to_cache:

            least_popular_device = np.argmin(P)

            least_popular_content_index = np.argmin(cache[least_popular_device])

            cache[least_popular_device][least_popular_content_index] = S[j] * F[:,j].sum()

    # Return the cached contents on each edge device

    cached_contents = []

    for k in range(M):

        cached_contents.append(np.where(cache[k] > 0)[0])

    return cached_contents

# Call the heuristic algorithm and print the results

cached_contents = cache_heuristic(N, M, C, F, S)

for k in range(M):

    print(f"Edge device {k}: Cached contents {cached_contents[k]}")