Minecraft इन्वेंट्री प्रबंधन कठिन है। आपके पास 17 हीरे हैं, लेकिन आपको एक मुग्ध टेबल, एक पिकैक्स और एक तलवार तैयार करने के लिए 7 की आवश्यकता है। क्या आप उन्हें उठाते हैं और 7 बार राइट क्लिक करते हैं? या क्या आप एक बार राइट क्लिक करते हैं और दो बार राइट क्लिक करते हैं और 7 लेफ्ट ले जाते हैं? यह बहुत भ्रामक है!

^{आप में से जो अब भ्रमित हैं, चिंता न करें, मैं इसे एक सेकंड में समझाता हूँ}

चुनौती

वस्तुओं के ढेर और एक वांछित राशि के आकार को देखते हुए, उस राशि को प्राप्त करने के लिए कम से कम क्लिक की संख्या निर्धारित करें। आपको केवल दोनों इनपुट के लिए 64 तक की आवश्यकता है और आप मान सकते हैं कि आपके पास अनंत इन्वेंट्री स्लॉट हैं। आप ड्रैग-टू-डिस्ट्रीब्यूट ट्रिक का उपयोग नहीं कर सकते।

परिभाषाएं

सूची स्लॉट जहां आइटम स्टोर कर सकते हैं का एक संग्रह है।

एक स्लॉट आपकी इन्वेंट्री में एक स्टोरेज स्पेस है जहां आप एक प्रकार का आइटम रख सकते हैं।

एक ढेर में एक ही समूह में रखा मदों की एक संख्या है। इस चुनौती के प्रयोजनों के लिए, एक स्टैक केवल एक ही स्थान पर वस्तुओं का एक गुच्छा है (इसलिए स्टैक-आकार को अनदेखा करें)

कर्सर अपने नुकीले thingy है। वह कर्सर। इसमें आइटम "उस पर" हो सकते हैं; अन्य शब्दों में, यदि आपने एक स्लॉट पर क्लिक किया और आइटम उठाए, तो आपके द्वारा उठाए गए आइटम "कर्सर पर" हैं जब तक आप उन्हें नीचे नहीं डालते।

विशेष विवरण

चार संभावित स्थितियां हैं। या तो आपके पास अपने कर्सर पर एक आइटम है या आप नहीं हैं, और या तो आपने बाएं क्लिक किया या आपने राइट क्लिक किया।

यदि आपके पास अपने कर्सर पर कोई आइटम नहीं है और आप एक स्लॉट पर बाएं क्लिक करते हैं, तो आप पूरे स्टैक को उठाते हैं।

यदि आपके पास अपने कर्सर पर कोई आइटम नहीं है और आप किसी स्लॉट पर राइट-क्लिक करते हैं, तो आप आधा स्टैक उठाते हैं, गोल।

यदि आपके पास अपने कर्सर पर एक आइटम है और आप किसी स्लॉट पर बाएं-क्लिक करते हैं, तो आप सभी आइटम को उस स्लॉट में रखते हैं। (आप सभी Minecraft खिलाड़ियों के लिए, आपके पास इस चुनौती के लिए> 64 आइटम नहीं होंगे और वे सभी 64-स्टैकेबल हैं, और आपके पास केवल एक प्रकार है, इसलिए आइटम स्वैप यहां लागू नहीं होता है)

यदि आपके पास अपने कर्सर पर कोई आइटम है और आप किसी स्लॉट पर राइट-क्लिक करते हैं, तो आप उस स्लॉट में एक आइटम रखते हैं।

तो, आप दिए गए सभी आइटम (पहले इनपुट, या दूसरा; आप ऑर्डर चुन सकते हैं) को एक स्लॉट में शुरू करते हैं, और आप अपने कर्सर में वांछित राशि (अन्य इनपुट) होने के साथ समाप्त करना चाहते हैं।

एक उदाहरण के माध्यम से चलते हैं। कहते हैं कि आप 17 वस्तुओं से शुरू करते हैं और आप चाहते हैं 7. सबसे पहले, आप स्टैक पर राइट-क्लिक करें, जिसका मतलब है कि आपने 9 उठाए हैं और उस स्लॉट में 8 हैं। फिर, यदि आप फिर से स्टैक पर राइट-क्लिक करते हैं, तो आप एक आइटम को स्लॉट में वापस रखते हैं, जो आपको 8 और स्लॉट के साथ छोड़ देता है। अंत में, आप फिर से राइट-क्लिक करते हैं और आपके पास 7 हैं और स्लॉट में 10. है। आप वापस लौटेंगे 3(क्लिकों की संख्या)।

^{यदि आप मुझे बाहर जाने के लिए क्लिक करते हैं, तो कृपया मुझे बताएं और मैं उदाहरण संपादित करूंगा: 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

स्पष्टीकरण

यह चुनौती गैर-Minecraft खिलाड़ियों के लिए मुश्किल हो सकती है, मुझे नहीं पता। यहाँ कुछ स्पष्टीकरण दिए गए हैं।

64, 8 -> 5 क्योंकि आप राइट क्लिक का उपयोग करके 32 उठाते हैं, इसे नीचे रखें, 16 उठाएँ, इसे नीचे रखें, फिर 8 उठाएँ।

63, 8 -> 5 एक ही कारण के लिए।

25, 17 -> 7 क्योंकि आप 13 उठाते हैं, इसे नीचे रखें, बचे हुए 12 में से 6 उठाएँ, 2 को बचे हुए ढेर में रखें, और फिर 4 को 13 में कर्सर रखें, और फिर उन्हें उठाएँ।

नियम

मानक खामियां लागू होती हैं
आप ऐसा मान सकते हैं 0 <= desired <= given <= 64
आप किसी भी क्रम में इनपुट ले सकते हैं और किसी भी उचित प्रारूप में I / O कर सकते हैं

code-golf game

— HyperNeutrino
स्रोत

1

ae-mod.info

— स्टीफन

सी ++ , 498 482 457 बाइट्स

यदि यह फ़ंक्शन केवल एक बार कहा जाता है, तो यह 455 बाइट्स हो सकता है।

मैंने पाया कि लगभग हर ऑनलाइन जीसीसी संकलक (टीआईओ सहित) मुझे फ़ंक्शन के प्रकार को छोड़ने के लिए मना करता है 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)}}}}

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

— कोलेरा सु
स्रोत

1

जेली , 74 बाइट्स

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

पहले इनपुट के साथ एक पूर्ण कार्यक्रम (तीसरा तर्क) वर्तमान स्टैक और दूसरा इनपुट (4 वां तर्क) वांछित कर्सर।

इसे ऑनलाइन आज़माएं! कार्यान्वयन के कारण यह25, 17टेस्ट केस केलिए 60 सेकंड का TIO समय समाप्त करताहै। इस का उपयोग कर golfiness के लिए अतिरेक में छोड़ दिया हटाने के द्वारा ठीक किया जा सकता है इस 84 byter (जो बाहर शून्य आकार ढेर फिल्टर और साथ शेष उन क्रमबद्ध करताḟ€Ṣ¥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)

— जोनाथन एलन
स्रोत

Minecraft इन्वेंटरी प्रबंधन