যুদ্ধের একটি ফলাফলের সন্ধান করুন

15

যুদ্ধের একটি ফলাফলের সন্ধান করুন

আমি যখন প্রাথমিক বিদ্যালয়ে ছিলাম, তখন "রক-পেপার-কাঁচি" -ইশ গেমটি আমরা সমাবেশগুলির মধ্যে খেলতাম, যখন আমাদের শিক্ষকের জন্য অপেক্ষা করতাম, ছুটিতে থাকতাম ইত্যাদি We আমরা এটিকে "যুদ্ধ" বলতাম। কিছু তবে অনুসন্ধানের পর এটি সক্রিয় আউট এই অনেক সহজ বৈচিত্র হয় "শটগান খেলা" (WikiHow অনুযায়ী) । নিয়ম কিছুটা আলাদা হওয়ায় আমি এটিকে "যুদ্ধ" বলব:

2 জন একে অপর থেকে বসে। গেমের লক্ষ্যটি অন্য খেলোয়াড়কে "হত্যা" করা। প্রতিটি পালা, আপনি 3 টি মুভের মধ্যে একটি খেলতে পারেন:

  • পুনঃলোড : আপনার কাছে একটি বন্দুক রয়েছে যা একটি মাত্র শট ধারণ করে। প্রতিবার ফায়ার করার আগে এটি অবশ্যই পুনরায় লোড করা উচিত। আপনার কাছে ইতিমধ্যে গোলাগুলি থাকলে পুনরায় লোড করা বৈধ, তবে কিছুই করে না। একটি পুনরায় লোড দুটি হাত দিয়ে আপনার মন্দিরগুলিতে আলতো চাপ দিয়ে প্রতীকী হয়েছিল। প্রতিটি প্লেয়ার 0 টি গোলাবারুদ দিয়ে শুরু হয়।

  • প্রহরী : একমাত্র নিরাপদ পদক্ষেপ। পাহারা দেওয়ার সময় যদি গুলি করা হয় তবে আপনি মারা যাবেন না। আপনার বুকের উপর দিয়ে অস্ত্রগুলি অতিক্রম করে গার্ডিংকে প্রতীকী করা হয়েছিল।

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

এটি আরপিএসের অনুরূপ খেলেছে, এতে প্রতিটি খেলোয়াড় একই সাথে তাদের পছন্দটি নিক্ষেপ করে (একে অপরের সাথে তাল বজায় রাখার জন্য আমরা দু'বার পা দু'বার ট্যাপ করেছিলাম, তবে এটি চ্যালেঞ্জের পক্ষে গুরুত্বপূর্ণ নয়)।

চ্যালেঞ্জ:

আপনার কাজ যুদ্ধের ফলাফলটি সন্ধান করা find এটি কোনও ফাংশন বা সম্পূর্ণ প্রোগ্রাম হতে পারে।

ইনপুট

  • প্রতিটি প্লেয়ার প্রতিটি টার্নটি পছন্দ করে এমন বিকল্পটি একটি অক্ষর / স্ট্রিং দ্বারা উপস্থাপিত হবে:

    • r : পুনরায় লোড করুন

    • g : প্রহরী

    • চ : আগুন

  • ইনপুট হ'ল জোড়গুলির তালিকা, একটি সীমানা / সীমাবদ্ধ না করা স্ট্রিং বা এই লাইনের পাশাপাশি অন্য যে কোনও কিছু anything

পাইথনের একটি উদাহরণ ইনপুট হতে পারে [("r", "g"), ("f", "r")], যার অর্থ প্রথম প্লেয়ারটিতে প্রথম প্লেয়ারটি পুনরায় লোড করা হয় এবং দ্বিতীয় খেলোয়াড় রক্ষিত থাকে। দ্বিতীয় টার্নে, প্রথম প্লেয়ার গুলি চালায়, যখন দ্বিতীয় প্লেয়ার পুনরায় লোড হয়। একজন খেলোয়াড় এই গেমটি জিতেন। একই ইনপুট ঐচ্ছিকরূপে হিসাবে প্রতিনিধিত্ব যেতে পারে "r g f r", "rgfr", "rg fr" "rg-fr"...

আপনি নিম্নলিখিত অনুমান করতে পারেন:

  • ইনপুট আপনার নির্বাচিত ফর্ম্যাটটির সাথে মিলবে এবং এতে কেবল বৈধ অক্ষর থাকবে।

  • কেউ কেউ 100 টার্নের মধ্যে মারা যাবে।

তবে আপনি ধরে নিতে পারবেন না যে কেউ মারা গেলে বাঁকগুলি শেষ হয়।

আউটপুট

কে জিতল (বা প্রথমে কে জিতল *) তা নির্দেশ করে এমন একটি মান । আপনি প্রতিটি দৃশ্যের জন্য কী আউটপুট করবেন তা চয়ন করতে পারেন তবে নিম্নলিখিতগুলির জন্য অবশ্যই অ্যাকাউন্টিং করতে হবে:

  • প্লেয়ার 1 জিতেছে

  • প্লেয়ার 2 জয়

  • তারা একে অপরকে হত্যা করে (অঙ্কন করে)

প্রতিটি ফলাফলের একটি জেলা মান থাকতে হবে এবং প্রতিটি দৃশ্যের জন্য সর্বদা একই হতে হবে।

উদাহরণস্বরূপ: 1খেলোয়াড় 1 জিতলে, 2খেলোয়াড় 2 জিতলে এবং 0ড্রয়ের ক্ষেত্রে আপনি আউটপুট পেতে পারেন। খেলোয়াড় 1 জিতলে, খেলোয়াড় 2 জিতলে এবং ড্রয়ের ক্ষেত্রে আপনাকে অবশ্যই সর্বদা আউটপুট দিতে হবে ।120

এটি ফেরত দেওয়া যেতে পারে, বা স্টাডাউটে মুদ্রণ করা যেতে পারে। স্পেস স্পেস ঠিক আছে।

ঠিক তাই এটি পরিষ্কার, উভয় খেলোয়াড় গুলি চালালে এবং উভয়ের মধ্যে গোলাগুলি থাকলে ড্রয়ের দিকে নিয়ে যায় এমন একমাত্র দৃশ্য।

*যেহেতু এই চ্যালেঞ্জের মধ্যে, কেউ মারা যাওয়ার পরে পালা অব্যাহত থাকতে পারে, শেষ পর্যন্ত সম্ভবত এটি 1 টির বেশি প্লেয়ার জিততে পারে। আপনাকে ইনপুট অনুযায়ী প্রথমে কে জিততে হবে তা খুঁজে বের করতে হবে।

পরীক্ষার কেস ( 1পি 1 জিতবে, 2যখন পি 2 জিতবে এবং 0একটি ড্রয়ের জন্য) ধরে নেওয়া:

"rg fr" => 1 (P1 shot P2 while they were reloading)

"rg ff" => 1 (They both shot, but only P1 had ammo)

"rr ff" => 0 (Both had ammo and shot each other)

"rr ff rr fg" => 0 (Both had ammo and shot each other. Everything after the first win is ignored)

"rr fg rf" => 2 (P2 shot P1 while they were reloading)

"rf gg rr fg rr fr" => 1
    (P2 tried to shoot but didn't have any ammo, then they both guarded, then they both reloaded, then P2 blocked a shot, then they both reloaded again [but P2 still only has 1 ammo!], then P1 shoots P2 while they're reloading.

"rr gf fr rf gg rg ff" => 1
       ^ Player 1 wins here. The rest to the right has no effect on the output

এটি কোড গল্ফ, তাই বাইটের ক্ষুদ্রতম সংখ্যার জয়!

দ্রষ্টব্য, পরীক্ষার কেসগুলি দেখানোর সাথে সাথে আপনাকে অবশ্যই "বোবা" চালগুলি পরিচালনা করতে হবে। কোনও খেলোয়াড়ের কাছে গোলাবারুদ না থাকলে গুলি করার চেষ্টা করার জন্য এটি পুরোপুরি বৈধ, বা একটানা ২ টি টার্ন পুনরায় লোড করুন (এবং কেবলমাত্র একটিমাত্র গোলাবারুদ জমে)

code-golf  game 
— Carcigenicate
সূত্র
আমি কি কিছু অনুপস্থিত বা আউটপুট ঠিক শেষ রাউন্ড থেকে নির্ধারণ করা যেতে পারে?
— xnor
@ প্রশ্ন আপডেট করেছেন। এবং না, যেহেতু আপনার জানা দরকার যে কোনও খেলোয়াড়ের কাছে গোলাবারুদ রয়েছে কি না। আমি বুঝতে পেরেছি যদিও আপনি শেষ মুহুর্তের ভিত্তিতে কোন খেলোয়াড়ের কাছে গোলাবারুদ রয়েছে তা ধরে নিতে পারেন। আমি আসলে শেষ মুহুর্তে নিয়মগুলি পরিবর্তন করেছি যা ধরে নিয়েছে যে কেউ মারা গেলে ইনপুটটি শেষ হবে। আমি এখন আফসোস করছি।
— কারসিজিনিট
আসুন আমরা এই আলোচনাটি আড্ডায় চলতে থাকি ।
— xnor
3
এই খুব অনুরূপ , লোড একটি খেলা স্কোর রক্ষার and Shoot । কেবলমাত্র পার্থক্যগুলি হ'ল অন্য চ্যালেঞ্জের একাধিক শটের সাথে বন্দুক রয়েছে এবং খালি বন্দুকের গুলি করা প্রতারণা হিসাবে বিবেচিত হয় এবং গেমটি হারায়।
— ডেনিস
রাউন্ডের পরিবর্তে আমরা দুটি খেলোয়াড়ের জন্য দুটি পৃথক ইনপুট নিতে পারি {"rff","rgf"}?
— betseg

উত্তর:

2

রেটিনা , 36 বাইট

s`(?<=r..([^f]..)*)f
!
A`g
G1`!
\w
_

ইনপুট ফর্ম্যাটটি পৃথক জোড়া লাইনফিড করা উচিত, যেমন

rr
fr

আউটপুট হল !_প্লেয়ার 1 জয়, _!খেলোয়াড় 2 জিতলে এবং !!যদি ড্র থাকে তবে।

এটি অনলাইন চেষ্টা করুন! (একটি পরীক্ষার স্যুট যা সুবিধার জন্য স্পেস-বিচ্ছেদ ব্যবহার করে))

আমি অবশ্যই এই চ্যালেঞ্জটিকে সম্পূর্ণ উপেক্ষা করেছি। আমি নিশ্চিত আমি অন্যথায় অন্যদিকে রেটিনায় এটি চেষ্টা করতাম। :)

ব্যাখ্যা

s`(?<=r..([^f]..)*)f
!

আমরা প্রথম চালু করার মাধ্যমে উপলক্ষে "বৈধ" শট করে শুরু fপ্রতিটি পর rমধ্যে! । আমরা একে অপরের সাথে অতিক্রম না করে একই প্লেয়ারের সাথে এটি fখুঁজে পেতে পারে এমন প্রতিটিটির সাথে মিল rরেখে এটি করি f। rসর্বদা একবারে তিনটি অক্ষর রেখে একই প্লেয়ারটিতে অনুসন্ধান সীমাবদ্ধ করা সহজ।

A`g

এখন আমরা সেই সমস্ত টার্নগুলি অগ্রাহ্য করি যার মধ্যে কেউ নিজেকে রক্ষা করে, কারণ শেষের মোড়টি এর মধ্যে একটি হতে পারে না।

G1`!

এখন আমরা রাখি কেবল প্রথম টার্নটি যা একটি থাকে !। যদি কোনও বৈধ শট ঘটে (এবং আমরা জানি যে কেউ রক্ষা করে না) গেমটি শেষ হয়।

\w
_

অবশেষে, ধারাবাহিক আউটপুট দেওয়ার জন্য আমাদের স্ট্রিংটি একত্রীকরণ করতে হবে এবং আমরা কেবল !অক্ষরগুলিকে (হয় rবা f) রূপান্তর করে এটি করি_ ।

— মার্টিন ইন্ডার
সূত্র
5

পাইথন, 139 বাইট

c=d=0
for i in input():
 b=(c&(i=='fr'))-(d&(i=='rf'));p,q=i
 if b|(i=='ff')&c&d:print b;break
 c,d=(p=='r',i!='fg')[c],(q=='r',i!='gf')[d]

স্ট্রিডনে 2-অক্ষরের স্ট্রিংগুলির তালিকা আকারে ইনপুট নেয় (উদা। ['Rf', 'rr', 'rg', 'ff'])। খেলোয়াড় 1 জিতলে আউটপুট 1, খেলোয়াড় 2 জিতলে -1 এবং একটি ড্রয়ের জন্য 0

ব্যাখ্যা: খেলাটি শেষ হলে যদি কেউ গুলি চালায় তবে প্রথমে তা পরীক্ষা করে দেখুন। তারপরে আমরা নির্ধারণ করি যে খেলোয়াড়রা হয় তাদের বন্দুকগুলি পুনরায় লোড করেছে বা তাদের গোলাগুলি নষ্ট করেছে।

এটি আমার প্রথম কোডগল্ফ পোস্ট :)

— গণিত জাঙ্কি
সূত্র
4

জাভাস্ক্রিপ্ট (ES6), 108 107 93 91 89 85 বাইট

টাইটাসের সাহায্যে 4 টি বাইট সংরক্ষণ করা হয়েছে

প্রতিটি খেলোয়াড়ের দ্বারা চালিত চলনগুলি বর্ণনা করে 2-অক্ষরের স্ট্রিংগুলির একটি অ্যারের হিসাবে ইনপুট নেয়।

b=>b.map(c=>w=w||b&'312'[b=(s='0210231')[m='ffrfgrrggf'.search(c)]|s[m-2]&b,m],w=0)|w

রিটার্নস:

  • 1 প্লেয়ার 1 জিতলে
  • 2 প্লেয়ার 2 জিতলে
  • 3 একটি ড্র জন্য

কিভাবে এটা কাজ করে

আমরা একটি বিটমাস্ক বজায় রেখেছি bযার বোঝা বুলেট রয়েছে:

  • বিট # 0: প্লেয়ার 1 এর একটি বুলেট রয়েছে
  • বিট # 1: প্লেয়ার 2 এর একটি বুলেট রয়েছে

সমস্ত 9 পদক্ষেপের সম্ভাব্য সংমিশ্রণগুলি সনাক্ত করতে আমরা ডি ব্রুইজন ক্রম ব্যবহার করি 'ffrfgrrggf'। bসরানো সংমিশ্রণ অনুযায়ী আপডেট করতে আমরা OR এবং AND বিটমাস্ক ব্যবহার করি । আমরা bবিজয়ী নির্ধারণের জন্য তৃতীয় সেট বিটমাস্ক ব্যবহার করি যা এন্ডআরড w। (শুধুমাত্র তিনটি বিজয়ী সমন্বয় হচ্ছে ff, frএবং rf।)

এটি লক্ষণীয় যে ওআর এবং এন্ড মাস্কগুলি একই প্যাটার্নের সাথে দুটি পজিশনে স্থানান্তরিত করে সংরক্ষণ করা যেতে পারে।

 Index in | Combination | Bullet   | Bullet  | Winner
 sequence |             | AND mask | OR mask | mask
----------+-------------+----------+---------+--------
    0     |     ff      |    0     |    0    |   3
    1     |     fr      |    0     |    2    |   1
    2     |     rf      |    0     |    1    |   2
    3     |     fg      |    2     |    0    |   0
    4     |     gr      |    1     |    2    |   0
    5     |     rr      |    0     |    3    |   0
    6     |     rg      |    2     |    1    |   0
    7     |     gg      |    3     |    0    |   0
    8     |     gf      |    1     |    0    |   0

পরীক্ষার মামলা

কোড স্নিপেট দেখান

— Arnauld
সূত্র
@ কারসিজেনিকেট এটি উভয় ব্যর্থ ক্ষেত্রেই স্থির করা উচিত। তবে, ড্র করার ক্ষেত্রে আমি এখন ফিরে আসছি 0(কাউকে গুলি করা হয়নি) বা 3(খেলোয়াড়রা একে অপরকে হত্যা করে)। এটি অনুমোদিত কিনা তা নিশ্চিত নয়। যদি না হয় তবে আমি w%3পরিবর্তে ফিরে আসতে পারি ।
— আর্নল্ড
আমি প্রতিটি দৃশ্যে 1 আউটপুট চেয়েছিলাম। আমি গ্যারান্টি দিচ্ছি যে যে কাউকে সর্বদা গুলি করা হবে, সুতরাং সেই ক্ষেত্রে অ্যাকাউন্টিং করা অপ্রয়োজনীয়। উভয় একে অপরকে অঙ্কুরিত করে এবং উভয়ের মধ্যে গোলাগুলি থাকে তখনই একটি ড্রয়ের দিকে পরিচালিত হয় case
— কারসিজিনিট
&মাস্ক জন্য 0 হতে পারে fr,rf,ff। '312'['0210231'[m='ffrfgrrggf'.search(c)]|'233331'[m-3]&b]বা '123'['2100231'[m='frffgrrggf'.search(c)]|'233331'[m-3]&b]একটি বাইট সংরক্ষণ করুন; কিন্তু তারা কি কাজ করে?
— টাইটাস
@ টিটাস মজার বিষয় হচ্ছে, ওআরডের আগে মাস্ক প্রয়োগ করা সমস্ত বিদ্যমান পরীক্ষার ক্ষেত্রে কাজ করবে। তবে এটি এমন কোনও কিছুর জন্য ব্যর্থ হবে["rr","fg","fr","rf"]
— আর্নল্ড
&এর চেয়ে বেশি অগ্রাধিকার রয়েছে |, সুতরাং অর্ডার পরিবর্তন করে সেখানে কোনও পরিবর্তন করা উচিত নয় (বাইট সংরক্ষণ করা বাদে)। কিন্তু অ্যাসাইনমেন্টটি আমার কোডটিতে অনুপস্থিত ছিল। ব্যবহার করে দেখুন ...'123'[b='2100231'...।
— তিতাস
2

পার্ল 6 , 71 62 বাইট

{&[<=>](|map {m/r[..[r|g]]*.$^f/.to//∞},/[r|f]f/,/.f[r|f]/)}

রেজেক্স-ভিত্তিক সমাধান।

ফর্মের স্ট্রিং হিসাবে ইনপুট নেয় "rg fr"।
তিনটি সম্ভাব্য আউটপুট enum মান More(প্লেয়ার 1 Won), Less(প্লেয়ার 2 Won), Sameযা যখন মুদ্রণ বা এই কথাগুলো পরিণত হচ্ছে, মধ্যে - (আঁকা) 1, -1, 0নম্বরে বাধ্য করে।

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

  • map { m/r[..[r|g]]*.$^f/.to // ∞ }, /[r|f]f/, /.f[r|f]/

    ইনপুটটিতে দুটি রেগেক্স ম্যাচ করে। অন্তরঙ্গকরণের পরে, দুটি রেজিেক্সগুলি হ'ল:

    • r[..[r|g]]*.[r|f]f - প্লেয়ার 2 দ্বারা প্রথম সফল শটটি মেলে।
    • r[..[r|g]]*..f[r|f] - প্লেয়ার 1 দ্বারা প্রথম সফল শটটি মেলে।

    প্রতিটি ক্ষেত্রে এটি ম্যাচের শেষ অবস্থান ( .to), বা কোনও মিল না থাকলে অনন্ততা দেয়।

  • &[<=>](|   )

    <=>দুটি ম্যাচের শেষের অবস্থানে অপারেটরটি প্রয়োগ করে । এটি প্রথম যুক্তিটি বৃহত্তর, কম, বা দ্বিতীয়টির সমান কিনা তার উপর নির্ভর করে Orderএনাম ( More,, Lessবা Same) থেকে কোনও মান ফেরত দেয় ।

— smls
সূত্র
ঝরঝরে। কৌতূহলের বাইরে আপনি কীভাবে অনন্তের প্রতীকটি টাইপ করবেন? বিশেষ কীবোর্ড, বা আপনি Alt + টাইপ করেন some number? এবং আপনি কি সাধারণ পার্ল কোডের মতো অক্ষরগুলি ব্যবহার করেন, বা এটি কেবল গল্ফ করার জন্য?
— কারসিজিনিট
@ কারসিজেনিকেট: আমার কাস্টমাইজড কীবোর্ড স্কিমটি আমাকে চারটি কী [Menu] i n f(এটি একটি কমপোজ সিকোয়েন্স বলা হয় ) আঘাত করে ইনপুট করতে দেয় । তবে, সমস্ত পার্ল 6 চিহ্নের ASCII সংস্করণ রয়েছে - উদাহরণস্বরূপ Infএবং ∞প্রতিশব্দগুলি - তাই পার্ল 6 কোডে ইউনিকোড চিহ্ন ব্যবহার করার প্রয়োজন নেই । আমি ঠিক এটি পছন্দ করেছি ... :)
— স্মেল
আহা। পার্ল সম্পর্কে যা আমাকে ফেলেছিল তা হ'ল অনন্ত প্রতীক। আমি ভেবেছিলাম এটি একটি প্রয়োজনীয়তা, যা অহেতুক জটিল বলে মনে হয়েছিল। আমি যখন ক্লোজার থেকে বিরক্ত হয়েছি তখন আমি পার্ল চেষ্টা করব। আমি ইদানীং প্রচুর পার্ল কোড দেখেছি।
— কারসিজিনিট
@ কারসিজেনিকেট: সচেতন থাকুন যে পার্ল 6 মূলত একটি নতুন ভাষা যা পার্লের সাথে পিছনের দিকে সামঞ্জস্যপূর্ণ নয় এবং এর অনুবাদক এখনও ধীর (এবং কিছু বৈশিষ্ট্যের জন্য বগি)। পার্ল, বর্তমানে সংস্করণ v5.24 এ, আলাদাভাবে রক্ষণাবেক্ষণ করা অবিরত রয়েছে।
— 12:48
ঠিক আছে ধন্যবাদ. জানা ভাল.
— কারসিজিনিট
2

হাস্কেল , 101 91 87 বাইট

n!(c:r)|'g'>c=n:1!r|'g'<c=1:0!r|1<3=2:n!r
_!r=[]
a#b=[x|x@(y,z)<-zip(1!a)$1!b,2>y+z]!!0

এটি অনলাইন চেষ্টা করুন! ইনফিক্স ফাংশন #দুটি প্লেয়ারের দুটি ক্রয়ের প্রতিনিধিত্ব করে এবং (0,1)খেলোয়াড় 1 (1,0)এবং প্লেয়ার 2 জিতলে প্রত্যাবর্তন করে(0,0) একটি ড্রয়ের

ব্যবহারের উদাহরণ:

Prelude> "rgrfrf" # "fgrgrr"
(0,1)

ব্যাখ্যা:

পোতা ফাংশন !একটি কর্মের ক্রম অনুবাদ 'r'(রিলোড), 'f'(অগ্নি) এবং 'g'পর্যবেক্ষণযোগ্য কর্মের একটি ক্রম থেকে (প্রহরা) 0(প্রকৃত আগুন), 1(কোনও ক্রিয়া) এবং 2(প্রহরা), যেখানে একটা আগুন পদক্ষেপ কেবলমাত্র হিসাবে গণনা করা হয় প্রকৃত আগুন কর্ম যদি বুলেটটি লোড হয় এবং অন্যথায় কোনও পদক্ষেপ না থাকে। এটি অর্জন করার জন্য প্রথম যুক্তিটি nহ'ল 0যদি কোনও বুলেট চাপানো হয় এবং 1বন্দুকটি লোড না করা হয়। এইভাবে প্রতিটি 'f'স্রোতের সাথে সহজভাবে প্রতিস্থাপন করা যেতে পারে n। ( n=0-> লোড -> প্রকৃত আগুন -> 0, n=1-> আনলোড -> কোনও পদক্ষেপ নেই -> 1)

n ! (c:r)                -- n is 0 or 1, c is 'f', 'g' or 'r' and r the rest of the string
    |'g'>c = n : (1 ! r) -- c is smaller 'g', so it must be 'f'. append n to the list
                         --  and set load status to 1 (unloaded)
    |'g'<c = 1 : (0 ! r) -- c is larger 'g', so it must be 'r'. append 1 (no action)
                         --  and set load status to 0 (loaded)
    |1<3   = 2 : (n ! r) -- c must be equal to 'g'. append 2 (guard)
                         --  and leave the load status unchanged
_ ! r = []               -- base case for recursion

নয়টি ফলাফল সম্ভাবনা হয়

  • (0,0): উভয় খেলোয়াড় গুলি করে মারা যায়, খেলা শেষ হয়।
  • (0,1)বা (1,0): একজন খেলোয়াড় অন্যকে গুলি করে, খেলা শেষ হয়।
  • (0,2)বা (2,0): একজন খেলোয়াড় গুলি করে তবে অন্য প্রহরী, খেলা অব্যাহত থাকে।
  • (1,1), (1,2), (2,1)বা (2,2): কোন খেলোয়াড় কান্ড, খেলা চলতে থাকে।

ডিজাইন অনুসারে গেমের সমাপ্তি বিকল্পগুলির যোগফল 2 এর চেয়ে কম হয় এবং প্রতিটি গেমের অব্যাহত সম্ভাবনার যোগফল বড় বা সমান 2 হয় of

a#b=[x|         -- build the list of all x
    x@(y,z) <-  -- where x is an alias for the tuple (y,z) which is drawn from the list
    zip (1!a)   -- of tuples where the first component is from 1!a = eg. [1,2,1,0,1,0] 
        (1!b)   -- and the second from 1!b = eg. [1,2,1,2,1,1]
    , 2 > y+z]  -- and y+z are smaller 2.
    !!0         -- return the first element of this list
— Laikoni
সূত্র
1

ব্যাচ, 249 বাইট

@echo off
set g=goto gg
set/ax=y=0
:gg
shift&goto %1
:fg
set x=0
%g%
:gf
set y=0
%g%
:rr
set/ax=y=1
%g%
:fr
if %x%==1 exit/b1
:gr
set y=1
%g%
:rf
if %y%==1 exit/b2
:rg
set x=1
%g%
:ff
set/az=3-x-x-y
if %z%==3 %g%
exit/b%z%

ইনপুট প্রতিটি টার্নের জন্য জোড়া অক্ষরের আকারে থাকে এবং ত্রুটি স্তর (0 = ড্র, 1 = প্লেয়ার 1, 2 = প্লেয়ার 2) দ্বারা আউটপুট হয়। xএবং yখেলোয়াড়ের কাছে গোলাবারুদ রয়েছে কিনা তা খোঁজখবর রাখুন, সুতরাং যখন উভয়ই আগুন ধরিয়ে দেয়, ফলাফলটি 3-x-x-y3 না হওয়া পর্যন্ত হয়, সেই ক্ষেত্রে আমরা চলতে থাকি। 5 লাইনে আমি ব্যাচের পার্সারটিকে অপব্যবহার করি - %1(যা বর্তমান পদক্ষেপ) shiftবিবৃতি কার্যকর করার আগে এবং এটি সরানোর আগে প্রতিস্থাপন করা হয়, তাই আমরা এখনও সঠিক লেবেলে যাই।

— নিল
সূত্র
1

ক্লোজার, 168 বাইট

#(reduce(fn[[l L r R][a A]](if(and l L)(let[M(fn[r a A](if(and(= a \f)r)[nil(= A \g)][(or(= a \r)r)1]))[r L](M r a A)[R l](M R A a)][l L r R])[l L r R]))[1 1 nil nil]%)

কম গল্ফড (যদি উভয় ব্যক্তিই জীবিত থাকে তবে আমরা Mতাদের গোলাবারুদ এবং শত্রুদের জীবন অবস্থা আপডেট করতে ব্যবহার করি , অন্যথায় আমরা বর্তমান অবস্থাটি ফিরিয়ে দিই):

(def f (fn[A] (reduce
                (fn [[l1 l2 r1 r2] [a1 a2]]
                  (if (and l1 l2)
                    (let[M (fn [r1 a1 a2]
                             (if (and(= a1 \f)r1)
                               [false (= a2 \g)]        ; we lost the ammo, a2 lives if he was guarding
                               [(or(= a1 \r)r1) true])) ; we might gain or keep ammo, a2 lives no matter what
                         [r1 l2] (M r1 a1 a2)
                         [r2 l1] (M r2 a2 a1)]
                      [l1 l2 r1 r2])
                    [l1 l2 r1 r2]))
                [true true false false] A)))

উদাহরণস্বরূপ ব্যবহার (প্রথম উপাদানটি বলছে যে প্লেয়ার 1 গেমের শেষে বেঁচে আছে কি না, দ্বিতীয় উপাদানটি বলে যে প্লেয়ার 2 বেঁচে আছে কিনা, তৃতীয় এবং চতুর্থ এ্যামো স্ট্যাটাসটি জানায় যা বিজয়ী নির্ধারণের সময় প্রাসঙ্গিক নয়):

(-> (for[[a b s] (partition 3 "rr fg rf fr ")][a b]) f (subvec 0 2))

আপডেট: ভাল যে দেখুন, loopএটির অভিন্ন দৈর্ঘ্য আছে! আমি reduceসংস্করণটি বিকাশ করা সহজ বলে মনে করি আপনি যদি ব্যবহার করেন তবে আপনি সহজেই মধ্যবর্তী রাজ্যগুলি পরিদর্শন করতে পারেন reductions।

#(loop[l 1 L 1 r nil R nil[[a A]& I]%](if(and l L)(let[M(fn[r a A](if(and(= a \f)r)[nil(= A \g)][(or(= a \r)r)1]))[r L](M r a A)[R l](M R A a)](recur l L r R I))[l L]))
— NikoNyrh
সূত্র
আমি অপেক্ষা্য ছিলাম! ওটা ঘন, বাহ!
— কারসিজিনিট
ওহে ধন্যবাদ, এটি এখনও আমাকে বিরক্ত করে যে আমাকে পুনরুক্ত করতে [l1 l2 r1 r2]হয়েছিল (এর পরিবর্তিত মান letএবং এর মূল মূল্যগুলি) এবং সেই fnস্বাক্ষরগুলি।
— নিকোনিহার
অন্ততপক্ষে পরবর্তীকালের জন্য, তাই আমি পক্ষে আছি loop। আমি দেখতে পাই এটি আরও সুন্দর কোডের দিকে নিয়ে যায়। যত তাড়াতাড়ি আমার 1 টিরও বেশি সংযোজকের সাথে ভাঁজ করা দরকার, আমি স্যুইচ করি।
— কারসিজিনিট
1

পিএইচপি, 107 101 90 বাইট

লোডিংয়ের স্থিতির জন্য একটি বিট মাস্ক $ ডি এবং ফায়ারিংয়ের পদক্ষেপগুলির জন্য একটি ডিব্রুজান ক্রম ব্যবহার করে।

for(;!$x=$d&strpos(_frff,$m=$argv[++$i]);)$d=$d&g<$m|h<$m|2*($d/2&f<$m[1]|g<$m[1]);echo$x;

ইনপুট 2-অক্ষর কমান্ড লাইন আর্গুমেন্ট হিসাবে গ্রহণ করে, সাথে চালানো -nr।

1 = প্লেয়ার 1 জয়
2 = প্লেয়ার 2 জয়
3 = ড্র

ভাঙ্গন

for(;!$x=$d&strpos(_frff,       // 1. $x=someone dies, loop while not
    $m=$argv[++$i]          // loop throug moves
);)
    $d=
        $d&g<$m|h<$m            // 2. unload/reload Player 1 = bit 0
    |2*(
        $d/2&f<$m[1]|g<$m[1]    // 3. unload/reload Player 2 = bit 1
    );
echo$x;
  • ডি ব্রুজইন সিকোয়েন্স: frঅবস্থান = 1 = পি 1 আগুন; rf= অবস্থান 2 = পি 2 আগুন, ff= অবস্থান 3 = উভয়ই আগুন
  • g<$m<=> f<$m[0]( f<$mসর্বদা সত্য, কারণ দ্বিতীয় চরিত্রটি রয়েছে)।
— তিতাস
সূত্র
0

পাইথন, 200 বাইট

def war_game(turns):
    turn=0
    player1=True
    player2=True
    ammo1=False
    ammo2=False
    while turn<len(turns):
        if turns[turn][0]=='f' and ammo1==True and turns[turn][1]!='g':
            player2=False
        elif turns[turn][0]=='f' and turns[turn][1]=='g':
            ammo1=False
        elif turns[turn][0]=='r':
            ammo1=True
        if turns[turn][1]=='f' and ammo1==True and turns[turn][0]!='g':
            player1=False
        elif turns[turn][1]=='f' and turns[turn][0]=='g':
            ammo2=False            
        elif turns[turn][1]=='r':
            ammo2=True
        if player2==False or player1==False:
            break
        turn+=1
    if player1==True and player2==False:
        print('Player 1 wins')
        return 1
    elif player1==False and player2==True:
        print('Player 2 wins')
        return 2
    print('Draw')
    return 0
— Galo
সূত্র
2
সাইটে স্বাগতম। প্রতিযোগিতাটি বাইট কাউন্টে স্কোর করা হয় তাই আমি আপনার শিরোনামে একটি বাইট গণনা অন্তর্ভুক্ত করার চেষ্টা করব এবং পরিবর্তনশীল নামের দৈর্ঘ্য হ্রাস করে এটি হ্রাস করার চেষ্টা করব। আপনি যে ভাষায় এটি লিখেছেন তাও আপনার অন্তর্ভুক্ত করা উচিত (আমার কাছে পাইথন 3 এর মতো দেখায়)।
— পোস্ট রক গার্ফ হান্টার
2
উপরে উল্লিখিত হিসাবে, এটি একটি প্রতিযোগিতা যিনি কাজটি সম্পাদন করতে ক্ষুদ্রতম প্রোগ্রামকে সম্ভব করে তুলতে পারেন। আপনি ন্যায়বিচারের turnsপরিবর্তে পুরো নাম ব্যবহার করছেন t, যার অর্থ প্রোগ্রামটি প্রয়োজনের চেয়ে অনেক বড়। এছাড়াও দয়া করে আপনার জমা দেওয়ার মতো কিছু দিয়ে শুরু করুন #Python 2, 200 bytes(ধরে নেওয়া এটি 2 এবং প্রোগ্রামটি 200 বাইট দীর্ঘ) সুতরাং আপনি যে ভাষাটি ব্যবহার করছেন তা পরিষ্কার।
— কারসিজেনিকেট
0

ক্লোজার, 180 173 বাইট

(fn[t](loop[z nil x nil[[c v]& r]t](let[k #(and %3(= %\f)(not= %2\g))h #(and(not= %\f)(or %2(= %\r)))q(k v c x)w(k c v z)](cond(and q w)0 q 2 w 1 1(recur(h c z)(h v x)r)))))

ম্যাক্রো ব্যবহার না করে ফাংশনটিকে পুরো ফাংশনে পরিবর্তন করে -7 বাইট এটি আমাকে অভ্যন্তরীণ ফাংশনগুলিকে ম্যাক্রো করতে দিন, যা কিছুটা সাশ্রয় করে।

এটি একটি খুব আক্ষরিক সমাধান। আমি একধরনের মন থেকে আবদ্ধ থাকি যেহেতু আমি কেবল গেমটির একটি সম্পূর্ণ সংস্করণ লিখেছি এবং এটি মূলত আমি ব্যবহৃত অ্যালগরিদমের একটি বিস্তৃত সংস্করণ। আমি করতে পারে এমন অনেকগুলি অপ্টিমাইজেশন সম্ভবত রয়েছে তবে আমি এতে মোটামুটি খুশি। ব্যাখ্যার জন্য প্রিগল্ফড কোড দেখুন।

(defn outcome [turns] ; Take input as ["rr" "ff"]
  (loop [p1-ammo? false ; Keep track of if each player has ammo
         p2-ammo? false
         [[p1-move p2-move] & rest-turns] turns] ; Deconstruct the turns out

    (let [killed? (fn [m m2 a] (and a (= m \f) (not= m2 \g))) ; Function that checks if one player killed the other
          has-ammo? (fn [m a] (and (not= m \f) (or a (= m \r)))) ; Function that decides if a player has ammo in the
                                                                 ;  next turn
          p1-killed? (killed? p2-move p1-move p2-ammo?) ; Check if each player was killed.
          p2-killed? (killed? p1-move p2-move p1-ammo?)]

      (cond ; Check who (if any) died. If no one died, recur to next turn.
        (and p1-killed? p2-killed?) 0
        p1-killed? 2
        p2-killed? 1
        :else (recur (has-ammo? p1-move p1-ammo?)
                     (has-ammo? p2-move p2-ammo?)
                     rest-turns)))))
— Carcigenicate
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.