কোথ: বিশ্বব্যাপী মহামারী

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

এখানে, আপনি দেখুন এটি 6th ষ্ঠ রাউন্ড এবং আপনি খেলোয়াড় ২। আপনার মধ্যে 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: কিউ ইউরেনটাইন [প্রভাব: 30 স্থানীয় সংক্রামিত সরান ]
O: হে কলম সীমানা [প্রভাব: স্থানীয় মাইগ্রেশন হার 10% বৃদ্ধি করুন ]
B: বি অর্ডারগুলি বন্ধ করুন [প্রভাবসমূহ: স্থানীয় অভিবাসনের হার 10% দ্বারা হ্রাস করুন ]
T: বায়ো টি ত্রুটিবাদ [প্রভাবগুলি: রূপান্তর 4 বিশ্বব্যাপী স্বাস্থ্যকর করতে সংক্রমিত ]
W: ওয়াট eaponization [এফেক্টস: বিশ্বব্যাপী বাড়ান সংক্রমণের হার 1, গ্লোবাল বৃদ্ধি প্রাণঘাতী হার 2%] এর দ্বারা
D: D: বিশ্বব্যাপী বৃদ্ধি: issemination [এফেক্টস সংক্রমণের হার1 দ্বারা, বৈশ্বিক সংক্রমণের হার 2% বাড়িয়ে নিন ]
P: পি অ্যাসিফিকেশন [প্রভাব: গ্লোবাল ইনফেকশন রেট 1 দ্বারা হ্রাস করুন, বৈশ্বিক সংক্রমণের হার 1% হ্রাস করুন, বৈশ্বিক লেথালિટી রেট 1% হ্রাস করুন ]

গেমপ্লের

সমস্ত পর্যায়ক্রমে

অবৈধ কমান্ড = কোনও কিছুই
পার্সেন্টেজ পূর্ণসংখ্যার মতো যোগ করা হয় না, অর্থাৎ 10% - 4% = 6%। যখন কোনও সূত্রে শতাংশ প্রয়োগ করা হয়, ফলাফলটি মেঝেতে থাকে।

পর্ব 1: রূপান্তর

মহামারীটি আরও শক্তিশালী হয়ে উঠছে। প্রতিটি পালা, এলোমেলোভাবে এই বৈশিষ্ট্যগুলির মধ্যে একটি লাভ করে (এই রূপান্তরটি সমস্ত খেলোয়াড়কে একবারে প্রভাবিত করে):

• বৈশ্বিক সংক্রমণের হার 2 দ্বারা বৃদ্ধি করুন
• বিশ্বব্যাপী সংক্রমণের হার 5% বৃদ্ধি করুন
• বৈশ্বিক প্রাণঘাতী হার 5% বাড়ান

দ্বিতীয় পর্যায়: প্রজনন

প্রতি পাঁচ রাউন্ডে (5, 10, 15 ...), নতুন নাগরিকের জন্ম হবে। প্রতিটি জোড়া স্বাস্থ্যকর এক করতে হবে স্বাস্থ্যকর (23 স্বাস্থ্যকর 11 নতুন জেনারেট স্বাস্থ্যকর )। প্রতিটি জোড়া সংক্রামিত এক করতে হবে সংক্রামিত ।

পর্ব 3: হিজরত

প্রতিটি পালা, স্বাস্থ্যকর এবং সংক্রামিতদের শতকরা এক ভাগ তাদের রাজ্য ছেড়ে চলে যাবে, তাদের মাইগ্রেশন হারের উপর নির্ভর করে (১০ জন স্বাস্থ্যবান ১০০ স্বাস্থ্যকর এবং ১০% অভিবাসন হার সহ একটি রাজ্য ত্যাগ করবে )। তারপরে, অভিবাসীদের আবারও প্রতিটি রাজ্যের মধ্যে বিতরণ করা হবে, আবারও অভিবাসন হারের উপর নির্ভর করে । (প্রতিটি রাজ্যের হার ওজনযুক্ত এবং অভিবাসীরা তারপরে সমস্ত বিতরণ করা হয়)।

পর্ব 4: সংক্রমণ

প্রতিটি রাজ্যের স্বাস্থ্যকর সংক্রমণের হার অনুযায়ী সংক্রামিত রূপান্তরিত হয় ।

পর্ব 5: সংক্রামক

সংক্রমণের হার অনুসারে প্রতিটি রাজ্যের স্বাস্থ্যকর সংক্রামিত রূপান্তরিত হয় । সংখ্যা গুন দ্বারা গণনা করা হয় সংক্রামিত দ্বারা রোগসংক্রমণ হার ।

Hase ম পর্যায়: বিলুপ্তি

সংক্রামকরা প্রাণঘাতী হার অনুসারে ডেডে রূপান্তরিত হয় । সংখ্যাকে প্রাণঘাতী হার দ্বারা সংক্রামিত করে গুণ করা হয় ।

পর্ব 7: খেলোয়াড়দের পালা

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

বিধি

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

জয়লাভ

বিজয়ী হ'ল 50 রাউন্ডের পরে সবচেয়ে স্বাস্থ্যকর with যদি কোনও খেলোয়াড় শেষ বেঁচে থাকে (0 টিরও বেশি স্বাস্থ্যকর বা সংক্রামিত ) খেলাটি বন্ধ হয়ে যায় এবং তিনি জিতেন। যদি একাধিক খেলোয়াড়ের স্বাস্থ্যকর পরিমাণ একই থাকে তবে সর্বাধিক সংক্রামিত ব্যক্তিই জিততে পারে, তবে একজন কম সংখ্যক মৃত ব্যক্তির সাথে ।

নিয়ামক

আপনি গিটহাবের নিয়ামকটি খুঁজে পেতে পারেন । এটিতে জাভাতে লেখা তিনটি স্যাম্পলবট রয়েছে।
এটি চালানোর জন্য, প্রকল্পটি দেখুন এবং এটি আপনার জাভা আইডিইতে খুলুন। 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 কমান্ড পেতে পারি যা X পরিমাণ সংক্রামিত খুন করে (তাদেরকে সরাসরি মরাতে পরিণত করে)? সম্ভবত জয়ের পক্ষে কার্যকর একটি পদ্ধতি নয়, তবে এমন একটি ক্রিয়া যা বৈধ বলে মনে হয়। যদি না কোয়ারানটাইন যা করে তা (এটি অস্পষ্ট)।

— ড্র্যাকো 18

দ্রুত ব্যাকরণ নোট: "সানে" এর অর্থ "মানসিকভাবে স্থিতিশীল"; আপনি যে শব্দটি (সম্ভবত) খুঁজছেন তা হ'ল স্বাস্থ্যকর "। (আপনার অনুমানের ক্ষেত্রে আমি কী সঠিক হতে পারি যে আপনার প্রথম ভাষা স্প্যানিশ, যেখানে "স্যানো" এর অর্থ "স্বাস্থ্যকর," বা ঘনিষ্ঠভাবে সম্পর্কিত কিছু?)

— ম্যাসন হুইলারের

@MasonWheeler Nitpicking পরিভাষা দ্রষ্টব্য: আপনার লক্ষ্য করুন, একটি পরিভাষা বা শব্দভান্ডার নোট হিসাবে কোন ব্যাকরণ জড়িত ছিল;)

— জানুয়ারী

@ থ্রাক্স যেভাবে মোড়গুলি বর্তমানে পরিচালনা করা হয় (শুরুতে এলোমেলোভাবে একই পদ্ধতি, তারপরে থেকে) একই সময়ে, পরবর্তী সময়ে আসা খেলোয়াড়দের একটি বিশাল সুবিধা প্রদান করে, যা শেষের ফলাফলটিকে বুনো রূপ দেয়। সম্ভবত আপনি যদি 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

বাহ, আমি প্রত্যাশা করিনি যে থিকিউরটি সর্বশেষ হবে

— জাস্টহাল্ফ

@ समायফাল্ট এই অনেক খেলোয়াড়ের সাথে, তারা সকলেই বোর্ডগুলিতে প্রচুর পরিমাণে ঘোরাঘুরি করে: ঠিক এখন দৌড়ে একটি যেখানে দ্যা কুরির ২ য় স্থানে শেষ হয়েছিল। উভয়ই ফ্যামিলিভ্যালু এবং ট্রেজ প্রায় সবসময় শীর্ষ দুটিতে থাকে যদিও এফভি বেশিরভাগ সময় # 1 পেয়ে থাকে।

— Mwr247

হুঁ, কাজ নিজেই নির্বিচারে, তাই না? তাহলে কি কিছু খেলোয়াড় তাদের অ্যালগরিদমে এলোমেলোভাবে রাখার কারণে?

— justhalf

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

— 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

এটি সরবরাহের জন্য জে আটকিনকে ধন্যবাদ:

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

AllOrN কিছুই, আর

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 অন্য রাজ্যের বিরুদ্ধে এটি অসাধারণ ভাল করছে বলে মনে হচ্ছে!

— থ্রাক্স

@ থ্রাক্স সত্যই, যদিও মাঝে মাঝে কিছু রান চলাকালীন সময়ে, এটি এখনও বেশ চিত্তাকর্ষকভাবে ব্যর্থ হয় :) তবে বেশিরভাগ ক্ষেত্রে এটি আপনার পরীক্ষার রান হিসাবে সফল হয়।

— প্ল্যানাপাস

বেশ আশ্চর্যজনক বট হয়, ভাল কাজ

— Eumel

এটি এমন একটি রাষ্ট্রের সাথে খুব মিল দেখাচ্ছে যখন আমি সময়টি পেলাম যখন অভিন্ন নয়, তবে আমি লিখতে যাচ্ছিলাম। আমার কেবলমাত্র আমার মাথায় উপস্থিত রয়েছে ("যদি 20 বিসুখ সংক্রামিত হয় তবে তাদেরকে পৃথক পৃথক করে রাখুন, যদি 10 টি হয় তবে তাদের নিরাময় করুন" ইত্যাদি) এত ভাল কাজ।

— ড্রাকো 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

অ্যাস্কেলপিয়াসের রডের মতো পাইথনস? না হার্মিসের কর্মীদের মত? এটি কিছুটা বোঝাতে পারে ...

— চার্লস

হয়! উভয়! কেন না? এটি সব বোঝায়!

— কনর ও'ব্রায়ান

++, 1; টিএফ 2 এর জন্য: ডি

— বিড়াল

Answer 5

উপশম

এটি কিছুটা সরল মনে হলেও এটি সংক্রমণ / মৃত্যুর হারকে নীচে রাখার মতো খুব ভাল পদ্ধতির মতো বলে মনে হয়। প্রতিটি ঘুরে, আউটপুট MCQ:

• সংক্রমণের হার হ্রাস করুন
• কিছু সংক্রামিত নিরাময়
• সংক্রামকৃত কিছু কিছুকে আলাদা করে রাখুন

এটাই!

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

আমি নিরাময় এবং পৃথকীকরণের পরিবর্তে আমার যদি বর্তমানে কোনও সংক্রামিত না হয়ে থাকে তবে আমি আরও বেশি আউটপুট করে Mবা এটি উন্নত করতে পারি B, তবে আমি দেখতে চাই যে এটি প্রথমে কতটা ভাল করে। দুর্ভাগ্যক্রমে, প্রথম পোস্ট করার একটি পার্শ্ব প্রতিক্রিয়া হ'ল কার্যকারিতাটি পরীক্ষা করা শক্ত:

Answer 6

দুষ্ট, কোটলিন

মনে রাখবেন, উইকড ভাল হয়।

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

সংকলন আমাকে গেম, প্লেয়ার এবং উইককেডিকেট ক্লাসের সাথে একটি "দুষ্ট" ফোল্ডার দেয়। যেমনটি আপনি বর্ণনা করেছেন তেমন দৌড়াচ্ছে: "ত্রুটি: প্রধান শ্রেণীর দুষ্টকে খুঁজে পেতে বা লোড করতে পারেনি WWICKEDKt"

— Mwr247

এটি অদ্ভুত, এটি ঠিক আমার কম্পিউটারে কাজ করে। আপনি কি নিশ্চিত যে উইকডেকেট ক্লাস ফাইলটির নাম প্রকৃতপক্ষে উইককেডকেট নয়? এছাড়াও, নিশ্চিত হয়ে নিন যে আপনার ওয়ার্কিং ডিরেক্টরিটি দুষ্ট ফোল্ডারের মধ্যে নেই।

— TheNumberOne

এটি উইকেডকেট আমি মন্তব্য টাইপ করেছি।

— Mwr247

@ Mwr247 আপনি কি সাবমিশন ফোল্ডারের ভিতরে উত্পন্ন দুষ্ট ফোল্ডারটি রেখে গেছেন? আপনি কি দুষ্ট ফোল্ডার থেকে উত্পন্ন ফাইলগুলি সরিয়ে নিয়েছেন?

— TheNumberOne

দুষ্ট ভাল ... আমি আপনাকে শুধু পড়েছি এমন জিনিসগুলির জন্য আপনাকে এবং আপনার রেফারেন্সগুলিকে তিরস্কার করা।

— আর্টঅফকোড

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");
        }
    }
}

<sub>সম্পাদনা 1 - আমি আরও-মাদাগাস্কার সম্পাদনা 2
- এই startsWithঅনুস্মারকটির জন্য ধন্যবাদ @ জিওবিটস</sub>

Comments

জিওবিটস যদি মাইগ্রেশন রেট 5 থেকে শুরু করে এবং শূন্যে হ্রাসযোগ্য না হয় সে সম্পর্কে সঠিক হন, বি এর একেবারেই কিছুই করবেন না।

— কুইন্টোপিয়া

এটি বর্তমানে এটি সংকলন হিসাবে দেখায় না। if (b == true)(যা if (b)স্টাইলের বিষয় হিসাবে হওয়া উচিত ) একটি ত্রুটি দেয় কারণ ভেরিয়েবলটি আসলে বলা হয় bool।

— পিটার টেলর

বৃত্তের বিরুদ্ধে পরীক্ষা করা যদি == 1 ফাইল তৈরির চেয়ে অনেক বেশি ভাল কাজ করে?

— ইউমেল

ভাগ্যক্রমে, টিমিডি, প্রথম দফাটি প্রথম, তাই খুব বেশি পার্সিংয়ের সাথে জড়িত নয়। ইনপুটটি শুরু হয় কিনা তা কেবল পরীক্ষা করুন1;

— জিওবিটস

@ জিওবিটস startsWith()অনুস্মারকটির জন্য ধন্যবাদ । বিভক্ত হওয়া ;এবং পুনরায় দখল করার চেষ্টা করার চেয়ে অনেক বেশি সহজ এবং ... আমি জানালাম আমি জাভাতে মরিচা পড়েছি।

— অ্যাডমবর্কবার্ক

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

সম্পাদনা: বেশিরভাগ "শেষ অবধি" বট মারা না যাওয়া পর্যন্ত বেঁচে থাকার উচ্চ সম্ভাবনা

উদাহরণ ফলাফল:

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

খুব সুন্দর কৌশল। আমি পছন্দ করি যে আপনি "ভাল" উপায়ে প্রাণঘাতীতা ব্যবহার করেছেন!

— থ্রাক্স

"দ্য ওয়ার্ল্ডের শেষ" বটগুলিকে শেষ করে দেওয়া ভাল কাজ! তবে, এই বটগুলিতে আরও কয়েকজন থাকলে লবণ পচে যেতে পারে, যদিও আমি নিশ্চিত নই। যে বেঁচে থাকার ক্ষমতা ইতিমধ্যে খুব চিত্তাকর্ষক, দুর্দান্ত এক ব্যক্তি!

— বুসুকসুয়ান

@ বুসুকক্সুয়ান বর্তমানে যেমন রয়েছে তেমনি বেশ কয়েকটি বটকে প্রাণহানির হারকে আরও বাড়িয়ে দিতে হবে তারা এটি মেরে ফেলার আগে, প্রক্রিয়াতে নিজেদের হত্যা করেছিল।

— 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

বাহ, কী প্রযুক্তিগত বিশুদ্ধতা! আমি পছন্দ করি আপনি কীভাবে পি কমান্ডটি ব্যাখ্যা করেন।

— বুসুকসুয়ান

আমি সবেমাত্র হাস্কেল 7..১০.৩ ইনস্টল করেছি এবং আমি যখন আপনার বট চালানোর চেষ্টা করি তখন এটি অনির্দিষ্ট সময়ের জন্য অপেক্ষা করে। আমি এই সাথে চেষ্টা: runhaskell.exe PureBot.hs 1;0;0_97_3_0_2_5_15_5;1_97_3_0_2_5_15_5। এটি চালানোর আগে আমার আরও কিছু করার দরকার আছে?

— থ্রাক্স

@ থ্রাক্স ওহ, দুঃখিত আমি ভেবেছিলাম আপনি স্ট্যান্ডিনের মাধ্যমে কমান্ডগুলি পাস করেছেন ... এটি না হলে আমি প্রোগ্রামটি পরিবর্তন করব।

— YoYoYonnY

কমান্ডগুলি আর্গুমেন্ট হিসাবে পাস করা হয়। আপনি আপনার বট আপডেট করার পরে আমি পরবর্তী রান করব।

— থ্রাক্স

@ থ্র্যাক্স সে ক্ষেত্রে এটি এখনই কাজ করা উচিত।

— 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

খুব সুন্দর মানক সুরক্ষা বট যা সীমানা বন্ধ করে দেয় এবং শহরে সংক্রমণের হার হ্রাস করার চেষ্টা করে। এটি প্রাণী ভেক্টরকে কুল করে (যা সংক্রামিত লোকেরা সংক্রমণের হারের উপর কোনও প্রভাব ফেলে না, এটি মানবেতর ভেক্টরগুলির সাথে অবশ্যই কিছু করার দরকার; মূলত এটি "রিসার্চ মাইক্রোবায়োলজি")। মাঝেমধ্যে এটি সংক্রামিত মানুষগুলিকেও "কুলস" করে দেয় ... আপনি জানেন, এআই ভুলগুলিও করে ...

# 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

আমি পাইথন লোক নই, সুতরাং আমি এই ভুলটি করতে পারি, তবে পাইথন ৩.৪ এ চালানো আমাকে 9

— নং

@ এমডব্লিউ 247 ধন্যবাদ, প্রমাণিত হয়েছে যে আমি যখন পার্সিং কোডটি লিখেছিলাম তখন আমি আমার মন থেকে পুরোপুরি বাইরে ছিলাম ... এর চেয়ে আরও অনেক বেশি সমস্যা ছিল।

— বুসুক্সুয়ান

এখন এটি "TypeError: 'list' অবজেক্টটিকে পূর্ণসংখ্যা হিসাবে ব্যাখ্যা করা যায় না" লাইন 11

— Mwr247

এখন এটি কাজ করে =)

— Mwr247

@ Mwr247 লোল! আমি ভেবেছিলাম আমি এটি ঠিক করে ফেলেছি, তবে আমি নতুন কোডটি অনুলিপি করে আটকালাম না তাই অনুমান করি আমি এটিটি মিস করেছি। আমি পরীক্ষা করেছি, এখন ঠিকঠাক হওয়া উচিত be যদি না আমি কোনওভাবে আই / ও বিধিগুলি ভুল বুঝি না।

— বুস্কুকুয়ান

Answer 12

এভিলবট, জাভা

এভিলবট মানুষকে নিরাময়ের বিষয়ে চিন্তা করে না। যতদিন তারা বেঁচে থাকে (কিন্ডা) বিশ্বের অন্যান্য অংশকে অসুস্থ করার চেষ্টা করে।

আমার স্থানীয় পরীক্ষায় ব্লেন্ডারবট আরও ভাল কাজ করছিল যতক্ষণ না আমি এভিলবটকে পরিচয় করিয়ে দিয়েছি। জিনিসগুলি কিছুটা ঝাঁকুনির মতো মনে হচ্ছে।

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");
    }
}

ডাব্লুএমডি বট হ'ল একটি বিড়ম্বনা: নিজস্ব সংক্রমণের হার কম রাখে এবং অন্য সকলের উত্থাপন করে।

সংক্ষিপ্ত আকারের জন্য বট নিখুঁতভাবে নির্মিত, সম্ভবত কোনও শক্তিশালী প্রতিযোগী নয়, তবে প্রতিযোগিতামূলক ক্ষেত্রটিকে আরও আকর্ষণীয় করে তুলবে ... কোড থিকিউর থেকে ধার নিয়েছে এবং সবেমাত্র এর ক্রিয়াটির স্ট্রিং পরিবর্তন করেছে।

Comments

প্রযুক্তিগতভাবে আপনি শ্রেণীর নামও পরিবর্তন করেছেন; পি

— ক্যাপ্টেন ম্যান

@ ডেনহামকোট: দয়া করে ভাষা যুক্ত করার জন্য ট্যাগ যুক্ত করবেন না। আপনি যদি কোনও পোস্ট সম্পাদনা করতে যাচ্ছেন তবে নিশ্চিত হয়ে নিন যে এটি আরও কিছু তাত্পর্যপূর্ণ (ব্যাকরণ, বিন্যাসকরণ ইত্যাদি)। ধন্যবাদ।

— জ্যাচ গেটস

উহু? আমার একবারে আমার পোস্টে একমাত্র সম্পাদনা হিসাবে ছিলাম - আমি কেবল অন্য কারও নেতৃত্ব অনুসরণ করছিলাম ...

— ডেনহাম কোট

@ ডেনহামকোট এটি এমন "সহজ সস্তা সম্পাদনা "গুলির মধ্যে একটি যা কিছুই যোগ করে না, তবে এগুলি আসলে নিষিদ্ধ নয়। তাদের একগুচ্ছ করা স্প্যামি হয়ে যায়।

— ড্রাকো 18

আপনি 'সস্তা' বলতে কী বোঝেন তা নিশ্চিত নন - এটি আমার পক্ষে পাঠযোগ্যতার সাথে যুক্ত হয়েছে ... একটি সাধারণ গল্ফিং চ্যালেঞ্জের চেয়ে এই চ্যালেঞ্জটি পড়ার জন্য আরও অনেক কোড রয়েছে এবং তাই আমি ভাবলাম বাক্য গঠনটি হাইলাইটটি স্বাগত হবে। আমি পয়েন্টের জন্য এটি করছি এমন নয়, আমি এই চ্যালেঞ্জটি উপভোগ করেছি।

— ডেনহাম কোট

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

@ থ্রাক্স দেখে মনে হচ্ছে আমার বটটি আপনার সাম্প্রতিকতম রানটিতে অন্তর্ভুক্ত ছিল না। আমি কিভাবে কৌতূহলী তা দেখতে আগ্রহী!

— টিট্রাউজারগুলি

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

বিবাহ তার অর্থের জন্য পারিবারিক মূল্যবোধকে এক রান দেয় run অন্যদিকে মোচ অসুস্থ মানুষের একটি ভীতিকর বিশাল সেনা গঠন করে চলেছে। সাবাশ!

— Mwr247

মোচবোট সবাইকে নির্বিঘ্নে রাখার চেষ্টা করছে না? স্টেট স্টেট.এক্স স্টেট মানটি পরিবর্তন করে না এবং তারপরে গেমটি আবার স্ট্রিং থেকে এটি পরিবর্তন করে যা আপনাকে দ্বিগুণ প্রভাব দেয়? শেষ রাউন্ডে

— থ্রিস

কোডটি এখনই বুঝতে পেরেছি এবং আমার দ্বিতীয় প্রশ্নটি বেশ বোকা বলে মনে হয়েছে

— ইউমেল

মোচবট শেষ পর্যন্ত একটি স্বাস্থ্যকর জনসংখ্যা তৈরি করার চেষ্টা করে তবে খোলা সীমানা + শূন্য প্রাণঘাতীতা নিশ্চিত করে যে সংক্রামিত জনসংখ্যা আরও দ্রুত বৃদ্ধি পাবে।

— হিস্টোক্র্যাট

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

আপনার করা পরিবর্তনটি পরবর্তী রানের জন্য বিবেচিত হবে। এটি এখনও দ্বিতীয় দৌড়ে প্রতিযোগিতা করবে না, যেহেতু আপনার কৌশলটি সংক্রামিতদের জন্য একটি নিরাপদ হ্যাভেন তৈরি করেছে। তবুও খুব আকর্ষণীয়!

— থ্র্যাক্স

@ থ্রাক্স লোল ধন্যবাদ, এটি আসলে কোনও কৌশল নয়। আমি কেবল ভেবেছিলাম আক্রান্তরা সম্ভবত সুস্থদের দ্বারা কুসংস্কারযুক্ত বা বৈষম্যমূলক আচরণ করবেন, তাই বিশৃঙ্খলা বিশ্বে সম্ভবত এটি সম্ভবত "সহযোগী সংক্রামিত" রাষ্ট্র গঠনের অনুঘটক করবে। সত্যি কথা বলতে কি এটি ছিল একটি মজাদার বট, তবে তারপরে আমি এতে কিছুটা সম্ভাবনা দেখেছি তাই আমি জমা দিয়েছি।

— বুসুকসুয়ান

@ থ্রাক্স দুঃখিত, যদি এটি অসুবিধে হয় তবে আমি কেবলমাত্র জানতে পেরেছিলাম যে আমি নীচের শর্তগুলিতে ভুল গণনা করেছি তাই আমি আবার আপডেট করেছি।

— বুসুক্সুয়ান

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]

প্রত্যেকে জড়িত ৪ রান:

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)

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

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

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

EDIT4: উন্নত সময় এবং নিরাময়ের কার্যকারিতা।

এডিআইটি 5: মাইগ্রেশনে জড়িত জিনিসগুলি সরানো হয়েছে, যেহেতু এটি আর শূন্য জনসংখ্যাকে কখনও আঘাত করে না এবং নিরাময়ের জন্য আরও কিছু বিশেষ ক্ষেত্রে।

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

EDIT7: উচ্চ মেমরির ব্যবহার রোধ করতে ক্যাপের সংক্রমণ / সংক্রমণের হারের 50 টি হার exp

Comments

অপেক্ষা করুন ... ইস্রায়েল কি ডাব্লুডাব্লুজেড জেরুজালেমের পরে খুব লম্বা দেয়াল দিয়ে মডেলিং করেছে?

— বাসুকসুয়ান

@ বুসুক্সুয়ান এটি অনুপ্রেরণা ছিল হ্যাঁ, কেবলমাত্র এই ইস্রায়েলিটি সিনেমায় জেরুজালেমের সাথে সাদৃশ্যপূর্ণ (দ্রুত সংক্রামিত দ্বারা ছাপিয়ে গেছে), যেহেতু এটি মূলত এটি ল মূচের সীমানা জুড়েই উন্মুক্ত। মূল পরিকল্পনাটি ছিল বেশিরভাগ ক্ষেত্রে 'পি' করার জন্য, তবে এটি কার্যকর কৌশল ছিল না।

— কুইন্টোপিয়া

এইচএম ... মনে হয় প্রিয় কুলবট যখন সংক্রমণ বাড়ানোর চেষ্টা করছে এমন আরও বট রয়েছে তখন আর ধরে রাখতে পারে না।

— বুসুকসুয়ান

এটি দুর্দান্ত কাজ করে যখন আমি সংক্রমণের জন্য গাড়ি চালানোর জন্য একটি

— বোটে

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

— বুসুকসুয়ান

Answer 18

রক্ষক, লুয়া

সহকর্মী ফরাসি ব্যাঙের দ্বারা করা কোটএইচ! আমাকে এই প্রতিযোগিতায় থাকতে হয়েছিল!

এই বটটি তার সংক্রমণ / সংক্রামক এবং মারাত্মক হার যতটা সম্ভব কম রাখতে যথাসাধ্য কিছু করবে। এর সর্বাধিক অগ্রাধিকার হ'ল 0 এর কাছাকাছি একটি প্রাণঘাতী হওয়া It তারপরে অনুমান করার চেষ্টা করা হবে যখন আরও বেশি লোককে "আমদানি" করার চেষ্টা করা ভাল।

সম্পাদনা: আমি ধরে 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 রাউন্ড ব্যতীত তাদের সম্পর্কে কম যত্ন নিতে পারে না every প্রতি রাউন্ডে জম্বি ফার্ম হওয়ার চেষ্টা করা হয়

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

জম্বি স্টেট, জাভা

আরে, এটি এই সাইটে আমার প্রথম পোস্ট। আমি মূলত একটি উদাহরণ বট নিয়েছি এবং আউটপুট সংক্রান্ত লাইনগুলি পরিবর্তন করেছি।

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

পিপিসিগিতে আপনাকে স্বাগতম :-) আশা করি আপনার এখানে ভাল সময়

— কাটবে

এটি এখনও পর্যন্ত ভাল করছে বলে মনে হচ্ছে। পিপিসিজিতে স্বাগতম, এবং ভাল কাজ!

— আর

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 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

OpenAndClose

সীমানা খোলার মাধ্যমে গেমটি শুরু করুন, তারপরে সমস্ত অসুস্থকে আসতে দিন। আমাদের বিশাল অসুস্থ জনসংখ্যা হওয়ার পরে (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

আরও দুটি পাইথন বট

ইস্রায়েল

এটি মুচের মতো, তবে মুছের মতো সম্ভবত এটি খুব ভাল নয়, বিরল ঘটনাগুলি বাদে যখন এটি আরও ভাল হয়:

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

যদি আপনি একটি বহুভুজকে গল্ফ করার চেষ্টা করছেন, খালি ফাইলটি ছোট হবে এবং পর্যবেক্ষক যা করেন ঠিক ঠিক তা করবে (এবং যেমনটি ঘটে, প্যাসিভবট ঠিক কী করেন - দু'জন একইরকম আচরণ করে), কারণ অনুবাদক একটি এনএনএনকে বিকল্প হিসাবে রাখে 0 দৈর্ঘ্যের প্রতিক্রিয়া।

— কুইন্টোপিয়া

@ কুইন্টোপিয়া আমি চেষ্টা করছিলাম না, ঠিক তখন বুঝতে পেরেছিলাম যে এটি বহুগ্লোট হিসাবে স্বাচ্ছন্দ্যে কাজ করেছে, তবে প্যাসিভবট কী করেছে তা আমি বুঝতে পারি নি, তাই আমি কেবল ওয়াচারকে মুছে ফেলব (দু'টি অভিন্ন হওয়ার কোনও মানে নেই)

— স্নোরিংফ্রোগ 21

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

@ থ্রাক্স এই বট আপডেট হয়েছে

— স্নোরিংফ্রাগ

Answer 28

CureThenQuarantine, জাভা

রাজ্যটি সেই ভাগ্যবান কয়েকজনের নিরাময়ের এবং পরে সংক্রামিত ব্যক্তিদের বাকিদের সরিয়ে দেওয়ার নীতি প্ররোচিত করেছে। একবার সংক্রামিত জনসংখ্যা হ্রাস পাওয়ার পরে স্থানীয় হারগুলি হ্রাস করার উপর দৃষ্টি নিবদ্ধ করা এবং তারপরে বৈশ্বিক হারগুলি হ্রাস করতে সহায়তা করে।

রাজ্যে কোনও সংক্রামিত স্থানান্তর নিশ্চিত করতে সীমান্তগুলি বন্ধ করা হয়।

আমি কেবল জাভা এবং পাইথন বটের বিরুদ্ধে বট পরীক্ষা করেছি ... মনে হচ্ছে এটি তাদের বিরুদ্ধে রয়েছে। এটিও মনে হয় যে আমার বটটি কুলবটের মতোই আচরণ করে।

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 সংক্রামিত নিরাময় করবে (হয় মাইগ্রেশন থেকে আগত বা স্বাস্থ্যকর জনসংখ্যার সংক্রমণ থেকে)। এরপরে স্বাস্থ্যকর জনসংখ্যার স্বাস্থ্যকর জনসংখ্যা বৃদ্ধিতে সুস্থ জনগণের জন্মের উপর নির্ভর করে সুস্থ থাকার জন্য এটি অবশিষ্ট কর্মগুলি ব্যবহার করবে use

রাজ্যে কোনও সংক্রামিত স্থানান্তর নিশ্চিত করতে সীমান্তগুলি বন্ধ করা হয়।

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;
        }
    }
}