যাদু: জড়িত লড়াইয়ের গল্ফ

Question

যাদু: জড়ো করা একটি ট্রেডিং কার্ড গেম যেখানে অন্যান্য বিষয়গুলির সাথে খেলোয়াড়রা জীবের প্রতিনিধিত্ব করে এমন কার্ড খেলেন যা অন্য খেলোয়াড়কে আক্রমণ করতে পারে বা অবরুদ্ধ করে অন্য খেলোয়াড়ের আক্রমণ থেকে রক্ষা করতে পারে।

এই কোড-গল্ফ চ্যালেঞ্জে, আপনার প্রোগ্রামটি ম্যাজিক প্লেয়ারের স্থানে থাকবে কীভাবে যুদ্ধে অবরুদ্ধ করবেন তা স্থির করে।

---

প্রতিটি প্রাণীর দুটি প্রাসঙ্গিক বৈশিষ্ট্য রয়েছে: শক্তি এবং শক্ততা। কোনও প্রাণীর শক্তিই যুদ্ধে মোকাবেলা করতে পারে এমন পরিমাণ ক্ষয়ক্ষতি এবং এর শক্ততা হ'ল এটি ধ্বংস করার জন্য প্রয়োজনীয় ক্ষতির পরিমাণ। শক্তি সর্বদা সর্বনিম্ন 0 হয় এবং শক্ততা সর্বদা সর্বনিম্ন 1 থাকে।

ম্যাজিকের লড়াইয়ের সময়, খেলোয়াড় যার পালা এটি তাদের কিছু প্রাণীকে প্রতিপক্ষের উপর আক্রমণ করার ঘোষণা দেয়। তারপরে, ডিফেন্ডিং প্লেয়ার হিসাবে পরিচিত অন্য খেলোয়াড় তাদের প্রাণীকে ব্লকার হিসাবে নিয়োগ করতে পারে। কোনও প্রাণী প্রতি যুদ্ধের জন্য কেবল একটি প্রাণীকে অবরুদ্ধ করতে পারে, তবে একাধিক প্রাণী সমস্ত একই প্রাণীকে অবরুদ্ধ করতে পারে।

ব্লকার ঘোষিত হওয়ার পরে, আক্রমণকারী প্লেয়ার সিদ্ধান্ত নিয়েছে যে প্রতিটি আক্রমণকারী প্রাণীকে অবরুদ্ধ করা হয়েছে, কীভাবে ক্ষতি (এটির শক্তির সমান) কীভাবে বন্টন করবেন যে প্রাণীটি এটি আটকাচ্ছে এমন জীবজন্তুদের আচরণ করে।

তারপরে, ক্ষতির সমাধান হয়। প্রতিটি প্রাণী তার শক্তির সমান ক্ষতির ক্ষতি করে। উপরে বর্ণনাকৃত প্রাণীগুলিকে আক্রমণকারী ক্ষতিকারকরা আক্রমণকে ক্ষতিগ্রস্থ করেছেন deal আনব্লকড আক্রমণকারী প্রাণীরা ডিফেন্ডিং প্লেয়ারের ক্ষতি করে। ব্লক করা প্রাণীগুলি তাদের অবরুদ্ধ করা প্রাণীর ক্ষতি করে। ডিফেন্ডিং প্লেয়ারের এমন প্রাণী যা কোনও ডিলের ক্ষতি করে না। (প্রাণীগুলিকে ব্লক করার দরকার নেই))

শেষ অবধি, যে কোনও প্রাণী তার শক্তির চেয়ে সমান বা তার বেশি ক্ষতি ডেকে আনে এবং যুদ্ধক্ষেত্র থেকে সরানো হয়। কোনও প্রাণীর শক্তির চেয়ে কম পরিমাণের ক্ষতির কোনও প্রভাব নেই।

---

এই প্রক্রিয়াটির উদাহরণ এখানে:

পাওয়ার পি এবং শক্ততা টি সহ একটি প্রাণী হিসাবে প্রতিনিধিত্ব করা হয় 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

আপনার এই পাহাড়ের রাজা করা উচিত।

— পাইরুলেজ

@ আরনাউল্ড না, এটিও একটি কার্যকর উত্তর।

— isaacg

Answer 1

জাভাস্ক্রিপ্ট (ES7),  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)

বাম অংশ আক্রমণকারীটির বেঁচে থাকলে স্কোরকে বিয়োগ করে। আক্রমণটি কিছুটা অবরুদ্ধ না করা হলে ডান অংশটি আক্রমণকারীর অর্ধেক দৃness়তা বিয়োগ করে বা সেরা আক্রমণকারীর স্কোর যুক্ত করে (অন্যদিকে রক্ষাকারী দিক থেকে এটি সবচেয়ে খারাপ)।