নির্জন দ্বীপে ট্রেজার শিকার

Question

ভূমিকা

আপনি কিছু চাকর নিয়ে নির্জন দ্বীপে আটকা পড়েছেন এবং ধনের খোঁজ করছেন। লম্বা একটি অনুসন্ধান করে, তত বেশি ধন খুঁজে পাওয়া যায়। যত লোক অনুসন্ধান করবে, তত বেশি লোক খুঁজে পাবে।

সীমিত সরবরাহের কারণে, নেতা সিদ্ধান্ত নিয়েছেন যে এই গোষ্ঠীর এক চতুর্থাংশ লোককে প্রতি রাতে মারা যেতে হবে। সময়ের আগে যে কোনও দিন ঠিক কত লোক মারা যাবে তা কাউকে না জানাতে তিনি সিদ্ধান্ত নিয়েছেন।

আপনি 5 জনের একটি ছোট গোষ্ঠীর নিয়ন্ত্রণে আছেন, যারা আপনার জন্য ধন খুঁজে পাওয়ার জন্য শিবিরের বাইরে চলে।

উদ্দেশ্য

এই প্রতিযোগিতার উদ্দেশ্য যতটা সম্ভব ধন সংগ্রহ করা। আপনার দাসরা প্রতিটি শিবিরে ফিরে যাওয়ার চেষ্টা না করে, তারা একটি নির্দিষ্ট সংখ্যক ধন খুঁজে পাবে। আপনার চাকররা বিভিন্ন সময়ে শিবিরে ফিরে আসতে পারে।

প্রতিটি টার্ন যে কোনও শ্রমিক ধন অনুসন্ধানের জন্য বাইরে থাকে, শ্রমিক 1+Rধনসম্পদের টুকরো খুঁজে পায় , যেখানে Rশিবিরে কর্মীদের সংখ্যা (সমস্ত বটগুলির মধ্যে) ইতিমধ্যে ফিরে এসেছে। মৃত বটগুলি এই গণনায় ফ্যাক্টর করে না।

প্রতিটি দিনের শুরুতে, একটি র্যান্ডম সংখ্যা ( n) থেকে 2থেকে max(3, floor(num_live_players/4))মনোনীত করা হবে না। (1 দিন 10 খেলোয়াড়দের জন্য, এই হল 2থেকে max(3,50/4)=12। 1 দিনে 20 খেলোয়াড়দের জন্য, এই হবে 2থেকে max(3,100/4)=25।) এই সংখ্যা খেলোয়াড় যারা যে দিন জন্য মরতে ছেড়ে দেওয়া হবে সংখ্যা প্রতিনিধিত্ব করে আর আপনার প্রোগ্রাম না দেওয়া হবে ।

যদি কোনও চাকর nফিরে আসার শেষ লোকদের মধ্যে থাকে তবে সে মারা যাবে এবং যে ধন সে নিজের হাতে পেয়েছিল তা হস্তান্তর করতে অক্ষম হবে। তদ্ব্যতীত, চাকর বাকী অ্যাডভেঞ্চারের জন্য ট্রেজার শিকারে অংশ নিতে সক্ষম হবে না।

আপনার চূড়ান্ত স্কোরটি অ্যাডভেঞ্চারের জন্য আপনি অর্জন করা গড় পরিমাণের পরিমাণ (নিয়ন্ত্রকের রান)।

খোলা স্লট থাকার চেয়ে যদি বেশি লোক একই পালা শিবিরে ফিরে যাওয়ার চেষ্টা করে, তবে এলোমেলো সংখ্যা নির্ধারণ করবে যে কে getsুকে পড়ে এবং কে মারা যায়।

এই দ্বীপে সূর্যোদয় থেকে সূর্যাস্ত পর্যন্ত এক দিন 30 টার্ন থাকে। রাতে অনেক বিপজ্জনক প্রাণী রয়েছে বলে সূর্যাস্তের মাধ্যমে ফিরে আসতে ব্যর্থ হওয়ার অর্থ আপনাকে শিবিরে প্রবেশ করতে দেওয়া হবে না।

ইনপুট আউটপুট

আপনার প্রোগ্রামটি পুরো সিমুলেশনের জন্য চালানো উচিত।

সিমুলেশনটির শুরুতে, INDEX Iইনপুট করা হবে, Iআপনার বটের সূচিটি কোথায় (এই সূচকটি 1 থেকে উপরে গণনা করা হয়)।

প্রতিটি দিনের শুরুতে, START_DAY D/Nআপনার প্রোগ্রামে ইনপুট করা হবে, কোথায় Dদিনটির সংখ্যা (শুরু থেকে 1), এবং Nএর সমান max(3, floor(num_live_players/4)), যা সেই বিশেষ দিনে মারা যাওয়ার সর্বাধিক সংখ্যক লোক।

প্রতিটি START_TURN Tটার্নের শুরুতে, আপনার প্রোগ্রামে ইনপুট করা হবে, যেখানে Tটার্ন নম্বর (শুরু থেকে 1)।

আপনার প্রোগ্রামটি এটি পেয়ে গেলে এটি আপনার চাকরদের চালনার তালিকার সাথে প্রতিক্রিয়া জানানো উচিত, প্রতিটি কমা দ্বারা পৃথক।

বৈধ চলনগুলি হ'ল:

• R: ক্যাম্পে ফিরে যাওয়ার চেষ্টা করুন।
• S: ধন সন্ধান করুন।
• N: চাকর ইতিমধ্যে মারা গেছে বা শিবিরে।

একটি অবৈধ পদক্ষেপ প্রবেশ করাকে এমন ব্যাখ্যা করা হবে যেমন Sবট জীবিত এবং শিবিরে নয় এবং Nঅন্যথায়।

প্রতিটি ঘুরে শেষে, আপনার প্রোগ্রামে একটি স্ট্রিং দেওয়া হবে:

END_TURN [Turn #] [Bot 1 Moves] [Bot 2 Moves] ...

যেখানে প্রতিটি বটের চাকরের চালকদের কমা দিয়ে আলাদা করা হয়।

এই পদক্ষেপগুলি নিম্নলিখিতগুলির মধ্যে একটি হবে:

• R: সেই টার্নে সাফল্যের সাথে ক্যাম্পে ফিরে এসেছিল।
• r: সেই টার্নে শিবিরে ফিরতে ব্যর্থ।
• S: তবুও ধন সন্ধান করছি।
• D: আগের টার্নে মারা গেছে।
• N: ইতিমধ্যে ক্যাম্প ফিরে।

পুরো সিমুলেশন জুড়ে বট এবং চাকররা একই ক্রমে থাকে।

উদাহরণ স্বরূপ:

INDEX 2
....
END_TURN 8 N,N,N,N,N r,r,r,r,D D,D,D,N,R S,D,D,N,D

এখানে, আপনি দ্বিতীয় বট ( r,r,r,r,r), যিনি এখনও বেঁচে থাকা চারটি চাকরকে ফিরিয়ে দেওয়ার চেষ্টা করেছিলেন (এবং চারিদিকে দুর্ভাগ্যক্রমে ব্যর্থ হয়েছেন)। বট 1 এর চাকররা সবাই শিবিরে ফিরে এসেছে। বট 3 এর তিনটি মৃত চাকর রয়েছে, একজন আবার শিবিরে ফিরেছেন এবং পঞ্চম চাকর যিনি সফলভাবে ফিরে এসেছেন। বট 4 এর এক চাকর রয়েছেন যারা রয়েছেন (এবং মারা যাবেন, কারণ এটি একটি দিনের শেষ পালা), শিবিরে একজন চাকর এবং তিনজন মৃত চাকর রয়েছে।

এই প্রতিটি স্ট্রিংয়ের পরে, দিনের শেষের সংকেতযুক্ত কোনও স্ট্রিংও যদি আউটপুট না করা হয় (নীচে দেখুন), আপনার প্রোগ্রামটি আপনার চাকরদের পরবর্তী পদক্ষেপগুলি কমা দ্বারা পৃথক করা হবে। সমস্ত চাকরকে অবশ্যই জবাবদিহি করতে হবে ( Nযদি ইতিমধ্যে শিবিরে Dথাকে এবং যদি ইতিমধ্যে মারা যায়)। অবৈধ পদক্ষেপগুলি এমন আচরণ করা হবে যেমন Sচাকর ইতিমধ্যে শিবিরে / মৃত অবস্থায় নেই। উদাহরণ:

N,N,S,S,R

যার অর্থ:

Servant # | Action
     1    | Do nothing.
     2    | Do nothing.
     3    | Stay put (keep looking for treasure).
     4    | Stay put (keep looking for treasure).
     5    | Try to return to camp.

একদিনের শেষে, শেষ ENDপাতার স্ট্রিংয়ের পরে নিম্নলিখিত স্ট্রিংটি কেটে যাবে , কে বেঁচে আছে তা সবাইকে জানিয়ে দিবে :

END_DAY [Day #] [Bot 1 Status] [Bot 2 Status] 

যেখানে স্ট্যাটাসটি A(জীবিত) বা D(মৃত) কমা দ্বারা বিচ্ছিন্ন তালিকা । পরের দিন অবিলম্বে শুরু হয়।

সিমুলেশনটি শেষ হয় যখন 6 টিরও কম লাইভ চাকর থাকে। আপনার প্রোগ্রাম সিমুলেশন শেষে নিম্নলিখিত ইনপুট পাবেন:

EXIT

বিধি / বিবরণ

• আপনার ক্রিয়া যেখানে কেবল সেই স্থানেই Sআপনি ধন খুঁজে পাবেন।
• সিমুলেশনের সংখ্যা: 1000 বার
• আপনার প্রোগ্রামটি চালগুলি নির্ধারণ করতে 1 সেকেন্ডের বেশি সময় নেওয়া উচিত নয়।
• আপনার প্রোগ্রামটি প্রারম্ভিক প্রস্থান করা উচিত নয়; এটি ঠিক একবার শুরু করা হবে।
• নিশ্চিত হয়ে নিন যে প্রতিটি আউটপুট পরে আউটপুট বাফার (প্রযোজ্য ক্ষেত্রে) ফ্লাশ করা হয়েছে।
• ফাইলগুলি আপনার বটের ফোল্ডারে লিখিত হতে পারে ( ./players/BotName/)। আপনার বট নামটি আপনার বোটের নাম হিসাবে যা কিছু আছে সমস্ত অক্ষর অক্ষর মুছে ফেলা এবং ক্যামেলকেসে লেখা রয়েছে। রানগুলি ক্রমান্বয়ে সম্পন্ন হওয়ায় এন্ট্রিগুলি নিয়ামকের রানগুলির মধ্যে ডেটা সংরক্ষণ করতে পারে।
• আপনার প্রোগ্রাম পাওয়ার পরে অবশ্যই প্রস্থান করতে হবে EXIT।
• যে প্রোগ্রামগুলি ত্রুটি সংকলন করতে বা ছোঁড়াতে ব্যর্থ হয় বা অবৈধ পাঠ্য আউটপুট দেয় (কমা দ্বারা আলাদা 5 টি অক্ষরের বিন্যাসে নয়) প্রতিযোগিতা থেকে বাদ দেওয়া যেতে পারে। একটি নতুন লাইন প্রতিটি আউটপুট অনুসরণ করা আবশ্যক।
• কন্ট্রোলারটি গিটহাবের সাথে পাওয়া যেতে পারে ।

দয়া করে বট নাম, ভাষা + সংস্করণ, কোড এবং সংকলন করতে কমান্ড অন্তর্ভুক্ত করুন (প্রযোজ্য ক্ষেত্রে) এবং আপনার বট চালান।

উদাহরণ

প্রোগ্রাম দ্বারা আউটপুট পাঠ্য এখানে একটি সঙ্গে উপসর্গ করা হয় >। আপনার প্রোগ্রাম এই অক্ষর আউটপুট করা উচিত নয়।

INDEX 2
START_DAY 1/3
START_TURN 1
>S,S,S,S,S
END_TURN 1 S,R,S,S,S S,S,S,S,S
START_TURN 2
>S,S,S,S,S
END_TURN 2 S,N,S,R,S S,S,S,S,S
START_TURN 3
>R,R,S,S,S
END_TURN 3 R,N,R,N,R R,R,S,S,S
START_TURN 4
>N,N,S,S,S
END_TURN 4 N,N,N,N,N N,N,S,S,S
START_TURN 5
>N,N,R,R,R
END_TURN 5 N,N,N,N,N N,N,r,r,R
END_DAY 1 A,A,A,A,A A,A,D,D,A
START_DAY 2/3
START_TURN 1
>S,S,N,S,N
END_TURN 1 R,R,R,R,R S,S,D,D,N
END_DAY 2 A,A,A,A,A D,D,D,D,D
EXIT

উপরের উদাহরণের জন্য স্কোরগুলি হ'ল:

Bot#    Day 1   Day 2   Total
1       10      0       10
  S1    1+2     0       3
  S2    0       0       0
  S3    1+2     0       3
  S4    1       0       1
  S5    1+2     0       3

2       20      0       20
  S1    1+2     0       3
  S2    1+2     0       3
  S3    0       0       0
  S4    0       0       0
  S5    1+2+3+8 0       14

বিজয়ী তাই খেলোয়াড়, বট 2। নোট করুন যে বিজয়ীর চূড়ান্ত শেষ পর্যন্ত টিকে থাকতে হবে না। (আরও লক্ষ করুন যে প্লেয়ারটি প্রথম দিন 30 বছর বয়সী না হওয়া পর্যন্ত থাকতে পারত, যেহেতু প্লেয়ার আরও একটি বট ফেরত না পাঠানো পর্যন্ত ক্যাম্পটি পূর্ণ হত না)।

স্কোর

Bot               Score
Bob               2939.422
Statisticians     2905.833
Morning Birds     1652.325
Evolved           1578.285
Slow Returners    1224.318
Wandering Fools   1065.908
Randomizers       735.313
Drunkards         0     
Plague            0

লগগুলি গিটহাবে পাওয়া যায় । প্রতিটি ট্রায়াল প্রতি ফলাফল এই গুগল স্প্রেডশিটে উপলব্ধ ।

Comments

যদি কোন চাকর ফিরে না আসে তবে সে কি আজ এই দিনে মারা যাওয়া লোকের সংখ্যার দিকে গণ্য হবে?

— agগলভি_আত্তনম

@ ইগলভি_আত্তনাম দিনটি শেষ হয় যখন পর্যাপ্ত পরিচারক ফিরে এসেছেন বা ৩০ টি পালা পেরিয়ে গেছে, যার মধ্যে ফিরে না আসা প্রত্যেকে মারা যাবে, নির্ধারিত মৃত্যুর সংখ্যা নির্বিশেষে।

— es1024

ঠিক আছে, এটি ছিল নির্বোধ, দুঃখিত।

— agগলভি_আত্তনাম

কোনও চাকর যদি শিবিরে ফিরে আসে তবে সে কি এখনও পর্যন্ত পাওয়া ধন বিতরণ করতে পারে এবং সেদিন আবার অনুসন্ধানে বেরিয়ে যেতে পারে?

— লজিক নাইট

@ মাইকসুইনাই নং একবার কোন চাকর ফিরে এলে সে থাকে।

— es1024

Answer 1

বব - সি ++

#include <iostream>
#include <string>
#include <vector>
#include <sstream>
#include <algorithm>

using namespace std;

int compare(int i, int j)
  {
  if (i < j)
    return (-1);
  if (i == j)
    return (0);
  if (i > j)
    return (1);
  }

int main()
  {
  int index;
  int day;
  int turn;
  int slash_index;
  int to_die;
  int num_alive;
  int mine_alive;
  int turn_to_return;
  bool returned;
  string line;
  vector<int> last_returns;
  vector<int> today_returns;

  getline(cin, line);

  if (line.compare(0, 6, "INDEX ") != 0)
    {
    cerr << "INVALID INDEX LINE \"" << line << "\"" << endl;

    return (-1);
    }

  index = atoi(line.substr(6).c_str()) - 1;

  while (1) // Day loop
    {
    getline(cin, line);
    if (line.compare(0, 4, "EXIT") == 0)
      {
      return (0);
      }
    else if (line.compare(0, 9, "START_DAY") != 0 || (slash_index = line.find('/')) == string::npos)
      {
      cerr << "INVALID START_DAY \"" << line << "\"" << endl;
      return (-1);
      }

    day = atoi(line.substr(10, slash_index - 10).c_str());
    to_die = atoi(line.substr(slash_index + 1, line.length() - slash_index - 1).c_str());

    if (day != 1)
      {
      if (to_die > num_alive)
        {
        turn_to_return = 30;
        }
      else
        {
        turn_to_return = last_returns[last_returns.size() - to_die] - 1;
        }
      }

    returned = false;

    for (turn = 1; turn <= 30; ++turn)
      {
      getline(cin, line);

      if (line.compare(0, 4, "EXIT") == 0)
        {
        return (0);
        }
      if (line.compare(0, 7, "END_DAY") == 0)
        {
        goto end_day;
        }
      if (line.compare(0, 10, "START_TURN") != 0)
        {
        cerr << "INVALID START_TURN \"" << line << "\"" << endl;
        }

      if (day == 1)
        {
        switch (compare(turn, 30))
          {
            case -1:
              cout << "S,S,S,S,S" << endl;
              break;

            case 0:
              cout << "R,R,R,R,R" << endl;
              break;

            case 1:
              cout << "N,N,N,N,N" << endl;
              break;
          }
        }
      else
        {
        if (returned)
          {
          cout << "N,N,N,N,N" << endl;
          }
        /*
        else if (num_alive - today_returns.size() < to_die)
          {
          cout << "R,R,R,R,R" << endl;
          returned = true;
          }
        */
        else if (turn >= turn_to_return)
          {
          cout << "R,R,R,R,R" << endl;
          returned = true;
          }
        else
          {
          cout << "S,S,S,S,S" << endl;
          }
        }

      getline(cin, line);

      if (line.compare(0, 4, "EXIT") == 0)
        {
        return (0);
        }
      if (line.compare(0, 8, "END_TURN") != 0)
        {
        cerr << "INVALID END_TURN \"" << line << "\"" << endl;
        }

      stringstream ss(line);
      string item;
      int i = 0;
      while (getline(ss, item, ' '))
        {
        i++;
        if (i > 2 && i - 3 != index)
          {
          int num_to_add = count(item.begin(), item.end(), 'R'); // Add turn to today_returns for each servant that returned
          for (int j = 0; j < num_to_add; j++)
            {
            today_returns.push_back(turn);
            }
          }
        }

      }

    getline(cin, line);

  end_day:

    if (line.compare(0, 4, "EXIT") == 0)
      {
      return (0);
      }
    else if (line.compare(0, 7, "END_DAY") != 0)
      {
      cerr << "INVALID END_DAY \"" << line << "\"" << endl;
      return (-1);
      }

    stringstream ss(line);
    string item;
    int i = 0;
    num_alive = 0;
    while (getline(ss, item, ' '))
      {
      i++;
      if (i > 2 && i - 3 != index)
        {
        num_alive += count(item.begin(), item.end(), 'A');
        }
      else if (i - 3 == index)
        {
        mine_alive = count(item.begin(), item.end(), 'A');
        }
      }

    last_returns = today_returns;
    today_returns.clear();

    }

  return (0);
  }

সংকলন করতে:

g++ -o Bob.exe Bob.cpp

চালানোর জন্য:

./players/Bob/Bob.exe

Answer 2

পরিসংখ্যানবিদ, পাইথন 3

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

কার্যক্রম

# Team of treasure-hunting statisticians
# Run with:
# python3 statisticians.py

num_others = None
running = True
while running:
    msg = input().split()
    msg_type = msg.pop(0)
    if msg_type == "INDEX":
        my_index = int(msg[0])-1
    elif msg_type == "START_DAY":
        day, max_deaths = tuple(map(int, msg[0].split('/')))
    elif msg_type == "START_TURN":
        turn = int(msg[0])
        if day == 1:
            if turn == 1:
                print("S,S,S,S,S")
            elif turn == 30 or num_active <= max_deaths * 4/5:
                print("R,R,R,R,R") # On first day, return when 4/5 of  maximum number of dying servants remain
            else:
                print("S,S,S,S,S")
        elif turn >= 29 or len(expected_servants[turn+1]) <= max(2, max_deaths * 3/4) or len(expected_servants[turn]) <= max(2, max_deaths * 1/4):
            print("R,R,R,R,R") # If many servants are expected to return next turn or someone is sure to die, return to camp
        else:
            print("S,S,S,S,S") # Otherwise, keep going
    elif msg_type == "END_TURN":
        turn = int(msg.pop(0))
        others_moves = [tuple(s.split(',')) for s in msg[:my_index] + msg[my_index+1:]]
        if num_others is None: # End of first turn, initialize variables that depend on number of servants
            num_others = len(others_moves)
            others_history = [{} for i in range(num_others)]
        if day == 1:
            num_active = sum([move.count('S') for move in others_moves])
        for i, moves in enumerate(others_moves): # Log the return habits of other bots
            if turn == 1:
                others_history[i][day] = [0]*5
            for j, move in enumerate(moves):
                if move == "R": # Only safely returned servants are taken into account
                    others_history[i][day][j] = turn
                    if day > 1:
                        for future_turn in range(turn, 30):
                            expected_servants[future_turn].discard((i,j))
    elif msg_type == "END_DAY":
        day = int(msg.pop(0))
        my_statuses = tuple(msg[my_index].split(','))
        others_statuses = [tuple(s.split(',')) for s in msg[:my_index] + msg[my_index+1:]]
        expected_servants = [set() for i in range(30)] # Compute the sets of expected servants for each turn
        for i in range(num_others):
            for j in range(5):
                if others_statuses[i][j] == 'A':
                    turn_sum = 0
                    for day_num in others_history[i]:
                        turn_sum += others_history[i][day_num][j]
                    for turn in range(turn_sum//day):
                        expected_servants[turn].add((i,j))
    elif msg_type == "EXIT":
        running = False

আপনি দেখতে পাচ্ছেন, আমি @ মাইক সুইউনির কাছ থেকে নির্লজ্জভাবে প্রোগ্রাম কাঠামোটি চুরি করেছি।

হুকুম

python3 statisticians.py

সম্পাদনা: দেশে ফেরার জন্য চেকটিতে একটি বাগ ফিক্সড। তাদের এখন কিছুটা আরও ভাল পারফরম্যান্স করা উচিত।

সম্পাদনা 2: পরিসংখ্যানবিদরা এখন আগের চেয়ে বেশি স্মার্ট: বর্তমান সময়ে কোন দাসেরা শিবিরে ফিরে এসেছেন সেগুলি তারা পর্যবেক্ষণ করে এবং সে অনুযায়ী তাদের ভবিষ্যদ্বাণীগুলি সামঞ্জস্য করে। এছাড়াও, তারা আরও ঝুঁকি নিয়ে থাকে, যখন সর্বোচ্চ সংখ্যক মারা যাওয়া চাকরের 3/4 জন রয়ে যায় তখন শিবিরে ফিরে আসে। এটি তাদের আবার শীর্ষে ঠেলে দেয় (সবে মাত্র; বব খুব বিপজ্জনক হয়ে উঠেছে)।

Answer 3

মাতাল, পার্ল 5

কিছুটা অত্যধিক অ্যালকোহল এবং তারা আর কখনও শিবিরে ফিরে আসবে না।

এই এন্ট্রিটি প্রাথমিকভাবে উদাহরণ, তবে এতে অংশ নেবে।

কার্যক্রম

#!/usr/bin/perl
use 5.10.1;
$| = 1; # disable buffering
@actions = qw(S S S S S);

$_ = <>; ~/^INDEX (\d+)/;
$index = $1;

while(<>){
    if(index($_, 'START_TURN') == 0){
        say join(',', @actions);
    }elsif(index($_, 'END_DAY') == 0){ 
        # update actions based on who is alive
        # index 1-indexed; first bot at position 2.
        # this is not actually necessary for Drunkards, as all of Drunkards'
        #  servants will die on day 1 in any case.
        # This check is here simply as an example.
        my @status = split(',',(split(' '))[$index + 1]);
        my $i;
        for($i = 0; $i < 5; ++$i){
            # action is S if alive, N if dead. Servants will never be in camp.
            $actions[$i] = $status[$i] eq 'A' ? 'S' : 'N';
        }
    }elsif(index($_, 'EXIT') == 0){
        exit 0;
    }
}

হুকুম

perl ./players/Drunkards/Drunkards.pl

Comments

আপনার কোড করা উচিত $status[$i] eq 'A' ? 'S' : 'D';হবে $status[$i] eq 'A' ? 'S' : 'N';বৈশিষ্ট দেখা করতে?

— লজিক নাইট

পছন্দ করুন এই চ্যালেঞ্জটি স্যান্ডবক্সে থাকা অবস্থায় আমি যখন অনুমানটি পরিবর্তন করেছি তখন আমি তা ঠিক করতে ভুলে গিয়েছি।

— es1024

Answer 4

মর্নিং পাখি

সকালে পাখি পোকা ধরে!!!

package players.MorningBirds;

import java.io.*;
import java.util.*;

/*
 * Java 7
 * 
 * Compile with "javac ./players/MorningBirds/MorningBirds.java"
 * Run with "java players.MorningBirds.MorningBirds"
 * 
 * Servants find treasure from morning until noon.
 * At noon they go to bed to prepare for next day.
 * 
 * According to Benjamin Franklin, "Early to bed, early to rise, keeps a 
 *      man healthy, WEALTHY, and wise."
 * 
 * 
 */
public class MorningBirds {

    protected final static String STARTDAY = "START_DAY";

    protected final static String STARTTURN = "START_TURN";

    protected final static String ENDTURN = "END_TURN";

    protected final static String ENDDAY = "END_DAY";

    protected final static String MOVERETURN = "R";

    protected final static String MOVESEARCH = "S";

    protected final static String MOVENOTHING = "N";

    protected final static String RETURNED = "R";

    protected final static String FAILEDRETURN = "r";

    protected final static String SEARCHING = "S";

    protected final static String DEAD = "D";

    protected final static String SLEEPING = "N";

    protected final static String EXIT = "EXIT";

    protected final static String ALIVE = "A";

    protected enum Status{SEARCHING, DEAD, RETURNED}

    protected enum Move{RETURN, SEARCH, NOTHING}

    protected int index;

    protected int day;

    protected int turnNum;

    protected int howManyTeams;

    protected int howManyWillDieTodayAtMost;

    protected int howManyHaveDiedToday;

    protected int howManyEnemyPlayers;

    protected int howManyAliveEnemyPlayers;

    protected int howManyEnemyTeams;

    protected int howManyDeadEnemyPlayers;

    protected int howManyReturnedEnemyPlayers;

    protected int howManySearchingEnemyPlayers;

    protected int howManyTotalPlayers;

    protected int howManyTotalAlivePlayers;

    protected int howManyTotalDeadPlayers;

    protected int howManyTotalReturnedPlayers;

    protected int howManyTotalSearchingPlayers;

    protected int howManyOwnAlivePlayers;

    protected int howManyOwnDeadPlayers;

    protected int howManyOwnReturnedPlayers;

    protected int howManyOwnSearchingPlayers;

    protected Status[] statuses = new Status[5];

    protected Status[][] allStatuses = null;

    protected List<Status[][]> allDayStatuses = null;

    protected List<List<Status[][]>> allTimeStatuses = new ArrayList<>();

    protected BufferedReader in = new BufferedReader(
            new InputStreamReader(System.in));

    public static void main (String args[]) throws Exception{
        new MorningBirds().start();
    }

    public void start() throws Exception{

        index = Integer.parseInt(in.readLine().split("\\s")[1]);
        Arrays.fill(statuses, Status.SEARCHING);

        while(true){
            String[] input = in.readLine().split("\\s");
            if (input[0].equals(ENDTURN) || input[0].equals(ENDDAY)){
                updateStatus(input);
            } else if (input[0].equals(EXIT)){
                return;
            } else if (input[0].equals(STARTDAY)){
                updateDay(input);
            } else if (input[0].equals(STARTTURN)){
                updateTurn(input);
                doTurn(input);
            }

        }

    }

    protected void updateStatus(String[] input){
        if (allStatuses == null && input[0].equals(ENDTURN)){
            allStatuses = new Status[input.length - 2][5];
            for (Status[] enemyStatus : allStatuses){
                Arrays.fill(enemyStatus, Status.SEARCHING);
            }
            howManyTeams = input.length - 2;
            howManyEnemyTeams = input.length - 3;
            howManyTotalPlayers = howManyTeams * 5;
            howManyTotalAlivePlayers = howManyTotalPlayers;
            howManyTotalSearchingPlayers = howManyTotalAlivePlayers;
            howManyAliveEnemyPlayers = howManyTotalPlayers - 5;
            howManyEnemyPlayers = howManyEnemyTeams * 5;
            howManyOwnAlivePlayers = 5;
            howManyOwnSearchingPlayers = 5;
            howManySearchingEnemyPlayers = howManyAliveEnemyPlayers;
        }
        for ( int j = 0; j < howManyTeams; j++){
            String[] stats = input[j + 2].split(",");
            for(int i = 0; i < 5; i++){
                switch (stats[i]){
                    case "R":
                    case "N":
                        if (allStatuses[j][i] != Status.RETURNED){
                            howManyTotalReturnedPlayers++;
                            howManyTotalSearchingPlayers--;
                            if (j == index - 1) {
                                howManyOwnReturnedPlayers++;
                                howManyOwnSearchingPlayers--;
                            } else {
                                howManyReturnedEnemyPlayers++;
                                howManySearchingEnemyPlayers--;
                            }
                        }
                        allStatuses[j][i] = Status.RETURNED;
                        break;
                    case "A":
                    case "S":
                        if (allStatuses[j][i] != Status.SEARCHING){
                            howManyTotalReturnedPlayers--;
                            howManyTotalSearchingPlayers++;
                            if (j == index - 1) {
                                howManyOwnReturnedPlayers--;
                                howManyOwnSearchingPlayers++;
                            } else {
                                howManyReturnedEnemyPlayers--;
                                howManySearchingEnemyPlayers++;
                            }
                        }
                        allStatuses[j][i] = Status.SEARCHING;
                        break;
                    case "r":
                    case "D":
                        if (allStatuses[j][i] != Status.DEAD){
                            howManyTotalAlivePlayers--;
                            howManyTotalDeadPlayers++;
                            howManyHaveDiedToday++;
                            howManyTotalSearchingPlayers--;
                            if (j == index - 1){
                                howManyOwnAlivePlayers--;
                                howManyOwnDeadPlayers++;
                                howManyOwnSearchingPlayers--;
                            } else {
                                howManyAliveEnemyPlayers--;
                                howManyDeadEnemyPlayers++;
                                howManySearchingEnemyPlayers--;
                            }
                        }
                        allStatuses[j][i] = Status.DEAD;
                        break;
                    default:
                        break;
                }
            }
        }
        statuses = allStatuses[index - 1];
        if (input[0].equals(ENDTURN)){
            allDayStatuses.add(allStatuses.clone());
        }
        if (input[0].equals(ENDDAY)){
            Status[][] statusesToAdd = new Status[howManyTeams][5];
            for (int i = 0; i < statusesToAdd.length; i++){
                for (int j = 0; j < statusesToAdd[i].length; j++){
                    if (allStatuses[i][j] == Status.SEARCHING){
                        statusesToAdd[i][j] = Status.RETURNED;
                    } else {
                        statusesToAdd[i][j] = Status.DEAD;
                    }
                }
            }
            while (turnNum <= 30){
                allDayStatuses.add(statusesToAdd.clone());
                turnNum++;
            }
            allTimeStatuses.add(allDayStatuses);
        }
    }

    protected void updateDay(String[] input) throws Exception{
        day = Integer.parseInt(input[1].split("/")[0]);
        howManyWillDieTodayAtMost = Integer.parseInt(input[1].split("/")[1]);
        howManyHaveDiedToday = 0;
        allDayStatuses = new ArrayList<>();
        if (day == 1){
            Arrays.fill(statuses, Status.SEARCHING);
            howManyOwnAlivePlayers = 5;
            howManyOwnSearchingPlayers = 5;
        }
    }

    protected void updateTurn(String[] input){
        turnNum = Integer.parseInt(input[1]);
    }

    protected void doTurn(String[] input){
        Move[] moves = new Move[5];
        for (int i = 0; i < 5; i++){
            if (statuses[i] == Status.DEAD ||
                        statuses[i] == Status.RETURNED) {
                moves[i] = Move.NOTHING;
                continue;
            } else {
                moves[i] = doMove(i);
            }
        }
        String[] outputs = new String[5];
        for (int i = 0; i < 5; i++){
            switch (moves[i]){
                case SEARCH:
                    outputs[i] = MOVESEARCH;
                    break;
                case RETURN:
                    outputs[i] = MOVERETURN;
                    break;
                case NOTHING:
                    outputs[i] = MOVENOTHING;
            }
        }
        String totalOutput = "";
        for(String output : outputs){
            if (totalOutput != ""){
                totalOutput += ",";
            }
            totalOutput += output;
        }
         System.out.println(totalOutput);
    }

    //Implement this method differently for different 
    //strategies. 
    public Move doMove(int playerNumber){
        if (turnNum >= 15){
            return Move.RETURN;
        }
        return Move.SEARCH;
    }

    /**
     * Returns the status of one of your players. 
     * Your players have numbers 1 to 5 inclusive.
     * Throws exception if number is outside range.
     * 
     */
    protected Status getStatus(int player){
        if (player > 5 || player < 1){
            throw new IllegalArgumentException(
                    "getStatus(" + player +") failed.");
        }
        return statuses[player - 1];
    }

    /**
     * Returns the status of a player in a team.
     * Team numbers start with 1 inclusive.
     * Players have numbers 1 to 5 inclusive.
     * Throws exception if argument player is outside range.
     * Throws exception if argument team is less than 1 or is greater
     * than the number of teams.
     * Returns Status.SEARCHING if day == 1 and turnNum == 1 and argument 
     * team >= 1.
     */
    protected Status getStatus(int team, int player){
        if (team < 1 || player < 1 || player > 1 || 
                (team > howManyTeams && day == 1 && turnNum == 1)){
            throw new IllegalArgumentException(
                    "getStatus(" + team + ", " + player + ") failed.");
        }
        if (day == 1 && turnNum == 1 && team >= 1){
            return Status.SEARCHING;
        }
        return allStatuses[team - 1][player - 1];
    }

    /**
     * Returns the status of a player in a team at the end of argument
     * turn.
     * Team numbers start with 1 inclusive.
     * Players have numbers 1 to 5 inclusive.
     * Turns have numbers 0 to 30 inclusive.
     * Status at turn 0 is equal to status at start of turn 1.
     * Throws exception if argument turn hasn't happened yet.
     * Throws exception if argument player is outside range.
     * Throws exception if argument team is less than 1 or is greater
     * than the number of teams.
     */
    protected Status getStatus(int turn, int team, int player){
        if (turn == 0){
            if (day == 1){
                return Status.SEARCHING;
            } else {
                return getStatus(day - 1, 30, team, player);
            }
        }
        if (turnNum <= turn || turn < 0|| player > 5 || player < 1 ||
                team < 1 || team > howManyTeams){
            throw new IllegalArgumentException("getStatus(" + turn + 
                    ", " + team + ", " + player + ") failed.");
        }
        return allDayStatuses.get(turn - 1)[team - 1][player - 1];
    }

    /**
     * Returns the status of a player in a team at the end of argument
     * turn on the day of argument day.
     * Team numbers start with 1 inclusive.
     * Players have numbers 1 to 5 inclusive.
     * Turns have numbers 0 to 30 inclusive.
     * Days have numbers 1 inclusive and up.
     * Status at turn 0 is equal to status at start of turn 1.
     * Throws exception if argument day hasn't ended yet or is less 
     * than one.
     * Throws exception if argument turn is out of range.
     * Throws exception if argument player is outside range.
     * Throws exception if argument team is less than 1 or is greater
     * than the number of teams.
     */
    protected Status getStatus(int day, int turn, int team, int player){
        if (turn == 0){
            if (day == 1){
                return Status.SEARCHING;
            } else {
                return getStatus(day - 1, 30, team, player);
            }
        }
        if (this.day <= day || day < 1 || turn > 30 || turn < 0 || 
                player > 5 || player < 1 ||
                team < 1 || team > howManyTeams){
            throw new IllegalArgumentException("getStatus(" + day + ", "
                    + turn + ", " + team + ", " + player + ") failed.");
        }
        return allTimeStatuses.get(day - 1).get(turn - 1)[team - 1][player - 1];
    }

}

সম্পাদনা করুন: এটি তৈরি করা হয়েছে যাতে যে কেউ সহজেই এটি সাবক্লাস করতে পারে। doMove(int playerNumber)আপনার নিজের বটের জন্য কেবল নতুন সংজ্ঞা দিন । আমি বেশ কয়েকটি সহায়ক ক্ষেত্র এবং পদ্ধতি যুক্ত করেছি। আমি এটি ব্যাপকভাবে পরীক্ষা করেছি। এটি পূর্ববর্তী সিমুলেশনগুলি থেকে স্ট্যাটাসগুলি সংরক্ষণ করে না । কোন সমস্যা আছে কিনা আমাকে বলুন।

এর সাথে সংকলন: javac ./players/MorningBirds/MorningBirds.java

সাথে চালান: java players.MorningBirds.MorningBirds

Comments

যদি আমি পদ্ধতিগুলি এবং ভেরিয়েবলগুলি সুরক্ষিত করে রাখি এবং পরে চ্যালেঞ্জের জন্য এটির একটি সাবক্লাস তৈরি করি তবে তা ঠিক হবে?

— TheNumberOne

প্রয়োজনে একাধিক উত্স ফাইল ব্যবহার করতে নির্দ্বিধায় বা অন্য এন্ট্রি থেকে কোড পুনরায় ব্যবহার করুন, যতক্ষণ না এন্ট্রি একসাথে কাজ করছে না।

— es1024

@ es1024 পরীক্ষায় আমি লক্ষ্য করেছি যে বটটি পুরো দিন থেকে কিছু না ঘটলে 1 মারা যায় that এটি কি উদ্দেশ্য?

— TheNumberOne

একটি বট যে কোনও দিন কখনই দেয় না ( R) কখনই সেদিন মারা যাবে।

— es1024

আমি খেলোয়াড়দের স্লোরেটার্নার্স এবং র্যান্ডোমায়ার্স যুক্ত করলে নিয়ামকটি প্রতিক্রিয়াহীন হয়ে যায়। দ্রষ্টব্য: দুঃখিত আমি এখানে মন্তব্য পোস্ট করছি। আমার অন্য কোথাও পোস্ট করার সুনাম নেই।

— TheNumberOne

Answer 5

র্যান্ডমাইজার্স - রুবি

কেবল পরিসংখ্যান দ্বারা চালিত বটগুলিকে গণ্ডগোলের জন্য, র্যান্ডমাইজারগুলি বেশ অনাকাঙ্ক্ষিত। এগুলি সমস্তই অন্যদেরকে আটকানোর প্রয়াসে এলোমেলোভাবে ঘুরে ফিরে আসে।

(অন্যান্য খেলোয়াড় দ্বারা প্রভাবিত নয়।)

def min(a,b);(a<b)?a:b;end
x=""
r=0
while x != "EXIT"
  x=gets.chomp
  if x =~ /^START_DAY/
    r = min(rand(30),rand(30))
  end
  if x =~ /^START_TURN (\d*)/
    puts ($1.to_i>r)?'R,R,R,R,R':'S,S,S,S,S'
  end
end

Answer 6

ঘুরে বেড়ানোর ফুল, পাইথন 2

এটি একটি সাধারণ পাইথন বট যা কোনও পূর্বনির্ধারিত "গব্যাক" সময় না পাওয়া পর্যন্ত দাসদের প্রেরণ করে, তারপরে তারা শিবিরে প্রবেশ করার চেষ্টা করে এবং পরের দিন পর্যন্ত থাকার চেষ্টা করে।

এটি আরও জটিল বটগুলির জন্য একটি প্রাথমিক কাঠামো যা অন্যরা ব্যবহার করতে চাইতে পারে। এটি অবশ্য বিচারকের ইঞ্জিনের সাথে অনির্ধারিত, সুতরাং আমি কোনও ত্রুটি করেছি কিনা তা আমাকে জানান।

কার্যক্রম

import sys
from random import randint, choice
team = range(5)

while True:
    inp = sys.stdin.readline().split()
    cmd = inp.pop(0)
    if cmd == 'INDEX':
        teamnum = int(inp[0]) - 1   # using zero based indexing
    elif cmd == 'START_DAY':
        daynum, deadnum = [int(v) for v in inp[0].split('/')]
        # Set up strategy for the day:
        goback = [randint(5,25) for i in team]
    elif cmd == 'START_TURN':
        turn = int(inp[0])
        # Output actions [R]eturn, [S]earch, [N]othing here:
        actions = ['S' if turn < goback[i] else 'R' for i in team]
        sys.stdout.write( (','.join(actions)) + '\n' )
        sys.stdout.flush()
    elif cmd == 'END_TURN':
        endturn = int(inp.pop(0))
        status = [v.split(',') for v in inp]  # R,r,S,D,N
        # [R]eturned, [r]ejected, [S]earching, [D]ead, [N]othing
        mystatus = status[teamnum]
    elif cmd == 'END_DAY':
        endturn = int(inp.pop(0))
        alive = [v.split(',') for v in inp]  # [A]live or [D]ead
        myalive = alive[teamnum]
    elif cmd == 'EXIT':
        sys.exit(0)

হুকুম

python WanderingFools.py

সম্পাদনা করুন: বিধি স্পষ্টকরণের পরে ক্রিয়াকলাপের সিদ্ধান্ত কোড অনুসরণ করে।

Answer 7

বিবর্তিত

আমি এই বটটি তৈরি করতে জেনেটিক প্রোগ্রামিং (জেজিএপি মাধ্যমে) ব্যবহার করেছি। এটি একটি সহজ উত্তর নিয়ে এসেছিল যা অন্য সকলকে (সবে) মারধর করে)

package players.Evolved;

import players.MorningBirds.*;
import java.util.*;

public class Evolved extends MorningBirds{

    List<Integer> scrambled = new ArrayList<>();

    public static void main(String[] args) throws Exception{
        new Evolved().start();
    }

    public Evolved() throws Exception{
        super();
    }

    @Override
    public MorningBirds.Move doMove(int playerNum){
        if (!(howManyTotalSearchingPlayers < (turnNum - getScrambled(index)))){
            return Move.SEARCH;
        } else {
            return Move.RETURN;
        }
    }

    @Override
    protected void updateStatus(String[] input){
        super.updateStatus(input);
        if (input[0].equals(ENDTURN) && (Integer.parseInt(input[1]) == 1)){
            for (int i = 1; i <= howManyTeams; i++){
                scrambled.add(i);
            }
            Collections.shuffle(scrambled);
        }
    } 

    public int getScrambled(int in){
        if (in > scrambled.size() || in < 1 ){
            return in;
        }
        return scrambled.get(in - 1);
    }
}

এর সাথে সংকলন: javac players/Evolved/Evolved.java

সাথে চালান: java players.Evolved.Evolved

সম্পাদনা: গ্রার ... বব আমাকে গণ্ডগোল করেছে !!!

সম্পাদনা: হ্যাঁ !!! বব, একটি বাজে প্লেগের কবলে পড়ে !!!

Answer 8

স্লো রিটার্নার্স - রুবি

প্রতি 5 টার্নে একজন চাকরকে ফেরত পাঠায়।

x=""
while x != "EXIT"
  x=gets.chomp
  if x =~ /^START_TURN (\d*)/
    puts (1..5).map{|i|(i<=$1.to_i/5)?"R":"S"}.join(",")
  end
end

Answer 9

প্লেগ

প্লেগ একটি রোগ। এটা যৌক্তিক নয়। এটা অনুমানযোগ্য। রোগগুলি ধন সংগ্রহ করতে পারে না, বা ধন-সম্পদের যত্নও করে না। প্লেগ অন্যান্য খেলোয়াড়দের অসুস্থ করে তোলে। জ্ঞানীরা বাড়িতে থাকে এবং ধন সম্পর্কে ভুলে যায়। মূর্খরা সর্বদা বোকা এবং কখনও বেশি ধন পাবে না। বিবর্তিত (ভাগ্যক্রমে) প্লেগের প্রতিরোধ ক্ষমতা। তিনিও বুদ্ধিমান। সে গিয়ে ধন সংগ্রহ করে, আর মরে না।

package players.Plague;

import players.MorningBirds.MorningBirds;

public class Plague extends MorningBirds{

    public static void main(String[] args) throws Exception{
        new Plague().start();
    }

    public Plague() throws Exception{
        super();
    }

    @Override
    public MorningBirds.Move doMove(int playerNum){
        if (day > howManyTotalDeadPlayers){
            return Move.SEARCH;
        } else {
            return Move.RETURN;
        }
    }
}

এর সাথে সংকলন: javac players/Plague/Plague.java

সাথে চালান: java players.Plague.Plague

বব এবং পরিসংখ্যানবিদরা এখন প্লেগ প্রতিরোধী।

Comments

হুম ... আমি যখন এই বোটটি চালাই তখন সর্বদা প্রথম দিনেই মারা যায় ...

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

— TheNumberOne