युद्ध के खेल के परिणाम का पता लगाएं

15

युद्ध के खेल के परिणाम का पता लगाएं

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

2 लोग एक दूसरे से दूर बैठते हैं। खेल का लक्ष्य अन्य खिलाड़ी को "मार" करना है। प्रत्येक मोड़, आप 3 चालों में से एक खेल सकते हैं:

  • रीलोड : आपके पास एक बंदूक है जो एक ही शॉट रखती है। इससे पहले कि इसे हर बार निकाल दिया जाए, इसे फिर से लोड करना होगा। जब आपके पास पहले से ही बारूद है तो फिर से लोड करना कानूनी है, लेकिन कुछ भी नहीं करता है। आपके दोनों हाथों से मंदिरों को टैप करके एक रीलोड का प्रतीक बनाया गया था। प्रत्येक खिलाड़ी 0 बारूद के साथ शुरू होता है।

  • गार्ड : एकमात्र सुरक्षित चाल। यदि आपको रखवाली करते समय गोली मार दी जाती है, तो आप मरते नहीं हैं। आपकी छाती पर अपनी बाहों को पार करके गार्डिंग का प्रतीक था।

  • आग : अपनी बंदूक आग। सफलतापूर्वक फायर करने के लिए, आपको अंतिम शॉट के बाद पुनः लोड करना होगा। यदि आपका प्रतिद्वंद्वी पुनः लोड कर रहा है, तो आप जीत जाते हैं। यदि वे भी आग लगाते हैं, और आप दोनों के पास बारूद है, तो यह एक ड्रॉ है। यदि वे रखवाली कर रहे हैं, तो आप बारूद को बर्बाद कर रहे हैं। जबकि बारूद के बिना फायरिंग एक कानूनी कदम है, यह कुछ भी नहीं करता है और आपको पुन: लोड करने की तरह कमजोर बनाता है। दूसरे खिलाड़ी की ओर इशारा करके फायरिंग की गई।

यह आरपीएस के समान खेला गया था, जिसमें प्रत्येक खिलाड़ी एक साथ अपनी पसंद को फेंक देता है (हमने एक-दूसरे के साथ ताल में ताल मिलाने के लिए अपने पैरों को दो बार घुमाया, लेकिन यह चुनौती के लिए महत्वपूर्ण नहीं है)।

चुनौती:

आपका काम युद्ध के खेल का परिणाम खोजना है। यह एक फ़ंक्शन या पूर्ण कार्यक्रम हो सकता है।

इनपुट

  • प्रत्येक खिलाड़ी ने प्रत्येक मोड़ को चुना विकल्प को एक चरित्र / स्ट्रिंग द्वारा दर्शाया जाएगा:

    • r : पुनः लोड करें

    • जी : गार्ड

    • f : आग

  • इनपुट जोड़े की सूची होगी, इन लाइनों के साथ एक सीमांकित / undelimited स्ट्रिंग, या कुछ और।

पाइथन में एक उदाहरण इनपुट हो सकता है [("r", "g"), ("f", "r")], जिसका अर्थ है कि पहले खिलाड़ी को पुनः लोड किया जाए, और दूसरा खिलाड़ी पहरा दे। दूसरे मोड़ पर, पहला खिलाड़ी आग लगाता है, जबकि दूसरा खिलाड़ी पुनः लोड करता है। खिलाड़ी एक इस खेल को जीतता है। एक ही इनपुट वैकल्पिक के रूप में प्रतिनिधित्व किया जा सकता है "r g f r", "rgfr", "rg fr" "rg-fr"...

आप निम्नलिखित मान सकते हैं:

  • इनपुट आपके चुने हुए प्रारूप से मेल खाएगा, और यह कि इसमें केवल मान्य वर्ण होंगे।

  • कोई 100 मोड़ के भीतर मर जाएगा।

हालाँकि आप यह नहीं मान सकते हैं कि जब कोई मर जाता है तो मोड़ समाप्त हो जाते हैं।

उत्पादन

एक मान दर्शाता है कि कौन जीता (या, जो पहले जीता *)। आप चुन सकते हैं कि प्रत्येक परिदृश्य के लिए आउटपुट क्या है, लेकिन निम्नलिखित के लिए खाता होना चाहिए:

  • खिलाड़ी 1 जीतता है

  • खिलाड़ी 2 जीत

  • वे एक दूसरे को मारते हैं (ड्रा)

प्रत्येक परिणाम का एक जिला मान होना चाहिए, और हमेशा प्रत्येक परिदृश्य के लिए समान होना चाहिए।

एक उदाहरण के रूप में: 1जब खिलाड़ी 1 जीतता है, 2जब खिलाड़ी 2 जीतता है, और 0ड्रा की स्थिति में आप आउटपुट कर सकते हैं । आपको तब हमेशा आउटपुट करना चाहिए 1जब खिलाड़ी 1 जीतता है, 2जब खिलाड़ी 2 जीतता है, और 0ड्रा की स्थिति में।

इसे लौटाया जा सकता है, या स्टडआउट में मुद्रित किया जा सकता है। ट्रेलिंग व्हाट्सएप ठीक है।

बस इसलिए यह स्पष्ट है, एक ही परिदृश्य जो ड्रॉ की ओर जाता है यदि दोनों खिलाड़ी आग लगाते हैं, और दोनों में बारूद है।

*इस चुनौती के बाद से, किसी के मरने के बाद भी मोड़ जारी रह सकते हैं, यह संभव है कि 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

यह कोड गोल्फ है, इसलिए सबसे छोटी संख्या बाइट्स जीतती है!

ध्यान दें, जैसा कि परीक्षण के मामले दिखाते हैं, आपको "गूंगा" चाल को संभालना होगा। यह पूरी तरह से एक खिलाड़ी के लिए शूट करने का प्रयास करने के लिए मान्य है जब उनके पास बारूद नहीं है, या एक पंक्ति में 2 बदल जाता है (और केवल एक बारूद जमा होता है)।

code-golf  game 
— Carcigenicate
स्रोत
क्या मुझे कुछ याद आ रहा है या केवल अंतिम दौर से ही आउटपुट का निर्धारण किया जा सकता है?
— xnor
@ प्रश्न पूछा। और नहीं, चूंकि आपको यह जानना होगा कि किसी खिलाड़ी के पास बारूद है या नहीं। मुझे एहसास है कि आप यह मान सकते हैं कि किस खिलाड़ी के पास इस तथ्य के आधार पर बारूद है कि यह अंतिम मोड़ है। मैंने वास्तव में नियमों को काफी अंतिम समय में बदल दिया था, जिससे किसी व्यक्ति की मृत्यु होने पर इनपुट समाप्त होने की अनुमति मिलती है। मुझे अब पछतावा हो रहा है।
— कैरिजनेट
— xnor
3
यह वह जगह है बहुत से मिलते-जुलते , लोड का एक खेल स्कोर की रक्षा और शूट । अंतर केवल इतना है कि दूसरी चुनौती में एक से अधिक शॉट वाली बंदूकें हैं और एक खाली बंदूक की शूटिंग को धोखा माना जाता है और खेल को रोक देता है।
— डेनिस
क्या हम राउंड के बजाय दो खिलाड़ियों के लिए दो अलग-अलग इनपुट ले सकते हैं, जैसे {"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 जीतता है, -1 अगर खिलाड़ी 2 जीतता है, और 0 ड्रा के लिए।

स्पष्टीकरण: पहले जाँच करता है कि किसी ने गोली चलाई, यदि ऐसा है तो खेल समाप्त हो जाएगा। फिर हम यह निर्धारित करते हैं कि क्या खिलाड़ियों ने अपनी बंदूकें फिर से लोड की हैं या उनकी बारूद को बर्बाद किया है।

यह मेरा पहला कोडगोल्फ पोस्ट है :)

— गणित के दीवाने
स्रोत
4

जावास्क्रिप्ट (ईएस 6), 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 में एक बुलेट है

हम डी ब्रूजन अनुक्रम 'ffrfgrrggf' का उपयोग चाल के सभी 9 संभावित संयोजनों की पहचान करने के लिए करते हैं। हम bमूव कॉम्बिनेशन के अनुसार अपडेट करने के लिए OR और AND का उपयोग करते हैं। हम bविजेता का निर्धारण करने के लिए AND'ed के साथ बिटमास्क के एक 3 सेट का उपयोग करते हैं 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
स्रोत
@Carcigenicate यह दोनों विफल मामलों के लिए तय किया जाना चाहिए। हालांकि, अब मैं ड्रॉ के मामले में वापस लौट रहा हूं 0(किसी को भी गोली नहीं लगी थी) या 3(खिलाड़ी एक-दूसरे को मारते हैं)। यकीन नहीं होता कि इसकी अनुमति है। यदि नहीं, तो मैं w%3इसके बजाय वापस आ सकता हूं ।
— अरनौलद
मुझे प्रति परिदृश्य 1 आउटपुट चाहिए था। मैं गारंटी देता हूं कि किसी को हमेशा गोली मार दी जाएगी, इसलिए उस मामले के लिए लेखांकन अनावश्यक है। केवल एक ड्रॉ के लिए अग्रणी मामला तब होता है जब दोनों एक दूसरे को गोली मारते हैं, और दोनों के पास बारूद होता है।
— १३
&मुखौटा के लिए 0 हो सकता है fr,rf,ff। '312'['0210231'[m='ffrfgrrggf'.search(c)]|'233331'[m-3]&b]या '123'['2100231'[m='frffgrrggf'.search(c)]|'233331'[m-3]&b]एक बाइट बचाओ; लेकिन क्या वे काम करते हैं?
— टाइटस
@Titus दिलचस्प है, और मास्क से पहले मास्क लगाना सभी मौजूदा परीक्षण मामलों के लिए काम करेगा। लेकिन यह कुछ इस तरह से विफल हो जाएगा["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"।
तीन संभावित आउटपुट एनम मान हैं More(खिलाड़ी 1 जीता), Less(खिलाड़ी 2 जीता), 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? और क्या आप वास्तव में उस तरह के पात्रों का उपयोग करते हैं जैसे कि आम पर्ल कोड में, या यह सिर्फ गोल्फिंग के लिए है?
— कारजिनेट
@Carcigenicate: मेरा अनुकूलित कुंजीपटल योजना मुझे चार कुंजी मारकर इनपुट यह सुविधा देता है [Menu] i n f(यह एक कहा जाता है तो लिखें अनुक्रम )। हालांकि, सभी पर्ल 6 प्रतीकों में ASCII संस्करण हैं - उदाहरण के लिए Infऔर ∞समानार्थक शब्द हैं - इसलिए पर्ल 6 कोड में यूनिकोड प्रतीकों का उपयोग करना आवश्यक नहीं है । मुझे यह पसंद है ... :)
— मुस्कुराता है
आह। यही एक बात है जो मुझे पर्ल के बारे में बताती है, वह अनंत प्रतीक था। मुझे लगा कि यह एक आवश्यकता है, जो अनावश्यक रूप से जटिल लग रहा था। शायद जब मैं क्लोजर से ऊब गया तो मैं पर्ल की कोशिश करूँगा। मैंने हाल ही में बहुत सारे पर्ल कोड देखे हैं।
— कैरिजनेट
@Carcigenicate: ज्ञात हो कि पर्ल 6 मूल रूप से एक नई भाषा है जो पर्ल के साथ पीछे-संगत नहीं है, और इसकी व्याख्या अभी भी धीमी है (और कुछ सुविधाओं के लिए, छोटी गाड़ी)। वर्तमान में संस्करण v5.24 पर पर्ल को अलग-अलग बनाए रखा जा रहा है।
— SMLS
ठीक है धन्यवाद। जानकार अच्छा लगा।
— Carcigenicate
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।

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-y, जब तक कि वह 3 न हो, जिस स्थिति में हम चलते रहते हैं। 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 जीवित है, 3 या 4 वें बारूद स्थिति को बताता है जो विजेता का निर्धारण करते समय प्रासंगिक नहीं है):

(-> (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
स्रोत
मैं इंतजार कर रहा था! वह सघन है, वाह।
— 16
हेह धन्यवाद, यह अभी भी मुझे गुस्सा दिलाता है कि मुझे [l1 l2 r1 r2](इसके संशोधित मूल्यों letऔर इसके मूल मूल्यों पर) और उन fnहस्ताक्षरों को दोहराना पड़ा ।
— निकोइरह
कम से कम उत्तरार्द्ध के लिए, इसलिए मैं एहसान करता हूं loop। मुझे लगता है कि यह खाने के लिए कोड की ओर जाता है। जैसे ही मुझे 1 से अधिक संचायक के साथ मोड़ने की आवश्यकता होती है, मैं स्विच करता हूं।
— कारजिनेट
1

PHP, 107 101 90 बाइट्स

लोडिंग स्थिति और फायरिंग चाल के लिए एक डीब्रिज अनुक्रम के लिए बिट मास्क $ d का उपयोग करना।

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;
  • DeBruijn अनुक्रम: 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
— गालो
स्रोत
2
साइट पर आपका स्वागत है। प्रतियोगिता को बाइट की गिनती में स्कोर किया जाता है, इसलिए मैं आपके शीर्षक में एक बाइट गिनती सहित सिफारिश करूंगा और चर नामों की लंबाई को कम करके इसे कम करने का प्रयास करूंगा। आपको उस भाषा को भी शामिल करना चाहिए जिसमें आपने यह लिखा है (मेरे लिए Python3 की तरह दिखता है)।
— पोस्ट रॉक गार्फ हंटर
2
जैसा कि ऊपर उल्लेख किया गया है, यह एक प्रतियोगिता है जो कार्य को पूरा करने के लिए सबसे छोटे कार्यक्रम को संभव बना सकती है। आप turnsसिर्फ के बजाय पूर्ण नाम का उपयोग कर रहे हैंt , जिसका अर्थ है कि कार्यक्रम आवश्यकता से कहीं अधिक बड़ा है। इसके अलावा कृपया अपना सबमिशन कुछ #Python 2, 200 bytesइस तरह से शुरू करें (मान लें कि यह 2 है, और प्रोग्राम 200 बाइट लंबा है) इसलिए आप जिस भाषा का उपयोग कर रहे हैं वह स्पष्ट है।
— कैरिजनेट 23
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
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.