Este desafío es realmente simple (¡y un precursor de uno más difícil!).
Dada una matriz de accesos a recursos (simplemente denotada por enteros no negativos) y un parámetro n
, devuelve el número de fallos de caché que supondría si nuestra caché tiene capacidad n
y utiliza un esquema de expulsión de primero en entrar, primero en salir (FIFO) cuando está lleno .
Ejemplo:
4, [0, 1, 2, 3, 0, 1, 2, 3, 4, 0, 0, 1, 2, 3]
0 = not in cache (miss), insert, cache is now [0]
1 = not in cache (miss), insert, cache is now [0, 1]
2 = not in cache (miss), insert, cache is now [0, 1, 2]
3 = not in cache (miss), insert, cache is now [0, 1, 2, 3]
0 = in cache (hit), cache unchanged
1 = in cache (hit), cache unchanged
2 = in cache (hit), cache unchanged
3 = in cache (hit), cache unchanged
4 = not in cache (miss), insert and eject oldest, cache is now [1, 2, 3, 4]
0 = not in cache (miss), insert and eject oldest, cache is now [2, 3, 4, 0]
0 = in cache (hit), cache unchanged
1 = not in cache (miss), insert and eject oldest, cache is now [3, 4, 0, 1]
2 = not in cache (miss), insert and eject oldest, cache is now [4, 0, 1, 2]
3 = not in cache (miss), insert and eject oldest, cache is now [0, 1, 2, 3]
Entonces, en este ejemplo hubo 9 fallas. Tal vez un ejemplo de código ayude a explicarlo mejor. En Python:
def num_misses(n, arr):
misses = 0
cache = []
for access in arr:
if access not in cache:
misses += 1
cache.append(access)
if len(cache) > n:
cache.pop(0)
return misses
Algunos casos de prueba adicionales (que contienen una pista hacia el próximo desafío, ¿notas algo curioso?):
0, [] -> 0
0, [1, 2, 3, 4, 1, 2, 3, 4] -> 8
2, [0, 0, 0, 0, 0, 0, 0] -> 1
3, [3, 2, 1, 0, 3, 2, 4, 3, 2, 1, 0, 4] -> 9
4, [3, 2, 1, 0, 3, 2, 4, 3, 2, 1, 0, 4] -> 10
El código más corto en bytes gana.
notice anything curious?
por un tiempo ahora ... y me di cuenta, ¿aumentar la capacidad de caché no necesariamente disminuye la cantidad de fallas?