Bu zorluk gerçekten basittir (ve daha zor olanın öncüsüdür!).

Bir dizi kaynak erişimi (yalnızca negatif olmayan tamsayılarla belirtilir) ve bir parametre nverildiğinde, önbelleğimizin kapasiteye sahip olduğunu nve ilk dolduğunda ilk giren ilk (FIFO) ejeksiyon şemasını kullandığını varsayarsa, önbellek sayısını geri döndürür. .

Örnek:

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]

Yani bu örnekte 9 özledim. Belki bir kod örneği daha iyi açıklamaya yardımcı olur. Python'da:

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

Bazı ileri test sınavları (bir sonraki yarışmaya ilişkin bir ipucu içeren - meraklı bir şey farkettiniz mi?):

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

Bayt cinsinden en kısa kod kazanır.

JavaScript (ES6), 55 bayt

Yöntem # 1: önbellek girdinin üzerine yazar.

Körleme sözdiziminde girdi alır (cache_size)(list).

n=>a=>a.map(x=>a[a.indexOf(x,k>n&&k-n)<k||k++]=x,k=0)|k

Çevrimiçi deneyin!

Nasıl?

0 ile başlatılan ayrı bir işaretçi k kullanarak, ön dizideki a [] giriş dizisinin üzerine yazıyoruz .

X'in önbellekte a.indexOf(x, k > n && k - n) < kolup olmadığını test etmek için kullanıyoruz .

Önbellek, orijinal dizinin içinden geçirilenden daha hızlı büyüyemez, bu nedenle her değerin, önbellek penceresinin içinde veya ötesinde bulunacağı garanti edilir (yani indexOf(), asla -1 döndürmez ).

Maksimum (0, k - n) ve k - 1 (her iki sınır dahil) arasında bir dizinde bulunursa önbellekte bir değer bulunur, bu durumda [true] = x yaparız . Bu yalnızca ardında yatan nesnenin bir özelliği etkiler bir [] , ancak değiştirmeyen dizi a [] . Aksi takdirde, bir [k ++] = x yaparız .

Örnek

Aşağıda [1, 1, 2, 3, 3, 2, 1, 4]önbellek boyutu 2 olan giriş için farklı adımlar verilmiştir :

• kalın kenarlıklar: map () pointer
• parantez: önbellek işaretçisi k
• turuncu: geçerli önbellek penceresi
• sarı: süresi dolmuş önbellek değerleri

JavaScript (ES6), 57 bayt

Yöntem # 2: önbellek girişin sonuna eklenir

Körleme sözdiziminde girdi alır (cache_size)(list).

n=>a=>a.map(x=>n*~a.indexOf(~x,-n)||a.push(~x)&k++,k=0)|k

Çevrimiçi deneyin!

Nasıl?

Giriş dizisi a [] ' nın negatif olmayan tamsayı içerdiği garanti edildiğinden , her bir x değerinin bir-tamamlayıcısını ~ x kullanarak [] sonunda önbelleği güvenle ekleyebiliriz .

Son x değerleri arasında ~ xn * ~a.indexOf(~x, -n) bulunup bulunmadığını test etmek için kullanıyoruz . Bu test başarısız zaman, biz ekleme ~ x için bir [] ve kaçırdığı sayısını artırmak k .

Örnek

Aşağıda, bu yöntemi kullanarak, yukarıdaki ile aynı örnek için farklı adımlar verilmiştir. Önbellek değerleri yalnızca dizinin sonuna eklendiğinden, açık bir önbellek işaretçisi yoktur.

Haskell , 50 bayt

f n=length.foldl(\r x->[x|all(/=x)$take n r]++r)[]

Çevrimiçi deneyin!

Lynn'in tüm önbellek tarihini saklama ve uzunluğunu alma yöntemine dayanıyor . Unary çıktısı biraz daha kısa olurdu:

Haskell , 47 bayt

n?l=1<$foldl(\r x->[x|all(/=x)$take n r]++r)[]l

Çevrimiçi deneyin!

Python 2 , 58 bayt

lambda n,a:len(reduce(lambda c,i:[i][i in c[:n]:]+c,a,[]))

Çevrimiçi deneyin!

3 byte için ovs ve 3 tane daha için xnor sayesinde.

R , 69 64 62 bayt

function(n,A,K={}){for(i in A)K=c(i[!i%in%K[0:n]],K);sum(K|1)}

Çevrimiçi deneyin!

Bazı iyileştirmeler önerdiğiniz için JayCe'ye ve başka bir çift için DigEmAll'a teşekkürler!

Haskell, 61 58 bayt

n!a|let(a:b)#c|elem a c=b#c|1<2=1+b#take n(a:c);_#_=0=a#[]

Çevrimiçi deneyin!

n!a|      =a#[]     -- take input 'n' and a list 'a'
                    -- and call # with the initial list and an empty cache
 let                -- bind function '#':
  (a:b)#c           -- if there's at least one element 'a' left in the list
     |elem a c=b#c  --  and it's in the cache, go on with the same cache
                    --  and the remainder of the list
     |1<2=          -- else (i.e. cache miss)
          1+        --  add one to the recursive call of
       b#           --  the remainder of the list and 
       take n(a:c)  --  the first n elements of 'a' prepended to the cach
 _#_=0              -- if there's no element in the list, return 0

Düzenleme: @Lynn sayesinde -3 bayt.

05AB1E , 17 16 bayt

)svDyå_i¼y¸ìI£]¾

Çevrimiçi deneyin!

açıklama

)                   # wrap the stack in a list
 sv                 # for each item y in input list
   D                # duplicate current list
    yå_i            # if y is not contained in the current list
        ¼           # increment counter
         y¸ì        # prepend y to the current list
            I£      # keep the first input elements
              ]¾    # end loop and push counter

Kotlin , 82 69 bayt

{a,n->a.fold(List(0){0}){c,v->if(v!in c.takeLast(n))c+v else c}.size}

Bir şekilde girişi alır IntArray, değil tipik List<Int>(a problem olmamalı hangi.) Bu, "bir önbellek geçmişi oluşturmak ve uzunluğunu saymak" yaklaşımını kullanır.

Çevrimiçi deneyin!

açıklama

{ a, n ->                         // lambda where a is accesses and n is cache size
    a.fold(List(0){0}) { c, v ->  // fold on empty list
        if(v !in c.takeLast(n))   // if resource is not in last n cache inserts
            c + v                 // insert to cache list
        else
            c                     // return cache as is
    }.size                        // length of cache list is number of inserts
}

Boş bir liste oluşturma

Kotlin'in koleksiyon hazırlayıcıları yoktur, ancak yeni koleksiyonlar oluşturmak için bazı işlevleri vardır.

Boş yaratmanın doğru yolu List<Int>basitçe:

List<Int>()

ancak boyutu kötüye kullanırsak daha kısadır ve başlatıcı bunu yapmayı ister:

List(0){0}
List(0)       // List of size 0
       { 0 }  // with generator returning 0

Jeneratör lambda değeri 0 döndürdüğünden, Kotlin bu listenin türünü girer List<Int>ve 0'ın boyutu bu listenin boş olduğu anlamına gelir.

Perl 6 , 48 bayt

{my@c;$_∈@c.tail($^n)||push @c,$_ for @^o;+@c}

Dene

{  # bare block with placeholder params $n,@o

  my @c; # cache


      $_ ∈ @c.tail($^n) # is the current value in the last bit of the cache
    ||
      push @c, $_       # if not add it to the cache

  for                   # do this for all of

    @^o;                # the input array


  +@c                   # numify the cache (the count)
}

Java 8, 96 bayt

Önbellek boyutu ( int) ve erişim listesini (değiştirilebilir java.util.List<Integer>) alan ve döndüren bir köreli lambda int.

s->a->{int w=0,m=0,i;for(int r:a)m+=(i=a.indexOf(r))<w&i<s?0:s<1?1:1+0*a.set(w++%s,r);return m;}

Çevrimiçi Deneyin

Ungolfed

Bu s, önbellek için giriş listesindeki ilk (en fazla) alanı kullanır .

s ->
    a -> {
        int
            w = 0,
            m = 0,
            i
        ;
        for (int r : a)
            m +=
                (i = a.indexOf(r)) < w & i < s ?
                    0
                    s < 1 ?
                        1
                        : 1 + 0*a.set(w++ % s, r)
            ;
        return m;
    }

Teşekkür

• nimi sayesinde bugfix

Pyth ,  16 15 18 14  13 bayt

İsaacg sayesinde 1 byte kaydedildi .

luaW-H>QGGHEY

Test odası!

Bu zorluk Pyth'in uyapısına çok uygun .

Nasıl çalışır

luaW-H>QGGHEY     Full program. Q = the cache length, E = the list.
 u         E      Reduce E with G = current value and H = corresponding element
            Y     With starting value Y, which is preinitialised to [] (empty list).
   W              Conditional application. If...
    -H            ... Filtering H on absence of...
      >QG         ... The last Q elements of G... 
                  ... Yields a truthy value (that is, H is not in G[-Q:]), then...
  a      GH       ... Append H to G.
                  ... Otherwise, return G unchanged (do not append H at all).
l                  Get the length of the result.

Wolfram Dili (Mathematica) , 60 59 bayt

Tr[k={};n=#;k~Take~UpTo@n~FreeQ~#&&k~PrependTo~#&/@#2;1^k]&

Çevrimiçi deneyin!

Desen eşleştirme, 60 bayt kullanma

Length[#2//.{p___,a_,q___,a_,r___}/;Tr[1^{q}]<#:>{p,a,q,r}]&

Bundan daha çok hoşlandım ama 1 bayt daha uzun ...

Çevrimiçi deneyin!

Japt, 16 bayt

;£A¯V øX ªAiXÃAl

Dene

açıklama

                     :Implicit input of array U and integer V
 £                   :Map over each X in U
; A                  :  Initially the empty array
   ¯V                :  Slice to the Vth element
      øX             :  Contains X?
         ª           :  Logical OR
          AiX        :  Prepend X to A
             Ã       :End map
              Al     :Length of A

K4 , 42 40 bayt

Çözüm:

{*1+/1_{r,,(y;x#z,y)r:~z in y:*|y}[x]\y}

Örnekler:

q)k)f:{*1+/1_{r,,(y;x#z,y)r:~z in y:*|y}[x]\y}
q)f[0;1 2 3 4 1 2 3 4]
8
q)f[2;0 0 0 0 0 0 0]
1
q)f[3;3 2 1 0 3 2 4 3 2 1 0 4]
9
q)f[4;3 2 1 0 3 2 4 3 2 1 0 4]
10

Açıklama:

İç işlev için y önbellek, z istek ve x önbellek boyutudur.

{*1+/1_{r,,(y;x#z,y)r:~z in y:*|y}[x]\y} / the solution
{                                      } / lambda taking 2 args
       {                         }       / lambda taking 3 args
                                  [x]\y  / iterate over lambda with each y
                              *|y        / last (reverse, first) y
                            y:           / assign to y
                       z in              / is z in y?
                      ~                  / not 
                    r:                   / assign result to r (true=1,false=0)
           ( ;     )                     / 2-element list
                z,y                      / join request to cache
              x#                         / take x from cache (limit size)
            y                            / (else) return cache unchanged
          ,                              / enlist this result
        r,                               / join with r
     1_                                  / drop the first result
  1+/                                    / sum up (starting from 1)
 *                                       / take the first result

Notlar:

Bunların hepsini yapmanın daha güzel bir yolu olabilir, ancak akla gelen ilk yol budur.

İşlev, 36 bayt için bu şekilde çalıştırılabilir :

q)k)*1+/1_{r,,(y;x#z,y)r:~z in y:*|y}[4]\3 2 1 0 3 2 4 3 2 1 0 4
10

Alternatif - durumunu depolamak için global bir değişken kullanma (çok K benzeri değil), 42 bayt :

{m::0;(){$[z in y;y;[m+:1;x#z,y]]}[x]\y;m}

Brain-Flak , 172 bayt

(([{}]<>)<{({}(()))}{}>)<>([]){{}<>((({})<{({}()<<>(({})<({}<>({}<>))>)<>>)}{}>)<<>(({})([{}]<>{<>(){[()](<{}>)}{}<><({}()<<>({}<>)>)>}{})){(<{}{}>)}{}>)<>([])}{}<>({}[]<>)

Çevrimiçi deneyin!

# Initialize cache with n -1s (represented as 1s)
(([{}]<>)<{({}(()))}{}>)<>

# For each number in input
([]){{}

    # Keep n on third stack
    <>((({})<

        # For last n cache entries, compute difference between entry and new value
        {({}()<<>(({})<({}<>({}<>))>)<>>)}{}

    >)<

        # Get negation of current entry and...
        <>(({})([{}]<>

            {

                # Count cache hits (total will be 1 or 0)
                <>(){[()](<{}>)}{}

                # while moving entries back to right stack
                <><({}()<<>({}<>)>)>

            }{}

        ))

        # If cache hit, don't add to cache
        {(<{}{}>)}{}

    >)

<>([])}{}

# Compute cache history length minus cache size (to account for the initial -1s)
<>({}[]<>)

Jöle , 18 bayt

Ṗɼṛ;ɼe®Uḣ⁴¤C$¡€ṛLɼ

Çevrimiçi deneyin!

Listeyi ilk argüman ve önbellek kapasitesini ikinci argüman olarak alır.

Ṗɼṛ;ɼe®Uḣ⁴¤C$¡€ṛLɼ
 ɼ                 Apply to the register:
Ṗ                  Pop. This initializes the register to the empty list.
  ṛ                Right argument. Yields the list of addresses.
              €    For each element in the list
             ¡     If{
     e                 the element is in
          ¤            nilad{
      ®                      the register
       U                     reversed
        ḣ                    first...
         ⁴                   (cache depth) number of elements
                             }
           C           Complement. 1 <-> 0. Easier to type this than "not".
            $          Combines everything up to `e` into a monad
                      }
                    Then{
    ɼ                    Apply to the register and store the result
   ;                     Append the element
                        }
                ṛ   Right argument:
                  ɼ Apply to the register:
                 L  Length

Ruby , 43 40 bayt

->s,a,*r{a.count{|*x|r!=r=(r|x).pop(s)}}

Çevrimiçi deneyin!

3 byte'ı tıraş ettiğin için teşekkürler.

C (gcc) , 112 110 108 bayt

f(x,y,z)int*y;{int*i=y+z,b[x],m=0;for(wmemset(b,z=-1,x);i-y;y++)wmemchr(b,*y,x)?:++m*x?b[z=++z%x]=*y:0;x=m;}

Çevrimiçi deneyin!

Biraz daha az golf oynadı

f(x,y,z)int*y;{
 int*i=y+z,b[x],m=0;
 for(wmemset(b,z=-1,x);i-y;y++)
  wmemchr(b,*y,x)?:
   ++m*
   x?
    b[z=++z%x]=*y
   :
    0;
 x=m;
}

C (gcc) , 156 bayt

s,n,m,i,j;f(x,_)int*_;{int c[x];n=m=0;for(i=0;i<x;++i)c[i]=-1;for(i=s=0;_[i]>=0;++i,s=0){for(j=0;j<x;++j)s|=(c[j]==_[i]);if(!s){c[n++]=_[i];m++;n%=x;}}x=m;}

Çevrimiçi deneyin!

Açıklama:

s,n,m,i,j;                       // Variable declaration
f(x,_)int*_;{                    // F takes X (the cache size) and _ (-1-terminated data)
    int c[x];                    // declare the cache
    n=m=0;                       // next queue insert pos = 0, misses = 0
    for(i=0;i<x;++i)c[i]=-1;     // initialize the cache to -1 (invalid data)
    for(i=s=0;_[i]>=0;++i,s=0){  // for each datum in _ (resetting s to 0 each time)
        for(j=0;j<x;++j)         // for each datum in cache
            s|=(c[j]==_[i]);     // set s if item found
        if(!s){                  // if no item found
            c[n++]=_[i];         // add it to the cache at position n
            m++;                 // add a mis
            n%=x;                // move to next n position (with n++)
        }} x=m;}                 // 'return' m by assigning to first argument

JavaScript (Node.js) , 44 bayt

n=>a=>a.map(y=t=>y[t]+n>p||(y[t]=++p),p=0)|p

Çevrimiçi deneyin!

Jöle , 17 bayt

Ṗœ|Ṛḣ⁴$Ṛʋ\-;⁸e"ċ0

Çevrimiçi deneyin!

Tam program

Değişken 1: yığın (Python 3 listarasında integers)
değişken 2: n(Python 3 intEger)

Pas , 129 bayt

|l:&[_],s|if s>0{let(mut c,mut m)=(vec![-1;s],0);for n in l.iter(){if!c.contains(n){c.remove(0);c.push(*n);m+=1;}}m}else{l.len()}

Çevrimiçi deneyin!

Ungolfed

|l: &[isize], s: usize| {
    if s > 0 {
        let mut c = vec![-1; s];
        let mut m = 0;
        for n in l.iter() {
            if !c.contains(n) {
                c.remove(0);
                c.push(*n);
                m += 1;
            }
        }
        m
    } else {
        l.len()
    }
}

Stax , 15 bayt

Ç═╛¢s▲▬╓í±°☻÷hi

Koş ve hata ayıkla