टेरा मिस्टिका: साइकिलिंग पावर

Question

बोर्डगेम टेरा मिस्टिका में प्राथमिक संसाधनों, बिजली में से एक के लिए कुछ बहुत ही दिलचस्प मैकेनिक्स हैं। प्रत्येक खिलाड़ी किसी बैंक से बिजली प्राप्त करने और खर्च करने की इकाइयों के बजाय, खेल की शुरुआत ठीक 12 इकाइयों की शक्ति से करता है जो तीन "बाउल" में वितरित की जाती हैं, जिन्हें I, II और III लेबल दिया जाता है। प्राप्त करने और खर्च करने की शक्ति तो बस इन कटोरे के बीच शक्ति को स्थानांतरित करती है:

• बिजली की एक इकाई खर्च करने के लिए, इसे बाउल III से कटोरे I ​​में स्थानांतरित करें (बशर्ते आपके पास कटोरे III में एक इकाई है)।
• जब आप शक्ति की एक इकाई प्राप्त करते हैं, अगर कटोरे I ​​में एक इकाई होती है, तो इसे कटोरी II में स्थानांतरित करें। यदि कटोरी I में कोई इकाइयाँ नहीं हैं, लेकिन कटोरे II में एक इकाई है, तो इसे III में कटाव करें। यदि सभी इकाइयां पहले से ही कटोरे III में हैं, तो कुछ भी नहीं होता है।
• जब आप एक साथ कई इकाइयाँ प्राप्त या खर्च करते हैं, तो उन्हें एक समय में एक इकाई संसाधित किया जाता है।

यहाँ एक उदाहरण है। कहते हैं, एक खिलाड़ी निम्नलिखित बिजली वितरण के साथ शुरू होता है (क्रम में दिया गया I | II | III):

5 | 7 | 0

उनकी शक्ति में परिवर्तन इस प्रकार होता है जैसे वे कुछ समय के लिए सत्ता प्राप्त करते हैं और खर्च करते हैं:

               5 |  7 |  0
Gain  3  ==>   2 | 10 |  0
Gain  6  ==>   0 |  8 |  4   (move 2 power from I to II, 
                              then the remaining 4 from II to III)
Gain  7  ==>   0 |  1 | 11
Spend 4  ==>   4 |  1 |  7
Gain  1  ==>   3 |  2 |  7
Spend 7  ==>  10 |  2 |  0
Gain 12  ==>   0 | 10 |  2   (move 10 power from I to II,
                              then the remaining 2 from II to III)
Gain 12  ==>   0 |  0 | 12   (the two excess units go to waste)

आपका कार्य इस तरह के एक लाभ या घटना के परिणाम की गणना करना है।

चुनौती

आपको इनपुट के रूप में चार पूर्णांक दिए गए हैं। पहले तीन, I, II, III, शक्ति की मात्रा तीन कटोरे में से प्रत्येक में प्रतिनिधित्व करते हैं। वे गैर-नकारात्मक होंगे, और वे 12 को योग करेंगे। चौथा नंबर, Pशक्ति प्राप्त या खर्च की गई राशि है, और समावेशी श्रेणी में होगा [-III, 24](इसलिए आप मान सकते हैं कि खिलाड़ी कभी भी अधिक शक्ति खर्च करने की कोशिश नहीं करेगा। वर्तमान में वे कर सकते हैं, लेकिन वे अधिक शक्ति प्राप्त कर सकते हैं, क्योंकि उन्हें सभी शक्ति को कटोरे III में स्थानांतरित करने की आवश्यकता है)।

पूर्णांक की सूची के रूप में, या पूर्णांक वाले स्ट्रिंग के रूप में आप इन संख्याओं को किसी भी सुसंगत क्रम में ले सकते हैं। तुम भी ले जा सकते हैं Pके रूप में, एक तर्क के रूप में I, II, IIIएक अलग सूची तर्क के रूप में।

आपको तीन पूर्णांकों का उत्पादन करना चाहिए , जो यूनिटों के प्राप्त होने या खर्च होने के बाद प्रत्येक कटोरे में बिजली की मात्रा का प्रतिनिधित्व करते हैं I', ऊपर वर्णित नियमों का पालन करते हुए।II'III' P

आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं और इनपुट प्राप्त करने और आउटपुट प्रदान करने के हमारे किसी भी मानक तरीके का उपयोग कर सकते हैं।

आप किसी भी प्रोग्रामिंग भाषा का उपयोग कर सकते हैं , लेकिन ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है।

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

परीक्षण के मामलों

I II III P => I' II' III'
5 7 0 3    => 2 10 0
2 10 0 6   => 0 8 4
0 8 4 7    => 0 1 11
0 1 11 -4  => 4 1 7
4 1 7 0    => 4 1 7
4 1 7 1    => 3 2 7
3 2 7 -7   => 10 2 0
10 2 0 12  => 0 10 2
0 10 2 12  => 0 0 12

Comments

मैं लिंग-विशिष्ट सर्वनाम को हटाने और उन्हें लिंग-तटस्थ वाले (या पुनर्गठन वाक्यों) के साथ बदलने की सलाह देता हूं: गेमर्स को पुरुष होने की आवश्यकता नहीं है।

— ग्रेग मार्टिन

@GregMartin बेशक। क्या मैंने उन सबको पकड़ लिया?

— मार्टिन एंडर

इसे देखो; इसके बारे में सोचने के लिए धन्यवाद! इसके अलावा, टेरा मिस्टिका भी उतनी ही भयानक है जितना मैंने सुना है?

— ग्रेग मार्टिन

@GregMartin हाँ। :)

— मार्टिन एंडर

कटोरा 2 से कोई बिजली नहीं जलती? यह सिर्फ इतना अधूरा लगता है।

— मोरोन

Answer 1

गणितज्ञ, 52 बाइट्स

{x=#-#4~Min~#,y=Max[#2+#-Abs[#4~Max~0-#],0],12-x-y}&

यह एक अनाम फ़ंक्शन है जो किसी सूची {I, II, III, P}को इनपुट के रूप में लेता है और एक सूची देता है {I', II', III'}।

एक बंद-रूप समाधान। यह वास्तव में अभी तक इष्टतम महसूस नहीं करता है ...

Comments

सोचा था कि मैं छोटा कर सकता हूं, लेकिन {##,12-+##}&[#-#4~Min~#,Max[#2+#-Abs[#4~Max~0-#],0]]&अब एक बाइट है। मुझे 12-+##हालांकि पसंद है ।

— ग्रेग मार्टिन

@GregMartin मैंने यही कोशिश की :)

— मार्टिन

Answer 2

सी, 97 94 बाइट्स

f(i,j,k,n){for(;n;n-=n/abs(n))n<0?k?++i+--k:0:i?++j+--i:j?++k+--j:0;printf("%d %d %d",i,j,k);}

असमतल रूप में:

f(i, j, k, n) {
    while (n) {
        if (n < 0) {
            if (k) {
                ++i; --k;
            }
            ++n;
        } else {
            if (i) {
                ++j; --i;
            }
            else if (j) {
                ++k; --j;
            }
            --n;
        }
    }
    printf("%d %d %d", i, j, k);
}

Answer 3

पायथन 2, 104 बाइट्स

def f(i,d,t,g):
 x=min(i,g);i-=x;q=g>0;g-=x
 if q:d+=x;x=min(d,g);g-=x;d-=x;t+=x
 else:t+=x
 print i,d,t

इसे ऑनलाइन आज़माएं

Ungolfed:

def f(i,d,t,g):
 if g>0:
    x=min(i,g)
    g-=x
    i-=x
    d+=x    
    x=min(d,g)
    g-=x
    d-=x
    t+=x
 else:
    x=min(i,g)
    g-=x
    i-=x
    t+=x
 print(i,d,t)

Answer 4

हास्केल, 58 बाइट्स

f(a,b,c)d|m<-min a d,z<-min(c+d-max 0 m)12=(a-m,b+c+m-z,z)

मध्यवर्ती मान mपहले कटोरे से जाने वाली बिजली की मात्रा (या, अगर नकारात्मक) को zदर्शाता है, क्रिया के बाद तीसरे कटोरे में शक्ति की मात्रा को दर्शाता है। अंतिम मिनट एक बाइट अनुकूलन ने 12-a+m-zपहचान का उपयोग करने से दूसरे कटोरे के लिए पुरानी अभिव्यक्ति को बदल दिया a+b+c=12।

प्राकृतिक परिणाम प्रकार कटोरे के लिए एक ट्रिपल है, इसलिए इनपुट भी कटोरे को ट्रिपल के रूप में लेता है और शक्ति दूसरे तर्क के रूप में बदल जाती है। यह एक के साथ एक आवेदन के साथ सभी परीक्षण मामलों को संभालने की अनुमति देता है scanl:

*Main> scanl f (5,7,0) [3,6,7,-4,0,1,-7,12,12]
[(5,7,0),(2,10,0),(0,8,4),(0,1,11),(4,1,7),(4,1,7),(3,2,7),(10,2,0),(0,10,2),(0,0,12)]

Answer 5

रोड़ा , 100 94 बाइट्स

f a,b,c,p{{c+=p;a-=p}if[p<0]else{{a--;b++;p--}while[p*a>0];{b--;c++;p--}while[p*b>0]};[a,b,c]}

Ungolfed:

f a,b,c,p {
    if [ p < 0 ] do
        c += p
        a -= p
    else
        { a-=1; b+=1; p-=1 } while [ p > 0 and a > 0 ]
        { b-=1; c+=1; p-=1 } while [ p > 0 and b > 0 ]
    done
    return a, b, c
}

Comments

क्या रोदा के पास ऑपरेटर ++और --ऑपरेटर नहीं है?

— क्रिति लिथोस

@KritiiLithos धन्यवाद! हाँ यह करता है।

— fergusq

Answer 6

जावास्क्रिप्ट, 61 59 बाइट्स

(a,b,c,d)=>[r=a-d>0?a-d:0,s=r?b:b-d+2*a>0?b-d+2*a:0,12-r-s]

इसे ऑनलाइन आज़माएं!

Answer 7

GNU sed , 66 बाइट्स

के लिए +1 शामिल है -r

/-/!{:
s/1,(.* )1/,1\1/
t}
s/(.*)(1+) -\2/\2\1/
s/(,,1{12}).*/\1/

यूरीरी का उपयोग करता है ( इस सहमति को देखें )।

इसे ऑनलाइन आज़माएं!

/-/!{                  # If there is not a '-'
  :                    # start loop
  s/1,(.* )1/,1\1/     # move a 1 from before a ',' to after the ',' for every 1 after the space
                       # sed reads left to right, so this takes everything from the first bowl before starting on the second
  t                    # loop if something changed
}                      # end if
s/(.*)(1+) -\2/\2\1/   # take all of the 1s from after a '-' and move them to the begining.
                       # at the same time, remove that many 1s from the 3rd bowl
s/(,,1{12}).*/\1/      # remove everything after 12 1s in the third bowl

Answer 8

रेटिना ,  46  41 39 38 बाइट्स

कई उपयोगी सुझावों के लिए मार्टिन एंडर को धन्यवाद !

+`1,(.*¶)1
,1$1
(.*)(1+)¶-\2$
$2$1
G`,

अनरीट में इनपुट लेता है। पहली पंक्ति में तीन कटोरे में शक्ति की मात्रा होती है, अल्पविराम अलग, दूसरी पंक्ति में चक्र की शक्ति की मात्रा।

टेस्ट सूट - एक इनपुट पर सभी इनपुट लेता है और उपयोग की सुविधा के लिए दशमलव से एकतरफा और इसके विपरीत में परिवर्तित करता है।

व्याख्या

+`1,(.*¶)1
,1$1

सकारात्मक मामला: हम बार-बार 1दूसरी पंक्ति से अग्रणी को हटाते हैं , और 1पहले गैर-खाली कटोरे से एक को आगे बढ़ाते हैं, जब तक कि यह ऑपरेशन संभव है (यानी चक्र की शक्ति की संख्या गैर-शून्य है और सभी नहीं शक्ति तीसरे कटोरे में है)। sसंशोधक साधन single-lineकी अनुमति .भी न्यू लाइन से मिलान करने के।

(.*)(1+)¶-\2$
$2$1

नकारात्मक मामला: सभी एक कदम में, तीसरे इनपुट से पहले इनपुट द्वारा इंगित बिजली की मात्रा को आगे बढ़ाते हुए। यह भी स्थानांतरित करने के लिए बिजली की नकारात्मक राशि युक्त रेखा को हटा देगा।

G`,

(Grep) केवल अल्पविराम वाली रेखाएँ रखें। इससे पहली पंक्ति के अंतिम अवशेषों से छुटकारा मिलेगा।

Answer 9

पायथन 2, 91 बाइट्स

इस उत्तर के आधार पर

def f(i,d,t,g):
 x=min(i,g);i-=x
 if g>0:y=min(d+x,g-x);d+=x-y;t+=y
 else:t+=x
 print i,d,t

इसे ऑनलाइन आज़माएं

Ungolfed:

def f(i,d,t,g):
 if g>0:
    x=min(i,g)
    y=min(d+x,g-x)
    i-=x
    d+=x-y
    t+=y
 else:
    x=min(i,g)
    i-=x
    t+=x
 print(i,d,t)

Comments

साइट पर आपका स्वागत है!

— DJMcMayhem

Answer 10

बैच, 87 बाइट्स

@set/a"i=%4-%1,j=%4*(-%4>>5)-%2-2*i*(-i>>5),i*=i>>5,j*=j>>5,k=12-i-j
@echo %i% %j% %k%

निम्नलिखित सूत्रों का उपयोग करें:

I' = min(I - P, 0)
II' = min(II + min(P, 0) - 2 * min(P - I, 0), 0)
III' = 12 - I' - II'

चूंकि बैच में ऑपरेटर से कम नहीं है, इसलिए मैं i = min(-i, 0)उपयोग करने की गणना करता हूं i*=i>>5।

Answer 11

पर्ल 6 , 99 बाइट्स

->\a,\b,\c,\d{d>0??[»+»] (a,b,c),|(|((-1,1,0)xx a),|((0,-1,1)xx a+b),|(0 xx*))[^d]!!(a- d,b,c+d)}

चलो a, bऔर cमैं, द्वितीय, और तृतीय क्रमशः कटोरे में टोकन शुरू करने की संख्या हो। फिर, जोड़ने शक्ति मामले के लिए, एक सूची बनाई गई है जिसमें aत्रिक की प्रतियां (-1, 1, 0), जिसके बाद a + bत्रिक की प्रतियां (0, -1, 1), के अनंत प्रतियां द्वारा पीछा किया 0। dइस सूची के पहले तत्व, dजोड़ने की शक्ति की मात्रा होने के नाते, प्रारंभिक बिजली वितरण में तत्वपूर्ण जोड़ दिए जाते हैं।

शक्ति (नकारात्मक d) को घटाने के लिए , एक सरल बंद फॉर्म का उपयोग किया जाता है (a - d, b, c + d):।

Answer 12

टिनिइलिश , 134 बाइट्स

(d f(q((x y z p)(i p(i(l p 0)(f(s x p)y(a z p)0)(i x(f(s x 1)(a y 1)z(s p 1))(i y(f x(s y 1)(a z 1)(s p 1))(f x y z 0))))(c x(c y(c z(

एक फ़ंक्शन को परिभाषित करता है fजो चार तर्क लेता है, तीन कटोरे ( x y z) और लेन-देन की शक्ति ( p) की मात्रा , और लेनदेन के बाद तीन कटोरे की एक सूची देता है। यहां सभी परीक्षण मामलों के साथ एक ठीक से स्थान दिया गया संस्करण है: इसे ऑनलाइन आज़माएं!

(d f                         Define f to be
 (q(                          a quoted two-item list (which acts as a function):
  (x y z p)                    Arglist: the three bowls x y z and power p
  (i p                         If p is nonzero
   (i (l p 0)                   then if p is negative (spending power)
    (f(s x p)y(a z p)0)          then take -p from z, add -p to x, and recurse with p=0
    (i x                         else (gaining power), if x is nonzero
     (f(s x 1)(a y 1)z(s p 1))    then take 1 from x, add to y, decrement p and recurse
     (i y                         else if y is nonzero
      (f x(s y 1)(a z 1)(s p 1))   then take 1 from y, add to z, decrement p and recurse
      (f x y z 0))))               else no moves possible; recurse with p=0
   (c x(c y(c z())))))))        else (p=0), cons x y z into a list and return it