Minecraft envanter yönetimi zordur. 17 elmasınız var, ama bir büyü masası, kazma ve kılıç yapmak için 7'ye ihtiyacınız var. Onları toplayıp 7 kez sağ tıklıyor musunuz? Yoksa bir kez sağ tıklayıp iki kez sağ tıklayıp 7 sola mı dönüyorsunuz? Çok kafa karıştırıcı!

^{şimdi şaşkın olanlarınız için endişelenmeyin, hepsini bir saniye içinde açıklayacağım}

Meydan okuma

Bir öğe kümesinin boyutu ve istenen bir miktar göz önüne alındığında, bu tutarı elde etmek için en az tıklama sayısını belirleyin. Her iki giriş için yalnızca 64'e kadar işlem yapmanız yeterlidir ve sonsuz envanter alanınız olduğunu varsayabilirsiniz. Dağıtmak için sürükle numarasını kullanamazsınız.

Tanımlar

envanter öğeleri saklayabilir yuvaları topluluğudur.

Bir yuva öğenin bir tip kadar yerleştirebilirsiniz envanterinizdeki bir depolama alanıdır.

Bir yığın , aynı grupta yer öğelerin bir sayıdır. Bu zorluğun amaçları doğrultusunda, bir yığın aynı yerde bulunan bir grup öğedir (bu nedenle yığın boyutunu yok sayın)

kürsör sivri şeysi olduğunu. O imleç. "Üzerinde" öğeler olabilir; diğer bir deyişle, bir alanı tıklayıp öğeleri aldıysanız, aldığınız öğeler siz bırakana kadar "imleç" üzerindedir.

Özellikler

Dört olası durum vardır. İmlecinizde bir öğe var ya da yok, ya da sol tıklama ya da sağ tıklama.

İmlecinizde bir öğe yoksa ve bir yuvaya sol tıklarsanız, tüm yığını alırsınız.

İmlecinizde bir öğe yoksa ve bir yuvaya sağ tıklarsanız, yığının yarısını yuvarlanırsınız.

İmlecinizde bir öğe varsa ve bir yuvaya sol tıklarsanız, tüm öğeleri o yuvaya yerleştirirsiniz. (Tüm Minecraft oyuncularınız için, bu meydan okuma için 64 öğeden fazla olmayacaksınız ve bunların hepsi 64 istiflenebilir ve yalnızca bir türünüz var, bu yüzden öğe takası burada geçerli değil)

İmlecinizde bir öğe varsa ve bir yuvaya sağ tıklarsanız, o yuvaya bir öğe yerleştirirsiniz.

Böylece, bir yuvada verilen tüm öğelerle (ilk giriş veya ikinci; siparişi seçebilirsiniz) başlarsınız ve imlecinizde istenen miktarda (diğer giriş) bulunarak bitirmek istersiniz.

Bir örnek verelim. 17 öğe ile başladığınızı ve 7 istediğinizi söyleyin. İlk olarak, yığını sağ tıklıyorsunuz, yani 9'u aldınız ve bu yuvada 8 var. Daha sonra, yığını tekrar sağ tıklarsanız, bir öğeyi yuvaya geri yerleştirirsiniz, sizi 8 ve yuvayı 9 ile bırakırsınız. Son olarak, tekrar sağ tıklarsınız ve 7'ye sahip olursunuz ve yuvanın 10'u vardır. Böylece, dönersiniz 3(tıklama sayısı).

^{Eğer bana golf ile tıklamayı başarırsanız, lütfen bana söyleyin ve örneği düzenleyeceğim: P}

Test Durumları

Bunlar manuel olarak oluşturulur, bu yüzden lütfen herhangi bir hata olup olmadığını bana bildirin. Ben envanter yönetimi sağ tıklama jitter tıklayarak tıklayarak yapmak böylece optimal stok yönetimi deneyimi yok: P

Given, Desired -> Output
17, 7 -> 3
64, 8 -> 5
63, 8 -> 5
10, 10 -> 1
10, 0 -> 0 # note this case
25, 17 -> 7

açıklamalar

Bu zorluk Minecraft dışı oyuncular için zor olabilir, hiçbir fikrim yok. İşte bazı açıklamalar.

64, 8 -> 5 çünkü sağ tıklama ile 32 toplar, yerleştirir, 16 toplar, yerleştirir ve sonra 8 toplarsınız.

63, 8 -> 5 aynı sebepten.

25, 17 -> 7 çünkü 13'ü alırsınız, yere yerleştirirsiniz, kalan 12'den 6'yı alırsınız, 2'yi artık yığınına geri yerleştirirsiniz ve sonra 4'ü imlece 13'e yerleştirirsiniz ve sonra bunları toplarsınız.

kurallar

• Standart boşluklar geçerlidir
• Bunu varsayabilirsin 0 <= desired <= given <= 64
• Her iki sırayla girdi alabilir ve herhangi bir makul biçimde G / Ç yapabilirsiniz

C ++ , 498 482 457 bayt

Bu işlev yalnızca bir kez çağrılırsa, 455 bayt olabilir.

Neredeyse her çevrimiçi GCC derleyicisinin (TIO dahil) işlevin türünü atlamamı engellediğini buldum f. Ancak, bilgisayarımdaki GCC buna izin veriyor ve nedenini bilmiyorum.

Bir yuva bu sayıda öğe içerebiliyorsa büyük girişleri işleyebilir (ancak daha büyük bir diziye ihtiyaç duyar ve muhtemelen zaman tükenir).

#import<bits/stdc++.h>
#define t N.first
#define X n.erase(n.find
#define p(c){if(c==r)return l;if(L.emplace(w={n,c},l).second)Q[U++]=w;}
#define T(S,C)n.insert(S);p(C)X(S));
using m=std::multiset<int>;using s=std::pair<m,int>;s Q[99999];int x,l,B,U;int f(int a,int r){if(!r)return 0;std::map<s,int>L;s f({a},B=0),w,N;L[Q[U=1]=f];for(;;){l=L[N=Q[B++]]+1;x=N.second;t.insert(0);for(int i:t){m n=t;X(i));if(x){T(i+x,0)T(i+1,x-1)}if(!x&&i){p(i)T(i/2,i-i/2)}}}}

Ungolfed:

#include <map>
#include <set>
#include <queue>
#include <iostream>

using namespace std;

struct state {
    multiset<int> t; int q;
    bool operator<(const state& i) const { return make_pair(t, q) < make_pair(i.t, i.q); }
};

int f(int a, int target) {
    if (target == 0) return 0;

    map<state, int> len;
    queue<state> qu;
    state first = {{a}, 0};
    qu.push(first);
    len[first] = 0;

    #define push(c) { state a = {n, c}; auto t = len.insert({a, l + 1}); if (t.second) { \
        if (a.q == target) return l + 1; qu.push(a); \
    } } // push new state into queue and check for termination
    #define next(stk, cur) { n.insert(stk); push(cur); n.erase(n.find(stk)); }
    // insert new stack, push new state, erase the stack (for another use)

    while (qu.size()) { // BFS cycle
        state now = qu.front();
        qu.pop();

        int q = now.q;
        int l = len[now];

        multiset<int> n(now.t);
        for (int i : now.t) { // click on non-empty stack
            n.erase(n.find(i));
            if (!q) { // nothing on cursor
                push(i); // click left
                next(i / 2, (i + 1) / 2); // click right
            }
            else { // item on cursor
                next(i + q, 0); // click left
                next(i + 1, q - 1); // click right
            }
            n.insert(i);
        }
        if (q) { // click on empty stack
            next(q, 0); // click left
            next(1, q - 1); // click right
        }
    }
}

Jöle , 74 bayt

Ẏċ⁴¬
HĊ,$Ḟµ€1¦€F€;⁸Ḣ,$€
‘1¦€ṭ€⁹’¤
+1¦€⁹ṭ€0;ç
⁹Ȧ‘Ḥ¤ŀ
Ṫ;0ṙJ$çḢ
Wṭ0WÇ€Ẏ$ÑпL’

İstenen imleci ilk girdi (3. argüman) ve ikinci girdiyi (4. argüman) içeren tam bir program.

Çevrimiçi deneyin! Uygulama nedeniyle bu,25, 17test durumuiçin 60 saniyelik TIO zaman aşımına uğrar. Bu, golf kullanımı için bırakılan fazlalıkları kaldırarak giderilebilir. bu 84 Byter sıfır boyutlu yığınlar filtreler ile kalmış olan sıralar ( ḟ€Ṣ¥0¦€0renkli 6 sonunda ve kullanımı ile her bir adımda özel durumları tutan tek Q$Main link).

Nasıl?

Program tanımlı durum makinesini uygular.
Orijinal durumu yaratır ve [0, [argument 1]]
ardından bir sonraki olası durumlara tekrar tekrar geçer
eşleşen bir tane bulunana kadar bir[argument 2, [...]] .

_{Not: Program girişi en alttaki olan ("Ana Bağlantı" Wṭ0WÇ€Ẏ$ÑпL’) ( )}

Ẏċ⁴¬ - Link 1, test a list of states for not having the desired cursor
Ẏ    - tighten by one
  ⁴  - program's fourth argument (second input) - desired cursor
 ċ   - count occurrences (the stack list will never match, so just inspecting the cursors)
   ¬ - logical negation

HĊ,$Ḟµ€1¦€F€;⁸Ḣ,$€ - Link 2, next states given a 0 cursor: list, rotatedStacks; number currentCursor (unused)
     µ€1¦€         - for each rotation of rotatedStacks apply to the first element:
H                  -   halve
   $               -   last two links as a monad
 Ċ                 -     ceiling
  ,                -     pair
    Ḟ              -   floor (vectorises) -- i.e. n -> [floor(ceil(n/2)),floor(n/2)]
                                                     = [ceil(n/2),floor(n/2)]
          F€       - flatten each -- i.e. each [[c1,f1],s2, s3,...] -> [c1,f1,s2,s3,...]
             ⁸     - chain's left argument, rotatedStacks
            ;      - concatenate -- i.e. [[c1,f1,s2,s3,...],[c2,f2,s3,...,s1],...,[s1,s2,s3,...],[s2,s3,...,s1],...]
                $€ - last two links as a monad for each:
              Ḣ    -   head
               ,   -   pair -- i.e. [c1,f1,s2,s3,...] -> [c1,[f1,s2,s3,...]]

‘1¦€ṭ€⁹’¤ - Link 3, next states given a non-0 cursor and a right-click: list, rotatedStacks; number currentCursor
 1¦€      - for each rotation of rotatedStacks apply to the first element:
‘         -   increment -- i.e. place an item into the first stack of each rotation
        ¤ - nilad followed by link(s) as a nilad:
      ⁹   -   chain's right argument -- currentCursor
       ’  -   decrement
    ṭ€    - tack each -- i.e. [s1-1,s2,s2,...] -> [currentCursor-1,[s1-1,s2,s2,...]]

+1¦€⁹ṭ€0;ç - Link 4, next states given a non-0 cursor: list, rotatedStacks; number currentCursor
 1¦€       - for each rotation of rotatedStacks apply to the first element:
    ⁹      -   chain's right argument -- currentCursor
+          -   add
     ṭ€0   - tack each to zero -- i.e. [s1+currentCursor,s2,s3,...] -> [0,[s1+currentCursor,s2,s3,...]]
         ç - call the last link (3) as a dyad -- get the right-click states
        ;  - concatenate

⁹Ȧ‘Ḥ¤ŀ - Link 5, next states: list, rotatedStacks; number currentCursor
     ŀ - call link at the given index as a dyad...
    ¤  -   nilad followed by link(s) as a nilad:
⁹      -     chain's right argument -- currentCursor
 Ȧ     -     any & all -- for our purposes zero if zero, one if not
  ‘    -     increment
   Ḥ   -     double
       - -- i.e. call link 2 if currentCursor is zero else call link 4

Ṫ;0ṙJ$çḢ - Link 6, next states: currentState  e.g. [cc, [s1, s2, s3, ...]]
Ṫ        - tail -- get the stacks, [s1, s2, s3, ...]
 ;0      - concatenate a zero - add an empty stack to the options for use
     $   - last two links as a monad for each:
    J    -   range(length)
   ṙ     -   rotate left by -- i.e. [[s2,s3,0,...,s1],[s3,0,...,s1,s2],[0,...,s1,s2,s3],[...,s1,s2,s3,0],...[s1,s2,s3,0,...]]
       Ḣ - head -- get the currentCursor, cc
      ç  - call the last link (5) as a dyad

Wṭ0WÇ€Ẏ$ÑпL’ - Main link: initialStack, requiredCursor
W             - wrap -- [initialStack]
 ṭ0           - tack to zero -- [0, [initialStack]]
   W          - wrap -- [[0, [initialStack]]]
         п   - loop while, collecting the results:
        Ñ     - ...condition: call next link (1) as a monad -- cursor not found
       $      - ...do: last two links as a monad:
    ǀ        -   call the last link (6) as a monad for each
      Ẏ       -   flatten the resulting list by one level
           L  - length
            ’ - decremented (the collect while loop keeps the input too)