마인 크래프트 재고 관리는 어렵습니다. 17 개의 다이아몬드가 있지만 마법 부여 테이블, 곡괭이 및 칼을 만들려면 7이 필요합니다. 당신은 그들을 픽업하고 마우스 오른쪽 버튼을 7 번 클릭합니까? 또는 마우스 오른쪽 버튼을 한 번 클릭하고 마우스 오른쪽 버튼을 두 번 클릭하고 7을 왼쪽으로 가져 갑니까? 너무 혼란 스러워요!

^{지금 혼란스러워하는 사람들을 위해 걱정하지 마십시오. 모든 것을 잠시 후에 설명하겠습니다.}

도전

항목 스택의 크기와 원하는 금액이 주어지면 해당 금액을 얻을 수있는 최소 클릭 수를 결정하십시오. 두 입력에 대해 최대 64 개만 처리하면되며 무한 재고 슬롯이 있다고 가정 할 수 있습니다. 끌어서 놓기 트릭을 사용할 수 없습니다.

정의

재고는 당신이 항목을 저장할 수있는 슬롯의 모음입니다.

슬롯은 이 항목의 한 종류까지 배치 할 수 있습니다 인벤토리에 저장 공간입니다.

스택은 동일한 그룹에 배치 된 아이템들의 수이다. 이 문제를 해결하기 위해 스택은 단순히 같은 장소에있는 여러 항목입니다 (스택 크기 무시)

커서가 당신의 뾰족한 꼬추입니다. 그 커서. "그 위에"항목이있을 수 있습니다. 다른 말로하면, 슬롯을 클릭하고 아이템을 픽업하면 픽업 한 아이템은 내려 놓을 때까지 "커서 상에"있습니다.

명세서

네 가지 가능한 상황이 있습니다. 커서에 항목이 있거나없는 상태에서 마우스 왼쪽 단추를 클릭하거나 마우스 오른쪽 단추를 클릭하십시오.

커서에 항목이없고 슬롯을 마우스 왼쪽 버튼으로 클릭하면 전체 스택을 가져옵니다.

커서에 아이템이없고 슬롯을 마우스 오른쪽 버튼으로 클릭하면 스택의 절반을 반올림합니다.

커서에 항목이 있고 슬롯을 마우스 왼쪽 단추로 클릭하면 모든 항목이 해당 슬롯에 배치됩니다. (마인 크래프트 플레이어에게는이 챌린지에 대해> 64 개 이상의 아이템이없고 모두 64 개 스택 가능하며 한 가지 유형 만 있으므로 아이템 스왑이 여기에 적용되지 않습니다)

커서에 항목이 있고 슬롯을 마우스 오른쪽 버튼으로 클릭하면 해당 항목을 하나의 슬롯에 넣습니다.

따라서 슬롯에 주어진 모든 항목 (첫 번째 입력 또는 두 번째; 순서를 선택할 수 있음)으로 시작하고 커서에 원하는 양 (다른 입력)을 갖는 것으로 끝내기를 원합니다.

예를 들어 봅시다. 17 개의 항목으로 시작하여 7을 원한다고 가정하십시오. 먼저, 스택을 마우스 오른쪽 버튼으로 클릭하면 9 개를 선택하고 해당 슬롯에 8 개가 있음을 의미합니다. 그런 다음 스택을 다시 마우스 오른쪽 버튼으로 클릭하면 하나의 항목을 슬롯에 다시 배치하여 8과 9를 남깁니다. 마지막으로 다시 마우스 오른쪽 버튼을 클릭하면 7과 슬롯이 10이됩니다. 3(클릭 수)를 반환 합니다.

^{out-click-golf me를 관리하는 경우 알려주십시오. 예를 편집하겠습니다 .P}

테스트 사례

이들은 수동으로 생성되므로 오류가 있는지 알려주십시오. 지터를 마우스 오른쪽 버튼으로 클릭하여 재고 관리를 수행하므로 최적의 재고 관리 경험이 없습니다 .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

설명

이 도전은 마인 크래프트가 아닌 플레이어에게는 까다로울 수 있습니다. 다음은 몇 가지 설명입니다.

64, 8 -> 5 마우스 오른쪽 버튼을 사용하여 32 개를 집어 올린 후 내려 놓고 16 번 집어 들어 올린 다음 8 번 집어 올립니다.

63, 8 -> 5 같은 이유로.

25, 17 -> 7 13을 집어 들고 내려 놓고 남은 12 개에서 6 개를 집어 들고 2를 다시 남은 스택에 놓은 다음 커서에 4를 13에 놓고 집어 올립니다.

규칙

• 표준 허점 적용
• 당신은 가정 할 수 있습니다 0 <= desired <= given <= 64
• 순서에 상관없이 입력을 받고 합리적인 형식으로 I / O를 수행 할 수 있습니다.

C ++ , 498 482 457 바이트

이 함수가 한 번만 호출되면 455 바이트 일 수 있습니다.

거의 모든 온라인 GCC 컴파일러 (TIO 포함)가 함수 유형을 생략하는 것을 금지한다는 것을 알았습니다 f. 그러나 내 컴퓨터의 GCC가이를 허용하며 이유를 모르겠습니다.

슬롯이 많은 수의 항목을 포함 할 수있는 경우 (이는 더 큰 배열이 필요하고 시간이 부족할 수 있음) 큰 입력을 처리 할 수 ​​있습니다.

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

언 골프 드 :

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

젤리 , 74 바이트

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

첫 번째 입력 (3 번째 인수)에 현재 스택과 2 번째 입력 (4 번째 인수)에 원하는 커서가있는 전체 프로그램.

온라인으로 사용해보십시오! 구현으로 인해25, 17테스트 사례에서 60 초의 TIO 시간 초과가발생했습니다. 이것은 사용 golfiness 속 왼쪽 중복을 제거함으로써 해결 될 수있다 이 84 byter 크기가 0 인 스택 필터링과 함께 나머지 것들 정렬 (ḟ€Ṣ¥0¦€0링크 (6)의 단부와의 사용과 각 단계에서의 고유 상태를 유지 만Q$주에 링크).

어떻게?

이 프로그램은 정의 된 상태 머신을 구현합니다.
원래 상태를 [0, [argument 1]]
만든 다음
일치하는 것으로 확인 될 때까지 다음으로 가능한 모든 상태로 반복적으로 이동합니다 [argument 2, [...]].

_{참고 : 프로그램 항목은 가장 아래쪽에있는 "주 링크"에 있습니다 ( 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)