Quản lý hàng tồn kho Minecraft là khó. Bạn có 17 viên kim cương, nhưng bạn cần 7 viên để chế tạo một chiếc bàn bùa mê, một cái cuốc và một thanh kiếm. Bạn có chọn chúng và nhấp chuột phải 7 lần? Hay bạn nhấp chuột phải một lần và nhấp chuột phải hai lần và lấy 7 trái? Thật khó hiểu!

^{Đối với những người hiện đang bối rối, đừng lo lắng, tôi sẽ giải thích tất cả trong giây lát}

Thử thách

Cho kích thước của một chồng các mặt hàng và số lượng mong muốn, xác định số lần nhấp ít nhất để có được số tiền đó. Bạn chỉ cần xử lý tối đa 64 cho cả hai đầu vào và bạn có thể cho rằng mình có các khoảng không quảng cáo vô hạn. Bạn không thể sử dụng thủ thuật kéo để phân phối.

Các định nghĩa

Hàng tồn kho là một tập hợp các vị trí nơi bạn có thể lưu trữ các mặt hàng.

Vị trí là không gian lưu trữ trong kho của bạn, nơi bạn có thể đặt tối đa một loại mặt hàng.

Một ngăn xếp là một số vật phẩm được đặt trong cùng một nhóm. Đối với mục đích của thử thách này, một ngăn xếp chỉ đơn giản là một loạt các vật phẩm ở cùng một nơi (vì vậy bỏ qua kích thước ngăn xếp)

Con trỏ là vật nhọn của bạn. Con trỏ đó. Nó có thể có các mục "trên đó"; trong các điều khoản khác, nếu bạn nhấp vào một vị trí và nhặt các mục, các mục bạn đã chọn là "trên con trỏ" cho đến khi bạn đặt chúng xuống.

Thông số kỹ thuật

Có bốn tình huống có thể xảy ra. Hoặc bạn có một mục trên con trỏ của bạn hoặc bạn không, và bạn nhấp chuột trái hoặc nhấp chuột phải.

Nếu bạn không có mục nào trên con trỏ và nhấp chuột trái vào vị trí, bạn chọn toàn bộ ngăn xếp.

Nếu bạn không có một mục trên con trỏ của mình và bạn nhấp chuột phải vào một vị trí, bạn chọn một nửa ngăn xếp, làm tròn lên.

Nếu bạn có một mục trên con trỏ và nhấp chuột trái vào một vị trí, bạn đặt tất cả các mục vào vị trí đó. (Đối với tất cả những người chơi Minecraft của bạn, bạn sẽ không có> 64 vật phẩm cho thử thách này và tất cả chúng đều có thể xếp chồng 64 và bạn chỉ có một loại nên việc hoán đổi vật phẩm không áp dụng ở đây)

Nếu bạn có một mục trên con trỏ và bạn nhấp chuột phải vào một vị trí, bạn đặt một mục vào vị trí đó.

Vì vậy, bạn bắt đầu với tất cả các mục được cung cấp (đầu vào đầu tiên hoặc thứ hai; bạn có thể chọn thứ tự) trong một vị trí và bạn muốn kết thúc với việc có số lượng mong muốn (đầu vào khác) trong con trỏ của bạn.

Hãy chạy qua một ví dụ. Giả sử bạn bắt đầu với 17 mục và bạn muốn 7. Đầu tiên, bạn nhấp chuột phải vào ngăn xếp, có nghĩa là bạn đã nhặt được 9 và có 8 mục trong khe đó. Sau đó, nếu bạn nhấp chuột phải vào ngăn xếp một lần nữa, bạn đặt một mục trở lại vào vị trí, để lại cho bạn 8 và vị trí có 9. Cuối cùng, bạn nhấp chuột phải lần nữa và bạn có 7 và vị trí có 10. Do đó, bạn sẽ trở lại 3(số lần nhấp).

^{Nếu bạn quản lý để nhấp chuột vào tôi, xin vui lòng cho tôi biết và tôi sẽ chỉnh sửa ví dụ: P}

Các trường hợp thử nghiệm

Chúng được tạo thủ công, vì vậy vui lòng cho tôi biết nếu có bất kỳ lỗi nào. Tôi thực hiện quản lý hàng tồn kho thông qua nhấp chuột phải để nhấp chuột phải vì vậy tôi không có kinh nghiệm với quản lý hàng tồn kho tối ưu: 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

Giải thích

Thử thách này có thể khó đối với những người chơi không phải Minecraft, tôi không biết. Dưới đây là một số giải thích.

64, 8 -> 5 bởi vì bạn chọn 32 bằng cách nhấp chuột phải, đặt nó xuống, chọn 16, đặt nó xuống, sau đó chọn 8.

63, 8 -> 5 cho cùng một lý do.

25, 17 -> 7 bởi vì bạn nhặt 13, đặt nó xuống, nhặt 6 từ 12 còn lại, đặt 2 trở lại vào ngăn xếp còn lại, sau đó đặt 4 trong con trỏ vào 13, sau đó chọn chúng.

Quy tắc

Áp dụng sơ hở tiêu chuẩn
Bạn có thể cho rằng 0 <= desired <= given <= 64
Bạn có thể nhận đầu vào theo thứ tự và thực hiện I / O ở bất kỳ định dạng hợp lý nào

code-golf game

— HyperNeutrino
nguồn

1

ae-mod.info

— Stephen

Liên quan

— admBorkBork

2

Vì vậy, nó giống như một nhà máy mà bắt đầu với một tình trạng 0,[n], có thể chuyển tiếp: (1) từ 0,[a,b,...]đến a,[b,...], b,[a,...], ceil(a/2),[floor(a/2),b,...], hoặc ceil(b/2),[a,floor(b/2),...]; hoặc (2) từ x,[a,b,...]( x>0) để x-1,[a+1,b,...], x-1,[a,b+1,...], x-1,[a,b,...,1], 0,[a+x,b,...], 0,[a,b+x,...], 0,[a,b,...,x]. Thử thách sau đó là tìm ra các chuyển đổi tối thiểu có thể có từ 0,[g]nơi g được đưa ra đến t,Lđâu tlà mục tiêu mong muốn và Lcó danh sách nào không?

— Jonathan Allan

2

C ++ , 498 482 457 byte

Nếu chức năng này chỉ được gọi một lần, nó có thể là 455 byte.

Tôi thấy rằng hầu hết mọi trình biên dịch GCC trực tuyến (bao gồm cả TIO) đều cấm tôi bỏ qua loại hàm này f. Tuy nhiên, GCC trên máy tính của tôi cho phép điều đó và tôi không biết tại sao.

Cái này có thể xử lý các đầu vào lớn nếu một vị trí có thể chứa số lượng vật phẩm đó (mặc dù cần một mảng lớn hơn và có thể sẽ hết thời gian).

#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)}}}}

Ung dung:

#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
        }
    }
}

— Colera Su
nguồn

1

Thạch , 74 byte

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

Một chương trình đầy đủ với đầu vào đầu tiên (đối số thứ 3) ngăn xếp hiện tại và đầu vào thứ hai (đối số thứ 4) con trỏ mong muốn.

Hãy thử trực tuyến! Do việc thực hiện, điều này đạt đến thời gian TIO hết 60 giây cho25, 17trường hợp thử nghiệm. Điều này có thể được khắc phục bằng cách loại bỏ các khoản dư thừa còn lại cho việc chơi gôn bằng cách sử dụng bộ rẽ 84 này (lọc các ngăn xếp có kích thước bằng 0 và sắp xếp các ngăn còn lạiḟ€Ṣ¥0¦€0ở cuối liên kết 6 và chỉ giữ các trạng thái duy nhất ở mỗi bước khi sử dụngQ$Chính liên kết).

Làm sao?

Chương trình thực hiện các máy trạng thái được xác định.
Nó tạo trạng thái ban đầu [0, [argument 1]]
sau đó lặp đi lặp lại tất cả các trạng thái có thể tiếp theo
cho đến khi tìm thấy trạng thái khớp [argument 2, [...]].

_{Lưu ý: mục nhập chương trình nằm ở "Liên kết chính", là mục cuối cùng ( 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)

— Jonathan Allan
nguồn

Quản lý kho Minecraft