जोखिम में एक लड़ाई के लिए पासा रोल की दो सूचियों को देखते हुए, आपके कार्यक्रम या फ़ंक्शन को आउटपुट करना होगा कि प्रत्येक खिलाड़ी कितने सैनिक खो देता है।
पृष्ठभूमि
आपको इसे पढ़ना नहीं है, क्योंकि यह केवल पृष्ठभूमि है। बेरोकटोक जारी रखने के लिए "टास्क" को छोड़ दें।
जोखिम के खेल में , एक खिलाड़ी दूसरे खिलाड़ी पर हमला कर सकता है (वास्तव में, यह जीतने के लिए आवश्यक है)। एक लड़ाई का परिणाम पासा के रोल से निर्धारित होता है। प्रत्येक लड़ाई उप-लड़ाइयों के उत्तराधिकार के रूप में होती है, जिसमें प्रत्येक खिलाड़ी 2अपनी सेना के टुकड़ों को खो सकता है ।
एक उप-लड़ाई में, रक्षक और हमलावर प्रत्येक पासा को रोल करते हैं जिनकी संख्या इस चुनौती के लिए अप्रासंगिक परिस्थितियों के आधार पर भिन्न हो सकती है। हमलावर की उच्चतम-मूल्यवान मृत्यु की तुलना रक्षक के उच्चतम-मूल्यवान मरने से की जाती है। यदि हमलावर की मृत्यु रक्षक के मरने की तुलना में अधिक है, तो रक्षक एक टुकड़ा खो देता है। अन्यथा, हमलावर एक टुकड़ा खो देता है।
फिर, यदि दोनों खिलाड़ियों के पास कम से कम दो पासे हैं, तो दोनों खिलाड़ियों के दूसरे-सर्वोच्च मूल्यवान पासे की तुलना की जाती है। फिर, यदि हमलावर की मृत्यु रक्षक के मरने से अधिक है, तो रक्षक एक टुकड़ा खो देता है। अन्यथा, हमलावर एक टुकड़ा खो देता है।
(डिफेंडर जीतता है। यदि डिफेंडर और हमलावर दोनों एक रोल करते हैं 4, तो हमलावर एक टुकड़ा खो देता है।)
विकिपीडिया लेख के इस उप-युद्ध में, हमलावर का पासा लाल है और रक्षक का पासा सफेद है। हमलावर का पासा 4सबसे ज्यादा है और बचावकर्ता का उच्चतम है 3। चूंकि हमलावर अधिक था, डिफेंडर एक टुकड़ा खो देता है। दूसरा-सबसे अधिक 3हमलावर के 2लिए और रक्षक के लिए हैं। चूंकि हमलावर फिर से उच्च था, डिफेंडर एक और टुकड़ा खो देता है। इस प्रकार इस उप-लड़ाई में, हमलावर कोई टुकड़ा नहीं खोता है और रक्षक 2टुकड़े खो देता है।
ध्यान दें कि तीसरे-उच्चतम टुकड़ों की तुलना नहीं की जाती है। इसका कारण यह है कि डिफेंडर के पास एक एकल उप-लड़ाई पर दो से अधिक पासा नहीं है, इसलिए कभी भी तुलना करने के लिए तीसरे-उच्चतम टुकड़े नहीं हैं।
कार्य
किसी भी सुविधाजनक रूप में दोनों के हमलावर और जोखिम की उप-लड़ाई के रक्षक के दोनों में अनसुचित पासा रोल (रेंज 1 से 6 समावेशी में पूर्णांक) को देखते हुए, प्रत्येक खिलाड़ी को सेना के टुकड़े की संख्या का उत्पादन होता है। आउटपुट किसी भी सुविधाजनक रूप में हो सकता है, जब तक कि पांच संभावनाओं को इंगित करने के लिए अलग-अलग आउटपुट होते हैं। आपको इंगित करना चाहिए कि आपके प्रश्न में उन विभिन्न आउटपुट क्या हैं।
आउटपुट निम्नानुसार निर्धारित किया जाता है: साथ शुरू करें def=0और atk=0। यदि हमलावर के पासा रोल की सूची का सबसे बड़ा मूल्य रक्षक के पासा रोल की सूची के सबसे बड़े मूल्य से अधिक है, तो वेतन वृद्धि def। अन्यथा, वेतन वृद्धि atk।
यदि पासा रोल की दोनों सूचियों की लंबाई कम से कम है 2, तो: यदि हमलावर के पासा रोल की सूची का दूसरा सबसे बड़ा मूल्य सूची के दूसरे सबसे बड़े मूल्य से अधिक है, तो वेतन वृद्धि defऔर अन्यथा वेतन वृद्धि atk।
अंत में, प्रोग्राम या फ़ंक्शन को निम्न 5 आउटपुट संभावनाओं में से प्रत्येक के लिए एक विशिष्ट पहचानकर्ता का उत्पादन करना चाहिए:
╔═══╦═══╗
║atk║def║
╠═══╬═══╣
║ 1 ║ 0 ║
║ 0 ║ 1 ║
║ 2 ║ 0 ║
║ 1 ║ 1 ║
║ 0 ║ 2 ║
╚═══╩═══╝
उदाहरण
डिफेंडर: [3, 2]
हमलावर: [2, 4, 1]
बचावकर्ता का 3अधिकतम और हमलावर का अधिकतम है 4। 4>3, तो def=1
दूसरा डिफेंडर है 2और दूसरा हमलावर है 2। Not(2>2), तो atk=1। तब उत्पादन हो सकता था [1,1]।
परीक्षण के मामलों
Defender
Attacker
Output (as [def,atk])
-----
[1]
[1]
[0,1]
-----
[6,6]
[1,1,1]
[0,2]
-----
[1,2]
[5,2,3]
[2,0]
-----
[5]
[3,4]
[0,1]
-----
[4]
[4,5]
[1,0]
-----
[1,3]
[1,2,3]
[1,1]
-----
[4]
[4,5,6]
[1,0]
-----
[4,5]
[6,2]
[1,1]
-----
[5]
[6,1,3]
[1,0]
-----
[5,5]
[4,4,1]
[0,2]
-----
[2,5]
[2,2]
[0,2]
-----
[6,6]
[4,4,3]
[0,2]
-----
[2,1]
[4,3]
[2,0]
-----
[4]
[1,5]
[1,0]
-----
[1]
[5,2]
[1,0]
-----
[6,2]
[4]
[0,1]
-----
[4,2]
[2,5,5]
[2,0]
-----
[2]
[6,6,2]
[1,0]
-----
[6]
[2,6]
[0,1]
-----
[3,1]
[1]
[0,1]
-----
[6,2]
[3,5,2]
[1,1]
-----
[4,2]
[1,1]
[0,2]
-----
[4,3]
[5,4,1]
[2,0]
-----
[5,6]
[1,2]
[0,2]
-----
[3,2]
[4,4]
[2,0]
-----
[2]
[6,3,4]
[1,0]
-----
[1,4]
[6,2,4]
[2,0]
-----
[4,2]
[2,5,4]
[2,0]
-----
[5]
[6,2,1]
[1,0]
-----
[3]
[2,5,4]
[1,0]
-----
[5,4]
[2]
[0,1]
-----
[6,3]
[2,6,5]
[1,1]
-----
[3,1]
[4]
[1,0]
-----
[4]
[6,6,5]
[1,0]
-----
[6,3]
[4,2]
[0,2]
-----
[1,6]
[5,4]
[1,1]
-----
[3,6]
[4,4]
[1,1]
-----
[5,4]
[5,1,1]
[0,2]
-----
[6,3]
[5,4]
[1,1]
-----
[2,6]
[1,2]
[0,2]
-----
[4,2]
[3,5,5]
[2,0]
-----
[1]
[1,2,1]
[1,0]
-----
[4,5]
[1,6]
[1,1]
-----
[1]
[3,5,1]
[1,0]
-----
[6,2]
[6,2]
[0,2]
नमूना कार्यान्वयन
अजगर 2 या 3
def risk(atk_rolls,def_rolls):
# set the rolls in descending order, e.g. [5,3,2]
atk_rolls = sorted(atk_rolls,reverse = True)
def_rolls = sorted(def_rolls,reverse = True)
# minimum length.
minlen = min(len(atk_rolls),len(def_rolls))
atk_lost = 0
def_lost = 0
# compare the highest-valued rolls
if atk_rolls[0]>def_rolls[0]:
def_lost += 1
else:
atk_lost += 1
if minlen == 2:
# compare the second-highest-valued rolls
if atk_rolls[1] > def_rolls[1]:
def_lost += 1
else:
atk_lost += 1
return [def_lost, atk_lost]
विशेष विवरण
- इनपुट को किसी भी रूप में लिया जा सकता है जो स्पष्ट रूप से केवल डिफेंडर के रोल और हमलावर के रोल को एन्कोड करता है ।
- आउटपुट किसी भी रूप में हो सकता है जो ऊपर सूचीबद्ध पांच संभावनाओं में से प्रत्येक के लिए एक अद्वितीय आउटपुट प्रदान करता है।
- डिफेंडर के रोल सेट में पूर्णांक
1या2पूर्णांकों की एक सूची है[1,2,3,4,5,6]। हमलावर रोल की एक सूची रहे हैं1करने के लिए3सेट में पूर्णांकों[1,2,3,4,5,6]। - चूंकि यह कोड-गोल्फ है , प्रत्येक भाषा में सबसे छोटा कोड जीतता है! करो नहीं गोल्फ भाषाओं में जवाब अन्य भाषाओं में पोस्टिंग जवाब से आप को हतोत्साहित करते हैं।
