दोनों: एक विश्व व्यापी महामारी

Question

अंतिम परिणाम यहाँ हैं!

परिचय

2042 में, दुनिया अतिपिछड़ी हो गई है। वैश्वीकरण, अधिक भीड़, नई जीवन शैली और स्वच्छता की वैश्विक कमी के कारण एक नई महामारी फैल गई है। उन कठिन समय के दौरान, राज्य के नेताओं को स्थिति का प्रबंधन करना होगा। आप अपनी आबादी को कम नहीं होने दे सकते, लेकिन शायद आप अपने पड़ोसियों को मरने देने से लाभ उठा सकते हैं ...

शब्दकोष

स्वस्थ : लोग नहीं संक्रमित
संक्रमित : जो लोग महामारी से मर सकते हैं
मृत : शरीर गिनती, कोई विशेष प्रभाव (केवल स्कोरिंग)
संक्रमण की दर : की संख्या स्वस्थ जो बन जाएगा संक्रमित प्रत्येक बारी
संक्रामक रोग की दर : का प्रतिशत संक्रमित कि परिवर्तित कर देंगे स्वस्थ करने के लिए संक्रमित प्रत्येक मोड़ की
सुस्ती दर : संक्रमित का प्रतिशत जो प्रत्येक मृत्यु को समाप्त कर देगा
प्रवासन दर : स्वस्थ और संक्रमित दोनों का प्रतिशत जो प्रत्येक मोड़ को अलग / अलग करेगा
।: केवल आपके राज्य को प्रभावित करता है
ग्लोबल : हर राज्य को प्रभावित करता है

सिद्धांत

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

खेल टर्न-आधारित है। एक मोड़ में सात चरण होते हैं , अंतिम एक अंतःक्रियात्मक होता है (एक कमांड के लिए बॉट्स पूछना)। खिलाड़ियों के क्रम को प्रत्येक मोड़ पर यादृच्छिक किया जाता है। अगला चरण तब शुरू होता है जब पिछले चरण को हर शहर द्वारा निष्पादित किया जाता है (टर्न 1: प्लेयर 1, प्लेयर 2, प्लेयर 3 ...; टर्न 2: प्लेयर 3, प्लेयर 2, प्लेयर 1 ...):

1. Mutation                                 - AUTOMATED
2. Reproduction                             - AUTOMATED
3. Migration                                - AUTOMATED
4. Infection                                - AUTOMATED
5. Contagion                                - AUTOMATED
6. Extinction                               - AUTOMATED
7. Players Turn                             - INTERACTIVE

नियंत्रक आपको कमांड तर्कों के माध्यम से इनपुट प्रदान करता है, और आपके प्रोग्राम को स्टडआउट के माध्यम से आउटपुट करना होता है।

वाक्य - विन्यास

इनपुट

हर बार जब आपका कार्यक्रम बुलाया जाता है, तो उसे इस प्रारूप में तर्क प्राप्त होंगे:

Round;YourPlayerId;PlayerId_Healthy_Infected_Dead_InfectionRate_ContagionRate_LethalityRate_MigrationRate;PlayerId_Healthy_Infected_Dead_InfectionRate_ContagionRate_LethalityRate_MigrationRate;...

गोल 1-अनुक्रमित हैं।

उदाहरण इनपुट

6;2;1_106_23_9_2_4_13_5;0_20_53_62_16_20_35_5;2_20_53_62_16_20_35_5

यहां, आप देखते हैं कि यह 6 वां दौर है और आप खिलाड़ी हैं। आपके पास 20 स्वस्थ, 53 संक्रमित, 62 मृत, 16% संक्रमण दर, 20% संक्रामक दर, 35% घातक दर और 5% प्रवासन दर है।

उत्पादन

आपको तीन वर्ण (कोई स्थान नहीं, कोई विभाजक नहीं) आउटपुट करना होगा, जो प्रत्येक एक क्रिया के अनुरूप हो जिसे आप इस मोड़ पर ले जाएंगे। वर्णों का क्रम क्रियाओं के क्रम को निर्धारित करता है। आप एक ही क्रिया को कई बार आउटपुट कर सकते हैं।

N: क्या एन othing
M: अनुसंधान एम icrobiology [प्रभाव: स्थानीय कम संक्रमण दर 4% से]
E: अनुसंधान ई pidemiology [प्रभाव: स्थानीय कम संक्रामक रोग की दर 8% से]
I: अनुसंधान मैं mmunology [प्रभाव: कम स्थानीय मारक दर 4% से]
V: रिसर्च वी accination [प्रभाव: कम स्थानीय संक्रमण दर एक एक करके, स्थानीय को कम संक्रामक रोग की दर 4% से, स्थानीय को कम मारक दर 2% की]
C: दें सी ure [प्रभाव: कन्वर्ट 10 स्थानीय संक्रमित करने के लिए स्वस्थ ]
Q: क्यू uarantine [प्रभाव: 30 स्थानीय संक्रमित निकालें ]
O: O पेन बॉर्डर्स [प्रभाव: स्थानीय माइग्रेशन दर 10% बढ़ाएँ ]
B: B ऑर्डर बंद करें [प्रभाव: स्थानीय माइग्रेशन दर 10% घटाएं ]
T: बायो टी त्रुटिवाद [प्रभाव: कन्वर्ट 4 वैश्विक स्वस्थ करने के लिए संक्रमित ]
W: डब्ल्यू eaponization [प्रभाव: वैश्विक बढ़ाएँ संक्रमण दर 1 से, वैश्विक वृद्धि मारक दर 2%] द्वारा
D: डी वैश्विक बढ़ाएँ: issemination [प्रभाव संक्रमण दर1 से, वैश्विक वृद्धि संक्रामक रोग की दर 2%] द्वारा
P: पी acification [प्रभाव: वैश्विक घटाएँ संक्रमण दर 1 से, वैश्विक कमी संक्रामक रोग की दर 1% से, वैश्विक कमी मारक दर 1% से]

खेल खेलते हैं

सभी चरण

अमान्य आदेश = कुछ भी नहीं
पूर्णांक की तरह जोड़े जाते हैं, यानी 10% - 4% = 6%। जब किसी सूत्र में प्रतिशत लागू किया जाता है, तो परिणाम फ़्लोर्ड होता है।

चरण 1: उत्परिवर्तन

महामारी अधिक शक्तिशाली होती जा रही है। प्रत्येक बारी, यह इन विशेषताओं में से एक को बेतरतीब ढंग से हासिल करती है (यह उत्परिवर्तन एक ही बार में सभी खिलाड़ियों को प्रभावित करता है):

• वैश्विक संक्रमण दर को 2 से बढ़ाएं
• 5% की वैश्विक वृद्धि दर बढ़ाएँ
• वैश्विक सुस्ती दर 5% बढ़ाएँ

चरण 2: प्रजनन

हर पांच राउंड (राउंड 5, 10, 15 ...), नए नागरिकों का जन्म होगा। हेल्दी की हर जोड़ी एक हेल्दी बनाएगी (23 हेल्दी जेनरेट 11 न्यू हेल्दी )। संक्रमित की प्रत्येक जोड़ी एक संक्रमित कर देगी ।

चरण 3: प्रवासन

प्रत्येक मोड़, स्वस्थ और संक्रमित का एक प्रतिशत राज्यों को छोड़ देगा, उनके प्रवासन दर के आधार पर (10 स्वस्थ 100 स्वस्थ और 10% प्रवासन दर के साथ एक राज्य छोड़ देगा )। फिर, प्रवासियों को हर राज्य में वितरित किया जाएगा, एक बार फिर से प्रवासन दर के आधार पर । (प्रत्येक राज्य की दरें भारित होती हैं और प्रवासियों को उसके अनुसार वितरित किया जाता है)।

चरण 4: संक्रमण

प्रत्येक राज्य के स्वस्थ को संक्रमण दर के अनुसार, संक्रमित में बदल दिया जाता है ।

चरण 5: संसर्ग

कॉनटैगियन रेट के अनुसार प्रत्येक राज्य के स्वस्थ को संक्रमित कर दिया जाता है । संख्या की गणना कॉन्टैगियन दर द्वारा संक्रमित को गुणा करके की जाती है ।

चरण 6: विलुप्त होने

घातक दर के अनुसार संक्रमित को मृत में बदल दिया जाता है । संख्या की गणना घातक दर द्वारा संक्रमित को गुणा करके की जाती है ।

चरण 7: खिलाड़ी मुड़ते हैं

प्रत्येक खिलाड़ी इनपुट प्राप्त करता है और उसे तीन कार्यों को आउटपुट करना होता है, जो कि वे आउटपुट में निष्पादित होते हैं।

नियम

• बॉट को विशिष्ट अन्य बॉट को हरा या समर्थन करने के लिए नहीं लिखा जाना चाहिए।
• फाइलों को लिखने की अनुमति है। कृपया "yoursubmissionname.txt" पर लिखें, गेम शुरू होने से पहले फ़ोल्डर खाली कर दिया जाएगा। अन्य बाहरी संसाधन अस्वीकृत हैं।
• आपके प्रस्तुत करने के लिए प्रति उत्तर एक सेकंड (प्रति शहर) है।
• अपने सबमिशन को संकलित करने और चलाने के लिए कमांड प्रदान करें।

जीतना

50 राउंड के बाद सबसे स्वस्थ के साथ विजेता है । यदि कोई खिलाड़ी अंतिम जीवित है (0 से अधिक स्वस्थ या संक्रमित ) तो खेल रुक जाता है और वह जीत जाता है। यदि कई खिलाड़ियों के पास स्वस्थ राशि है , तो अधिकांश संक्रमित व्यक्ति जीत जाएगा, तो कम मृतकों वाला ।

नियंत्रक

आप GitHub पर नियंत्रक पा सकते हैं । इसमें तीन सैंपलबॉट भी शामिल हैं, जो जावा में लिखे गए हैं।
इसे चलाने के लिए, प्रोजेक्ट देखें और इसे अपने जावा आईडीई में खोलें। mainकक्षा की विधि में प्रवेश बिंदु Game। जावा 8 की आवश्यकता है।

बॉट्स जोड़ने के लिए, पहले आपको जावा (.class फ़ाइलों) के लिए संकलित संस्करण या व्याख्या की गई भाषाओं के स्रोतों की आवश्यकता होगी। उन्हें प्रोजेक्ट के रूट फ़ोल्डर में रखें। फिर, playersपैकेज में एक नया जावा वर्ग बनाएं (आप पहले से मौजूद बॉट्स पर उदाहरण ले सकते हैं)। इस वर्ग को Playerविधि को ओवरराइड करने के लिए लागू करना चाहिए String getCmd()। लौटाई गई स्ट्रिंग आपके बॉट्स को चलाने के लिए शेल कमांड है। आप उदाहरण के लिए इस आदेश के साथ रूबी बॉट काम कर सकते हैं return "C:\Ruby\bin\ruby.exe MyBot.rb";:। अंत में, वर्ग playersके शीर्ष पर सरणी में बॉट जोड़ें Game।

अंतिम परिणाम (2016-03-04 08:22 GMT)

वैश्विक (100 प्रतिष्ठा):

100 खेल परिणाम: http://pasted.co/942200ff

1. EvilBot (24, 249, 436)
2. Triage (23, 538, 486)
3. WICKED (23, 537, 489)
4. Israel (23, 40, 240)
5. InfectedTown (22, 736, 482)
6. ZombieState (22, 229, 369)
7. Mooch (22, 87, 206)
8. InfectedHaven (21, 723, 483)
9. Crossroads (16, 9, 136)
10. TheKeeper (3, 4, 138)
11. Terrorist (0, 595, 496)
12. InfectionBot (0, 511, 430)
13. FamilyValues (0, 6, 291)
14. UndecidedBot (0, 0, 20)
15. XenoBot (0, 0, 26)
16. Researcher (0, 0, 33)
17. Strategist (0, 0, 42)
18. TheCure (0, 0, 55)
19. Socialist (0, 0, 67)
20. TrumpBot (0, 0, 77)
21. CullBot (0, 0, 81)
22. BackStabber (0, 0, 87)
23. BlunderBot (0, 0, 104)
24. RemoveInfected (0, 0, 111)
25. PFC (0, 0, 117)
26. BioterroristBot (0, 0, 118)
27. PassiveBot (0, 0, 118)
28. Smaug (0, 0, 118)
29. WeaponOfMassDissemination (0, 0, 119)
30. AllOrNothing (0, 0, 121)
31. Obamacare (0, 0, 122)
32. DisseminationBot (0, 0, 123)
33. CureThenQuarantine (0, 0, 125)
34. Madagascar (0, 0, 129)
35. OpenAndClose (0, 0, 129)
36. ThePacifist (0, 0, 130)
37. MedicBot (0, 0, 131)
38. Medic (0, 0, 133)
39. Salt (0, 0, 134)
40. Piecemeal (0, 0, 136)
41. Graymalkin (0, 0, 137)
42. PureBot (0, 0, 140)
43. MadScienceBot (0, 0, 144)
44. BipolarBot (0, 0, 149)
45. RedCross (0, 0, 151)

प्रलय-कम (200 प्रतिष्ठा):

100 खेल परिणाम: http://pasted.co/220b575b

1. FamilyValues (5708, 14, 2)
2. BlunderBot (5614, 12, 3)
3. Graymalkin (5597, 17, 4)
4. PureBot (5550, 12, 5)
5. Crossroads (5543, 11, 4)
6. Salt (5488, 24, 7)
7. CureThenQuarantine (5453, 13, 7)
8. Piecemeal (5358, 121, 23)
9. TrumpBot (5355, 12, 5)
10. CullBot (5288, 12, 9)
11. AllOrNothing (5284, 13, 10)
12. Madagascar (5060, 180, 35)
13. TheKeeper (4934, 165, 44)
14. WICKED (4714, 25, 5)
15. Strategist (2266, 25, 5)
16. BackStabber (2180, 1327, 596)
17. RemoveInfected (2021, 33, 27)
18. OpenAndClose (1945, 667, 394)
19. Triage (1773, 401, 80)
20. TheCure (1465, 46, 26)
21. Obamacare (1263, 525, 247)
22. Mooch (1103, 546, 269)
23. Israel (1102, 580, 292)
24. RedCross (1086, 1700, 727)
25. ThePacifist (1069, 636, 580)
26. Researcher (1035, 113, 37)
27. UndecidedBot (825, 219, 93)
28. PassiveBot (510, 990, 567)
29. MedicBot (411, 1474, 667)
30. Medic (392, 1690, 619)
31. Socialist (139, 63, 90)
32. XenoBot (0, 82, 170)

आपकी भागीदारी के लिए सभी को धन्यवाद। मुझे आशा है कि आपके पास अपने बॉट्स को डिजाइन करने और कोडिंग करने में बहुत अच्छा समय था क्योंकि मैंने गेम चलाया था।

Comments

क्या हम एक ई xecute कमांड प्राप्त कर सकते हैं जो संक्रमित की एक्स राशि की हत्या करता है (उन्हें सीधे मृत कर देता है)? शायद जीतने के लिए एक व्यवहार्य तरीका नहीं है, लेकिन एक कार्रवाई जो वैध लगती है। जब तक कि क्वारंटाइन क्या नहीं करता (यह स्पष्ट नहीं है)।

— ड्रेको 18

त्वरित व्याकरण नोट: "साने" का अर्थ है "मानसिक रूप से स्थिर"; आप जिस शब्द (शायद) की तलाश में हैं वह "स्वस्थ" है। (क्या मैं यह अनुमान लगाने में सही रहूंगा कि आपकी पहली भाषा स्पेनिश है, जहां "सनो" का अर्थ "स्वस्थ," या कुछ और निकटता से है?)

— मेसन व्हीलर

@MasonWheeler Nitpicking शब्दावली नोट: आपका नोट एक शब्दावली या शब्दावली नोट था, जिसमें कोई भी व्याकरण शामिल नहीं था;)

— Jan

@ थ्रक्स जिस तरह से वर्तमान में संभाला जाता है (शुरुआत में यादृच्छिक रूप से, उसी समय से उसी क्रम पर), बाद में आने वाले खिलाड़ियों को एक बड़ा लाभ मिलता है, जो अंतिम परिणाम को बेतहाशा रूप देता है। शायद अगर आप 1) बारी-बारी से प्रत्येक क्रम को राउंड ऑर्डर करते हैं, या 2) हर कोई अपनी बारी के दौरान एक ही स्थिति को देखता है और राउंड के अंत में सभी को एक साथ परिवर्तन लागू करता है, तो परिणाम अधिक संतुलित हो सकते हैं, और आधारित हो सकते हैं प्रस्तुत करने की गुणवत्ता पर अधिक। मैंने पहले विकल्प का परीक्षण किया, और परिणाम बहुत अधिक सुसंगत हैं।

— Mwr247

@ थ्रैक्स वर्तमान में बॉट्स का अतिरेक है जो केवल "दुनिया को नष्ट करने" के लिए मौजूद हैं। हालांकि यह एक मजेदार चुनौती हो सकती है, यह उस बिंदु पर है जहां बॉट वास्तव में प्रतिस्पर्धा करने का प्रयास कर रहे हैं, अब इसे प्रभावी रूप से मुकाबला नहीं कर सकते हैं, और हम विजेता के रूप में अंत में "क्योर एक्स 3" के लिए जो भी बॉट प्रोग्राम किए जाते हैं, उसके साथ छोड़ दिए जाते हैं। मैं एक नियम परिवर्तन का सुझाव देना चाहूंगा, जहां कोठ के लिए विचार करने के लिए, पैसिवबोट के खिलाफ 1-ऑन -1 मैच में सकारात्मक "संन्यास" के साथ बॉट को कम से कम सक्षम होने की आवश्यकता है? जब रणनीति वास्तव में प्रभाव डालती है तो चुनौती अधिक मजेदार होती है।

— Mwr247

Answer 1

पारिवारिक मूल्य, नोड (ES6)

// Process input
var data = process.argv[2].split(';');
var round = data.shift()*1;
var id = data.shift()*1;
var playerCount = data.length;
var local = data.find(function(v) {
  return !v.indexOf(id+'_')}
).split('_');
local = {
  sane: local[1]*1,
  infected: local[2]*1,
  dead: local[3]*1,
  infectionRate: local[4]*1,
  contagionRate: local[5]*1,
  lethalityRate: local[6]*1,
  migrationRate: local[7]*1
};

// Determine response
var response = [];
for(var i=0;i<3;i++) {
  var model = {
    M: local.infectionRate,
    E: local.contagionRate * (local.sane > 0 ? 1 : 0.5),
    I: local.lethalityRate * (round > 45 ? 0 : local.sane > 0 ? 1 : 2),
    V: (local.infectionRate/4 + local.contagionRate/2 + local.lethalityRate/2) * (round > 45 ? 0 : 1),
    C: local.infected / Math.max(local.infectionRate, 1) * (round > 48 ? round : local.infectionRate + local.contagionRate/100 * local.infected < (3 - i) * 10 ? 1 : 0),
    B: local.migrationRate * 10
  };
  var max = 'M';
  for(k in model) {
    if (model[k] > model[max] ) {
      max = k;
    } else if(model[k] == model[max]) {
      max = [max, k][Math.random()*2|0];
    }
  }
  response.push(max);

  // Refactor priorities
  if(max == 'M') {
    local.infectionRate -= 4;
  } else if(max == 'E') {
    local.contagionRate -= 8;
  } else if(max == 'I') {
    local.lethalityRate -= 4;
  } else if(max == 'V') {
    local.infectionRate -= 1;
    local.contagionRate -= 4;
    local.lethalityRate -= 2;
  } else if(max == 'C') {
    local.infected -= 10;
  } else if(max == 'B') {
    local.migrationRate -= 10;
  }
}

// Respond with actions
process.stdout.write(response.join(''));

पारिवारिक मूल्य आत्म-संरक्षण और रक्षा का ध्यान केंद्रित करते हैं, और केवल उस अंत तक कार्रवाई करते हैं। यह कार्रवाई के सर्वोत्तम पाठ्यक्रम को निर्धारित करने के लिए एक बिंदु-मूल्य प्रणाली का उपयोग करता है, और फिर यह बेहतर है कि यह अगली प्राथमिकता निर्धारित करने के लिए बेहतर स्थिति मानों को समायोजित करता है। एक टाई की स्थिति में, यह बेतरतीब ढंग से सर्वश्रेष्ठ विकल्पों में से चुनता है।

संपादित करें: ऐसा लगता है कि अब तक ठीक हो रहा है:

    ********** FINISH **********
    1. FamilyValues (1143, 0, 188)
    2. Triage (582, 0, 158)
    3. Researcher (281, 0, 142)
    4. Madagascar (149, 0, 162)
    5. Mooch (148, 0, 331)
    6. MedicBot (142, 0, 161)
    7. Medic (66, 65, 211)
    8. XenoBot (0, 0, 22)
    9. WMDbot (0, 0, 218)
    10. PassiveBot (0, 0, 221)
    11. BioterroristBot (0, 0, 221)
    12. MadScienceBot (0, 0, 221)
    13. DisseminationBot (0, 0, 221)
    14. TheCure (0, 0, 222)

---

द पैसिफिस्ट, नोड

// Process input
var data = process.argv[2].split(';');
var round = data.shift()*1;

// Respond with actions
process.stdout.write(round == 1 ? 'OOO' : 'PPP');

हत्या और मौत पर इतना ध्यान देने के साथ, पेसिफिस्ट का मानना ​​है कि मजबूत वैश्विक स्वास्थ्य का मतलब मजबूत स्थानीय स्वास्थ्य है। जैसे, वे बहुत अधिक सिर्फ वैश्विक बीमारी को कम करने पर ध्यान केंद्रित करते हैं, जबकि सीमाओं को आंशिक रूप से खुला छोड़ देते हैं जिससे कि अच्छाई फैल सके।

Comments

वाह, मुझे उम्मीद नहीं थी कि TheCure आखिरी होगा

— बजे

@ अन्याय इस कई खिलाड़ियों के साथ, वे सभी अंत में बोर्डों पर एक-दूसरे के चारों ओर बढ़ रहे हैं: बस एक अब भाग गया जहां TheCure 3 में समाप्त हो गया। फैमिलीवैल्यूज़ और ट्राइएज दोनों ही लगभग हमेशा शीर्ष दो में रहते हैं, हालांकि एफवी को ज्यादातर समय # 1 ही मिलता है।

— Mwr247

हम्म, कार्य ही नियतात्मक है, है ना? तो क्या यह कुछ खिलाड़ियों द्वारा उनके एल्गोरिथ्म में यादृच्छिकता डालने के कारण है?

— जस्टफुल

@ अन्याय अब तक का सबसे बड़ा कारक टर्न ऑर्डर प्रतीत होता है, जिसे यादृच्छिक रूप से (लेकिन एक गेम में हर दौर के लिए समान) किया जाता है। पहले जाने का मतलब है कि आपके पास वर्तमान मोड़ के दौरान हर किसी के कार्यों पर प्रतिक्रिया करने का कोई मौका नहीं है, जबकि अंतिम बार जाने से आपको अन्य खिलाड़ियों के साथ आपके द्वारा किए गए सर्वोत्तम समायोजन की अनुमति मिलती है।

— Mwr247

@ अन्याय मुझे सिर्फ एक संशोधित नियंत्रक का परीक्षण करना है जो प्रत्येक दौर के लिए बारी क्रम को यादृच्छिक करता है, और परिणाम अब बहुत अधिक सुसंगत हैं।

— Mwr247

Answer 2

TrumpBot

private void sleep(String[] args) {

    round = Integer.parseInt(args[0]);
    thisTownID = Integer.parseInt(args[1]);

    states = new ArrayList<>();
    //states.add(new State(args[thisTownID+2]));

    otherStates = new ArrayList<>();


    for (int i = 2; i < args.length; i++){
        states.add(new State(args[i]));
    }

    for (State state : states){
        if (state.ownerId == thisTownID) {
            thisState = state;
        } else {
            otherStates.add(state);
        }
    }

    StringBuilder cmd = new StringBuilder();

    for (int j =0;j<3;j++){
        if (thisState.infected > 7) {
          if (thisState.infected > 25){
            cmd.append("Q");
            thisState.infected -= 30;
          }
          else {
            cmd.append("C");
            thisState.infected -= 10;
          }
        }
        else if (thisState.migrationRate > 2) {
          cmd.append("B");
          thisState.migrationRate -= 10;
        }
        else if (thisState.infectionRate > 4) {
          cmd.append("M");
          thisState.infectionRate  -= 4;
        }
        else if (thisState.contagionRate > 10 || thisState.lethalityRate > 6 || thisState.infectionRate > 0) {
          cmd.append("V");
          thisState.contagionRate  -= 4;
          thisState.lethalityRate  -= 2;
          thisState.infectionRate  -= 1;
        }

        else if (thisState.infected % 10 <= 6){
          cmd.append("T");
          thisState.infected +=4;
        }
        else cmd.append("V");
    }
    System.out.print(cmd.reverse());
}

सभी संक्रमित लोगों का इलाज करके अमेरिका को महान बनाता है जब तक कि केवल 2 या उससे कम न हों; अल्पसंख्यकों की अनदेखी होगी।

कम संक्रमण होने से दवा सस्ती हो जाती है।

आप्रवासियों की आवश्यकता नहीं है - वे केवल संक्रमण लाते हैं।

अगर करने के लिए कुछ नहीं बचा है, तो दूसरे खिलाड़ियों पर बम बरसाएँ।

अमेरिकी तरीके से उलट आदेश, बम पहले लोगों को बाद में ठीक करता है।

संपादित करें: एक बग को ठीक किया गया है जो कि ठीक हो जाएगा क्योंकि संक्रमित गणना इलाज के बाद कम नहीं हुई थी।

Trumpscript

इसे उपलब्ध कराने के लिए J Atkin का धन्यवाद:

Make turn 4000000
As long as, turn larger than 1000000;:
If, refugee count > 2000000;: say "C"!
Else if, infectionRate > 200000;: say "M"!
Else if, immigration rate > 9000000;: say "B"!
Else: say "T"!
Make turn old turn - 1000000!
America is Great. 

Answer 3

ऑलऑर्नरिंग, आर

args <- strsplit(commandArgs(TRUE),";")[[1]]
round <- as.integer(args[1])
me <- as.integer(args[2])
stats <- do.call(rbind,strsplit(args[-(1:2)],"_"))
stats <- as.data.frame(apply(stats,2,as.integer))
colnames(stats) <- c("id","Sane","Infected","Dead","InfRate","ContRate","LethRate","MigRate")
out <- ""
statme <- stats[stats$id==me,]
while(nchar(out)<3){
    if(round==1 & !nchar(out)){
        out <- paste0(out, "B")
    }else if(round%%5==4 & statme$Infected > 20){
        statme$Infected <- statme$Infected - 30
        out <- paste0(out, "Q")
    }else if(statme$Sane*statme$InfRate/100 >= 1){
        o <- ifelse(statme$Sane*statme$InfRate/100 < statme$Infected*statme$ContRate/100, "C", "M")
        if(o=="C") statme$Infected <- statme$Infected - 10
        if(o=="M") statme$InfRate <- statme$InfRate - 4
        out <- paste0(out, o)
    }else if(statme$Infected > 0){
        statme$Infected <- statme$Infected - 10
        out <- paste0(out, "C")
    }else if(median(stats$LethRate)<20){ 
        out <- paste0(out, "W")
    }else{
        out <- paste0(out, "E")     
    }
}
cat(substr(out,1,3))

द्वारा मंगवाया गया Rscript AllOrNothing.R।

यह विचार एक तरफ संक्रमण के जोखिम को कम करने के लिए है (संक्रमण दर को कम करके, संक्रमित को ठीक करके और संक्रमित को संक्रमित करने से रोकना) और दूसरी तरफ बीमारी की घातकता को बढ़ाने के लिए ताकि लोगों को ऐसा न हो संक्रमित, दूसरों को दूषित करने से पहले मर जाते हैं।

संपादित करें: रणनीति को थोड़ा छोटा किया।

Comments

अच्छा लगा, यह 21 अन्य राज्यों के मुकाबले असाधारण रूप से अच्छा कर रहा है!

— थ्रैक्स

@ थ्रैक्स वास्तव में, हालांकि कभी-कभी, कुछ रनों के दौरान, यह अभी भी काफी प्रभावशाली रूप से विफल रहता है :) लेकिन अक्सर यह आपके टेस्ट रन के रूप में सफल होता है।

— प्लेनैपस

काफी अद्भुत बॉट, अच्छा काम thats

— Eumel

यह उस स्थिति से बहुत मिलता-जुलता है जो मैं लिखने जा रहा था जब मुझे समय मिला, यदि समान नहीं था। मेरा केवल मेरे सिर में मौजूद है, हालांकि ("यदि 20ish संक्रमित हैं, तो उन्हें संगरोध करें, यदि 10ish, उन्हें ठीक करें, आदि") तो अच्छा काम है।

— ड्रेको 18

Answer 4

चिकित्सक

चिकित्सा हमेशा से थी ... परेशान , इसलिए बोलने के लिए, बिना दवा के लोगों द्वारा। वह चिकित्सा का अभ्यास करना पसंद करता है, इसलिए वह यही करता है। उन्हें अजगर भी पसंद हैं, इसलिए उन्होंने पायथन में अपना कोड लिखा। यह सब समझ में आता है, अगर आप इसके बारे में सोचते हैं। _{नहीं, यह वास्तव में नहीं है। ^{दरअसल, यह थोड़े करता है ...}}

from random import *
commands = ""
while len(commands) < 3:
    chance = random()
    if chance < .5: commands += "V"
    elif chance < .66: commands += "I"
    elif chance < .84: commands += "E"
    else: commands += "M"

print(commands)

मैं यहां मदद के लिए हूं।

Comments

Asclepius की छड़ी के रूप में अजगर? या हेमीज़ के कर्मचारियों के रूप में? यह कुछ समझ में आता है ...

— नहीं कि चार्ल्स

या तो! दोनों! क्यों नहीं? इस सब का एक अर्थ है!

— कॉनर ओ'ब्रायन

++ 1; टीएफ 2 के लिए: डी

— बिल्ली

Answer 5

इलाज

यह थोड़ा बहुत सरलीकृत लगता है, लेकिन यह संक्रमण / मृत्यु दर को कम रखने के लिए एक बहुत अच्छी विधि भी है। हर मोड़ पर, आउटपुट MCQ:

• संक्रमण दर को कम करें
• कुछ संक्रमित का इलाज करें
• शेष संक्रमित में से कुछ को संगरोध करें

बस!

public class TheCure{
    public static void main(String[]a){
        System.out.println("MCQ");
    }
}

मैं शायद इसे अधिक M(या B) आउटपुट करके सुधार सकता हूं यदि मेरे पास वर्तमान में इलाज और संगरोध के बजाय कोई संक्रमित नहीं है, लेकिन मैं यह देखना चाहता हूं कि यह पहले कितना अच्छा है। दुर्भाग्य से, पहले पोस्टिंग का एक पक्ष प्रभाव यह है कि प्रभावशीलता को मापना मुश्किल है:

Answer 6

विकेड, कोटलिन

याद रखें, WICKED अच्छा है।

package wicked

import java.util.*

fun clamp(value : Double, floor : Double, ceil : Double = Double.POSITIVE_INFINITY) = Math.max(Math.min(value, ceil), floor)
fun clamp(value : Int, floor : Int, ceil : Int = Integer.MAX_VALUE) = Math.max(Math.min(value, ceil), floor)

data class Player(
        val id            : Int,
        var healthy          : Int,
        var infected      : Int,
        var dead          : Int,
        var infectionRate : Int,
        var contagionRate : Double,
        var lethalityRate : Double,
        var migrationRate : Double)

class Game(val players : List<Player>) {

    fun doAction(playerId: Int, a: Char) {
        val player = players.first { it.id == playerId }
        with(player) {
            when (a) {
                'N' -> {}
                'M' -> infectionRate = clamp(infectionRate - 4, 0)
                'E' -> contagionRate = clamp(contagionRate - .08, 0.0, 1.0)
                'I' -> lethalityRate = clamp(lethalityRate - .04, 0.0, 1.0)
                'V' -> {
                    infectionRate = clamp(infectionRate - 1, 0)
                    contagionRate = clamp(contagionRate - .04, 0.0, 1.0)
                    lethalityRate = clamp(lethalityRate - .02, 0.0, 1.0)
                }
                'C' -> {
                    val cured = Math.min(infected, 10)
                    infected -= cured
                    healthy += cured
                }
                'Q' -> infected = clamp(infected - 30, 0)
                'O' -> migrationRate = clamp(migrationRate + .1, 0.0, 1.0)
                'B' -> migrationRate = clamp(migrationRate - .1, 0.0, 1.0)
                'T' -> {
                    players.forEach {
                        val infected = Math.min(it.healthy, 4)
                        it.healthy -= infected
                        it.infected += infected
                    }
                }
                'W' -> {
                    players.forEach {
                        it.infectionRate++
                        it.lethalityRate = clamp(it.lethalityRate + .02, 0.0, 1.0)
                    }
                }
                'D' -> {
                    players.forEach {
                        it.infectionRate++
                        it.contagionRate = clamp(it.contagionRate + .02, 0.0, 1.0)
                    }
                }
                'P' -> {
                    players.forEach {
                        it.infectionRate = clamp(it.infectionRate - 1, 0)
                        it.contagionRate = clamp(it.contagionRate - .01, 0.0, 1.0)
                        it.lethalityRate = clamp(it.lethalityRate - .01, 0.0, 1.0)
                    }
                }
                else -> throw IllegalArgumentException("Invalid action: $a")
            }
        }
    }

    fun copy() = Game(players.map { it.copy() })

    fun migration() {
        var migratingHealthy = 0
        var migratingInfected = 0
        var totalMigratingWeight = 0.0

        players.forEach {
            migratingHealthy += (it.healthy * it.migrationRate).toInt()
            migratingInfected += (it.infected * it.migrationRate).toInt()
            totalMigratingWeight += it.migrationRate

            it.healthy = (it.healthy * (1 - it.migrationRate)).toInt()
            it.infected *= (it.healthy * (1 - it.migrationRate)).toInt()
        }

        players.forEach {
            it.healthy += (migratingHealthy * it.migrationRate / totalMigratingWeight).toInt()
            it.infected += (migratingInfected * it.migrationRate / totalMigratingWeight).toInt()
        }
    }

    fun infection() {
        players.forEach {
            val infected = it.infectionRate //Allow negative healthy.
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun contagion() {
        players.forEach {
            val infected = (it.infected * it.contagionRate).toInt()
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun extinction() {
        players.forEach {
            val killed = (it.infected * it.lethalityRate).toInt()
            it.infected -= killed
            it.dead += killed
        }
    }

    operator fun get(playerId : Int) = players.first { it.id == playerId }

    fun calculateBenefit(action : Char, myId: Int) : Int {

        val copy1 = copy()
        copy1.doAction(myId, action)

        copy1.migration()
        copy1.infection()
        copy1.contagion()
        copy1.extinction()

        return copy1[myId].healthy
    }

}

fun main(args : Array<String>) {
    @Suppress("NAME_SHADOWING")
    val args = args[0].split(';')

    val round = args[0].toInt()
    val myId = args[1].toInt()

    val players : MutableList<Player> = ArrayList()

    for ( i in 2..args.size-1) {
        val data = args[i].split('_')
        players.add(Player(data[0].toInt(), data[1].toInt(), data[2].toInt(), data[3].toInt(), data[4].toInt(), data[5].toDouble() / 100, data[6].toDouble() / 100, data[7].toDouble() / 100))
    }

    val currentGame = Game(players)

    if (round == 50) {
        println("CCC")  //Extra 30 at end of game.
        return
    }

    for (i in 1..3) {
        val action = determineBestAction(currentGame, myId)
        currentGame.doAction(myId, action)
        print(action)
    }
}

fun determineBestAction(game : Game, myId : Int) : Char {

    if (game[myId].lethalityRate > .02) {        //Save the executives!!!
        return 'I'
    } else if (game[myId].lethalityRate > 0) {
        return 'V'
    }

    val bestAction = "NMEIVQCOBP".maxBy { game.calculateBenefit(it, myId) }!!

    return bestAction

}

इसके साथ संकलित करें: साथ चलें kotlinc WICKED.kt
:kotlin wicked.WICKEDKt

पीएफसी, कोटलिन

बीमारी को सभी पर छोड़ने का प्रयास।

package pfc

import java.util.*

fun clamp(value : Double, floor : Double, ceil : Double = Double.POSITIVE_INFINITY) = Math.max(Math.min(value, ceil), floor)
fun clamp(value : Int, floor : Int, ceil : Int = Integer.MAX_VALUE) = Math.max(Math.min(value, ceil), floor)

data class Player(
        val id            : Int,
        var healthy          : Int,
        var infected      : Int,
        var dead          : Int,
        var infectionRate : Int,
        var contagionRate : Double,
        var lethalityRate : Double,
        var migrationRate : Double)

class Game(val players : List<Player>) {

    fun doAction(playerId: Int, a: Char) {
        val player = players.first { it.id == playerId }
        with(player) {
            when (a) {
                'N' -> {}
                'M' -> infectionRate = clamp(infectionRate - 4, 0)
                'E' -> contagionRate = clamp(contagionRate - .08, 0.0, 1.0)
                'I' -> lethalityRate = clamp(lethalityRate - .04, 0.0, 1.0)
                'V' -> {
                    infectionRate = clamp(infectionRate - 1, 0)
                    contagionRate = clamp(contagionRate - .04, 0.0, 1.0)
                    lethalityRate = clamp(lethalityRate - .02, 0.0, 1.0)
                }
                'C' -> {
                    val cured = Math.min(infected, 10)
                    infected -= cured
                    healthy += cured
                }
                'Q' -> infected = clamp(infected - 30, 0)
                'O' -> migrationRate = clamp(migrationRate + .1, 0.0, 1.0)
                'B' -> migrationRate = clamp(migrationRate - .1, 0.0, 1.0)
                'T' -> {
                    players.forEach {
                        val infected = Math.min(it.healthy, 4)
                        it.healthy -= infected
                        it.infected += infected
                    }
                }
                'W' -> {
                    players.forEach {
                        it.infectionRate++
                        it.lethalityRate = clamp(it.lethalityRate + .02, 0.0, 1.0)
                    }
                }
                'D' -> {
                    players.forEach {
                        it.infectionRate++
                        it.contagionRate = clamp(it.contagionRate + .02, 0.0, 1.0)
                    }
                }
                'P' -> {
                    players.forEach {
                        it.infectionRate = clamp(it.infectionRate - 1, 0)
                        it.contagionRate = clamp(it.contagionRate - .01, 0.0, 1.0)
                        it.lethalityRate = clamp(it.lethalityRate - .01, 0.0, 1.0)
                    }
                }
                else -> throw IllegalArgumentException("Invalid action: $a")
            }
        }
    }

    fun copy() = Game(players.map { it.copy() })

    fun migration() {
        var migratingHealthy = 0
        var migratingInfected = 0
        var totalMigratingWeight = 0.0

        players.forEach {
            migratingHealthy += (it.healthy * it.migrationRate).toInt()
            migratingInfected += (it.infected * it.migrationRate).toInt()
            totalMigratingWeight += it.migrationRate

            it.healthy = (it.healthy * (1 - it.migrationRate)).toInt()
            it.infected *= (it.healthy * (1 - it.migrationRate)).toInt()
        }

        players.forEach {
            it.healthy += (migratingHealthy * it.migrationRate / totalMigratingWeight).toInt()
            it.infected += (migratingInfected * it.migrationRate / totalMigratingWeight).toInt()
        }
    }

    fun infection() {
        players.forEach {
            val infected = Math.min(it.healthy, it.infectionRate)
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun contagion() {
        players.forEach {
            val infected = Math.min(it.healthy, (it.infected * it.contagionRate).toInt())
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun extinction() {
        players.forEach {
            val killed = (it.infected * it.lethalityRate).toInt()
            it.infected -= killed
            it.dead += killed
        }
    }

    operator fun get(playerId : Int) = players.first { it.id == playerId }

    fun calculateBenefit(action : Char, myId: Int) : Int {

        val copy1 = copy()
        copy1.doAction(myId, action)

        copy1.migration()
        copy1.infection()
        copy1.contagion()
        copy1.extinction()

        return copy1.players.sumBy { it.infected }
    }

}

fun main(args : Array<String>) {
    @Suppress("NAME_SHADOWING")
    val args = args[0].split(';')

    @Suppress("UNUSED_VARIABLE")
    val round = args[0].toInt()
    val myId = args[1].toInt()

    val players : MutableList<Player> = ArrayList()

    for ( i in 2..args.size-1) {
        val data = args[i].split('_')
        players.add(Player(data[0].toInt(), data[1].toInt(), data[2].toInt(), data[3].toInt(), data[4].toInt(), data[5].toDouble() / 100, data[6].toDouble() / 100, data[7].toDouble() / 100))
    }

    val currentGame = Game(players)

    for (i in 1..3) {
        val action = determineBestAction(currentGame, myId)
        currentGame.doAction(myId, action)
        print(action)
    }
}

fun determineBestAction(game : Game, myId : Int) : Char {

    val bestAction = "NMEIVCQOBTWDP".maxBy { game.calculateBenefit(it, myId) }!!

    return bestAction

}

इसके साथ संकलित करें: साथ चलें kotlinc PFC.kt
:kotlin pfc.PFCKt

आतंकवादी, कोटलिन

सभी लोगों को मृत बनाने की कोशिश करता है।

package terrorist

import java.util.*

fun clamp(value : Double, floor : Double, ceil : Double = Double.POSITIVE_INFINITY) = Math.max(Math.min(value, ceil), floor)
fun clamp(value : Int, floor : Int, ceil : Int = Integer.MAX_VALUE) = Math.max(Math.min(value, ceil), floor)

data class Player(
        val id            : Int,
        var healthy          : Int,
        var infected      : Int,
        var dead          : Int,
        var infectionRate : Int,
        var contagionRate : Double,
        var lethalityRate : Double,
        var migrationRate : Double)

class Game(val players : List<Player>) {

    fun doAction(playerId: Int, a: Char) {
        val player = players.first { it.id == playerId }
        with(player) {
            when (a) {
                'N' -> {}
                'M' -> infectionRate = clamp(infectionRate - 4, 0)
                'E' -> contagionRate = clamp(contagionRate - .08, 0.0, 1.0)
                'I' -> lethalityRate = clamp(lethalityRate - .04, 0.0, 1.0)
                'V' -> {
                    infectionRate = clamp(infectionRate - 1, 0)
                    contagionRate = clamp(contagionRate - .04, 0.0, 1.0)
                    lethalityRate = clamp(lethalityRate - .02, 0.0, 1.0)
                }
                'C' -> {
                    val cured = Math.min(infected, 10)
                    infected -= cured
                    healthy += cured
                }
                'Q' -> infected = clamp(infected - 30, 0)
                'O' -> migrationRate = clamp(migrationRate + .1, 0.0, 1.0)
                'B' -> migrationRate = clamp(migrationRate - .1, 0.0, 1.0)
                'T' -> {
                    players.forEach {
                        val infected = Math.min(it.healthy, 4)
                        it.healthy -= infected
                        it.infected += infected
                    }
                }
                'W' -> {
                    players.forEach {
                        it.infectionRate++
                        it.lethalityRate = clamp(it.lethalityRate + .02, 0.0, 1.0)
                    }
                }
                'D' -> {
                    players.forEach {
                        it.infectionRate++
                        it.contagionRate = clamp(it.contagionRate + .02, 0.0, 1.0)
                    }
                }
                'P' -> {
                    players.forEach {
                        it.infectionRate = clamp(it.infectionRate - 1, 0)
                        it.contagionRate = clamp(it.contagionRate - .01, 0.0, 1.0)
                        it.lethalityRate = clamp(it.lethalityRate - .01, 0.0, 1.0)
                    }
                }
                else -> throw IllegalArgumentException("Invalid action: $a")
            }
        }
    }

    fun copy() = Game(players.map { it.copy() })

    fun migration() {
        var migratingHealthy = 0
        var migratingInfected = 0
        var totalMigratingWeight = 0.0

        players.forEach {
            migratingHealthy += (it.healthy * it.migrationRate).toInt()
            migratingInfected += (it.infected * it.migrationRate).toInt()
            totalMigratingWeight += it.migrationRate

            it.healthy = (it.healthy * (1 - it.migrationRate)).toInt()
            it.infected *= (it.healthy * (1 - it.migrationRate)).toInt()
        }

        players.forEach {
            it.healthy += (migratingHealthy * it.migrationRate / totalMigratingWeight).toInt()
            it.infected += (migratingInfected * it.migrationRate / totalMigratingWeight).toInt()
        }
    }

    fun infection() {
        players.forEach {
            val infected = Math.min(it.healthy, it.infectionRate)
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun contagion() {
        players.forEach {
            val infected = Math.min(it.healthy, (it.infected * it.contagionRate).toInt())
            it.healthy -= infected
            it.infected += infected
        }
    }

    fun extinction() {
        players.forEach {
            val killed = (it.infected * it.lethalityRate).toInt()
            it.infected -= killed
            it.dead += killed
        }
    }

    operator fun get(playerId : Int) = players.first { it.id == playerId }

    fun calculateBenefit(action : Char, myId: Int) : Int {

        val copy1 = copy()
        copy1.doAction(myId, action)

        copy1.migration()
        copy1.infection()
        copy1.contagion()
        copy1.extinction()

        return copy1.players.sumBy { it.dead }
    }

}

fun main(args : Array<String>) {
    @Suppress("NAME_SHADOWING")
    val args = args[0].split(';')

    @Suppress("UNUSED_VARIABLE")
    val round = args[0].toInt()
    val myId = args[1].toInt()

    val players : MutableList<Player> = ArrayList()

    for ( i in 2..args.size-1) {
        val data = args[i].split('_')
        players.add(Player(data[0].toInt(), data[1].toInt(), data[2].toInt(), data[3].toInt(), data[4].toInt(), data[5].toDouble() / 100, data[6].toDouble() / 100, data[7].toDouble() / 100))
    }

    if (round == 50) {
        println("TTT")  //Let's mess up the scoreboard :D
        return
    }

    val currentGame = Game(players)
    for (i in 1..3) {
        val action = determineBestAction(currentGame, myId)
        currentGame.doAction(myId, action)
        print(action)
    }
}

fun determineBestAction(game : Game, myId : Int) : Char {

    if (game[myId].lethalityRate > .02) {          //We don't want to hurt ourselves.
        return 'I'
    } else if (game[myId].lethalityRate > 0) {
        return 'V'
    }

    val bestAction = "NMEIVCQOBTWDP".maxBy { game.calculateBenefit(it, myId) }!!

    return bestAction

}

इसके साथ संकलित करें: साथ चलें kotlinc Terrorist.kt
:kotlin terrorist.TerroristKt

Comments

संकलन मुझे गेम, प्लेयर, और विकटकट कक्षाओं के साथ "दुष्ट" फ़ोल्डर देता है। आपके द्वारा बताए गए रिटर्न के अनुसार दौड़ना: "त्रुटि: मुख्य वर्ग को दुष्ट नहीं मिला या लोड नहीं कर सका।

— विकट।

यह अजीब है, यह मेरे कंप्यूटर पर ठीक काम करता है। क्या आप सुनिश्चित हैं कि WICKEDkt वर्ग फ़ाइल को वास्तव में WICKEDKt नाम नहीं दिया गया है? इसके अलावा, सुनिश्चित करें कि आपकी कार्यशील निर्देशिका दुष्ट फ़ोल्डर के अंदर नहीं है।

— TheNumberOne

यह WICKEDKt है। मैंने टिप्पणी में टाइप किया।

— मकार

@ Mwr247 क्या आपने प्रस्तुत फ़ोल्डर के अंदर उत्पन्न दुष्ट फ़ोल्डर को छोड़ दिया है? क्या आपने दुष्ट फ़ोल्डर से उत्पन्न फ़ाइलों को स्थानांतरित किया है?

— TheNumberOne

WICKED अच्छा है ... लानत है आपके और आपके द्वारा पढ़ी गई चीजों के संदर्भ में।

— आर्टऑफकोड

Answer 7

मेडागास्कर, जावा

हां, मेडागास्कर मार्ग जा रहा है। पहला दौर, हम BBBअपनी सीमाओं को बंद करते हैं। अन्यथा, यह एक इलाज देता है, और स्थानीय टीकों पर ध्यान केंद्रित करता है।

public class Madagascar{
    public static void main(String[]args){
        Boolean bool = false;
        bool = args[0].startsWith("1;");

        if(bool) {
            System.out.println("BBB");
        }
        else {
            System.out.println("CVV");
        }
    }
}

_{Edit1 - मैं और मेडागास्कर को
Edit2 - धन्यवाद @ startsWithअनुस्मारक के लिए धन्यवाद}

Comments

अगर Geobits 5 पर शुरू होने वाली माइग्रेशन दर के बारे में सही है और शून्य के लिए reducible नहीं है, तो बी बिल्कुल कुछ नहीं करते हैं।

— क्विंटोपिया

यह वर्तमान में ऐसा नहीं लगेगा क्योंकि यह संकलन करेगा। if (b == true)(जो if (b)शैली के रूप में होना चाहिए ) एक त्रुटि देगा क्योंकि चर वास्तव में कहा जाता है bool।

— पीटर टेलर

यदि फ़ाइल के निर्माण की तुलना में राउंड == 1 के खिलाफ जांच करना बेहतर होता है?

— Eumel

@TimmyD सौभाग्य से, राउंड पहले है, इसलिए ज्यादा पार्सिंग शामिल नहीं है। बस जाँच करें कि क्या इनपुट के साथ शुरू होता है1;

— Geobits

@Geobits startsWith()अनुस्मारक के लिए धन्यवाद । MUCH को विभाजित करने ;और हटाए जाने की कोशिश करने की तुलना में आसान है और ... बताया कि मैं जावा के साथ जंग खा रहा था।

— AdBBorkBork

Answer 8

नमक, कोटलिन

यह बॉट तब तक जीवित रहता है जब तक सभी खराब खिलाड़ी मर नहीं जाते। उसके बाद, यह अपनी आबादी को ठीक करता है और स्वस्थ लोगों के साथ शहर को फिर से खोल देता है।

इस बॉट में 5 चरण हैं:

1. सीमाओं को बंद करें।
2. संक्रमित को मरने की अनुमति दें, लेकिन बहुत जल्दी नहीं (यह पता लगाना कि कितनी जल्दी बहुत कठिन हिस्सा है)।
3. स्वस्थ को संक्रमित करने से संक्रमित को रोकें।
4. संक्रमित को ठीक करें (नमक के साथ: पी)।
5. प्रजनन करते हैं।

यह रहा:

package salt

import java.io.File
import java.util.*

data class Player(
        val id            : Int,
        var healthy       : Int,
        var infected      : Int,
        var dead          : Int,
        var infectionRate : Int,
        var contagionRate : Int,
        var lethalityRate : Int,
        var migrationRate : Int)

fun main(args : Array<String>) {
    @Suppress("NAME_SHADOWING")
    val args = args[0].split(';')

    val round = args[0].toInt()
    val myId = args[1].toInt()

    val players : MutableList<Player> = ArrayList()

    for ( i in 2..args.size-1) {
        val data = args[i].split('_')
        players.add(Player(data[0].toInt(), data[1].toInt(), data[2].toInt(), data[3].toInt(), data[4].toInt(), data[5].toInt(), data[6].toInt(), data[7].toInt()))
    }

    if (round == 50) {
        println("CCC")  //Extra 30 at end of game.
        return
    }

    var actionsLeft = 3

    val me = players.first { it.id == myId }
    val dataFile = File("Salt.txt")
    val lastRoundInfected : Int
    var roundsInHole : Int
    if (round == 1) {
        lastRoundInfected = 1
        roundsInHole = 0
    } else {
        val lines = dataFile.readLines()
        lastRoundInfected = lines[0].toInt()
        roundsInHole = lines[1].toInt()
    }

    val wantedInfected = lastRoundInfected * Math.pow(1/1.5, 1.0/5) * (if (round % 5 == 0 && round != 0) 1.5 else 1.0)

    while (me.migrationRate > 0) {
        print('B')          //Close borders
        me.migrationRate = Math.max(0, me.migrationRate - 10)
        actionsLeft--
    }

    if (me.infected <= wantedInfected) {   //Our infected are dieing too quickly
        roundsInHole++
    } else {
        roundsInHole = Math.max(0, roundsInHole - 1)
    }

    if (me.lethalityRate > 0) {
        var lethalityRateDelta = roundsInHole * 2
        while (lethalityRateDelta > 0 && me.lethalityRate > 0 && actionsLeft > 0) {
            if (lethalityRateDelta == 2 || me.lethalityRate <= 2) {
                lethalityRateDelta -= 2
                print('V')  //Research vaccines
                me.infectionRate = Math.max(0, me.infectionRate - 1)
                me.contagionRate = Math.max(0, me.contagionRate - 4)
                me.lethalityRate = Math.max(0, me.lethalityRate - 2)
                actionsLeft--
            } else {
                lethalityRateDelta -= 4
                print('I')
                me.lethalityRate = Math.max(0, me.lethalityRate - 4)
                actionsLeft--
            }
        }
    }

    dataFile.writeText("${me.infected}\n$roundsInHole")

    while (actionsLeft > 0) {
        if (me.infectionRate + me.contagionRate * me.infected / 100 <= 0) {
            break
        }
        val mWeight = Math.min(me.infectionRate, 4)
        val eWeight = Math.min(me.contagionRate, 8) * me.infected / 100
        val vWeight = Math.min(me.contagionRate, 4) * me.infected / 100 + Math.min(me.infectionRate, 1)
        if (mWeight > eWeight && mWeight > vWeight) {
            print('M')      //Research microbiology
            me.infectionRate = Math.max(0, me.infectionRate - 4)
        } else if (eWeight > vWeight){
            print('E')      //Research epidemiology
            me.contagionRate = Math.max(0, me.contagionRate - 8)
        } else {
            print('V')      //Research vaccines
            me.infectionRate = Math.max(0, me.infectionRate - 1)
            me.contagionRate = Math.max(0, me.contagionRate - 4)
            me.lethalityRate = Math.max(0, me.lethalityRate - 2)
        }
        actionsLeft--
    }

    while (actionsLeft > 0) {
        if (me.infected <= 0) {
            break
        }
        print('C')          //Cure
        val cured = Math.min(me.infected, 10)
        me.infected -= cured
        me.healthy += cured
        actionsLeft--
    }

    while (actionsLeft > 0) {
        print('N')          //Do nothing
        actionsLeft--
    }

    return
}

इसके साथ संकलित करें: साथ चलें kotlinc Salt.kt
:kotlin salt.SaltKt

EDIT: जीवित रहने की उच्च संभावना तब तक है जब तक कि "अंत दुनिया" बॉट्स मृत नहीं हो जाते।

उदाहरण के परिणाम:

1. Salt (247, 12, 280)
2. InfectedTown (30, 2016, 843)
3. ZombieState (30, 1030, 609)
4. WICKED (30, 413, 222)
5. Triage (18, 965, 706)
6. Mooch (18, 657, 597)
7. MadScienceBot (18, 305, 647)
8. TheKeeper (13, 0, 158)
9. FamilyValues (10, 110, 373)
10. Madagascar (2, 0, 271)
11. Terrorist (0, 1358, 651)
12. InfectionBot (0, 1217, 830)
13. Medic (0, 27, 340)
14. MedicBot (0, 1, 200)
15. UndecidedBot (0, 0, 33)
16. Researcher (0, 0, 63)
17. TheCure (0, 0, 71)
18. TrumpBot (0, 0, 88)
19. WeaponOfMassDissemination (0, 0, 137)
20. Strategist (0, 0, 142)
21. PassiveBot (0, 0, 149)
22. DisseminationBot (0, 0, 152)
23. PassiveBot (0, 0, 155)
24. Crossroads (0, 0, 164)
25. InfectedHaven (0, 0, 170)
26. Socialist (0, 0, 172)
27. BioterroristBot (0, 0, 175)
28. XenoBot (0, 0, 184)
29. ThePacifist (0, 0, 199)
30. CullBot (0, 0, 294)
31. AllOrNothing (0, 0, 327)

Comments

बहुत अच्छी रणनीति। मुझे पसंद है कि आप "अच्छे" तरीके से सुस्ती का उपयोग करें!

— थ्रक्स

"एंड-ऑफ-द-वर्ल्ड" बॉट्स के लिए अच्छा काम! हालांकि, अगर नमक उन बॉट के कुछ और थे, तो मैं टॉपलेस हो सकता हूं, हालांकि मुझे यकीन नहीं है। जीवित रहने की क्षमता पहले से ही बहुत प्रभावशाली है, अच्छा एक आदमी!

— बसुक्सुआन

@busukxuan जैसा कि वर्तमान में है, इस प्रक्रिया में खुद को मारने से पहले कई बॉट को घातक दर को अधिकतम करना होगा।

— TheNumberOne

Answer 9

प्योरबोट (हास्केल)

PureBot एक चीज़ से नफरत करता है: दुष्प्रभाव!
यह सभी दुष्प्रभावों को संभालने की कोशिश करेगा, और अगर सबकुछ ठीक हो जाता है, तो यह बाहरी दुनिया द्वारा उत्पादित दुष्प्रभावों की मात्रा को कम कर देगा।
यह अपनी गणना में सभी दुष्प्रभावों की अनदेखी भी करता है।
इससे यह निष्क्रिय दुश्मनों के खिलाफ बेहतर प्रदर्शन करता है (जो वैश्विक दरों में बदलाव नहीं करता है)।

तो infected, infection, contagion, lethalityऔर migrationसब शून्य है, इसके साथ अन्य बॉट में मदद मिलेगी रहे हैं P(के लिए Pure) आदेश।

module Main where
import Control.Monad (void)
import Data.List (find)
import System.Environment (getArgs)
import System.Exit (exitFailure)
import Text.Parsec

-- | The world
data World = World
    { worldRound  :: Int    -- ^ The current round
    , worldTownID :: Int    -- ^ The current town ID
    , worldTowns  :: [Town] -- ^ List of all towns in the world
    }
    deriving (Show)

-- | A town in the world
data Town = Town
    { townID            :: Int -- ^ The town ID
    , townDeath         :: Int -- ^ The number of death people in the town
    , townHealthy       :: Int -- ^ The number of healthy people in the town
    , townInfected      :: Int -- ^ The number of infected people in the town
    , townInfectionRate :: Int -- ^ The infaction rate of the town
    , townContagionRate :: Int -- ^ The contagion rate of the town
    , townLethalityRate :: Int -- ^ The lethality rate of the town
    , townMigrationRate :: Int -- ^ The migration rate of the town
    }
    deriving (Show)

-- | Parse a Int
parseInt :: Parsec String () Int
parseInt = do
    sign <- option '+' $ oneOf "+-"
    numb <- read <$> many1 digit
    return $ if sign == '+'
        then numb
        else negate numb

-- | Parse a town
parseTown :: Parsec String () Town
parseTown = do
    nID <- parseInt
    void $ char '_'
    nHealthy <- parseInt
    void $ char '_'
    nInfected <- parseInt
    void $ char '_'
    nDeath <- parseInt
    void $ char '_'
    nInfectionRate <- parseInt
    void $ char '_'
    nContagionRate <- parseInt
    void $ char '_'
    nLethalityRate <- parseInt
    void $ char '_'
    nMigrationRate <- parseInt
    return Town
        { townID            = nID
        , townDeath         = nDeath
        , townHealthy       = nHealthy
        , townInfected      = nInfected
        , townInfectionRate = nInfectionRate
        , townContagionRate = nContagionRate
        , townLethalityRate = nLethalityRate
        , townMigrationRate = nMigrationRate }

-- | Parse a world
parseWorld :: Parsec String () World
parseWorld = do
    nRound <- parseInt
    void $ char ';'
    nTownID <- parseInt
    void $ char ';'
    towns <- parseTown `sepBy` char ';'
    let nTowns = length towns
    if nTowns < nTownID
        then let nExpected   = (nTownID - nTowns) in
            fail $ "expected at least " ++ show nExpected ++ " more town(s)"
        else return World
            { worldRound  = nRound
            , worldTownID = nTownID
            , worldTowns  = towns }

-- | Update a town
updateTown :: World -> Town -> String
updateTown world town = take 3 $ lastRound
                   ++ prepareForReproduction
                   ++ decreaseInfected
                   ++ decreaseMigration
                   ++ decreaseInfection
                   ++ decreaseContagion
                   ++ decreaseLethality
                   ++ decreaseWorldWide
  where
    -- | The current round number
    nRound         = worldRound world
    -- | The current number of infected
    nInfected      = townInfected town
    -- | The current lethality rate
    nLethalityRate = townLethalityRate town
    -- | The current migration rate
    nMigrationRate = townMigrationRate town
    -- | The current infection rate
    nInfectionRate = townInfectionRate town
    -- | The current contagion rate
    nContagionRate = townContagionRate town
    -- | What to do on the last round
    lastRound
        | nRound == 50 = "CCC"
        | otherwise    = ""
    -- | What to do in order to prepare for reproduction
    prepareForReproduction
        | (nRound+1) `mod` 5 == 0 = decreaseInfected
        | otherwise               = ""
    -- | What to do in order to decrease infected
    decreaseInfected
        | nInfected > 25 = "CCC"
        | nInfected > 15 = "CC"
        | nInfected > 5  = "C"
        | otherwise      = ""
    -- | What to do in order to decrease lethality
    decreaseLethality
        | nLethalityRate > 4 = "I"
        | otherwise          = ""
    -- | What to do in order to decrease migration
    decreaseMigration
        | nMigrationRate > 0 = "B"
        | otherwise          = ""
    -- | What to do in order to decrease infection
    decreaseInfection
        | nInfectionRate > 0 = "M"
        | otherwise          = ""
    -- | What to do in order to decrease contagion
    decreaseContagion
        | nContagionRate > 4 = "E"
        | otherwise          = ""
    -- | What to do if everything else has been taken care of
    decreaseWorldWide = "PPP"

-- | Update a world
updateWorld :: World -> Maybe String
updateWorld world = updateTown world <$> town
  where
    town          = find ((==worldTownID world) . townID) (worldTowns world)

-- | Main program entry point
main :: IO ()
main = do
    cmds <- concat <$> getArgs
    case parse parseWorld "stdin" cmds of
        Left err    -> print err >> exitFailure
        Right world -> case updateWorld world of
            Just cmd -> putStrLn cmd
            Nothing  -> putStrLn "Failed to update world!" >> exitFailure

साथ दौड़ो: runhaskell PureBot.hs

Comments

वाह, क्या तकनीकी शुद्धता! मुझे पसंद है कि आप पी कमांड की व्याख्या कैसे करते हैं।

— बुसुकुआन २ bus

मैंने बस हास्केल 7.10.3 स्थापित किया है, और जब मैं आपके बॉट को चलाने की कोशिश करता हूं, तो यह अनिश्चित काल तक इंतजार करता है। मैंने इसके साथ प्रयास किया runhaskell.exe PureBot.hs 1;0;0_97_3_0_2_5_15_5;1_97_3_0_2_5_15_5:। क्या इसे चलाने से पहले मुझे कुछ और करना होगा?

— थ्रैक्स

@ थ्रक्स ओह, सॉरी। मुझे लगा कि आपने स्टड के माध्यम से आदेश पारित किए हैं ... यदि यह नहीं होता है तो मैं कार्यक्रम को बदल दूंगा।

— YoYoYonnY

आदेशों को तर्क के रूप में पारित किया जाता है। आपके बॉट को अपडेट करने के बाद मैं अगला रन करूंगा।

— थ्रैक्स

@ थ्रक्स उस मामले में अब काम करना चाहिए।

— योयोयोनी

Answer 10

संक्रमित टाउन, जावा

संक्रमित शहर की परवाह नहीं है अगर लोग तब तक पीड़ित हैं जब तक वे मर नहीं जाते हैं। इसलिए यह स्थानीय सुस्ती दर को यथासंभव कम कर देगा।

जब सुस्ती दर पहले से ही बहुत कम है, तो यह अपने स्वयं के घटने से पहले वैश्विक सुस्ती दर को बढ़ाने के लिए अपने शेष कार्यों का उपयोग करता है।

चूंकि यह आसपास का सबसे बड़ा शहर होने की कोशिश करता है, इसलिए आव्रजन संतुलन केवल नकारात्मक हो सकता है, इसलिए इसकी पहली कार्रवाई सीमाओं को बंद करना है।

अंतिम मोड़ के दौरान, सुस्ती दर पर कोई प्रभाव नहीं पड़ता है और रैंकिंग शहर के समझदार लोगों की संख्या पर की जाती है, इसलिए यह 30 लोगों को ठीक करता है और उम्मीद करता है कि यह पर्याप्त होगा।

import java.util.ArrayList;
import java.util.List;

public class InfectedTown {

    int playerID;
    State thisState;

    public static void main(String[] args){
        new InfectedTown().sleep(args[0].split(";"));
    }

    private void sleep(String[] args) {
        // Parse arguments
        int round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        for (int i = 2; i < args.length; i++){
            thisState = new State(args[i]);
            if(thisState.isMine()){
                break;
            }
        }

        // Special actions on turn 1 and 50.
        String action="";
        if(round == 1){
            action = "B";
        } else if(round == 50){
            action="CCC";
        } 

        while(action.length()<3){
            if(thisState.lethalityRate<=2 && action.length()<2){
                // We still have at least one action: lets increase the 
                // lethality rate for everyone, we will decrease it with our 
                // remaining actions.
                action+="W";
                thisState.lethalityRate+=2;
            } else if (thisState.lethalityRate>=4 
                    ||(thisState.lethalityRate>0 && action.length()==2)) {
                // Don't let people die!
                action+="I";
                thisState.lethalityRate-=4;
            } else {
                // Nothing better to do, lets distract other towns by  
                // increasing some useless values
                action+="D";
            }
        }

       System.out.println(action);
    }

    private class State {
        public int ownerId;
        public int lethalityRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            lethalityRate = Integer.parseInt(args[6]);
        }

        public boolean isMine(){
            return ownerId == playerID;
        }
    }
}

Answer 11

कलबोट, पायथन 3

बहुत हद तक मानक आत्म-सुरक्षा बॉट जो सीमाओं को बंद कर देती है और शहर में संक्रमण दर को कम करने की कोशिश करती है। यह जानवरों के वैक्टर को संक्रमित करने से होता है (चूंकि संक्रमित लोगों पर संक्रमण दर का कोई प्रभाव नहीं पड़ता है, गैर-मानव वैक्टर के साथ कुछ करना चाहिए। मूल रूप से यह "रिसर्च माइक्रोबायोलॉजी" है)। कभी-कभी यह "मनुष्यों" को भी संक्रमित कर देता है ... आप जानते हैं, AI गलतियाँ भी करता है ...

# Parsing code
from sys import argv

args = argv[1].split(";")

n = int(args[0])
pid = int(args[1])
dic = ["pid","healthy","infected","dead","infection","contagion","lethality","migration"]
players = []
for p in args[2:]:
    players += [{dic[i]:int(p.split("_")[i]) for i in range(len(p.split("_")))}]
    if int(p.split("_")[0]) == pid:
        me = players[-1]

# Bot code

actions = ""
nextInfected = me["infected"]*me["contagion"]/100 + me["infection"] + me["infected"] - me["infected"]*me["lethality"]/100
if n%5 == 4:
    nextInfected *= 1.5

if n == 1:
    actions += "BM"
    if nextInfected*1.3 > 10:
        actions += "C"
    elif me["infection"] > 6:
        actions += "M"
    elif me["infection"] > 4:
        actions += "V"
    else:
        actions += "E"
    print(actions)
    exit()
elif n == 50:
    print("CCC")
    exit()


if nextInfected*1.2 > 30:
    if me["infected"] >= 23:
        actions += "Q"
        me["infected"] -= 30
    else:
        actions += "C"
        me["infected"] -= 10
elif me["infection"] > 0:
    actions += "M"
    me["infection"] -= 4
elif me["contagion"] >= 6:
    actions += "E"
    me["contagion"] -= 8
elif me["infected"] > 0:
    actions += "C"
    me["infected"] -= 10
else:
    actions += "E"
    me["contagion"] -= 8

if me["infection"] >= 3:
    actions += "M"
    me["infection"] -= 4
elif me["infected"] >= 7 :
    actions += "C"
    me["infected"] -= 10
elif me["infection"] > 0 and me["contagion"] >= 3:
    actions += "V"
    me["infection"] -= 1
    me["contagion"] -= 4
elif me["contagion"] >= 6:
    actions += "E"
    me["contagion"] -= 8
elif me["infection"] > 0:
    actions += "M"
    me["infection"] -= 4
elif me["infected"] > 0:
    actions += "C"
    me["infected"] -= 10
else:
    actions += "E"
    me["contagion"] -= 8

if me["infection"] >= 3:
    actions += "M"
    me["infection"] -= 4
elif me["infected"] >= 7 :
    actions += "C"
    me["infected"] -= 10
elif me["infection"] > 0 and me["contagion"] >= 3:
    actions += "V"
    me["infection"] -= 1
    me["contagion"] -= 4
elif me["contagion"] >= 6:
    actions += "E"
    me["contagion"] -= 8
elif me["infection"] > 0:
    actions += "M"
    me["infection"] -= 4
elif me["infected"] > 0:
    actions += "C"
    me["infected"] -= 10
else:
    actions += "E"
    me["contagion"] -= 8

if actions[-2:] == "VV":
    actions = actions[0] + "ME"
print(actions)

Comments

मैं अजगर आदमी नहीं हूं, इसलिए मैं यह गलत कर सकता हूं, लेकिन पायथन 3.4 में इसे चलाने से मुझे "NameError: name 'डिक्शनरी' लाइन 9 में परिभाषित नहीं है"

— Mwr247

@ Mwr247 धन्यवाद, पता चलता है कि जब मैंने पार्सिंग कोड लिखा था, तो मेरे दिमाग से पूरी तरह से बाहर था ... उस पर बहुत अधिक समस्याएं थीं।

— बुसुक्सुआन

अब यह "TypeError: 'लिस्ट' ऑब्जेक्ट को पूर्णांक के रूप में व्याख्या नहीं कर सकता है" पंक्ति 11 पर

— Mwr247

अब यह काम करता है =)

— Mwr247

@ Mwr247 लोल! मुझे लगा कि मैंने तय कर लिया है, लेकिन मैंने नए कोड को कॉपी और पेस्ट नहीं किया है, इसलिए मुझे लगता है कि मैं उस एक को याद करता हूं। मैंने परीक्षण किया, अब इसे ठीक चलना चाहिए। जब तक मैं किसी तरह I / O नियमों को गलत नहीं मानता।

— बसुक्सुआन

Answer 12

एविलबिल, जावा

EvilBot लोगों का इलाज करने के बारे में परवाह नहीं करता है। जब तक वे जीवित रहते हैं (थोड़े)। बाकी दुनिया को बीमार करने की कोशिश करता है।

मेरे स्थानीय परीक्षण में, ब्लंडरबॉट तब तक बहुत अच्छा कर रहा था जब तक कि मैंने ईविलबोट भी पेश नहीं किया। चीजों को थोड़ा हिलाने लगता है।

import java.util.ArrayList;
import java.util.List;

public class EvilBot {

int round;
int phase;
int playerID;
int thisTownID;

List<State> states;
List<State> otherStates;

State thisState;
String action = "";
int cc=0; // command count

public static void main(String[] args){
    new EvilBot().sleep(args[0].split(";"));
}

private void action(String newAction) {
    action += newAction;
    cc+= newAction.length();
    if (cc>=3) {
        System.out.println(action.substring(0, 3));
        System.exit(0);;
    }
}
private void sleep(String[] args) {

    round = Integer.parseInt(args[0]);
    thisTownID = Integer.parseInt(args[1]);

    states = new ArrayList<>();
    otherStates = new ArrayList<>();

    for (int i = 2; i < args.length; i++){
        states.add(new State(args[i]));
    }

    for (State state : states){
        if (state.isMine()) {
            thisState = state;
        } else {
            otherStates.add(state);
        }
    }

    // Round specific commands
    if (round == 1 )                                { action("B");   }
    if (round == 50)                                { action("CCC"); }

    for (int i=0;i<3;i++){
        if (thisState.getLethalityRate() >= 4)  { action("I"); thisState.lethalityRate -= 4;}
    }

    // Nothing else to do, cause trouble.
    action("DWT");
}


private class State {

    private final int ownerId;
    private int healthy;
    private int infected;
    private int dead;
    private int infectionRate;
    private int contagionRate;
    private int lethalityRate;
    private int migrationRate;

    public State(String string) {
        String[] args = string.split("_");
        ownerId = Integer.parseInt(args[0]);
        healthy = Integer.parseInt(args[1]);
        infected = Integer.parseInt(args[2]);
        dead = Integer.parseInt(args[3]);
        infectionRate = Integer.parseInt(args[4]);
        contagionRate = Integer.parseInt(args[5]);
        lethalityRate = Integer.parseInt(args[6]);
        migrationRate = Integer.parseInt(args[7]);
    }

    public int getOwnerId() {
        return ownerId;
    }

    public int getHealthy() {
        return healthy;
    }

    public int getInfected() {
        return infected;
    }

    public int getDead() {
        return dead;
    }

    public int getInfectionRate() {
        return infectionRate;
    }

    public int getContagionRate() {
        return contagionRate;
    }

    public int getLethalityRate() {
        return lethalityRate;
    }

    public int getMigrationRate() {
        return migrationRate;
    }

    public boolean isMine(){
        return getOwnerId() == thisTownID;
    }

}

}

Answer 13

सामूहिक दुष्प्रचार का हथियार

public class WMDbot{
    public static void main(String[]a){
        System.out.println("WMD");
    }
}

WMD बॉट एक झटका है: अपनी स्वयं की संक्रमण दर को कम रखता है और बाकी सभी को बढ़ाता है।

संक्षिप्त रूप से बॉट का निर्माण संक्षिप्त रूप से नहीं किया गया, बल्कि प्रबल दावेदार के रूप में, लेकिन प्रतिस्पर्धी क्षेत्र को थोड़ा और दिलचस्प बना देगा। कोड TheCure से उधार लिया गया है और बस इसके एक्शन स्ट्रिंग में बदलाव किया गया है।

Comments

तकनीकी रूप से आपने कक्षा का नाम भी बदल दिया है; पी

— कप्तान मैन

@DenhamCoote: कृपया मास-ऐडिंग लैंग्वेज टैग के आसपास न जाएं। यदि आप किसी पोस्ट को संपादित करने जा रहे हैं, तो सुनिश्चित करें कि यह कुछ अधिक महत्वपूर्ण है (व्याकरण, स्वरूपण, आदि)। धन्यवाद।

— Zach गेट्स

ओह? मैं एक बार अपने पोस्ट में से एक के रूप में संपादित किया था - मैं सिर्फ किसी और के नेतृत्व का पालन कर रहा था ...

— Denham Coote

@DenhamCoote यह उन "आसान सस्ते संपादन" में से एक है जो कुछ भी नहीं जोड़ता है, लेकिन जो वास्तव में निषिद्ध नहीं हैं। इनका एक गुच्छा करने से स्पैम हो जाता है।

— Draco18s

यकीन नहीं होता कि 'सस्ते' से आपका क्या तात्पर्य है - यह मेरे लिए पठनीयता को जोड़ता है ... इस चुनौती में सामान्य गोल्फिंग चुनौती की तुलना में पढ़ने के लिए बहुत अधिक कोड है, और इसलिए मैंने सोचा कि वाक्यविन्यास हाइलाइटिंग का स्वागत होगा। यह ऐसा नहीं है कि मैं अंकों के लिए ऐसा कर रहा हूं, मैं सिर्फ इस चुनौती का आनंद लिया है।

— डेनहम कोट

Answer 14

ग्रेल्मकिन, जावा

ग्रेमल्किन का प्राथमिक ध्यान संक्रमण दर को 0 पर कम कर रहा है और इसकी स्वस्थ आबादी को बढ़ा रहा है। यह संगरोध में विश्वास नहीं करता है ... बेशक बाहरी दुनिया से।

मेरी पहली पोस्ट - समालोचनात्मक स्वागत है। :)

import java.util.ArrayList;
import java.util.List;

public class Graymalkin {

    int round;
    int phase;
    int playerID;
    int thisTownID;

    List<State> states;
    List<State> otherStates;

    State thisState;

    public static void main(String[] args) {
        new Graymalkin().sleep(args[0].split(";"));
    }

    private void sleep(String[] args) {

        round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        states = new ArrayList<>();
        otherStates = new ArrayList<>();

        for (int i = 2; i < args.length; i++) {
            states.add(new State(args[i]));
        }

        for (State state : states) {
            if (state.isMine()) {
                thisState = state;
            } else {
                otherStates.add(state);
            }
        }

        if (round == 50) {
            System.out.println("CCC");
            return;
        }

        String out = "";

        if (round == 1) {
            out += "B";
        }

        if (thisState.infectionRate < 10 && thisState.infected >= 10) {
            out += "C";
            thisState.infected -= 10;
        }

        while (thisState.infectionRate >= 4) {
            out += "M";
            thisState.infectionRate -= 4;
        }

        while (thisState.infectionRate > 0) {
            out += "V";
            thisState.infectionRate -= 1;
        }

        while (out.length() < 3) {
            if (thisState.infected > 0) {
                out += "C";
                thisState.infected -= 10;
            } else if (thisState.contagionRate > 0) {
                out += "E";
                thisState.contagionRate -= 8;
            } else if (thisState.lethalityRate > 0) {
                out += "I";
                thisState.lethalityRate -= 4;
            } else {
                out += "N";
            }
        }

        System.out.println(out.substring(0, 3));
    }

    private class State {

        private final int ownerId;
        private int sane;
        private int infected;
        private int dead;
        private int infectionRate;
        private int contagionRate;
        private int lethalityRate;
        private int migrationRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            sane = Integer.parseInt(args[1]);
            infected = Integer.parseInt(args[2]);
            dead = Integer.parseInt(args[3]);
            infectionRate = Integer.parseInt(args[4]);
            contagionRate = Integer.parseInt(args[5]);
            lethalityRate = Integer.parseInt(args[6]);
            migrationRate = Integer.parseInt(args[7]);
        }

        public int getOwnerId() {
            return ownerId;
        }

        public int getSane() {
            return sane;
        }

        public int getInfected() {
            return infected;
        }

        public int getDead() {
            return dead;
        }

        public int getInfectionRate() {
            return infectionRate;
        }

        public int getContagionRate() {
            return contagionRate;
        }

        public int getLethalityRate() {
            return lethalityRate;
        }

        public int getMigrationRate() {
            return migrationRate;
        }

        public boolean isMine() {
            return getOwnerId() == playerID;
        }
    }
}

Comments

@ थ्रक्स ऐसा लगता है जैसे मेरा बॉट आपके सबसे हाल के रन में शामिल नहीं था। मैं यह देखने के लिए उत्सुक हूं कि यह कैसे होता है!

— 14

Answer 15

ट्राइएज, जावा

import java.util.ArrayList;
import java.util.List;

public class Triage {

    int round;
    int phase;
    int playerID;

    List<State> states;
    List<State> otherStates;

    State thisState;

    public static void main(String[] args){
        new Triage().sleep(args[0].split(";"));
    }

    private void sleep(String[] args) {

        round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        states = new ArrayList<>();
        otherStates = new ArrayList<>();

        for (int i = 2; i < args.length; i++){
            states.add(new State(args[i]));
        }

        for (State state : states){
            if (state.isMine()) {
                thisState = state;
            } else {
                otherStates.add(state);
            }
        }

        if (round == 50) {
          System.out.println("CCC");
          return;
        }

        String output = "";

        while( thisState.lethalityRate >= 4) {
          output += "I";
          thisState.lethalityRate -= 4;
        }

        while( thisState.lethalityRate > 0) {
          output += "V";
          thisState.lethalityRate -= 2;
          thisState.contagionRate -= 4;
          thisState.infectionRate -= 1;
        }

        while( thisState.contagionRate >= 8) {
          output += "E";
          thisState.contagionRate -= 8;
        }

        while( thisState.contagionRate > 0) {
          output += "V";
          thisState.lethalityRate -= 2;
          thisState.contagionRate -= 4;
          thisState.infectionRate -= 1;
        }

        while( thisState.infectionRate > 0) {
          output += "M";
          thisState.infectionRate -= 4;
        }

        while( output.length() < 3) {
          output += "C";
        }

        System.out.println(output.substring(0,3));

    }

    private class State {

        private final int ownerId;
        public int sane;
        public int infected;
        public int dead;
        public int infectionRate;
        public int contagionRate;
        public int lethalityRate;
        public int migrationRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            sane = Integer.parseInt(args[1]);
            infected = Integer.parseInt(args[2]);
            dead = Integer.parseInt(args[3]);
            infectionRate = Integer.parseInt(args[4]);
            contagionRate = Integer.parseInt(args[5]);
            lethalityRate = Integer.parseInt(args[6]);
            migrationRate = Integer.parseInt(args[7]);
        }

        public int getOwnerId() {
            return ownerId;
        }

        public boolean isMine(){
            return getOwnerId() == playerID;
        }

    }

}

पहले अपने नागरिकों को जीवित रखता है, फिर उन्हें दूसरों को संक्रमित करने से रोकता है, फिर उन्हें ठीक करता है।

मूच, जावा

import java.util.ArrayList;
import java.util.List;

public class Mooch {

    int round;
    int phase;
    int playerID;

    List<State> states;
    List<State> otherStates;

    State thisState;

    public static void main(String[] args){
        new Mooch().sleep(args[0].split(";"));
    }

    private void sleep(String[] args) {

        round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        states = new ArrayList<>();
        otherStates = new ArrayList<>();

        for (int i = 2; i < args.length; i++){
            states.add(new State(args[i]));
        }

        for (State state : states){
            if (state.isMine()) {
                thisState = state;
            } else {
                otherStates.add(state);
            }
        }

        if (round == 50) {
          System.out.println("CCC");
          return;
        }

        String output = "";

        while( thisState.migrationRate < 100) {
          output += "O";
          thisState.migrationRate += 10;
        }

        while( thisState.lethalityRate >= 4) {
          output += "I";
          thisState.lethalityRate -= 4;
        }

        while( thisState.lethalityRate > 0) {
          output += "V";
          thisState.lethalityRate -= 2;
          thisState.contagionRate -= 4;
          thisState.infectionRate -= 1;
        }

        while( thisState.contagionRate >= 8) {
          output += "E";
          thisState.contagionRate -= 8;
        }

        while( thisState.contagionRate > 0) {
          output += "V";
          thisState.lethalityRate -= 2;
          thisState.contagionRate -= 4;
          thisState.infectionRate -= 1;
        }

        while( thisState.infectionRate > 0) {
          output += "M";
          thisState.infectionRate -= 4;
        }

        while( output.length() < 3) {
          output += "C";
        }

        System.out.println(output.substring(0,3));

    }

    private class State {

        private final int ownerId;
        public int sane;
        public int infected;
        public int dead;
        public int infectionRate;
        public int contagionRate;
        public int lethalityRate;
        public int migrationRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            sane = Integer.parseInt(args[1]);
            infected = Integer.parseInt(args[2]);
            dead = Integer.parseInt(args[3]);
            infectionRate = Integer.parseInt(args[4]);
            contagionRate = Integer.parseInt(args[5]);
            lethalityRate = Integer.parseInt(args[6]);
            migrationRate = Integer.parseInt(args[7]);
        }

        public int getOwnerId() {
            return ownerId;
        }

        public boolean isMine(){
            return getOwnerId() == playerID;
        }

    }

}

ट्राइएज के समान, इसके अलावा यह पूरी तरह से अपनी सीमाओं को खोलने से शुरू होता है। यह संक्रमित, अन्य बॉट्स को असुविधाजनक बनाने और संभावित रूप से टाई-ब्रेकर के रूप में कार्य करने की विशाल आबादी को सुनिश्चित करता है।

Comments

ट्राइएज फैमिली वैल्यूज को पैसे के लिए चलाती रहती है। दूसरी ओर मूच बीमार लोगों की एक बड़ी सेना का निर्माण करता रहता है। बहुत बढ़िया!

— Mwr247

moochbot को सभी को असंक्रमित रखने की कोशिश कर रहा है? Doesn´t thisState.x राज्य मान को संशोधित करता है और फिर खेल आपको इसे फिर से दोहराता हुआ स्ट्रिंग से बदल देता है? अंतिम दौर में थ्रू CCC पर शानदार विचार हालांकि

— Eumel

अब इस कोड को समझें और मेरे दूसरे सवाल को बहुत बेवकूफाना

— मानें

Moochbot अंततः एक स्वस्थ आबादी बनाने की कोशिश करता है, लेकिन खुली सीमाएँ + शून्य सुस्ती यह सुनिश्चित करती है कि संक्रमित आबादी बहुत तेज़ी से बढ़ेगी।

— हिस्टोक्रेट

Answer 16

इंफ़ेक्टवेन, पायथन 3

बंद सीमाओं के साथ संक्रमित के लिए एक सुरक्षित स्थान। घातकता को कम करने की कोशिश करता है। यदि कम से कम किया जाता है, तो स्थानीय संक्रमित "लाभ" के लिए अन्य राज्यों में घातकता बढ़ाने की कोशिश करता है।

# parsing code
from sys import argv
args = argv[1].split(";")

n = int(args[0])
pid = int(args[1])
dic = ["pid","healthy","infected","dead","infection","contagion","lethality","migration"]
players = []
for p in args[2:]:
    players += [{dic[i]:int(p.split("_")[i]) for i in range(len(p.split("_")))}]
    if int(p.split("_")[0]) == pid:
        me = players[-1]

# bot code

actions =""

if n == 50:
    print("CCC")
    exit()
elif n == 1:
    actions += "B"
    if me["lethality"] <= 6:
        actions += "WI"
    else:
        actions += "II"
    print(actions)
    exit()

if me["lethality"] >= 9:
    actions += "III"
elif me["lethality"] >= 3:
    actions += "WII"
else:
    actions += "WWI"
print(actions)

Comments

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

— थ्रैक्स

@ थ्रक्स लोल धन्यवाद, यह वास्तव में एक रणनीति नहीं है। मुझे लगा कि संक्रमित लोगों को संभवतः स्वस्थ द्वारा पूर्वाग्रहित या भेदभाव किया जाएगा, इसलिए एक अराजक दुनिया में यह "साथी संक्रमित" राज्य के गठन को उत्प्रेरित करेगा। सच कहूं तो यह एक फ़न-फ़न बॉट था, लेकिन तब मैंने इसमें थोड़ी क्षमता देखी, इसलिए मैंने इसे प्रस्तुत किया।

— बुसुकुआन २ bus'१६ को

यदि यह असुविधाजनक है तो @ थ्रैक्स खेद है, लेकिन मुझे अभी पता चला है कि मैंने नीचे की स्थितियों को गलत तरीके से रखा है इसलिए मैंने फिर से अपडेट किया।

— बसुक्सुआन

Answer 17

चौराहा, पायथन 2

चौराहा एक लोकतांत्रिक राष्ट्र है जो भविष्य के वैज्ञानिक मूल्यों पर ध्यान केंद्रित करता है। अधिकांश लोकतंत्रों की तरह, अधिकांश निर्णय अवैज्ञानिक-प्रशिक्षित, स्वार्थी और दुष्क्रियाशील समितियों द्वारा किए जाते हैं, जो अक्सर बहुत ही अजीब और खराब - स्पष्ट रूप से यादृच्छिक, यहां तक ​​कि निर्णय लेते हैं। हालाँकि, सरकार अंततः अपने लोगों और मानव जाति के सामान्य भलाई के लिए काम कर रही है।

import sys
import random
import itertools
def sample_wr(population, k):
    "Chooses k random elements (with replacement) from a population"
    n = len(population)
    _random, _int = random.random, int  # speed hack
    return [population[_int(_random() * n)] for i in itertools.repeat(None, k)]
a = sys.argv[1].split(';')
round = int(a[0])
myid = a[1]
players = {}
Sane = 0
Infected = 1
Dead = 2
InfectionRate = 3
ContagionRate = 4
LethalityRate = 5
MigrationRate = 6
worldpopulation = 0
for i in range(2,len(a)):
    b = a[i].split('_')
    players[b[0]]=map(int,b[1:])
    worldpopulation += (int(b[1])+int(b[2]))*int(b[7])/100
output = ""
if round == 1:
    output="BM"
    if players[myid][Infected]>6: output+="C"
    else: output+="E"
if round == 50: 
    if players[myid][Infected] > 20: output = "CCC"
    elif players[myid][Infected]> 6: output = "CTC"
    else: output = "TTC"
if round == 48 and players[myid][Infected] > 45 and players[myid][InfectionRate]>12:
    output = "MMM"
if round == 49 and players[myid][Infected] > 30:
    output = "CCC"
if (round+1)%5==0:
    if players[myid][Sane]==0 or players[myid][Infected]/players[myid][Sane] > 2: output+="I"*(players[myid][LethalityRate]/4)
    output+="M"*(players[myid][InfectionRate]/4)
    output+="C"*max((players[myid][Infected]/10),1)
if players[myid][InfectionRate] < 8 and players[myid][ContagionRate] < 20 and players[myid][Sane]+min(players[myid][Infected]/5,60)>players[myid][Infected] and (round+2)%5==0:
    output+="C"*max((players[myid][Infected]/10),1)
    players[myid][Infected] -= min(max((players[myid][Infected]/10),1)*10,players[myid][Infected])
if players[myid][Sane] > players[myid][Infected] > 30: 
    output +="Q"
    players[myid][Infected] -= min(players[myid][Infected],30)
if players[myid][Sane] > players[myid][Infected] > 20:
    output+="CC"
    players[myid][Infected] -= min(players[myid][Infected],20)
if (players[myid][Sane] > 2*players[myid][Infected] > 20):
    output+="C"
    players[myid][Infected] -= min(players[myid][Infected],10)
if round <= 5 and players[myid][Infected] > 10:
    output+="C"
    players[myid][Infected] -= min(players[myid][Infected],10)
if 25 <= players[myid][Infected] < 40 and players[myid][InfectionRate]<10:# and players[myid][ContagionRate]*(players[myid][Infected]-20)/100 < 10:
    output+="CCC"

if players[myid][InfectionRate]-players[myid][ContagionRate]>10: output+="M"
if players[myid][ContagionRate]-players[myid][InfectionRate]>20: output+="E"
population = []
population +=["I" for i in range(int(1.15**players[myid][LethalityRate]))]
if players[myid][Sane]<10 or players[myid][Infected]-players[myid][Sane]>10: population+=["I" if players[myid][LethalityRate]>8 else "V" for i in range(players[myid][InfectionRate])]
if players[myid][Sane]+players[myid][Infected]>10 and (players[myid][Sane]>15 or players[myid][LethalityRate]<10): population += ["M" if players[myid][InfectionRate] > 6 else "V" for i in range(2*max(players[myid][InfectionRate]*players[myid][Sane]/100,int((1.15+0.002*(50-round))**min(50,players[myid][InfectionRate]))))]
if players[myid][Sane]+players[myid][Infected]>10 and (players[myid][Sane]>15 or players[myid][LethalityRate]<10): population += ["E" if players[myid][ContagionRate] > 10 else "V" for i in range(max(min(players[myid][Sane],players[myid][ContagionRate]*players[myid][Infected]/100),int(1.15**min(50,players[myid][ContagionRate]))))]
if players[myid][InfectionRate]+players[myid][ContagionRate]<15: population += ["C" for i in range(players[myid][Infected])]
if players[myid][Infected] < 10: population += ["WV" for i in range(int(1.05**round))]
output += ''.join(sample_wr(population,3))
print output[:3]

सभी को शामिल करते हुए 4 रन:

1. Crossroads (36, 12, 185)
2. InfectedTown (14, 1040, 510)
3. InfectedHaven (14, 977, 481)
4. Triage (14, 668, 531)
5. ZombieState (14, 523, 393)

1. AllOrNothing (541, 0, 312)
2. InfectedTown (30, 1125, 574)
3. InfectedHaven (30, 1020, 612)
4. WICKED (30, 732, 622)
5. Triage (30, 553, 554)
6. Mooch (30, 80, 240)
7. Crossroads (25, 0, 162)

1. AllOrNothing (846, 12, 241)
2. Crossroads (440, 15, 146)
3. FamilyValues (388, 34, 201)
4. Salt (170, 0, 176)
5. InfectedHaven (18, 1290, 664)

1. Crossroads (80, 14, 365)
2. InfectedHaven (30, 1596, 603)
3. InfectedTown (30, 1286, 576)
4. Triage (30, 1084, 412)
5. WICKED (18, 1286, 578)

"प्रलय का दिन" के बिना 4 रन:

1. Salt (6790, 0, 58)
2. FamilyValues (6697, 7, 9)
3. Crossroads (6616, 4, 16)
4. PureBot (6454, 0, 50)
5. Piecemeal (6260, 0, 111)

1. Crossroads (6970, 0, 39)
2. PureBot (6642, 0, 77)
3. CureThenQuarantine (6350, 2, 51)
4. FamilyValues (6153, 13, 21)
5. Piecemeal (5964, 4, 132)

1. PureBot (6142, 0, 34)
2. CureThenQuarantine (6010, 4, 75)
3. Piecemeal (5971, 4, 72)
4. CullBot (5409, 8, 115)
5. Crossroads (5129, 0, 27)

1. FamilyValues (7277, 12, 26)
2. Crossroads (6544, 4, 32)
3. Salt (5830, 26, 103)
4. Piecemeal (5757, 8, 164)
5. PureBot (5657, 8, 127)

संपादित करें: CullBot की सफल "लोगों की स्वस्थता को बनाए रखने और लोगों को स्वस्थ रखने पर ध्यान केंद्रित करने" की रणनीति को देखने के बाद, मैंने संक्रमण और छूत को कम करने और घातकता को कम करने के लिए इलाज को प्राथमिकता दी है, जबकि आवश्यक निर्णय-दर-समिति यादृच्छिक स्वभाव को नहीं छोड़ा है।

EDIT2: यह पता चलता है कि बहुत सारे आतंकवादियों के साथ घातक होने की अनदेखी करना बुरा है। सुस्ती को कम करने की प्राथमिकता फिर से बढ़ गई, अब सुस्ती दर के साथ बढ़ रही है। इसके अलावा कुछ अन्य खराब फैसले भी तय किए, जैसे एक ही मोड़ पर बॉर्डर को खोलना और बंद करना, और जहां संभव हो, वहां इलाज करना पसंद करते हुए संगरोध के लिए सीमा बढ़ा दी।

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

EDIT4: बेहतर समय और इलाज की प्रभावकारिता।

EDIT5: माइग्रेशन के साथ गड़बड़ करने वाले सामान को हटा दिया, क्योंकि यह कभी भी शून्य जनसंख्या को हिट नहीं करता है, और इलाज के लिए कुछ और विशेष मामले।

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

EDIT7: उच्च स्मृति उपयोग को रोकने के लिए 50 पर कैप संक्रमण / छूत की दर घातांक।

Comments

प्रतीक्षा करें ... क्या इजरायल ने डब्ल्यूडब्ल्यूजेड यरूशलेम के बाद बहुत ऊंची दीवारों के साथ मॉडलिंग की है?

— बसुक्सुआन

@busukxuan जो प्रेरणा के लिए हाँ था, सिवाय इसके कि यह इज़राइल फिल्म में जेरुसलम से अधिक दिखता है (तेजी से संक्रमित होकर उग आया), क्योंकि यह मूल रूप से इसे खोलने के लिए एक ला मूच चौड़ा करता है। मूल योजना इसके लिए थी कि वह ज्यादातर 'पी' करे, लेकिन यह एक प्रभावी रणनीति नहीं थी।

— क्विंटोपिया

हम्म ... ऐसा लगता है कि प्रिय CullBot अब और नहीं रख सकता है जब संक्रमण को बढ़ाने की कोशिश कर रहे अधिक बॉट हैं।

— बसुक्सुआन

यह बहुत अच्छा होता है जब मैं संक्रमण को कम करने के लिए एक बॉट में जुड़ जाता हूं (ऑर्डर यादृच्छिकता को चालू करने के लिए)

— क्विंटोपिया

तो मूल रूप से CullBot बहुत अस्थिर है और स्थिति पर निर्भर है। वास्तव में, जब मैंने कोड लिखा था, तो मैंने संक्रमण को रोक दिया था। एकमात्र वापसी प्रति चक्कर 1 क्विंटल तक थी।

— बसुकक्सुआन

Answer 18

कीपर, लुआ

एक साथी फ्रेंच मेंढक द्वारा किया गया एक KotH! मुझे इस प्रतियोगिता में होना था!

यह बॉट अपने संक्रमण / छूत और घातक दर को यथासंभव कम रखने के लिए कुछ भी संभव करेगा। इसकी सबसे बड़ी प्राथमिकता 0. के पास एक सुस्ती है। यह अनुमान लगाने की कोशिश करेगा कि कब अधिक लोगों को "आयात" करने की कोशिश करना अच्छा है।

संपादित करें: मुझे लगता है कि हम जो कुछ भी प्राप्त करते हैं, argवह खिलाड़ी द्वारा सॉर्ट किया गया था। यह एक गलत धारणा है, इसलिए मैंने इसके लिए एक बबल सॉर्ट जोड़ा datas।

input=arg[1]

datas={}
format={"playerID","sane","infected","dead","infection","contagion","lethality","migration"}
i=1
for s in input:gmatch("[^;]+") 
do
  j=1
  if round==nil then round=tonumber(s) 
  elseif me==nil then me=tonumber(s)+1
  else
    table.insert(datas,{})
    for r in s:gmatch("%d+")
    do
      datas[i][format[j]]=tonumber(r)
      j=j+1
    end
    i=i+1
  end
end
for i=#datas-1,1,-1
do
  for j=1,i
  do
    if datas[j].playerID>datas[j+1].playerID
    then
      datas[j],datas[j+1]=datas[j+1],datas[j]
    end
  end
end

-- First, we put ourself in a safe state
if round==1 then print("VVV")os.exit(0)end
if round==50 then print("CCC")os.exit(0)end

actions=""

-- Safety actions first
if datas[me].lethality>2 
then 
  actions=actions.."I"
  datas[me].lethality=datas[me].lethality-4>0 and datas[me].lethality-4 or 0
end

if datas[me].infected>=10
then
  if(datas[me].infection+datas[me].contagion+datas[me].lethality>4)
  then
    actions=actions.."V"
    datas[me].infection=datas[me].infection-1>0 and datas[me].infection-1 or 0
    datas[me].contagion=datas[me].contagion-4>0 and datas[me].contagion-4 or 0
    datas[me].lethality=datas[me].lethality-2>0 and datas[me].lethality-2 or 0
  end
  actions=actions.."C"
  datas[me].sane=datas[me].sane+10
  datas[me].infected=datas[me].infected-10
end

-- We can now try taking some initiatives
while #actions<3
do
  rates={}
  for i=1,#datas
  do
    if i~=me 
    then
      table.insert(rates,(datas[i].infected/datas[i].sane>0 and datas[i].sane or 0)*(datas[i].migration/100))
    end
  end
  rates["total"]=0
  for i=1,#rates
  do
    rates.total=rates.total+rates[i]
  end
  rates.total=(rates.total/#rates)*100


  if datas[me].migration<=15 and datas[me].migration+10>rates.total
  then
    actions=actions.."O"
    datas[me].migration=datas[me].migration+10>0 and datas[me].migration+10 or 0
  elseif (datas[me].sane/datas[me].infected)*100<rates.total
  then
    actions=actions.."B"
    datas[me].migration=datas[me].migration-10>0 and datas[me].migration-10 or 0
  elseif datas[me].infected>=10
  then
    actions=actions.."C"
    datas[me].infected=datas[me].infected-10
  else
    actions=actions.."V"
    datas[me].infection=datas[me].infection-1>0 and datas[me].infection-1 or 0
    datas[me].contagion=datas[me].contagion-4>0 and datas[me].contagion-4 or 0
    datas[me].lethality=datas[me].lethality-2>0 and datas[me].lethality-2 or 0
  end
end
print(actions)
os.exit(0)

Comments

@ थ्रक्स ओह .. स्रोत कोड को ठीक किया, अब input=arg[1]इसके बजाय का उपयोग करें input=io.read()।

— काटेंको

Answer 19

मैडिसेंसबोट, पायथन 2

आप जानते हैं कि इस दुनिया को क्या चाहिए?

अधिक विज्ञान!

हम और अधिक कैसे प्राप्त करते हैं?

ब्रांज के साथ

केवल अंतिम सेकंड में लोगों को ठीक किया जाता है, राउंड 50 को छोड़कर उनके बारे में कम देखभाल नहीं की जा सकती है। हर दूसरे दौर में एक ज़ोंबी फार्म होने की कोशिश करता है

import sys, copy
import itertools

mults = {'mig_rate': -15, 'let_rate': -15, 'dead': -20, 'inf_rate': -20, 'sane': 0, 'infected': 60, 'con_rate': -30, 'id': 0}
def get_score(player_data):
    score = 0
    for k in player_data:
        score += player_data[k] * mults[k] / 100.
    return score


def add_rates(player_data):
    #Infection
    no_sane_converted = player_data["sane"]*player_data["inf_rate"]/100.
    player_data["infected"] += no_sane_converted
    player_data["sane"] -= no_sane_converted
    #Contagion
    no_sane_converted = player_data["con_rate"]
    player_data["infected"] += no_sane_converted
    player_data["sane"] -= no_sane_converted
    #Extinction
    no_killed = player_data["infected"]*player_data["let_rate"]/100.
    player_data["dead"] += no_killed
    player_data["infected"] -= no_killed

def correct(data):
    if round % 5 == 4:
        data["sane"] += int(data["sane"])/2
        data["infected"] += int(data["infected"])/2
    data["inf_rate"] += 2
    data["con_rate"] += 5
    data["let_rate"] += 5

args = sys.argv[1].split(";")
round = int(args[0])
self_id = int(args[1])
player_data = [map(int, player.split("_"))for player in args[2:]]
player_data = [dict(zip(("id", "sane", "infected", "dead", "inf_rate", "con_rate", "let_rate", "mig_rate"), player)) for player in player_data]
self_data = [player for player in player_data if player["id"] == self_id][0]

f = open("MadScienceBot.txt", "a")
f.write("\n")
f.write(`round`+"\n")
f.write("INPUT: "+`self_data`+"\n")

def m(p): p["inf_rate"] -= 4
def e(p): p["con_rate"] *= 92/100.
def i(p): p["let_rate"] -= 4
def v(p): p["inf_rate"] -= 1; p["con_rate"]-=4;p["let_rate"]-=2
def c(p): x=min(p['infected'], 10); p['infected']-=x; p['sane']+=x
def q(p): x=min(p['infected'], 30); p['infected']-=x; p['dead']+=x
def o(p): p["mig_rate"] += 10
def b(p): p["mig_rate"] -= 10

out = ""
instructions = {"M": m,
                "E": e,
                "I": i,
                "V": v,
                "C": c,
                "Q": q,
                "O": o,
                "B": b}

def run_inst(new_data, inst_id, i):
    inst = instructions[inst_id]
    if i != 2:
        inst(new_data)
        for j in new_data: new_data[j] = max(0, int(new_data[j]))
        #f.write("%s %s %s\n"%(inst_id, get_score(new_data), new_data))
    else:
        inst(new_data)
        for j in new_data: new_data[j] = max(0, int(new_data[j]))
        correct(new_data)
        add_rates(new_data)
        for j in new_data: new_data[j] = max(0, int(new_data[j]))
        #f.write("%s %s %s\n"%(inst_id, get_score(new_data), new_data))
    return new_data

def run_3_insts(self_data, insts):
    new_data = copy.copy(self_data)
    for i, inst in enumerate(insts):
        run_inst(new_data, inst, i)
    return get_score(new_data)

scores = {}
for combo in itertools.permutations(instructions.keys(), 3):
    joined = "".join(combo)
    score = run_3_insts(self_data, joined)
    scores[score] = joined
#print scores
out = scores[max(scores)]

if round == 50:
    out = "CCC"

f.write(out+"\n")
print out

Answer 20

ZombieState, जावा

अरे, इस साइट पर यह मेरी पहली पोस्ट है। मैंने मूल रूप से सिर्फ एक उदाहरण बॉट लिया और आउटपुट के बारे में लाइनें बदल दीं।

import java.util.ArrayList;
import java.util.List;

public class ZombieState {

int round;
int phase;
int playerID;
int thisTownID;

List<State> states;
List<State> otherStates;

State thisState;

public static void main(String[] args){
    new ZombieState().sleep(args[0].split(";"));
}

private void sleep(String[] args) {

    round = Integer.parseInt(args[0]);
    thisTownID = Integer.parseInt(args[1]);

    states = new ArrayList<>();
    otherStates = new ArrayList<>();

    for (int i = 2; i < args.length; i++){
        states.add(new State(args[i]));
    }

    for (State state : states){
        if (state.isMine()) {
            thisState = state;
        } else {
            otherStates.add(state);
        }
    }

    StringBuilder sb = new StringBuilder();
    if(round == 1)
        System.out.println("TTT");
    else if(round == 50)
        System.out.println("CCC");
    else
    {
        while(thisState.lethalityRate >= 4)
        {
            sb.append("I");
            thisState.lethalityRate -= 4;
        }
        sb.append("DDD");
        System.out.println(sb.toString().substring(0, 3));
    }
}

private class State {

    private final int ownerId;
    public int sane;
    public int infected;
    public int dead;
    public int infectionRate;
    public int contagionRate;
    public int lethalityRate;
    public int migrationRate;

    public State(String string) {
        String[] args = string.split("_");
        ownerId = Integer.parseInt(args[0]);
        sane = Integer.parseInt(args[1]);
        infected = Integer.parseInt(args[2]);
        dead = Integer.parseInt(args[3]);
        infectionRate = Integer.parseInt(args[4]);
        contagionRate = Integer.parseInt(args[5]);
        lethalityRate = Integer.parseInt(args[6]);
        migrationRate = Integer.parseInt(args[7]);
    }

    public int getOwnerId() {
        return ownerId;
    }

    public boolean isMine(){
        return getOwnerId() == playerID;
    }

}

}

मुझे उम्मीद है कि यह ठीक है और बॉट ने अपने रनों के मामले में काफी अच्छा प्रदर्शन किया। क्योंकि अगर आपको 30 स्वस्थ और अंत में संक्रमित होने की अधिकतम मात्रा हो सकती है, तो जीवित लोगों की आवश्यकता किसे है। यह सब कुछ शुरू करने के लिए 3x जैव-तंत्रवाद के साथ खेल शुरू करता है और स्थानीय सुस्ती को कम रखने की कोशिश करता है। यदि यह 4 से कम है तो यह डिसेमिनेशन के साथ वैश्विक संक्रमण और छूत की दर को कम करने की कोशिश करता है।

Comments

PPCG में आपका स्वागत है :-) आशा है कि आपके पास यहाँ एक अच्छा समय है

— बसुकक्सुआन

ऐसा लगता है कि यह अब तक अच्छा कर रहा है। PPCG, और अच्छी नौकरी में आपका स्वागत है!

— R

Answer 21

दुष्प्रचार, रूबी

यह बॉट ठीक हो जाएगा जब तक कि 10 या अधिक इलाज के लिए छोड़ दिए जाते हैं। अगला, यदि संक्रमण दर कम से कम 4 है, तो बॉट इसे कम कर देगा। अन्य सभी कार्यों को छूत की दर को बढ़ाने में खर्च किया जाता है, जिससे मुझे कोई नुकसान नहीं होगा, क्योंकि मेरे पास कोई संक्रमित नहीं बचा है।

#You can copy this code if you want. Not specific to my strategy.
PlayerId = 0
Sane = 1
Infected = 2
Dead = 3
InfectionRate = 4
ContagionRate = 5
LethalityRate = 6
MigrationRate = 7

a = ARGV[0].split ';'
round = a.shift.to_i
my_id = a.shift.to_i
players = a.map{|s|s.split('_').map{|str| str.to_i}}

my_index = players.index{|p|
    p[PlayerId] == my_id
}
me = players[my_index]

#strategy specific code starts here.

commands = ""
commands += 'C' if me[Infected] >= 10
commands += 'C' if me[Infected] >= 20
commands += 'C' if me[Infected] >= 30
commands += 'M' if me[InfectionRate] >= 4 and commands.length < 3
commands += 'D' while commands.length < 3

print commands
$stdout.flush

Answer 22

XenoBot (Node.js)

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

XenoBot को इस तरह सक्रिय करें:

node xenobot.js [data]

कोड:

const argv = String(process.argv),
    data = argv.split(";"),
    round = data[0],
    id = Number(data[1]),
    info = data[id + 1].split("_"),
    sane = info[1],
    infected = info[2],
    dead = info[3],
    infectionRate = info[4],
    contagionRate = info[5],
    lethalityRate = info[6],
    migrationRate = info[7]

var moves = 3
function exec(a) {
  process.stdout.write(a)
}
if(migrationRate >= 10) {
  exec("B")
}
if (infectionRate >= 8) {
  exec("MQ")
  moves-=2;
} else if(contagionRate >= 16) {
  exec("EC")
  moves-=2;
} else if(lethalityRate >= 8) {
  exec("IV")
  moves--;
} else {
  exec("B");
  moves--;
}

if (sane / 3 > infected + dead) {
  exec("Q")
  moves--;
}
if(moves > 0) {
  exec("B")
}

Answer 23

रणनीतिकार, पायथन

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

के साथ बुलाया गया python strategist.py।

import sys
import random
import math


def main():
    id = int(get_player_id(sys.argv[1]))
    stats = get_player_stats(sys.argv[1], id)
    round = int(get_round(sys.argv[1]))

    if id == -1 or stats == None or round == -1:
        # Something is wrong here. RED ALERT! Close all possible entry routes and set 
        # quarantine levels to maximum!
        print("BQQ")
        sys.exit(1)

    if round == 1:
        # remove migration, cure some infected, and remove some danger
        print("BCM")
    elif round % 5 == 4:
        # Rounds 4, 9, 14 etc. One before repopulation. We want as many Healthy and as 
        # few Infected as possible to reproduce. Prioritise curing infected, because that
        # maximises Healthy for reproduction. If that's not possible, quarantine them.
        quarantine = math.ceil(int(stats['infected']) / 30)
        cure = math.ceil(int(stats['infected']) / 10)
        if cure <= 3:
            # we can deal with all our infections within 3 cures
            output = "C" * cure
            for i in range(3 - cure):
                # got moves left? Great, remove some danger.
                output += get_random_science()
            print(output)
        elif quarantine <= 3:
            # we can deal with all our infections within 3 quarantines
            output = "Q" * quarantine
            for i in range(3 - quarantine):
                # got moves left? Great, remove some danger.
                output += get_random_science()
            print(output)
        else:
            # We can't deal with all the infected in one round, so deal with some. Yes, we
            # don't get rid of as many as we could here, but we're about to reproduce so
            # we want Healthies in the next round.
            print("QQC")
    else:
        output = ""
        if int(stats['infected']) <= 10:
            # we can deal with all our infections by curing them
            output += "C"
        elif int(stats['infected']) <= 30:
            # we can deal with all our infections by quarantining them
            output += "Q"
        elif int(stats['infected']) >= int(stats['healthy']) * 0.5:
            # we're getting overrun with infected people, get rid of some
            output = "QCC"

        for i in range(3 - len(output)):
            # if we haven't used all our moves, we can remove some danger factors
            output += get_random_science()

        print(output)


def get_random_science():
    return random.choice(["M", "E", "I", "V"])


def get_player_id(args):
    splat = args.split(";")
    return splat[1] if len(splat) >= 2 else -1


def get_player_stats(args, id):
    splat = args.split(";")
    players_data = [x for x in splat if "_" in x]
    my_data = [y for y in players_data if y.split("_")[0] == str(id)]
    data_splat = my_data[0].split("_")

    if len(data_splat) == 8:
        # Id, Healthy, Infected, Dead, InfRate, ConfRate, LethRate, MigRate
        return {
            'healthy': data_splat[1],
            'infected': data_splat[2],
            'dead': data_splat[3],
            'inf_rate': data_splat[4],
            'conf_rate': data_splat[5],
            'leth_rate': data_splat[6],
            'mig_rate': data_splat[7]
        }
    else:
        return None


def get_round(args):
    splat = args.split(";")
    return splat[0] if len(splat) >= 1 else -1


if __name__ == "__main__":
    main()

Answer 24

खोलें और बंद करें

सीमाओं को खोलकर खेल शुरू करें, फिर सभी बीमारों को आने दें। हमारे पास एक बड़ी बीमार आबादी (30 राउंड) के बाद, सीमाओं को बंद करें और बीमारों को ठीक करने पर काम करें।

#You can copy this code if you want. Not specific to my strategy.
PlayerId = 0
Healthy = 1
Infected = 2
Dead = 3
InfectionRate = 4
ContagionRate = 5
LethalityRate = 6
MigrationRate = 7

a = ARGV[0].split ';'
round = a.shift.to_i
my_id = a.shift.to_i
players = a.map{|s|s.split('_').map{|str| str.to_i}}

my_index = players.index{|p|
    p[PlayerId] == my_id
}
me = players[my_index]

#strategy specific code starts here.

commands = ""
if round < 30
  commands += me[MigrationRate] == 100 ? (me[InfectionRate] <= 1 ? "V" : "M") : "O"
  commands += me[LethalityRate] <= 2 ? "V" : "I"
  commands += me[ContagionRate] <= 4 ? "V" : "E"
elsif round < 50
  commands += me[MigrationRate] == 0 ? "V" : "B"
  commands += me[LethalityRate] < 20 ? "C" : "I"
  commands += me[ContagionRate] <  5 ? "C" : "E"
else
  commands = "CCC"
end

print commands
$stdout.flush

Answer 25

दो और पायथन बॉट

इजराइल

यह Mooch के समान है, लेकिन शायद Mooch जितना अच्छा नहीं है, दुर्लभ अवसरों को छोड़कर जब यह बहुत बेहतर हो:

import sys
a = sys.argv[1].split(';')
round = int(a[0])
myid = a[1]
players = {}
Sane = 0
Infected = 1
Dead = 2
InfectionRate = 3
ContagionRate = 4
LethalityRate = 5
MigrationRate = 6
for i in range(2,len(a)):
    b = a[i].split('_')
    players[b[0]]=map(int,b[1:])
output=''
if round<=4:output = ["OOO","OOO","OOO","OII"][round-1]
if round==50: output = "CCC"
mycontrate = players[myid][ContagionRate]
myfatrate = players[myid][LethalityRate]
myinfrate = players[myid][InfectionRate]
if myinfrate+mycontrate<5:
    output+="V"
    myfatrate-=2
    if round < 47: 
        output+="I"*(myfatrate/4)
        if myfatrate%4: output+="V"
else:
    if round < 47: 
        output+="I"*(myfatrate/4)
        if myfatrate%4: output+="V"
    output+="M"*(myinfrate/4)
    if round < 47: 
        output+="E"*(mycontrate/4)
output+="CCC"

print output[:3]

रेड क्रॉस

शांतिवादी की तरह, सिवाय इसके कि वह अपने लोगों को मरने से रोकने की कोशिश करता है। इस पर बुरी तरह से विफल रहता है, लेकिन खेल के मैदान पर एक और अनुकूल होना अच्छा है।

import sys
a = sys.argv[1].split(';')
round = int(a[0])
myid = a[1]
players = {}
Sane = 0
Infected = 1
Dead = 2
InfectionRate = 3
ContagionRate = 4
LethalityRate = 5
MigrationRate = 6
for i in range(2,len(a)):
    b = a[i].split('_')
    players[b[0]]=map(int,b[1:])
output="PPPPP"
if round<=4:output = ["OOO","OOO","OOO","OII"][round-1]
elif round==50: output = "CCC"
else: output = output[:2-3*round%5]+"I"+output[2-3*round%5:]
print output[:3]

Answer 26

स्मॉग (पायथन)

मैं आग हूं; मैं मृत्यु हूं।

स्मॉग जितना संभव हो उतना मौत पैदा करता है, चाहे वह कहीं भी हो।

# "I am fire, I am death"
# Smaug has two goals: hoard gold and bring death...
#    and this world seems to be all out of gold

from sys import argv
args = argv[1].split(";")

round = int(args.pop(0))
me = int(args.pop(0))

if round==50: # can't cause more death on the last round, might as well infect
    print('TTT')

def predict_infected(infected, infection_rate, contagion_rate):
    i = infected + infection_rate
    return i + int(i*contagion_rate)

def predict_dead(infected, lethality_rate):
    return int(infected*lethality_rate)

strategies = {'WWW':0, 'WWD':0, 'WDD':0, 'DDD':0}
for player in args:
    player=player.split('_')
    healthy=int(player[1])
    infected=int(player[2])
    infection_rate=int(player[4])
    contagion_rate=int(player[5])/100.
    lethality_rate=int(player[6])/100.

    if round%5==0:
        healthy+=healthy/2
        infected+=infected/2

    pi_old = predict_infected(infected, infection_rate, contagion_rate)
    pd_old = predict_dead(pi_old, lethality_rate)

    for strat in strategies:
        ir_new = infection_rate + 3
        lr_new = lethality_rate + (strat.count('W')*.02) 
        cr_new = contagion_rate + (strat.count('D')*.02) 

        pi_new = predict_infected(infected, ir_new, cr_new)
        pd_new = predict_dead(pi_new, lr_new)

        increase = pd_new - pd_old

        strategies[strat]+=increase

print max(strategies, key=strategies.get)

Comments

यदि आप एक पॉलीग्लॉट को गोल्फ करने की कोशिश कर रहे हैं, तो खाली फ़ाइल कम होगी और वही करेगा जो देखने वाला करता है (और यह भी, जैसा कि होता है, बिल्कुल PassiveBot क्या करता है - दो पहचानता है), क्योंकि दुभाषिए के लिए कोई विकल्प नहीं है 0 लंबाई प्रतिक्रिया।

— क्विंटोपिया

@ क्विंटोपिया मैं कोशिश नहीं कर रहा था, मुझे एहसास हुआ कि जब मैंने इसे टाइप किया था कि यह आसानी से एक पॉलीग्लॉट के रूप में काम करता था, लेकिन मुझे एहसास नहीं हुआ कि पैसिवबॉट ने क्या किया है, इसलिए मैं सिर्फ वॉकर को हटाने वाला हूं (दो समान वाले होने का कोई मतलब नहीं)

— SnoringFrog

Answer 27

निकालें संक्रमित (अजगर)

सभी यादृच्छिक तर्क के बावजूद, मैं बहुत यह दुर्लभ है यह कुछ भी लेकिन क्यू के और सी के वापस जाने के लिए के लिए कर रहा हूँ (निवारक साधन कभी नहीं लग रहे हैं कि उपयोगी)। ओह अच्छा। हो सकता है कि यह किसी अन्य बॉट के लिए कुछ उधार ले, लेकिन अगर यह मदद करता है तो इसे छोड़ देना चाहिए।

# Remove as many of it's own infected as possible, preferably by curing, but quarantining if it's getting out of hand
# If not very many can be cured, takes preventative measures (B,E,M, or V)

from sys import argv

CMDS=3
C_RATE=10
E_RATE=.08
M_RATE=4
Q_RATE=30
V_RATE=(1,.04)

def find_me(args):
    for player in args:
        player=player.split('_')
        if int(player[0])==me:
            return player

def actions_available():
    global actions
    if len(actions) < CMDS:
        return True
    else:
        return False

def add_actions(new_actions):
    global actions
    actions = (actions + new_actions)[0:CMDS]

def get_remaining_infected(local_infected):
    global actions
    return local_infected - (Q_RATE*actions.count('Q')) - (C_RATE*actions.count('C'))

def too_many_infected(local_infected):
    max_infected = C_RATE*(CMDS+1) # If we can get down to 10 or less without quarantining, that's good
    if local_infected > max_infected:
        return True
    else: return False

def projection(infection_rate, remaining_infected, action):
    additional_M=0
    additional_E=0
    additional_V=0

    if action == "M":
        additional_M=1
    elif action == "E":
        additional_E=1
    else:
        additional_V=1

    M_level = M_RATE*(actions.count('M')+additional_M)
    E_level = E_RATE*(actions.count('E')+additional_E)
    V_level = (V_RATE[0]*(actions.count('V')+additional_V), V_RATE[1]*(actions.count('V')+additional_V))

    projection = infection_rate - M_level - V_level[0] + (remaining_infected * (contagion_rate - E_level - V_level[1])) 
    return int(projection)

def get_best_action(local_infected):
    global actions
    remaining_infected = get_remaining_infected(local_infected)

    # If we can leave no infected, do so
    if remaining_infected <= C_RATE and remaining_infected >= 0:
        return 'C'

    strategies = {'M':0, 'E':0, 'V':0,'C':min(remaining_infected,C_RATE)}

    pni = int(infection_rate + (remaining_infected*contagion_rate)) # predicted new infected
    strategies['M'] = pni - projection(infection_rate, remaining_infected, 'M')
    strategies['E'] = pni - projection(infection_rate, remaining_infected, 'E')
    strategies['V'] = pni - projection(infection_rate, remaining_infected, 'V')
    # any benefit to including P as an option? 

    #print(strategies)
    max_saved = 'C'
    for strat,saved in strategies.iteritems():
        if saved > strategies[max_saved]:
            max_saved=strat
        elif saved == strategies[max_saved]:
            #prioritize V because of it's extra benefit of reducind lethality_rate
            max_saved=max(strat,max_saved) 

    if strategies[max_saved] <= C_RATE/2:
        # can't save that many, just close borders instead
        selected_action = 'B'
    else: selected_action = max_saved
    return selected_action


args = argv[1].split(";")
round = int(args.pop(0))
me = int(args.pop(0))
actions = ""

my_town = find_me(args)

local_infected = int(my_town[2])
infection_rate = int(my_town[4])
contagion_rate = int(my_town[5])/100.

if round!=50 and too_many_infected(local_infected):
    # Things are getting out of hand, quarantine and consider preventative measures
    actions = ('Q'*(local_infected/Q_RATE))[0:CMDS]

    while actions_available():
        add_actions(get_best_action(local_infected))
else: actions='CCC'

print ''.join(sorted(actions)) # always cure first

Comments

@ थ्रक्स इस बॉट को अपडेट किया गया है

— SnoringFrog

Answer 28

CureThenQuarantine, जावा

राज्य ने उन भाग्यशाली लोगों को ठीक करने और फिर संक्रमित व्यक्तियों के बचे रहने को रोकने के लिए नीति बनाई है। एक बार जब संक्रमित आबादी कम हो जाती है तो स्थानीय दरों को कम करने और फिर वैश्विक दरों को कम करने में मदद मिलती है।

राज्य में कोई संक्रमित प्रवास सुनिश्चित करने के लिए सीमाएं बंद हैं।

मैंने केवल बॉट का परीक्षण जावा और पाइथन बॉट्स के खिलाफ किया है ... ऐसा लगता है कि यह उनके खिलाफ है। यह भी लगता है कि मेरा बॉट CullBot के समान व्यवहार करता है।

public class CureThenQuarantine {
    static int playerID;

    public static void main(String[] args)
    {
        State thisState=null;

        args = args[0].split(";");

        // Parse arguments
        int round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        for (int i = 2; i < args.length; i++){
            thisState = new State(args[i]);
            if(thisState.isMine()){
                break;
            }
        }

        String action="";
        if(round == 1) action = "B"; // ensure no migration.
        else if (round == 50 ) action ="CCC"; // not much else we can do so just cure some people.

        // Highest Priority to Curing and then Quarantining infected, but do not perform either action if it would be wasteful.
        if (thisState.infected>9)
        {
            if (thisState.infected<19) action+="C";
            else if (thisState.infected<29) action+="CC";
            else if (thisState.infected<39) action+="CCC";
            else if (thisState.infected<49) action+="CQ";
            else if (thisState.infected<59) action+="CCQ";
            else if (thisState.infected<79) action+="CQQ";
            else action+="QQQ";
        }

        // Next priority is to reduce infection rate
        if (thisState.infectionRate>8) action+="MMM";
        else if (thisState.infectionRate>4) action+="MM";
        else if (thisState.infectionRate>1) action+="M";
        else if (thisState.infectionRate>0) action+="V";

        // then reduce contagion rate
        if (thisState.contagionRate>16) action+="EEE";
        else if (thisState.contagionRate>8) action+="EE";
        else if (thisState.contagionRate>1) action+="E";
        else if (thisState.contagionRate>0) action+="V";

        // and least priority is lethality rate... since we are only going to quarantine infected persons anyway.
        if (thisState.lethalityRate>8) action+="III";
        else if (thisState.lethalityRate>4) action+="II";
        else if (thisState.lethalityRate>1) action+="I";
        else if (thisState.lethalityRate>0) action+="V";

        // and if we have managed to clean up our state then we help others states.
        action+="PPP";

        System.out.println(action.substring(0,3));
    }

    static private class State {
        public int ownerId;
        public int lethalityRate;
        public int healthy;
        public int infected;
        public int infectionRate;
        public int contagionRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            healthy = Integer.parseInt(args[1]);
            infected = Integer.parseInt(args[2]);
            infectionRate = Integer.parseInt(args[4]);
            contagionRate = Integer.parseInt(args[5]);
            lethalityRate = Integer.parseInt(args[6]);
        }

        public boolean isMine(){
            return ownerId == playerID;
        }
        public String toString()
        {
            return "H: "+healthy+" I: "+infected+" IR: "+infectionRate+" LR: "+lethalityRate+" CR: "+contagionRate;
        }
    }
}

Answer 29

शोधकर्ता, जावा

यह बॉट अनुसंधान पर केंद्रित है। यदि संक्रमित की संख्या 15 से कम है, तो यह उन्हें ठीक करने की कोशिश करता है। यदि यह इससे अधिक है, तो यह अधिक प्रभावी समाधान चुनता है ।

public class Researcher {
    public static void main(String[] args){
        String[] args1 = args[0].split(";");
        int id = Integer.parseInt(args1[1]);
        for (int i = 2; i < args1.length; ++ i) {
            String[] args2 = args1[i].split("_");
            if (Integer.parseInt(args2[0]) == id) {
                int infected = Integer.parseInt(args2[2]);
                if (infected == 0) {
                    System.out.println("MEI");
                } else if(infected < 15) {
                    System.out.println("MEC");
                } else {
                    System.out.println("MEQ");
                }
            }
        }
    }
}

Comments

जावा भाषा, मुझे लगता है ??

— बिल्ली

Answer 30

टुकड़ा, जावा

मेरे पिछले बॉट (CureThenQuarantine) के आधार पर, मैंने पाया है कि खेलने में आक्रामक बॉट्स के साथ, संगरोध की कोई आवश्यकता नहीं है क्योंकि संक्रमित बहुत जल्दी मर जाएगा, इसलिए यह बॉट अवसरवादी रूप से 10 संक्रमित प्रत्येक मोड़ को ठीक कर देगा (या माइग्रेशन से आ रहा है) स्वस्थ जनसंख्या से संक्रमण से)। यह तब स्वस्थ जीवन को बढ़ावा देने के लिए स्वस्थ जनसंख्या को जन्मों पर निर्भर रहने के लिए शेष कार्यों का उपयोग करेगा।

राज्य में कोई संक्रमित प्रवास सुनिश्चित करने के लिए सीमाएं बंद हैं।

public class Piecemeal{
    static int playerID;

    public static void main(String[] args)
    {
        State thisState=null;

        args = args[0].split(";");

        // Parse arguments
        int round = Integer.parseInt(args[0]);
        playerID = Integer.parseInt(args[1]);

        for (int i = 2; i < args.length; i++){
            thisState = new State(args[i]);
            if(thisState.isMine()){
                break;
            }
        }

        String action="";
        if(round == 1) action = "B"; // ensure no migration.
        else if (round == 50 ) action ="CCC"; // not much else we can do so just cure some people.

        // Highest Priority to Curing up to ten infected if there are any.
        if (thisState.infected>0)
        {
            action+="C";
        }

        // Next priority is to reduce infection rate
        if (thisState.infectionRate>8) action+="MMM";
        else if (thisState.infectionRate>4) action+="MM";
        else if (thisState.infectionRate>1) action+="M";
        else if (thisState.infectionRate>0) action+="V";

        // then reduce contagion rate
        if (thisState.contagionRate>16) action+="EEE";
        else if (thisState.contagionRate>8) action+="EE";
        else if (thisState.contagionRate>1) action+="E";
        else if (thisState.contagionRate>0) action+="V";

        // and least priority is lethality rate... since we are only going to quarantine infected persons anyway.
        if (thisState.lethalityRate>8) action+="III";
        else if (thisState.lethalityRate>4) action+="II";
        else if (thisState.lethalityRate>1) action+="I";
        else if (thisState.lethalityRate>0) action+="V";

        // and if we have managed to clean up our state then we help others states.
        action+="PPP";

        System.out.println(action.substring(0,3));
    }

    static private class State {
        public int ownerId;
        public int lethalityRate;
        public int healthy;
        public int infected;
        public int infectionRate;
        public int contagionRate;

        public State(String string) {
            String[] args = string.split("_");
            ownerId = Integer.parseInt(args[0]);
            healthy = Integer.parseInt(args[1]);
            infected = Integer.parseInt(args[2]);
            infectionRate = Integer.parseInt(args[4]);
            contagionRate = Integer.parseInt(args[5]);
            lethalityRate = Integer.parseInt(args[6]);
        }

        public boolean isMine(){
            return ownerId == playerID;
        }
        public String toString()
        {
            return "H: "+healthy+" I: "+infected+" IR: "+infectionRate+" LR: "+lethalityRate+" CR: "+contagionRate;
        }
    }
}