অনুকূল ক্যাচিং

Question

আপনাকে মেমরি অনুরোধের ক্রম এবং একটি ক্যাশে আকার দেওয়া হবে। কোনও ক্যাশে প্রতিস্থাপনের কৌশল অনুসারে আপনাকে অবশ্যই সর্বনিম্ন সম্ভাব্য সংখ্যক ক্যাশে মিস করতে হবে।

একটি অনুকূল কৌশল হ'ল বেলার্ডের অ্যালগরিদম , যা আপনি চাইলে ব্যবহার করতে পারেন।

---

একটি ক্যাশে ব্যবস্থা নিম্নরূপে কাজ করে: ক্যাশেটি খালি শুরু হয়। মেমোরি অনুরোধগুলি আসে the যদি অনুরোধটি ক্যাশে ডেটার একটি অংশের জন্য জিজ্ঞাসা করে, তবে সবকিছু ঠিক আছে। যদি তা না হয় তবে আপনাকে ক্যাশে মিস করতে হবে। এই মুহুর্তে আপনি ভবিষ্যতে ব্যবহারের জন্য ক্যাশে অনুরোধ করা ডেটা .োকাতে পারেন। যদি ক্যাশে পূর্ণ ছিল এবং আপনি নতুন ডেটা sertোকাতে চান, আপনাকে অবশ্যই সেই ডেটাটি উচ্ছেদ করতে হবে যা আগে ক্যাশে ছিল। আপনি কখনই ডেটা inোকাতে পারবেন না যা কেবল ক্যাশে ছিল না।

আপনার লক্ষ্য একটি প্রদত্ত মেমরি অনুরোধের ক্রম এবং ক্যাশে আকারের জন্য সর্বনিম্ন সম্ভাব্য সংখ্যক ক্যাশে মিস করা সন্ধান করা।

---

আপনাকে ক্যাশের আকার, ধনাত্মক পূর্ণসংখ্যার এবং মেমরি অনুরোধের ক্রম দেওয়া হবে, যা টোকেনের একটি তালিকা। এই টোকেনগুলি আপনার যে ধরণের টোকেন পছন্দ করে তা হতে পারে, যতক্ষণ না কমপক্ষে 256 টি বিভিন্ন টোকেন সম্ভব হয় (বাইট ভাল, বুল হয় না)। উদাহরণস্বরূপ, ints, স্ট্রিং, তালিকা সব ঠিক আছে। প্রয়োজনে স্পষ্টতা জিজ্ঞাসা করুন।

---

পরীক্ষার কেস:

3
[5, 0, 1, 2, 0, 3, 1, 2, 5, 2]

6

প্রতিস্থাপনের নীতি যা এটি অর্জন করে তার জন্য উইকিপিডিয়া দেখুন ।

2
[0, 1, 2, 0, 1, 0, 1]

3

কেবল 2ক্যাশে যুক্ত করা এড়িয়ে চলুন ।

3
[0, 1, 2, 1, 4, 3, 1, 0, 2, 3, 4, 5, 0, 2, 3, 4]

9

এটি অর্জনের একটি উপায় হ'ল কখনই উচ্ছেদ না করা 0এবং এর শেষ ব্যবহারের পরে যত তাড়াতাড়ি সম্ভব 2উচ্ছেদ 1করা।

---

স্কোরিং: এটি কোড গল্ফ। সবচেয়ে কম বাইট জেতা

Comments

আমরা কি ধরে নিতে পারি যে তালিকায় কমপক্ষে 2 টোকেন রয়েছে?

— আর্নৌল্ড

@ আরনাউল্ড আমি না বলতে যাচ্ছি, যদিও এর মধ্যে যদি কেবলমাত্র 1 টি সমাধান পাওয়া যায় তবে উত্তরটি অবশ্যই সর্বদা 1।

— isaacg

Answer 1

জাভাস্ক্রিপ্ট (ES6), 128 বাইট

হিসাবে ইনপুট লাগে (size)(list)।

s=>a=>a.map((x,i)=>c.includes(x)?0:c[e++,[x,...c].map(m=(x,j)=>(k=[...a,x].indexOf(x,i+1))<m||(p=j,m=k)),i<s?i:p-1]=x,e=c=[])&&e

এটি অনলাইন চেষ্টা করুন!

মন্তব্য

এটি বেলডি অ্যালগরিদমের একটি বাস্তবায়ন।

s => a =>                      // s = cache size; a[] = token list
  a.map((x, i) =>              // for each token x at position i in a[]:
    c.includes(x) ?            //   if x is currently stored in the cache:
      0                        //     do nothing
    :                          //   else:
      c[                       //     update the cache:
        e++,                   //       increment the number of errors (cache misses)
        [x, ...c]              //       we want to find which value among x and all current
                               //       cache values will be needed for the longest time in
                               //       the future (or not needed anymore at all)
        .map(m =               //       initialize m to a non-numeric value
                 (x, j) =>     //       for each x at position j in this array:
          ( k = [...a, x]      //         k = position of x in the array made of all values
            .indexOf(x, i + 1) //         of a[] followed by x, starting at i + 1
          ) < m                //         if it's greater than or equal to m, or m is
          || (p = j, m = k)    //         still non-numeric: set p to j and m to k
        ),                     //       end of inner map()
        i < s ?                //       if i is less than the cache size:
          i                    //         just fill the cache by using the next cache slot
        :                      //       else:
          p - 1                //         use the slot that was found above
                               //         special case: if p = 0, x was the best candidate
                               //         and we're going to store it at c[-1], which is
                               //         simply ignored (it will not trigger c.includes(x))
      ] = x,                   //     store x at this position
      e = c = []               //     start with e = [] (coerced to 0) and c = []
  ) && e                       // end of outer map; return e

Answer 2

পার্ল 5 , 193 বাইট

sub g{
  my($i,$m,$s,@a,%c)=(-1,0,@_);
  for(@a){
    $i++;
    next if $c{$_}++ || ++$m && keys%c <= $s;
    my($x,$d);
    for $k (sort keys %c){  #find which to delete, the one furtherst away
      my $n=0;
      ++$n && /^$k$/ && last for @a[$i+1..$#a];
      ($x,$d)=($n,$k) if $n>$x
    }
    delete $c{$d}
  }
  $m
}

এটি অনলাইন চেষ্টা করুন!

print g(3,  5, 0, 1, 2, 0, 3, 1, 2, 5, 2),"\n";                     # 6
print g(2,  0, 1, 2, 0, 1, 0, 1),"\n";                              # 3
print g(3,  0, 1, 2, 1, 4, 3, 1, 0, 2, 3, 4, 5, 0, 2, 3, 4),"\n";   # 9

ইনডেন্টেশন, নিউলাইনস, স্পেস, মন্তব্য ছাড়াই 193 বাইট:

sub g{my($i,$m,$s,@a,%c)=(-1,0,@_);for(@a){$i++;next if$c{$_}++||++$m&&keys%c<=$s;my($x,$d);for$k(sort keys%c){my$n=0;++$n&&/^$k$/&&last for@a[$i+1..$#a];($x,$d)=($n,$k)if$n>$x}delete$c{$d}}$m}

Answer 3

05 এ বি 1 ই , 20 বাইট

vI∍Dyå≠i¼yª¹N.$sÃÙ]¾

এটি অনলাইন চেষ্টা করুন!

Answer 4

হাস্কেল , 82 বাইট

f n|let(d:t)#c=1-sum[1|elem d c]+minimum[t#take n e|e<-scanr(:)(d:c)c];_#_=0=(#[])

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

নিষ্ঠুর শক্তি দ্বারা কাজ করে: সমস্ত ক্যাশে কৌশল চেষ্টা করা হয় এবং সেরা ফলাফল ফিরে আসে।

f n            Define a function f on argument n (cache size) and a list (implicit).
 |let(d:t)#c=  Define binary helper function #.
               Arguments are list with head d (current data) and tail t (remaining data), and list c (cache).
 1-            It returns 1 minus
 sum[1|        1 if
 elem d c]+    d is in the cache, plus
 minimum[      minimum of
 t#            recursive calls to # with list t
 take n e|     and cache being the first n values of e, where
 e<-           e is drawn from
 scanr(:)  c]  the prefixes of c
 (d:c)         with d and c tacked to the end.
 ;_#_=0        If the first list is empty, return 0.
 =(#[])        f then calls # with the list argument and empty cache.

Answer 5

পার্ল 6 , 146 বাইট

->\a,\b {$_=set();$!=0;for b.kv ->\i,\v {$_{v}&&next;++$!;v∈b[i^..*]||next;$_∖=.keys.max({(grep $_,:k,b[i^..*])[0]//Inf})if $_>=a;$_∪=v};$!}

এটি অনলাইন চেষ্টা করুন!