मैजिक: द गैदरिंग कॉम्बैट गोल्फ

Question

जादू: सभा एक व्यापारिक कार्ड गेम है जहां, अन्य चीजों के अलावा, खिलाड़ी प्राणियों का प्रतिनिधित्व करने वाले कार्ड खेलते हैं, जो तब दूसरे खिलाड़ी पर हमला कर सकता है, या अवरुद्ध करके दूसरे खिलाड़ी के हमलों से बचाव कर सकता है।

इस कोड-गोल्फ चुनौती में, आपका कार्यक्रम मैजिक प्लेयर के स्थान पर होगा, जो यह निर्णय लेगा कि मुकाबला कैसे किया जाए।

---

प्रत्येक प्राणी के दो प्रासंगिक गुण होते हैं: शक्ति, और क्रूरता। एक प्राणी की शक्ति एक युद्ध में निपटने के लिए नुकसान की मात्रा है, और इसकी कठोरता इसे नष्ट करने के लिए आवश्यक क्षति की मात्रा है। शक्ति हमेशा कम से कम 0 है, और क्रूरता हमेशा कम से कम 1 है।

मैजिक में युद्ध के दौरान, जिस खिलाड़ी की बारी है, वह अपने कुछ प्राणियों को प्रतिद्वंद्वी पर हमला करने की घोषणा करता है। फिर, अन्य खिलाड़ी, जिसे बचाव करने वाले खिलाड़ी के रूप में जाना जाता है, अपने प्राणियों को अवरोधक के रूप में निर्दिष्ट कर सकता है। एक प्राणी प्रति प्राणी केवल एक प्राणी को रोक सकता है, लेकिन कई जीव सभी एक ही प्राणी को रोक सकते हैं।

ब्लॉकर्स घोषित किए जाने के बाद, हमला करने वाला खिलाड़ी निर्णय लेता है, प्रत्येक हमलावर प्राणी के लिए जिसे अवरुद्ध किया गया था, क्षति को कैसे वितरित किया जाए (उसकी शक्ति के बराबर) जो उस प्राणी को अवरुद्ध करने वाले जीवों से संबंधित है।

फिर, क्षति से निपटा जाता है। प्रत्येक प्राणी अपनी शक्ति के बराबर क्षति का सौदा करता है। हमला करने वाले जीवों को ऊपर से नीचे उतारे जाने के साथ सौदा नुकसान हुआ। अनब्लॉक किए गए हमलावर जीव बचाव करने वाले खिलाड़ी को नुकसान पहुंचाते हैं। अवरुद्ध प्राणियों को अवरुद्ध किए गए प्राणी को नुकसान पहुंचाता है। बचाव करने वाले खिलाड़ी से संबंधित जीव जो कोई नुकसान नहीं पहुंचाते थे। (जीवों को ब्लॉक करने की आवश्यकता नहीं है।)

अंत में, किसी भी प्राणी को उसकी कठोरता के बराबर या उससे अधिक क्षति से निपटा जाता है, और युद्ध के मैदान से हटा दिया जाता है। किसी भी प्राणी की क्रूरता से कम क्षति का कोई प्रभाव नहीं पड़ता है।

---

यहाँ इस प्रक्रिया का एक उदाहरण है:

पी और क्रूरता टी के साथ एक प्राणी के रूप में प्रतिनिधित्व किया है P/T

Attacking:
2/2, 3/3
Defending player's creatures:
1/4, 1/1, 0/1
Defending player declares blockers:
1/4 and 1/1 block 2/2, 0/1 does not block.
Attacking player distributes damage:
2/2 deals 1 damage to 1/4 and 1 damage to 1/1
Damage is dealt:
2/2 takes 2 damage, destroyed.
3/3 takes 0 damage.
1/1 takes 1 damage, destroyed.
1/4 takes 1 damage.
0/1 takes 0 damage.
Defending player is dealt 3 damage.

---

बचाव करने वाले खिलाड़ी के मुकाबले में 3 लक्ष्य होते हैं: प्रतिद्वंद्वी के जीवों को नष्ट करना, अपने प्राणियों को संरक्षित करना और जितना संभव हो उतना कम नुकसान से निपटना। इसके अलावा, अधिक शक्ति और क्रूरता वाले प्राणी अधिक मूल्यवान हैं।

इन्हें एक ही माप में संयोजित करने के लिए, हम कहेंगे कि किसी खिलाड़ी का मुकाबला करने से बचाव करने वाले का स्कोर उनके जीवित प्राणियों की शक्तियों और मुश्किलों के योग के बराबर है, अपने प्रतिद्वंद्वी के जीवित प्राणियों की शक्तियों और मुश्किलों का योग, माइनस एक नुकसान की मात्रा का आधा बचाव करने वाले खिलाड़ी को दिया जाता है। बचाव करने वाला खिलाड़ी इस स्कोर को अधिकतम करना चाहता है, जबकि हमलावर खिलाड़ी इसे कम से कम करना चाहता है।

ऊपर दिखाए गए मुकाबले में, स्कोर था:

Defending player's surviving creatures:
1/4, 0/1
1 + 4 + 0 + 1 = 6
Attacking player's surviving creature:
3/3
3 + 3 = 6
Damage dealt to defending player:
3
6 - 6 - 3/2 = -1.5

यदि ऊपर वर्णित वर्णन में बचाव करने वाला खिलाड़ी बिल्कुल भी अवरुद्ध नहीं होता, तो स्कोर होता

8 - 10 - (5/2) = -4.5

बचाव करने वाले खिलाड़ी के लिए इष्टतम विकल्प , और के 2/2साथ ब्लॉक करने के लिए 1/1और 1/4के 3/3साथ ब्लॉक करना होता 0/1। यदि उन्होंने ऐसा किया होता, तो केवल 1/4और केवल 3/3जीवित रहते, और कोई भी नुकसान बचाव खिलाड़ी को नहीं किया जाता, जिससे स्कोर बनता

5 - 6 - (0/2) = -1

---

आपकी चुनौती एक कार्यक्रम लिखने की है जो बचाव करने वाले खिलाड़ी के लिए इष्टतम अवरोधक विकल्प का उत्पादन करेगा। "इष्टतम" का अर्थ है वह विकल्प जो स्कोर को अधिकतम करता है, यह देखते हुए कि प्रतिद्वंद्वी उस तरीके से नुकसान को वितरित करता है जो स्कोर को कम करता है, यह देखते हुए कि आपने कैसे अवरुद्ध किया है।

यह एक अधिकतम है: क्षति वितरण पर अधिकतम स्कोर जो प्रत्येक अवरुद्ध संयोजन के लिए स्कोर को कम करता है।

---

इनपुट: इनपुट में 2-ट्यूपल की दो सूचियां शामिल होंगी, जहां प्रत्येक 2-ट्यूपल फॉर्म (पावर, टफनेस) का होता है। पहली सूची में प्रत्येक हमलावर प्राणी (आप प्रतिद्वंद्वी के जीव) की शक्तियां और क्रूरताएं शामिल होंगी। दूसरी सूची में आपके प्रत्येक प्राणी की शक्तियाँ और कठिनाइयाँ होंगी।

टुपल्स और सूचियों को किसी भी सुविधाजनक प्रारूप में दर्शाया जा सकता है, जैसे:

[[2, 2], [3, 3]]
[[1, 4], [1, 1], [0, 1]]

आउटपुट: आउटपुट में 2-टुपल्स की एक श्रृंखला शामिल होगी, फॉर्म में (अवरुद्ध प्राणी, अवरुद्ध प्राणी) - यानी, आपके जीवों में से एक के बाद उनका एक जीव। इनपुट सूचियों में जीवों को उनके सूचकांक द्वारा संदर्भित किया जाएगा। सूचकांक 0 या 1 अनुक्रमित हो सकते हैं। फिर, किसी भी सुविधाजनक प्रारूप। कोई भी आदेश ठीक है। उदाहरण के लिए, ऊपर दिए गए इनपुट को देखते हुए, ऊपर से इष्टतम अवरोधन परिदृश्य को निम्न के रूप में दर्शाया जा सकता है:

[0, 0]    # 1/4 blocks 2/2
[1, 0]    # 1/1 blocks 2/2
[2, 1]    # 0/1 blocks 3/3

उदाहरण:

Input:
[[2, 2], [3, 3]]
[[1, 4], [1, 1], [0, 1]]
Output:
[0, 0]
[1, 0]
[2, 1]

Input:
[[3, 3], [3, 3]]
[[2, 3], [2, 2], [2, 2]]
Output:
[1, 0]
[2, 0]
or
[1, 1]
[2, 1]

Input:
[[3, 1], [7, 2]]
[[0, 4], [1, 1]]
Output:
[1, 0]
or
[0, 0]
[1, 0]

Input:
[[2, 2]]
[[1, 1]]
Output:

(No output tuples).

इनपुट और आउटपुट STDIN, STDOUT, CLA, फ़ंक्शन इनपुट / रिटर्न, आदि के माध्यम से हो सकता है। मानक कमियां लागू होती हैं। यह कोड-गोल्फ है: बाइट्स जीत में सबसे छोटा कोड।

---

कल्पना को स्पष्ट करने और प्रारंभिक विचार प्रदान करने के लिए, यह पास्टबिन पायथन में एक संदर्भ समाधान प्रदान करता है। best_blockसमारोह इस चुनौती के एक नमूना समाधान है, और कार्यक्रम चलाने अधिक वर्बोज़ इनपुट और आउटपुट प्रदान करेगा।

Comments

आपको पहाड़ी का यह राजा बनाना चाहिए।

— PyRulez

@ अर्नुलड नोप, यह भी एक मान्य उत्तर है।

— isaacg

Answer 1

जावास्क्रिप्ट (ईएस 7),  354  348 बाइट्स

के रूप में इनपुट लेता है ([attackers], [defenders])।

(a,d,O,M)=>eval(`for(N=(A=a.push([,0]))**d.length;N--;)O=a[X='map'](([P,T],i)=>S-=((g=(n,l)=>n?l[X](([t,S],i)=>g(n-1,b=[...l],b[i]=[t-1,S])):m=l[X](([t,S])=>s+=t>0&&S,s=0)&&s>m?m:s)(P,l[n=0,i][X](m=([p,t])=>[t,p+t,n+=p])),n<T&&P+T)+(l[i]<1?T/2:-m),S=0,d[X]((x,i)=>l[(j=N/A**i%A|0)<A-1&&o.push([i,j]),j].push(x),o=[],l=a[X](_=>[])))&&S<M?O:(M=S,o)`)

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

कम गोल्फ और प्रारूपित

यह कोड केवल mapउपनाम और eval()पठनीयता के लिए लपेटे बिना गोल्फ संस्करण के समान है।

(a, d, O, M) => {
  for(N = (A = a.push([, 0])) ** d.length; N--;)
    O =
      a.map(([P, T], i) =>
        S -=
          (
            (g = (n, l) =>
              n ?
                l.map(([t, S], i) => g(n - 1, b = [...l], b[i] = [t - 1, S]))
              :
                m = l.map(([t, S]) => s += t > 0 && S, s = 0) && s > m ? m : s
            )(
              P,
              l[n = 0, i].map(m = ([p, t]) => [t, p + t, n += p])
            ),
            n < T && P + T
          ) + (
            l[i] < 1 ? T / 2 : -m
          ),
        S = 0,
        d.map((x, i) =>
          l[
            (j = N / A ** i % A | 0) < A - 1 && o.push([i, j]),
            j
          ].push(x),
          o = [],
          l = a.map(_ => [])
        )
      ) && S < M ? O : (M = S, o)
  return O
}

कैसे?

प्रारंभिक और मुख्य लूप

$0$push$A$

A = a.push([, 0])

हम किसी भी प्राणी को रोकने के बजाय इस डमी प्राणी को अवरुद्ध करने जा रहे हैं। यह कोड में कुछ सरलीकरण की अनुमति देता है।

$A^D$$D$$N$

for(N = (A = a.push([, 0])) ** d.length; N--;)

$S$$M$$o$$O$

$M$$O$

O = (...) && S < M ? O : (M = S, o)

हमारी रक्षा का निर्माण

$l$

d.map((x, i) =>              // for each defender x at position i:
  l[                         //   update l[]:
    (j = N / A ** i % A | 0) //     j = index of the attacker that we're going to block
    < A - 1 &&               //     if this is not the 'dummy' creature:
    o.push([i, j]),          //       add the pair [i, j] to the current solution
    j                        //     use j as the actual index to update l[]
  ].push(x),                 //   push x in the list of blockers for this attacker
  o = [],                    //   initialize o to an empty list
  l = a.map(_ => [])         //   initialize l to an array containing as many empty lists
                             //   that there are attackers
)                            // end of map()

हमले का अनुकूलन

हमलावरों के फैसले एक-दूसरे से असंबद्ध हैं। हमलावर पक्ष के लिए वैश्विक इष्टतम प्रत्येक हमलावर के लिए स्थानीय ऑप्टिमा का योग है।

$P$$T$$i$

a.map(([P, T], i) => ...)

$l[i]$

l[n = 0, i].map(m = ([p, t]) => [t, p + t, n += p])

$n$

$g$$P$

(g = (n, l) =>            // n = remaining damage points; l = list of blockers
  n ?                     // if we still have damage points:
    l.map(([t, S], i) =>  //   for each blocker of toughness t and score S at index i:
      g(                  //     do a recursive call:
        n - 1,            //       decrement the number of damage points
        b = [...l],       //       create a new instance b of l
        b[i] = [t - 1, S] //       decrement the toughness of blocker i
      )                   //     end of recursive call
    )                     //   end of map()
  :                       // else:
    m =                   //   update the best score m (the lower, the better):
      l.map(([t, S]) =>   //     for each blocker of toughness t and score S:
        s += t > 0 && S,  //       add S to s if this blocker has survived
        s = 0             //       start with s = 0
      ) &&                //     end of map()
      s > m ? m : s       //     set m = min(m, s)
)                         //

डिफेंडर स्कोर को अपडेट करना

एक हमलावर पर प्रत्येक पुनरावृत्ति के बाद, हम डिफेंडर स्कोर को इसके साथ अपडेट करते हैं:

S -= (n < T && P + T) + (l[i] < 1 ? T / 2 : -m)

यदि यह बच गया है तो बायाँ भाग हमलावर के स्कोर को घटाता है। यदि हमलावर को बिल्कुल भी अवरुद्ध नहीं किया गया था, तो सही भाग हमलावर की आधी कठोरता को घटाता है, या सबसे अच्छा हमलावर स्कोर जोड़ता है अन्यथा (जो बचाव पक्ष के दृष्टिकोण से सबसे खराब है)।