টেস্ট ড্রাইভার • চ্যালেঞ্জ আলোচনা • অভিযাত্রী জমা দিন

ট্রেজার রুম ( চিত্র উত্স )

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

গেমপ্লের

প্রতিটি অ্যাডভেঞ্চারার অন্ধকারের প্রথম ঘরে 1000 স্ট্যামিনা পয়েন্ট এবং তাদের ব্যাকপ্যাকে 50 কেজি জায়গা দিয়ে শুরু হয়।

গেমটি টার্ন-ভিত্তিক ফ্যাশনে পরিচালিত হয়, সমস্ত খেলোয়াড় একই সাথে তাদের পালা সমাধান করে। প্রতিটি পালা, আপনি নিম্নলিখিত ক্রিয়াগুলির মধ্যে একটি করতে পারেন:

পাশের ঘরে চলে যান।
আগের ঘরে চলে যান।
ধন নিতে স্ট্যামিনা বিড করুন।
একটি ধন ফেলে দিন।

কক্ষগুলির মধ্যে চলতে 10 টি স্ট্যামিনা প্রয়োজন হয় এবং আপনার ব্যাকপ্যাকটিতে বর্তমানে প্রতি 5 কেজি জন্য 1 টি গোল করা হয়। উদাহরণস্বরূপ, 3 কেজি ধনসম্পদ বহনকারী একজন অ্যাডভেঞ্চারারের জন্য 11 স্ট্যামিনা সরানো দরকার এবং 47 কেজি বহনকারী একজনকে 20 স্ট্যামিনা সরানো দরকার।

খসড়া বাদ দেওয়ার জন্য 1 টি স্ট্যামিনা প্রয়োজন।

ধ্বংসাবশেষ থেকে বেরিয়ে আসার পরে, খেলোয়াড় আর কোনও পালা নেবেন না।

যদি কোনও খেলোয়াড় এগুলির কোনও পদক্ষেপ নিতে না পারে (স্ট্যামিনার অভাব বা কোষাগারের অভাবের কারণে), তাদের অ্যাডভেঞ্চারার ক্লান্ত হয়ে মারা যায়, তাদের অধিষ্ঠিত ধনটিকে বর্তমানে অধিষ্ঠিত ঘরে intoেলে দেয়। একইভাবে, কোনও খেলোয়াড় যদি কোনও অবৈধ পদক্ষেপ নেওয়ার চেষ্টা করে, তবে তাদের অভিযাত্রী তার পরিবর্তে ফাঁদে পড়ে মারা যাবে, ফলস্বরূপ একই ধনাত্মক স্প্লাইজে পরিণত হবে।

আদেশ

ধনটির জন্য সর্বনিম্ন বিড 1 কেজি প্রতি 1 টি স্ট্যামিনা the ধনসাধ্য হওয়ার সম্ভাবনা বেশি হওয়ার জন্য আপনি অতিরিক্ত স্ট্যামিনা পয়েন্টগুলিকেও বিড করতে পারেন। যে স্ট্যামিনা বিড করা হয়েছিল তা ফলাফল কী তা বিবেচনা না করেই গ্রাস করা হয়।

একাধিক খেলোয়াড় একই ধন নেওয়ার জন্য বিড করে থাকলে, যে খেলোয়াড় সর্বাধিক বিড করে সে ধন পায়। যদি একাধিক খেলোয়াড় সর্বোচ্চ বিড করেন তবে তাদের কেউই এই ধনটি পাবেন না।

উইন কন্ডিশন

ট্রেজারের বৃহত্তম মোট মান সহ খেলোয়াড়টি বিজয়ী। টাই হওয়ার সম্ভাবনা কম থাকলে, বন্ধনগুলি সর্বনিম্ন মোট ওজনে যায়, তারপরে ক্ষুদ্রতম সংখ্যার, তারপরে সর্বাধিক মূল্যবান ধনটির মান, দ্বিতীয় সর্বাধিক মূল্যবান, তৃতীয় ... টাই না ভাঙার আগ পর্যন্ত। এখনও এই সময়ে একটি টাই থাকা সন্নিকট-অসম্ভব ইভেন্টে, পরীক্ষা চালক "এটিকে স্ক্রু করুন" বলে এবং বিজয়ী নির্বিচারে নির্ধারিত হয়।

টুর্নামেন্টের প্রসঙ্গে খেলোয়াড়রা 10 পয়েন্ট প্রাপ্ত প্রথম স্থান, 9 পয়েন্ট নিয়ে দ্বিতীয় স্থান, 8 পয়েন্ট সহ তৃতীয় স্থান ইত্যাদি ... মৃত খেলোয়াড় এবং অ্যাডভেঞ্চারারদের সাথে 0 পয়েন্ট অর্জন না করে।

ধ্বংসাবশেষ সম্পর্কে

প্রতিটি ঘরে প্রাথমিকভাবে মধ্যে থাকে $\lfloor{r \over 3}\rfloor + 3$ এবংট্রেজারে। (রুমের নম্বরটিকোথায়) $\lfloor{r \over 2}\rfloor + 5$ $r$
নির্বিচারে অনেক কক্ষ রয়েছে, কেবল অ্যাডভেঞ্চারার স্ট্যামিনা এবং অন্বেষণে ইচ্ছুক দ্বারা সীমাবদ্ধ।
প্রতিটি ধনটির আর্থিক মূল্য (পুরো $) এবং একটি ওজন (পুরো কেজিতে) থাকবে।
- ভাঙ্গনের গভীরে যাওয়ার সাথে সাথে ট্রেজারার আরও মূল্যবান এবং প্রচুর পরিমাণে ঝোঁক।
কোষাগার উত্পন্ন করার জন্য নির্দিষ্ট সূত্রগুলি নিম্নরূপ: ( পাশা রোলগুলির জন্য স্বরলিপি ব্যবহার করে) $xdy$
- সূত্রটি ব্যবহার করে প্রথমে ওজন তৈরি করা হয় (সর্বনিম্ন 1) $2d6 - 2$
- ট্রেজার মান তারপর মাধ্যমে উৎপন্ন হয় (যেখানে রুম সংখ্যা এবং ওজন) $1d[10 * w] + 2d[5 * r+ 10]$ $r$ $w$

খেলোয়াড়দের কাছে দৃশ্যমান তথ্য

প্রতিটি ঘুরে, খেলোয়াড়গণ নিম্নলিখিত তথ্য পান:

তারা বর্তমানে যে ঘরে রয়েছে তার সংখ্যা This এটি 1-ইনডেক্সড, সুতরাং ধারণাগতভাবে প্রস্থানটি "রুম 0" এ রয়েছে
ঘরে বর্তমানে ট্রেজারের একটি তালিকা
বর্তমানে অন্যান্য আসরে থাকা অন্য খেলোয়াড়দের একটি তালিকা।
আপনার বর্তমান কোষাগারগুলির তালিকা
আপনার বর্তমান স্ট্যামিনা স্তর

আইনসংগ্রহ

পরীক্ষার ড্রাইভারটি এখানে পাওয়া যাবে ।

আপনার এই Adventurerশ্রেণীর একটি সাবক্লাস বাস্তবায়ন করা উচিত :

class Adventurer:
    def __init__(self, name, random):
        self.name = name
        self.random = random

    def get_action(self, state):
        raise NotImplementedError()

    def enter_ruins(self):
        pass

আপনার কেবল get_actionপদ্ধতিটি ওভাররাইড করা দরকার । enter_ruinsএকটি গেম শুরু হওয়ার আগেই চালানো হয় এবং আপনি গেমটির জন্য প্রস্তুত থাকতে চান তা প্রস্তুত করার সুযোগ। আপনার ওভাররাইড করার দরকার নেই __init__এবং আপনার সত্যই হওয়া উচিত নয় । যদি আপনার __init__ক্রাশ হয়, আপনি অযোগ্য হবেন।

get_actionnamedtupleনিম্নলিখিত ক্ষেত্রগুলির সাথে একটি একক যুক্তি প্রাপ্ত করে (এই ক্রমে, আপনি যদি কাঠামোগত পছন্দ করেন):

room: আপনি বর্তমানে যে ঘরে আসছেন তার নম্বর
treasures: ঘরে ভাণ্ডারগুলির তালিকা
players: ঘরের অন্যান্য খেলোয়াড়দের তালিকা। আপনি কেবল এইভাবে খেলোয়াড়ের নাম পান, তাই আপনি জানেন না কোন বট তাদের বা তাদের জায় / স্ট্যামিনা নিয়ন্ত্রণ করছে।
inventory: আপনার ব্যাকপ্যাকের কোষাগুলির তালিকা
stamina: আপনার বর্তমান স্ট্যামিনা স্তর

এই বস্তুটি অতিরিক্তভাবে দুটি ইউটিলিটি বৈশিষ্ট্য সরবরাহ করে:

carry_weight: আপনি বহন করছেন এমন সমস্ত কোষাগারের মোট ওজন
total_value: আপনি বহন করছেন এমন সমস্ত কোষাগারের মোট মান

treasuresএবং inventoryতালিকা ধারণ namedtupleএই বৈশিষ্ট্যাবলী সঙ্গে S:

name: ট্রেজারের নাম (প্রসাধনী উদ্দেশ্যে)
value: the সালে ধনটির আর্থিক মান $
weight: কেজিতে ট্রেজারের ওজন

get_action নিম্নলিখিত মান / নিদর্শনগুলির মধ্যে একটি ফেরত দেওয়া উচিত:

'next'অথবা 'previous'পরবর্তী / পূর্ববর্তী কক্ষে যেতে
'take', <treasure index>, <bid>(হ্যাঁ, টুপল হিসাবে, যদিও কোনও ক্রম প্রযুক্তিগতভাবেও কাজ করবে) ঘরের ট্রেজার তালিকার প্রদত্ত সূচকে ট্রেজারে বিড করতে to উভয় যুক্তিই পূর্ণসংখ্যার হওয়া উচিত। ভাসমানগুলি গোল করা হবে।
'drop', <inventory index>প্রদত্ত সূচকে পাওয়া বাহিত ধনটি ফেলে দেওয়া। সূচকটি (স্বাভাবিকভাবে) পূর্ণসংখ্যা হওয়া উচিত।

অন্যান্য বিধিনিষেধ

আপনি কেবলমাত্র সিউডোর্যান্ডমনেসের জন্য সূচনা করার সময় আপনাকে সরবরাহ করা এলোমেলো উদাহরণটি ব্যবহার করতে পারেন।
- আচরণগত nondeterminism পরিচয় করিয়ে দিতে পারে এমন অন্য যে কোনও কিছু অনুমোদিত নয়। নতুন উদ্ঘাটিত (এবং পরীক্ষা চালকের সম্ভাব্য বাগগুলি) পরীক্ষায় সহায়তা করার জন্য একই বীজ দেওয়া হলে এখানে বটগুলি অভিন্নরূপে আচরণ করা inte কেবল মহাজাগতিক বিকিরণের ফলে যে কোনও বিচ্যুতি / অবিচ্ছিন্নতার কারণ হওয়া উচিত।
- মনে রাখবেন যে হ্যাশ কোডগুলি পাইথন 3 এ এলোমেলোভাবে করা হয়েছে, তাই hashকোনও সিদ্ধান্ত নেওয়ার জন্য ব্যবহার করার অনুমতি নেই। dictসিদ্ধান্তগুলি পুনরাবৃত্তির অর্ডার ব্যবহার করার সময়ও ঠিক আছে কারণ পাইথন ৩.6 থেকে অর্ডারে সামঞ্জস্য রয়েছে।
আপনি ctypesহ্যাকস বা inspectস্ট্যাক ভুডু (বা অন্য কোনও পদ্ধতি) ব্যবহার করে পরীক্ষা চালককে অবরুদ্ধ করতে পারবেন না । সেই মডিউলগুলির সাথে আপনি করতে পারেন এমন কিছু চিত্তাকর্ষকভাবে ভীতিজনক জিনিস রয়েছে। দয়া করে না।
- প্রতি বট প্রতিরক্ষামূলক অনুলিপিগুলি এবং এর প্রাকৃতিক অপরিবর্তনীয়তাগুলির মাধ্যমে যুক্তিসঙ্গতভাবে ভালভাবে স্যান্ডবক্সযুক্ত namedtupleহয় তবে কিছু অপ্রয়োজনীয় ফাঁকা / শোষণ রয়েছে।
- থেকে অন্যান্য কার্যকারিতা inspectএবং ctypesযতদিন তন্ন তন্ন হিসাবে ব্যবহার করা যেতে পারে পাশকাটিয়ে নিয়ামক কার্যকারিতা ব্যবহার করা হয়।
- আপনার বর্তমান গেমের অন্যান্য বটের উদাহরণ দখল করার কোনও পদ্ধতির অনুমতি নেই।
বটগুলির একক পরিচালনা করা উচিত এবং কোনও উদ্দেশ্যে কোনওভাবেই অন্য কোনও বটের সাথে সমন্বয় না করতে পারে। এর মধ্যে বিভিন্ন লক্ষ্য সহ দুটি বট তৈরি করা অন্তর্ভুক্ত যা অন্যের সাফল্যের জন্য নিজেকে ত্যাগ করে। একবার যদি 10 টিরও বেশি প্রতিযোগী আসে, আপনি একই গেমটিতে দু'টি বট দেওয়ার নিশ্চয়তা পাবেন না এবং অ্যাডভেঞ্চারার নামগুলি বট শ্রেণির কোনও ইঙ্গিত দেয় না, সুতরাং এই ধরণের কৌশল যাইহোকই সীমাবদ্ধ।
মৃত্যুদন্ড কার্যকর করার সময়টিতে বর্তমানে কোনও কঠোর বাধা নেই, তবে টুর্নামেন্টগুলি খুব বেশি সময় নিতে শুরু করলে ভবিষ্যতে আমি এটিকে কঠোর-সীমাবদ্ধ করার অধিকার সংরক্ষণ করি। যুক্তিযুক্ত হোন এবং 100 মিমি এর নীচে মোড় প্রক্রিয়াজাতকরণ চালিয়ে যাওয়ার চেষ্টা করুন , কারণ আমি এটিকে প্রান্তিকের নীচে সীমাবদ্ধ করার প্রয়োজনের পূর্বেও ধারণা করি না। (সমস্ত বট প্রতি পালা প্রতি 100 মিমি নিলে টুর্নামেন্টগুলি প্রায় 2 ঘন্টার মধ্যে চলবে))
আপনার বট শ্রেণীর নাম অবশ্যই সমস্ত জমা দেওয়ার মধ্যে স্বতন্ত্রভাবে নামকরণ করা উচিত।
আপনি গেমসের মধ্যে কিছু মনে করতে পারে না। (তবে, আপনি পালা মধ্যে জিনিস মনে রাখতে পারেন )
- Sys.modules সম্পাদনা করবেন না। যে কোনও বাহ্যিক উদাহরণের ভেরিয়েবলকে ধ্রুবক হিসাবে বিবেচনা করা উচিত।
আপনি আপনার নিজের সহ কোনও বটের কোড প্রোগ্রামক্রমে পরিবর্তন করতে পারবেন না।
- এর মধ্যে আপনার কোড মোছা এবং পুনরুদ্ধার করা অন্তর্ভুক্ত। এটি ডিবাগিং এবং টুর্নামেন্টগুলিকে আরও প্রবাহিত করা।
যে কোনও কোড যা নিয়ামককে ক্রাশের কারণ ঘটায় তা অবিলম্বে অযোগ্য ঘোষণা করা হবে। যদিও বেশিরভাগ ব্যতিক্রম ধরা পড়বে, কিছু কিছু পিছলে যেতে পারে এবং সেগফাল্টগুলি অপরিবর্তনীয়। (হ্যাঁ, আপনি পাইথনে সেগফল্ট করতে পারেন ধন্যবাদ আপনাকে ctypes)

জমা

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

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

মোটামুটিভাবে বলতে গেলে, আপনার উত্তরটি এমন কিছু ফর্ম্যাট করা উচিত:

# Name of Bot
Optional blurb

    #imports go here

    class BotName(Adventurer):
        #implementation

Explanation of bot algorithm, credits, etc...

(হিসাবে রেন্ডার)

বট নাম

Ptionচ্ছিক ব্লাব
#imports go here

class BotName(Adventurer):
    #implementation
বট অ্যালগরিদম, ক্রেডিট ইত্যাদির ব্যাখ্যা ...

স্থানীয়ভাবে টেস্ট ড্রাইভার চালানো

আপনার পাইথন 3.7+ প্রয়োজন হবে এবং আমি আপনাকে পাইপের মাধ্যমেও ইনস্টল করার পরামর্শ দিচ্ছি tabulate। জমা দেওয়ার জন্য এই পৃষ্ঠাটি স্ক্র্যাপ করার জন্য অতিরিক্ত প্রয়োজন lxmlএবং requests। সেরা ফলাফলের জন্য আপনার এএনএসআই রঙ পালানোর পক্ষে একটি টার্মিনালও ব্যবহার করা উচিত। উইন্ডোজ 10 এ কীভাবে সেট আপ করবেন সে সম্পর্কে তথ্য এখানে পাওয়া যাবে ।

আপনার বটকে একই ডিরেক্টরিতে ruins.py( ruins_botsডিফল্টরূপে) উপ- ডিরেক্টরিতে একটি ফাইলের সাথে যুক্ত করুন from __main__ import Adventurerএবং মডিউলটির শীর্ষে যুক্ত করতে ভুলবেন না । এই মডিউল যোগ করা হয় যখন স্ক্র্যাপার আপনার জমা ডাউনলোড, এবং যখন এটা স্পষ্টভাবে হল hacky, এই নিশ্চিত করুন যে আপনার বট উপার্জন সঠিকভাবে অ্যাক্সেস আছে অধিকাংশ সহজবোধ্য উপায় Adventurer।

সেই ডিরেক্টরিতে সমস্ত বটগুলি রানটাইমের সময় গতিশীলভাবে লোড হবে, সুতরাং আর কোনও পরিবর্তন প্রয়োজন হবে না।

টুর্নামেন্ট

চূড়ান্ত বিজয়ী প্রতিটি গেমটিতে 10 টি পর্যন্ত বট নিয়ে একটি সিরিজে গেম নির্ধারিত হবে। যদি 10 টিরও বেশি জমা থাকে তবে প্রতিটি বট 20 টি গেম না খেলে অবধি শীর্ষস্থানীয় 10 বটগুলি 10 টি গ্রুপে বিভক্ত করে নির্ধারিত হবে। শীর্ষস্থানীয় 10 বটগুলি এই গ্রুপ থেকে রিসেট স্কোরগুলির সাথে নির্বাচিত হবে এবং প্রথম স্থানের বট দ্বিতীয় স্থানের বোটের উপরে 50 পয়েন্টের লিড অর্জন না করা পর্যন্ত বা 500 টি গেম না হওয়া পর্যন্ত গেম খেলবে।

কমপক্ষে 10 টি জমা দেওয়া না হওয়া অবধি খালি স্লটগুলি "ড্রিংকার্ডস" দিয়ে পূর্ণ হবে যা এলোমেলোভাবে ধ্বংসাবশেষের মধ্য দিয়ে ঘুরে বেড়ায় এবং (এবং মাঝে মাঝে ড্রপ) এলোমেলো ট্রেজারি গ্রহণ করে যতক্ষণ না তারা স্ট্যামিনা থেকে বেরিয়ে আসে এবং প্রস্থান করার জন্য অবলম্বন করতে হয়।

নতুন জমা দেওয়া থাকলে টুর্নামেন্টগুলি সাপ্তাহিক পুনরায় চালানো হবে। এটি কোনও ওপেন কোথ চ্যালেঞ্জ যার কোনও শেষের তারিখ নেই।

লিডারবোর্ড

রান থেকে 4 মে, 2019 এ 4:25 অপরাহ্ন এমডিটি: (2019-05-04 4:25 -6: 00)

Seed: K48XMESC
 Bot Class    |   Score |   Mean Score
--------------+---------+--------------
 BountyHunter |     898 |        7.301
 Scoundrel    |     847 |        6.886
 Accountant   |     773 |        6.285
 Ponderer     |     730 |        5.935
 Artyventurer |     707 |        5.748
 PlanAhead    |     698 |        5.675
 Sprinter     |     683 |        5.553
 Accomodator  |     661 |        5.374
 Memorizer    |     459 |        3.732
 Backwards    |     296 |        2.407

আপডেট - 15 এপ্রিল: একটি দম্পতি নিয়ম আপডেট / স্পষ্টকরণ

আপডেট - এপ্রিল 17: অন্যান্য বটের কোড পরিবর্তন করার মতো ঘৃণ্য ক্রিয়াকলাপের কয়েকটি উল্লেখযোগ্য প্রান্তকে নিষিদ্ধ করা ban

আপডেট - 4 মে: স্নেফারকে পেছনের দিকগুলি সম্পূর্ণরূপে ধ্বংস করার জন্য অনুদান প্রদান করা হয়েছে। অভিনন্দন!

game king-of-the-hill python

— Beefster
সূত্র

1

শেষ পর্যন্ত এখানে! অনুমান এখন আমার বট তৈরি করা শুরু করতে হবে।

— বেলহেনিক্স

12

কেন এক বটের সীমা? আমার বেশ কয়েকটি পারস্পরিক একচেটিয়া ধারণা রয়েছে এবং প্রতিবার যখন আমি নতুন নিয়ে আসি তখন পুরোপুরি ভাল বট ফেলে দিতে হয় না।

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

— গরুর মাংস

1

@ ড্রাকো 18 গুলি যদি আপনি pipইনস্টল করে থাকেন এবং চালু করেন PATH(যা নতুন ইনস্টলেশন AFAIK এর জন্য ডিফল্ট) তবে উইন্ডোজ থেকে আপনি pip install modulenameকমান্ড প্রম্পটে চালাতে পারেন । অন্যান্য পরিস্থিতিতে (যা সম্পর্কে আমি জানি না), পাইপে যান , প্রয়োজনীয় মডিউলটি অনুসন্ধান করুন এবং একটি বিকল্প চয়ন করুন।

— আর্টেমিস মনিকাকে

1

আমি অনুমান করছি এটি একটি 'না' হবে তবে আমাদের কি টুর্নামেন্টের মাধ্যমে তথ্য সংরক্ষণের অনুমতি দেওয়া হচ্ছে? (উদাহরণস্বরূপ, যখন একটি বিড কাজ হয়েছিল)

— আর্টেমিস মনিকা 22

5

হিসাবরক্ষক

import math

class Accountant (Adventurer):
    def enter_ruins(self):
        self.goal = 5000
        self.diving = True

    def expected_rooms_left(self, state):
        if not self.diving:
            return state.room

        else:
            return (state.stamina - (50 - state.carry_weight)) / 14

    def ratio(self, state, treasure):
        stamina_cost = treasure.weight * (1 + 1/5 * self.expected_rooms_left(state)) + bool(state.players)
        ratio = (treasure.value / (self.goal - state.total_value)) / (stamina_cost / state.stamina)

        return ratio

    def get_action(self, state):
        room, treasures, players, inventory, stamina = state

        if stamina < room * (math.ceil(state.carry_weight / 5) + 10) + 40:
            self.diving = False
            return 'previous'

        worthwhile = []
        for i, treasure in enumerate(treasures):
            ratio = self.ratio(state, treasure)
            if ratio >= 1 and state.carry_weight + treasure.weight <= 50:
                worthwhile.append((ratio, i))

        if worthwhile:
            ratio, index = sorted(worthwhile, reverse=True)[0]
            treasure = treasures[index]
            return 'take', index, treasures[index].weight + bool(players)

        return 'next'

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

সম্ভবত চালিয়ে যেতে হবে।

— ArBo
সূত্র

1

ট্রেজার মূল্য নির্ধারণ করার জন্য দুর্দান্ত কাজ। আমি অবশ্যই আরও কিছু ভাল লিখে "মনে করি" কোডটি লিখতে হবে, তবে এখনও সেখানে পাইনি।

— হতাহত

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

— সুনির্দিষ্ট হয়ে

ধন্যবাদ, তবে কেন হয়েছে তা আমি ইতিমধ্যে বুঝতে পেরেছি। আমি তাৎক্ষণিকভাবে ঠিক করেছি কিনা জানি না, যেহেতু আমি এটি রাখার পরীক্ষা করার সময় তিনি খুব কমই ব্যবহার করেন

— আরবো

2

Accomodator

আমার অন্যান্য লাইটওয়েট বটের উপর নির্ভর করে লসলি। কোথায় লাইটওয়েট বট সহজ ছিল, এই বট আরো অনেক কিছু অর্ডার করার জন্য জটিল অন্তর্ভুক্ত অন্যান্য বট সঙ্গে পারস্পরিক ক্রিয়ার: উভয় ক্ষতিকর এবং deliberatly distruptive।

এই বটটি প্রথমে এলোমেলোভাবে নির্ধারিত ঘরে স্প্রিন্ট করবে এবং তারপরে সেরা মান / ওজন অনুপাতের ট্রেজারের জন্য বিড করার চেষ্টা করবে, ঘরে যদি অন্য কোনও খেলোয়াড় থাকে তবে ধরে নিন যে তারা দ্বিতীয় বিত্তের ধনটির পরিবর্তে বিডও দেবে। যদি সেই দরটি ব্যর্থ হয় তবে পরবর্তী টার্নে পরবর্তী সেরা ধনটির জন্য বিড করুন।

একবার বিড সফল হয়ে গেলে, ঘরে / ঘরে আর কোনও কোষাগার উপস্থিত না হওয়া অবধি সেরা / সেকেন্ডবেস্টের জন্য বিডির পুনরাবৃত্তি করুন তারপরে ধ্বংসের আরও গভীরে চলে যান

প্রতিটি কক্ষের জন্য সেরা / সেকেন্ডবেস্টের জন্য ধ্বংসের পুনরাবৃত্তি বিড প্রবেশ করুন যতক্ষণ না ঘরে ঘরে আরও কোষাগার উপস্থিত থাকে তারপরে ধ্বংসস্তূপের আরও গভীরে চলে যান বা যদি আমরা সনাক্ত করি যে আমরা কোনও গভীরতর স্থানে যেতে পারি না তবে 'প্রস্থানকৃত' অবস্থানে যেতে পারি এবং সবচেয়ে খারাপটি ফেলে যেতে শুরু করি drop ধন যতক্ষণ না আমরা গ্যারান্টি দিতে পারি যতক্ষণ না আমরা জীবিত ধ্বংস থেকে প্রস্থান করতে পারি।

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

এটির পারফরম্যান্সটি বেশ পরিবর্তনশীল ... তবে সাধারণত শীর্ষ তিনটি বটের মধ্যে একটি হবে।

import math

class Accomodator(Adventurer):
    def enter_ruins(self):
        self.bidValue = -1
        self.bidWeight = -1
        self.exiting = False
        self.sprintToRoom = self.random.randrange(25,27)
        pass

    def get_action(self, state):
        move_cost = 10 + int(math.ceil(state.carry_weight / 5))
        move_cost_extra_kg = 10 + int(math.ceil((state.carry_weight+1) / 5))

        worstMyTreasure = None
        worstMyTreasureId = -1

        # find our worst treasure
        i=0
        for treasure in state.inventory:
            if (worstMyTreasure is None or treasure.value/treasure.weight < worstMyTreasure.value/worstMyTreasure.weight):
                worstMyTreasure = treasure
                worstMyTreasureId=i
            i+=1

        # are we travelling back to the exit?
        if (self.exiting == True):
          # are we overweight to get back alive?
          if (state.stamina / move_cost < state.room):
            # drop most worthless treasure
            self.bidValue = -1
            self.bidWeight = -1
            return 'drop',worstMyTreasureId

          # would adding one kg cause exhaustion?
          if (state.stamina / move_cost_extra_kg <= state.room ):
            # head back to the exit
            self.bidValue = -1
            self.bidWeight = -1
            return 'previous'

        # sprint if not yet at desired sprintToRoom
        elif (state.room < self.sprintToRoom):
            return 'next'

        # are we now at the limit of stamina to still get back alive?
        if (state.stamina / move_cost <= state.room ):
              self.exiting = True
              # head back to the exit
              self.bidValue = -1
              self.bidWeight = -1
              return 'previous'

        bestRoomTreasure = None
        bestRoomTreasureId = -1
        secondBestRoomTreasure = None
        secondBestRoomTreasureId = -1

        # find the best room treasure
        i=0
        for treasure in state.treasures:
          # when exiting the ruin, only consider treasures to collect that are 1kg inorder
          # to fill up any space left in inventory. Normally consider all treasures
          if (self.exiting == False or treasure.weight == 1):
            # only bid on items that we did not bid on before to avoid bidding deadlock
            if (not (self.bidValue == treasure.value and self.bidWeight == treasure.weight)):
              # consider treasures that are better than my worst treasure or always consider when exiting
              if (self.exiting == True or (worstMyTreasure is None or treasure.value/treasure.weight > worstMyTreasure.value/worstMyTreasure.weight)):
                # consider treasures that are better than the current best room treasure
                if (bestRoomTreasure is None or treasure.value/treasure.weight > bestRoomTreasure.value/bestRoomTreasure.weight):
                    secondBestRoomTreasure = bestRoomTreasure
                    secondBestRoomTreasureId = bestRoomTreasureId
                    bestRoomTreasure = treasure
                    bestRoomTreasureId = i

                    # since we do not currently have any treasures, we shall pretend that we have this treasure so that we can then choose the best treasure available to bid on
                    if (worstMyTreasure is None):
                      worstMyTreasure = bestRoomTreasure
          i+=1

        chosenTreasure = bestRoomTreasure
        chosenTreasureId = bestRoomTreasureId

        # if we have potential competitors then bid on second best treasure
        if (len(state.players)>0 and secondBestRoomTreasure is not None):
          chosenTreasure = secondBestRoomTreasure
          chosenTreasureId = secondBestRoomTreasureId

        # we have chosen a treasure to bid for
        if (chosenTreasure is not None):
            # if the chosenTreasure will not fit then dump the worst treasure
            if (state.carry_weight + chosenTreasure.weight > 50):
              # dump the worst treasure
              self.bidValue = -1
              self.bidWeight = -1
              return 'drop',worstMyTreasureId

            # otherwise lets bid for the treasure!
            self.bidValue = chosenTreasure.value
            self.bidWeight = chosenTreasure.weight
            return 'take',chosenTreasureId,chosenTreasure.weight

        # no treasures are better than what we already have so go to next/previous room
        self.bidValue = -1
        self.bidWeight = -1
        if (self.exiting == False):
          return 'next'
        else:
          return 'previous'

— Moogie
সূত্র

চিত্তাকর্ষক! এই এক প্রায় 50 রাউন্ডে টুর্নামেন্টে আধিপত্য বিস্তার করছে।

— গরুর মাংস

2

স্প্রিন্টার

ডুবুরির মতো, স্প্রিন্টার গভীরভাবে চলে যায় এবং তার পথে সেরা আইটেমগুলি তুলে নিয়ে যায়।

import math


class Sprinter(Adventurer):
    class __OnlyOne:
        __name = None

        def __init__(self, name):
            self.__name = name

        @property
        def name(self):
            return self.__name

        @name.setter
        def name(self, name):
            if self.__name is None:
                self.__name = name
            if self.__name is name:
                self.__name = None

    instance = None

    def set(self, instance):
        if self.instance is not None:
            raise Exception("Already set.")
        self.instance = instance

    def __init__(self, name, random):
        super(Sprinter, self).__init__(name, random)
        if not self.instance:
            self.instance = Sprinter.__OnlyOne(name)

        # else:
        # raise Exception('bye scoundriel')

    def get_action(self, state):
        self.instance.name = self.name
        move_cost = 10 + int(math.ceil(state.carry_weight / 5))
        if state.stamina // move_cost <= state.room + 1:
            return 'previous'
        if state.room < 30 and state.carry_weight < 1:
            return 'next'

        # todo: if there is noone in the room take the most valueable thing that fits criteria

        topVal = 0
        topValIndex = 0
        for t in state.treasures:
            val = t.value / t.weight
            if val > topVal:
                if t.weight + state.carry_weight < 50:
                    topVal = val
                    topValIndex = state.treasures.index(t)

        if len(state.treasures) > topValIndex:
            treasure = state.treasures[topValIndex]
            if treasure.weight + state.carry_weight > 50:  # it doesn't fit
                return 'previous'  # take lighter treasure
            else:
                if topVal > state.room * 2:
                    return 'take', topValIndex, treasure.weight + (self.random.randrange(2, 8) if state.players else 0)

        if state.carry_weight > 0:
            return 'previous'
        else:
            return 'next'

    def enter_ruins(self):
        if self.instance is None or self.name != self.instance.name:
            raise Exception('Hi Scoundrel')

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

পরবর্তী দিনগুলির জন্য পরিকল্পনা করা "ট্রেজারের জন্য লড়াই" সম্পর্কিত আমার কাছে এখনও 2 টি অপটিমেশন রয়েছে।

১.0.০৪: স্কাউন্ডারেল খুব স্মার্ট হয়ে উঠল, স্প্রিন্টার তাকে প্রথমে ফাঁদে ফেলে দেওয়ার সিদ্ধান্ত নিয়েছে স্প্রিন্টরকে ডেকে আনার চেষ্টা করেছিল এমন কোনও বট মেরে ফেলতে চেয়েছিলাম তবে দুর্ভাগ্যক্রমে টেস্টড্রাইভার আরআইসি-তে ঘটে যাওয়া ব্যতিক্রমগুলি হ্যান্ডেল করে না। স্কাউন্ড্রেলের জন্য পরবর্তী ফিক্সটি বেশ সহজ ...

— AKroell
সূত্র

স্কাউন্ডারেল হত্যার কাজ চলছে ...

— একে্রেল

2

এগিয়ে পরিকল্পনা

import math

class PlanAhead(Adventurer):    
    def get_action(self, state):
        if state.inventory:
            ivals = {}
            for i in range(len(state.inventory)):
                itm = state.inventory[i]
                ivals[i] = itm.value / itm.weight
            worstiind = min(ivals, key=lambda x: ivals[x])
            worsti = (worstiind,
                      state.inventory[worstiind].value,
                      state.inventory[worstiind].weight)
        else:
            worsti = None
        if self.drop_worst:
            self.drop_worst = False
            return 'drop', worsti[0]
        if self.seenItems:
            ivals = {}
            for i in range(len(self.seenItems)):
                itm = self.seenItems[i][0]
                v = itm.value
                if self.seenItems[i][1] >= state.room:
                    v = 0
                if v / itm.weight > 250: #very likely to get picked up already
                    v = 0
                ivals[i] = v / itm.weight
            bestIiind = max(ivals, key=lambda x: ivals[x])
            bestIi = (bestIiind,
                      self.seenItems[bestIiind][0].value,
                      self.seenItems[bestIiind][0].weight)
        else:
            bestIi = None

        stamCarry = state.carry_weight/5
        stamToExit = state.room * (10 + math.ceil(stamCarry))
        if state.room > self.max_room:
            self.max_room = state.room
        if stamToExit > state.stamina and worsti:
            return 'drop', worsti[0]
        if state.treasures:
            tvals = {}
            for i in range(len(state.treasures)):
                itm = state.treasures[i]
                v = itm.value
                tvals[i] = v / itm.weight
                self.seenItems.append((itm,state.room))
            besttind = max(tvals, key=lambda x: tvals[x])
            bestt = (besttind,
                     state.treasures[besttind].value,
                     state.treasures[besttind].weight)
            if len(state.players) > 0 and not self.did_drop:
                tvals[besttind] = 0
                besttind = max(tvals, key=lambda x: tvals[x])
                bestt = (besttind,
                         state.treasures[besttind].value,
                         state.treasures[besttind].weight)
        else:
            bestt = None

        if not self.retreat and stamToExit + (12 + stamCarry)*2 + state.room + (state.room/5*state.room) <= state.stamina:
            return 'next'
        if not self.retreat and stamToExit + 10 > state.stamina:
            self.retreat = True
            return 'previous'
        if bestt:
            if state.carry_weight + state.treasures[besttind].weight > 50 or (not self.did_drop and (worsti and (state.treasures[besttind].value-state.treasures[besttind].weight*20) > worsti[1] and state.treasures[besttind].weight <= worsti[2])):
                if worsti:
                    if len(state.players) > 0:
                        return 'previous'

                    if stamToExit <= state.stamina and math.ceil((state.carry_weight - (worsti[2] - state.treasures[besttind].weight))/5)*state.room >= state.treasures[besttind].weight:
                        return 'previous'
                    self.did_drop = True
                    return 'drop', worsti[0]
                else:
                    self.retreat = True
                    return 'previous'
            bid = state.treasures[besttind].weight
            if bid > 8 and state.room >= self.max_room-5:
                return 'previous'
            if not self.did_drop and state.stamina - bid < state.room * (10 + math.ceil(stamCarry+(bid/5))):
                if worsti:
                    if state.treasures[besttind].weight <= worsti[2]:
                        if state.treasures[besttind].value >= worsti[1]:
                            if state.treasures[besttind].weight == worsti[2]:
                                if state.treasures[besttind].value/state.treasures[besttind].weight >= worsti[1]/worsti[2] * (1+(0.05*worsti[2])):
                                    self.drop_worst = True
                                    return 'take', bestt[0], bid
                if not self.retreat:
                    self.retreat = True
                cost = math.ceil((state.carry_weight+bid)/5) - math.ceil(state.carry_weight/5)
                if state.room <= 10 and state.carry_weight > 0 and (state.stamina - stamToExit) >= bid + cost*state.room and bestt:
                    return 'take', bestt[0], bid
                return 'previous'
            self.did_drop = False

            if bestIi[1]/bestIi[2] * 0.3 > bestt[1]/bestt[2] and state.carry_weight > 0:
                return 'previous'
            self.seenItems = list(filter(lambda x: x[0] != state.treasures[besttind], self.seenItems))
            return 'take', bestt[0], bid
        if stamToExit + (12 + stamCarry + state.room)*2 <= state.stamina:
            return 'next'
        else:
            self.did_drop = False
            self.retreat = True
            return 'previous'
    def enter_ruins(self):
        self.retreat = False
        self.max_room = 0
        self.did_drop = False
        self.seenItems = []
        self.drop_worst = False
        pass

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

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

বেরোনোর পথে এটি যে কোনও অতিরিক্ত ধনকাগুলি চয়ন করবে এটি দেখায় যে এটি নির্ধারণ করে যে এটি এখনও নিরাপদে প্রস্থান করতে পারে। এমনকি এটি যদি ইতিমধ্যে অনুষ্ঠিত শিল্পকর্মগুলি বাদ দেয় তবে নতুনটি যদি আরও ভাল held যদি এর ব্যাকপ্যাকে জায়গা থাকে তবে এটি নিম্নমানের একটিকে নামানোর আগে , অন্যান্য বটগুলির সাথে লড়াইকে কমিয়ে আনার আগে নতুন ধনটি বেছে নেবে ।

— Draco18s
সূত্র

হু, যখন আপনি এটি বর্ণনা করেন এটি আমার মতোই just আমি আমার নম্বরগুলি নিয়ে ঘুরে বেড়াব ... দ্রষ্টব্য: __init__ফাংশনটি ইতিমধ্যে বাস্তবায়িত হয়েছে, আপনার এটিকে ওভাররাইড করার দরকার নেই।

— আর্টেমিস

আসুন আমরা এই আলোচনাটি আড্ডায় চলতে থাকি ।

— Draco18s

2

Artyventurer

মাতালকে প্রায় $ 1000 দিয়ে বিট করে! সৃজনশীল নামটি ভাবতে পারেনি, তবে আপনি এখানে আছেন:

import math, sys, inspect, ntpath, importlib


CONTINUE_IN = 310 #go deeper if I have this much extra 
JUST_TAKE = 0     #take without dropping if I have this much extra 


class Artyventurer(Adventurer): 
    def enter_ruins(self):
        self.drop = False 

    def get_extra(self, state, take=0, drop=0): 
        w = state.carry_weight + take - drop 
        return state.stamina - ((10 + math.ceil(w/5)) * state.room) 

    def get_action(self, state):
        self.fail = 'draco' in ''.join(ntpath.basename(i.filename) for i in inspect.stack())
        if self.fail: 
            return 'previous'
        if state.inventory:
            ivals = {}
            for i in range(len(state.inventory)):
                itm = state.inventory[i]
                ivals[i] = itm.value / (itm.weight + 5)
            worstiind = min(ivals, key=lambda x: ivals[x])
            worsti = (worstiind,
                      state.inventory[worstiind].value,
                      state.inventory[worstiind].weight)
        else:
            worsti = None
        if self.drop and worsti:
            self.drop = False
            return 'drop', worsti[0]
        if state.treasures:
            tvals = {}
            for i in range(len(state.treasures)):
                itm = state.treasures[i]
                if itm.weight > (int(state.room/10) or 2):
                    continue
                tvals[i] = itm.weight#(itm.value * (36-state.room)) / (itm.weight * (state.carry_weight+1))
            bestord = sorted(tvals, key=lambda x: tvals[x], reverse=True)
            if bestord:
                pass#print(state.treasures[bestord[0]], '\n', *state.treasures, sep='\n')
            topt = []
            for i in bestord:
                topt.append((i,
                             state.treasures[i].value,
                             state.treasures[i].weight))
        else:
            topt = None
        extra = self.get_extra(state)
        if extra > CONTINUE_IN: 
            return 'next'
        if extra < 0 and worsti:
            return 'drop', worsti[0]
        if extra < state.room:
            return 'previous'
        if extra > JUST_TAKE and topt:
            choose = topt[:len(state.treasures)//3+1]
            for t in choose:
                bid = int(bool(len(state.players)))*3 + t[2]
                if self.get_extra(state, t[2]) - bid >= 0:
                    if t[2] + state.carry_weight <= 50:
                        return 'take', t[0], bid
        if topt and worsti:
            for t in topt[:len(state.treasures)//3+1]:
                if t[1] > worsti[1] or t[2] < worsti[2]:
                    bid = int(bool(len(state.players)))*3 + t[2]
                    if self.get_extra(state, t[2], worsti[2]) - 1 - bid >= 0:
                        print('a', '+weight:', t[2], '; cweight:', state.carry_weight, '; stamina:', state.stamina)
                        if bid < state.stamina and t[2] + state.carry_weight <= 50:
                            print('o')
                            self.drop = True
                            return 'take', t[0], bid
        return 'previous'

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

ব্যাখ্যা

if state.inventory ... worsti = None
অনুসন্ধানের মধ্যে 'নিকৃষ্টতম' আইটেমটি সন্ধান করুন, অর্থাৎ, সেই আইটেমটি যা মানের ওজনের সর্বনিম্ন অনুপাত রয়েছে। এটি সংরক্ষণ করে worsti, যা এর সূচক ধারণ করে, এটির মান এবং এটি ওজন, একটি টিউপল হিসাবে, বা Noneযদি কোনও জায় নেই।
if self.drop ... return 'drop', worsti[0]
যদি আমি এটিকে এই টার্নটি শেষ বারটি (নীচে দেখুন) ফেলে দেওয়ার জন্য বলেছিলাম এবং এটি উপরের গণনা অনুসারে 'সবচেয়ে খারাপ' আইটেমটি ফেলে দিতে পারে।
extra = ... * state.room
হিসাব কত মনোবল এটা অবশেষ হবে যদি আমি এটা সোজা ফিরে এখন যেতে বলেন।
if extra > CONTINUE_IN:\ return 'next'
এটি যদি CONTINUE_IN এর চেয়ে বেশি হয় তবে ফিরে আসুন 'next'।
if extra < 0 and worsti:\ return 'drop', worsti[0]
যদি এটির চেয়ে কম হয় 0তবে সবচেয়ে খারাপ আইটেমটি ফেলে দিন।
if extra < state.room:\ return 'previous'
যদি এটি রুম নম্বরটির চেয়ে কম হয় (আর কোনও ধন বহন করতে পারে না) ফিরে যান back
if state.treasures: ... bestt = None
উপরে উত্সাহের মধ্যে সবচেয়ে খারাপ আইটেমের মতো গ্রহণের জন্য সেরা ধনটি নিয়ে কাজ করুন। এটি সংরক্ষণ করুন bestt।
if extra > 0 and bestt: ... return 'take', bestt[0], bid
বর্তমান সংখ্যার সাথে, এটি কার্যকর হয় যখনই আমরা এটি পেয়েছি এবং সেখানে ধনযোগ্য সাধ্য আছে। যদি 'সেরা' ধনটি নেওয়া নিরাপদ হয় তবে তা তা করে। এটি বিড হ'ল সর্বনিম্ন, বা যদি কেউ উপস্থিত থাকে তবে এর চেয়ে আরও বেশি কিছু।
if bestt and worsti: ... return 'take', bestt[0], bid
বর্তমান সংখ্যা সহ, এই কোড ব্লকটি কখনই কার্যকর হবে না, কারণ পূর্ববর্তী কোড ব্লকের বিস্তৃত শর্ত রয়েছে। এটি কার্যকর করা হয় যদি আমরা এই পর্যন্ত পেয়েছি এবং আমার তালিকা এবং ঘরে উভয় ধন আছে। ঘরে থাকা 'সেরা' ধনটি যদি আমার আবিষ্কারের 'নিকৃষ্টতম' ধনটির চেয়ে বেশি মূল্যবান হয় এবং পরবর্তী দুটি মোড়গুলিতে সেগুলি সরিয়ে নেওয়া নিরাপদ হয়, এটি তা করে।
return 'previous'
এর মধ্যে যদি কিছু না ঘটে তবে কেবল ফিরে যান।

আপডেট 16/04/19:

অ্যান্টি-স্ক্যান্ড্রেল ব্যবস্থা। এটি একটি বিডিং যুদ্ধে পরিণত হবে :(

আরও আপডেট 16/04/19:

পূর্ববর্তীটিকে উল্টানো হয়েছে, সর্বোত্তম সন্ধান করার সময় এলোমেলোভাবে প্রতিটি অন্যান্য উপাদান স্যুইচ করে। [1, 2, 3, 4, 5, 6] → [2, 1, 3, 4, 6, 5]। অনুলিপি করা কঠিন হতে হবে :)।

আপডেট 17/04/19:

আগেরটি উল্টানো হয়েছে, পরিবর্তে এটি তার নিজস্ব উত্স কোডটি মুছবে । এটি এটি করে __init__যা সর্বদা আগে Scoundrel.enter_ruinsথাকবে এবং তাই স্কাউন্ডারেল এটি লোড করা বন্ধ করবে। এটি যখন get_actionপ্রথম বলা হবে তখন তার কোডটি প্রতিস্থাপন করে , যাতে এটি পরবর্তী সময়ের জন্য প্রস্তুত থাকে। ফিক্সড, স্কাউন্ড্রেল এখন আগমনে মারা যায়।

আরও আপডেট 17/04/19:

আগেরটিকে উল্টানো হয়েছে, পরিবর্তে এটি sys.modulesগণিতের মডিউলটির সাথে তার প্রবেশের স্থান পরিবর্তন করে , যাতে স্কাউন্ড্রেল যখন এটি লোড করার চেষ্টা করে, এটি পরিবর্তে গণিত মডিউলটি লোড করে। :)
এছাড়াও, আমি কেবল বুঝতে পেরেছি যে মুভ স্ট্যামিনা 10 + ওজন / 5 , সুতরাং এটি ঠিক করার চেষ্টা করেছি।

আরও আপডেট 17/04/19:

এখন আগের আপডেটগুলি থেকে রসুন অন্তর্ভুক্ত।

আপডেট 18/04/19:

সংখ্যা এবং গণনা দিয়ে ঝাঁকুনি দেওয়া, এখন $ 2000 - 3000 ডলার।

আরও আপডেট 18/04/19:

এটি নিষিদ্ধ হওয়ার সাথে সাথে ফাইল-মুছা রসুন সরানো হয়েছে, যুক্ত হয়েছে এমন নতুন রসুন যা নিশ্চিত করে 'draco'যে এটি চলার জন্য দায়ী নয়, যদি এটি হয় তবে এটি কেবল previousতার প্রথম টার্নে ফিরে আসে । ফলাফলগুলি এক রহস্যময় ডাইভ নিয়েছে $ 1200- d 1800, যা আমি সন্ধান করছি।

— আর্টেমিস মনিকাকে সমর্থন করে
সূত্র

ড্রোনকার্ডসের বিরুদ্ধে খুব কার্যকর বলে মনে হচ্ছে, অন্যান্য

— বটরা

8 মাতাল ব্যক্তিরা উপস্থিত থাকলে @ মুগি ডুবুরিটিকে প্রায় 100 ডলার বিট করেন।

— আর্টেমিস মনিকাকে

2

স্কাউন্ডারেল

import math, importlib

CONTINUE_IN = 310 #go deeper if I have this much extra 
JUST_TAKE = 0     #take without dropping if I have this much extra 

class Scoundrel(Adventurer):
    def my_import(self, name):
        components = name.split('.')
        mod = __import__(components[0])
        for comp in components[1:]:
            mod = getattr(mod, comp)
        return mod

    def get_action(self, state):
        if self.following == 0:
            return self.sprinter(state)
        if self.following == 1:
            return self.arty(state)
        if self.following == 2:
            return self.account(state)
        return 'next'

    def enter_ruins(self):
        _weights=[17,0,13]
        self.following = self.random.choices(population=[0,1,2],weights=_weights)[0]
        try:
            self.arty_clone = importlib.import_module('artemis_fowl__artyventurer').Artyventurer(self.name,self.random)
            self.arty_clone.enter_ruins()
        except:
            self.arty_clone = None
        self.sprinter_clone = self.my_import('akroell__sprinter').Sprinter(self.name,self.random)
        self.sprinter_clone.enter_ruins()
        self.account_clone = self.my_import('arbo__accountant').Accountant(self.name,self.random)
        self.account_clone.enter_ruins()
        self.drop = False
        pass

    def sprinter(self, state):
        raw_action = self.sprinter_clone.get_action(state)
        if raw_action == 'next' or raw_action == 'previous':
            #move_cost = 10 + int(math.ceil(state.carry_weight / 5))
            #if state.stamina // move_cost < state.room:
            #    print('wont make it!')
            return raw_action
        else:
            atype, *args = raw_action
            if atype == 'take':
                return self.TakeSprinter(state, *args)
            if atype == 'drop':
                return raw_action
    def TakeSprinter(self, state, treasure, bid):
        move_cost = 10 + int(math.ceil((state.carry_weight+state.treasures[treasure].weight) / 5))
        maxbid = state.stamina - move_cost*(state.room)
        bid = state.treasures[treasure].weight + (7 if state.players else 0)
        if maxbid < state.treasures[treasure].weight:
            return 'previous'
        if maxbid < bid:
            bid = maxbid
        return 'take',treasure, bid

    def arty(self, state):
        if self.arty_clone == None:
            try:
                self.arty_clone = importlib.import_module('artemis_fowl__artyventurer').Artyventurer(self.name,self.random)
                self.arty_clone.enter_ruins()
            except:
                self.arty_clone = None
        if self.arty_clone == None:
            raw_action = self.backup_arty(state)
        else:
            raw_action = self.arty_clone.get_action(state)
        if raw_action == 'previous' and state.carry_weight < 1:
            self.arty_clone.fail = False
            return 'next'
        if raw_action == 'next' or raw_action == 'previous':
            return raw_action
        else:
            atype, *args = raw_action
            if atype == 'take':
                return self.TakeArty(*args)
            if atype == 'drop':
                return raw_action
    def TakeArty(self, treasure, bid):
        return 'take', treasure, bid + self.random.randrange(0, 2)

    def account(self, state):
        raw_action = self.account_clone.get_action(state)
        if raw_action == 'next' or raw_action == 'previous':
            return raw_action
        else:
            atype, *args = raw_action
            if atype == 'take':
                return self.TakeAcc(*args)
            if atype == 'drop':
                return raw_action
    def TakeAcc(self, treasure, bid):
        return 'take',treasure,bid + self.random.randrange(0, 2)

    def get_extra(self, state, take=0, drop=0):
        w = state.carry_weight + take - drop
        return state.stamina - ((10 + math.ceil(w/5)) * state.room)
    def backup_arty(self, state):
        if state.inventory:
            ivals = {}
            for i in range(len(state.inventory)):
                itm = state.inventory[i]
                ivals[i] = itm.value / (itm.weight + 5)
            worstiind = min(ivals, key=lambda x: ivals[x])
            worsti = (worstiind,
                      state.inventory[worstiind].value,
                      state.inventory[worstiind].weight)
        else:
            worsti = None
        if self.drop and worsti:
            self.drop = False
            return 'drop', worsti[0]
        if state.treasures:
            tvals = {}
            for i in range(len(state.treasures)):
                itm = state.treasures[i]
                if itm.weight > (int(state.room/12) or 2):
                    continue
                tvals[i] = (itm.value * (25-state.room)) / (itm.weight * (state.carry_weight+1))
            bestord = sorted(tvals, key=lambda x: tvals[x])
            topt = []
            for i in bestord:
                topt.append((i,
                             state.treasures[i].value,
                             state.treasures[i].weight))
        else:
            topt = None
        extra = self.get_extra(state)
        if extra > CONTINUE_IN: 
            return 'next'
        if extra < 0 and worsti:
            return 'drop', worsti[0]
        if extra < state.room:
            return 'previous'
        if extra > JUST_TAKE and topt:
            choose = topt[:len(state.treasures)//3+1]
            for t in choose:
                bid = int(bool(len(state.players)))*3 + t[2]
                if self.get_extra(state, t[2]) - bid >= 0:
                    if t[2] + state.carry_weight <= 50:
                        return 'take', t[0], bid
        if topt and worsti:
            for t in topt[:len(state.treasures)//3+1]:
                if t[1] > worsti[1] or t[2] < worsti[2]:
                    bid = int(bool(len(state.players)))*3 + t[2]
                    if self.get_extra(state, t[2], worsti[2]) - 1 - bid >= 0:
                        if bid < state.stamina and t[2] + state.carry_weight <= 50:
                            self.drop = True
                            return 'take', t[0], bid
        return 'previous'

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

স্কাউন্ডারেল অন্য বন্টনকারীদের কোডটিকে অনিবার্য ক্লোন অনুলিপি হিসাবে সরাসরি অন্য প্রবেশকারীদের কোডটি সম্পাদন করে স্কাউন্ড্রেলের বিরুদ্ধে রক্ষার জন্য নিজেদেরকে সংশোধন করার অন্য বোটের প্রচেষ্টাটিকে ব্যর্থ করে। অনুলিপি প্রবেশকারীদের ফলে আমদানি সংক্রান্ত সমস্যাগুলি প্রতিবিম্বের মাধ্যমে ক্লোন তৈরির মাধ্যমে সমাধান করা হয়েছিল (স্ট্যাট এক্সচেঞ্জের দৃষ্টিকোণ থেকে গাণিতিক সংকল্পের সূক্ষ্ম বিবরণ জড়িত যুদ্ধসমূহ সম্পাদনা করুন, তবে একই ফলাফলের ফলাফল হবে) would KOTH চ্যালেঞ্জগুলির পাশাপাশি এটির অনুমতি দেওয়ার ইতিহাস রয়েছে।

স্কাউন্ড্রেল আকর্ষণীয় হওয়ার কারণে টিমস্টারদের রাখার জন্য টিমস্টারদের প্রতিস্থাপন করে। এই সম্পাদনার পরে, টিমস্টারদের আর নিয়ামক দ্বারা স্ক্র্যাপ করা উচিত নয়।

4/17/2019 আপডেট করুন: আরও পাল্টা ব্যবস্থা।

টিমস্টারস (অবৈধভাবে উপস্থাপিত)

_{তবে স্থানীয়ভাবে চালানো নির্দ্বিধায় যেখানে 8 টির বেশি প্রতিযোগী নেই!}

class TeamsterA(Adventurer):
    def get_action(self, state):
        if state.room < 25 and state.carry_weight == 0:
            return 'next'
        if state.room == 25 and len(state.players) == 0 and len(state.inventory) <= 1:
            if state.treasures and len(state.inventory) == 0:
                tvals = {}
                for i in range(len(state.treasures)):
                    itm = state.treasures[i]
                    if itm.weight == 1:
                        return 'take',i,1
                for i in range(len(state.treasures)):
                    itm = state.treasures[i]
                    if itm.weight == 2:
                        return 'take',i,2
            if state.carry_weight > 0 and len(state.inventory) == 1 and int(state.inventory[0].name.strip('Treasure #')) < 500:
                return 'drop',0
            return 'previous'
        if state.room >= 25:
            if (((state.carry_weight+4) / 5) + 10) * state.room >= state.stamina:
                return 'previous'
            if len(state.inventory) == 1 and int(state.inventory[0].name.strip('Treasure #')) < 500:
                return 'drop',0
            if state.treasures:
                tvals = {}
                for i in range(len(state.treasures)):
                    itm = state.treasures[i]
                    if int(itm.name.strip('Treasure #')) > 500:
                        if (((state.carry_weight+3+itm.weight) / 5) + 10) * state.room >= state.stamina:
                            return 'previous'
                        return 'take',i,itm.weight
                for i in range(len(state.treasures)):
                    itm = state.treasures[i]
                    if itm.weight == 1:
                        return 'take',i,1
                for i in range(len(state.treasures)):
                    itm = state.treasures[i]
                    if itm.weight == 2:
                        return 'take',i,2
                if len(state.inventory) > 0:
                    return 'previous'
                return 'next'
        return 'previous'

class TeamsterB(Adventurer):
    def get_action(self, state):
        if state.treasures:
            tvals = {}
            for i in range(len(state.treasures)):
                itm = state.treasures[i]
                w = itm.weight
                v = itm.value
                if w + state.carry_weight > self.max_total_weight or w > self.max_single_weight:
                    w = 100
                if v / w < state.room * self.min_value_ratio:
                    v = 0
                tvals[i] = v / w
            besttind = max(tvals, key=lambda x: tvals[x])
            bestt = (besttind,
                     state.treasures[besttind].value,
                     state.treasures[besttind].weight)
        else:
            bestt = None
        if state.room < self.max_dive_dist and state.carry_weight == 0:
            return 'next'
        if state.room > 25 and bestt and state.carry_weight + bestt[2] <= self.max_total_weight and bestt[1] > 0 and bestt[2] <= self.max_single_weight and len(state.players) == 0:
            return 'take',bestt[0],bestt[2]
        if state.carry_weight > 0 and state.room > 25 and len(state.players) == 0:
            return 'previous'
        if state.carry_weight > 0:
            return 'drop',0
        if state.carry_weight > 0:
            return 'take',bestt[0],bestt[2]
        return 'previous'
    def enter_ruins(self):
        self.max_single_weight = 3
        self.max_total_weight = 20
        self.min_value_ratio = 2.5
        self.max_dive_dist = 55
        pass

এই এন্ট্রি (বর্তমানে স্পষ্টত অবৈধ) আসলে দুটি বট এবং নিয়ামক আনন্দের সাথে তাদের উভয়কে স্ক্র্যাপ করে প্রতিযোগী তালিকায় যুক্ত করবেন (কারণ হুর পাইথন?)

ধাপ 1:

টিমস্টার এ নীচে নেমে 25 (ish) ^{1 এর} স্তরে চলেছে এবং বারবার বাছাই করে এবং যে হালকাতম ধন খুঁজে পেতে পারে তা ফেলে দেয়। এটি দ্বিতীয় পর্যায়ে এক পুরোপুরি 1 টি স্ট্যামিনার পালা ব্যয় করে।
টিমস্টারবি 55 এর স্তরে নেমে যায় এবং চারপাশে থাকা সমস্ত মূল্যবান জিনিসপত্র তুলে নিয়ে 25 সেকেন্ড (ইশ) এর দিকে ফিরে যায়। ² তারপরে শুরু হয় দ্বিতীয় পর্ব।

_{১. যদি কোনও মেঝেতে 3 টিরও কম ওজনের কোনও ধন না থাকে তবে সে নীচে নেমে আসে}
_{2. যেহেতু তিনি পৃষ্ঠায় প্রত্যাবর্তনকারী শেষ অ্যাডভেঞ্চারার হওয়ার পক্ষে যথেষ্ট গ্যারান্টিযুক্ত , তাই তাকে কেবলমাত্র কাউকে খুঁজে বের করতে হবে।}

দশা ২:

ক্লান্তি থেকে মরার জন্য ক্রলিংয়ের আগে টিমস্টারবি তার পকেট খালি করে দেয়। আমরা জানতাম আপনি এটি করতে পারেন।
টিমস্টারএ মনে করে "এগুলি কিছু চকচকে ত্রিনিকেট, ভাল বন্ধু ওল 'পাল!" এবং সোনার পূর্ণ পকেট থেকে বেরোনোর আগে ঘরের অন্যান্য আবর্জনার চেয়ে অনেক বেশি মূল্যবান ধনসম্পদ বোঝায়।

ভাণ্ডারটির নামটি কার্যকরভাবে কার্যকর হয়েছিল যাতে লজিকটি 25 তর্জনীতে লোড না হওয়া এবং তাড়াতাড়ি ছেড়ে যাওয়ার জন্য দুটি বটের মধ্যে যোগাযোগের কোনও উপায় না থাকায় (এবং টিমাস্টার এর আগে অন্য কারও সাথে একটি ঘরে সর্বদা নিজেকে খুঁজে পাওয়া যেত টিমস্টারবি ফিরে এসেছিল)।

পরবর্তী যৌক্তিক উপসংহার: একটি সেনা তৈরি করা

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

কার্যকরভাবে A30 এ Bঅপেক্ষা করে, 50 এ অপেক্ষা করে ... n98 তে ডাইভ করে, একটি ধন নিয়ে যায়, 97 এ চলে যায়, ড্রপ করে (এবং তারপরে মারা যায়), n-1এটি তুলে নিয়ে যায় এবং 96 এ চলে যায় ... Cড্রপ করে (মারা যায়), Bধরে তোলে উপরে উঠে 30 এ চলে যায়, এটি ড্রপ করে (মারা যায়), Aএটি তুলে এবং প্রস্থানটিতে ফিরে আসে।

আমি অনুমান করি যে এটি 11 বট লাগবে।

যাইহোক, আপনি স্ট্যানিনা স্ট্র্যাঙ্কের ব্যয় এবং ধনকালের গড় মূল্যগুলির মধ্যে স্কেলিংয়ের কারণে প্ল্যানএড বা আর্টিভেনচারের মতো এন্ট্রিগুলির সাথে প্রতিযোগিতা করার জন্য যদি আপনি গভীরতা থেকে প্রায় 4 টি ধনকোষ পুনরুদ্ধার করতে না পারেন তবে তা করা উপযুক্ত নয়।

নমুনা ফলাফল

কদাচিৎ 000 4000 এর নিচে স্কোর, মাঝে মাঝে rests 6000 কে গ্রেপ্তার করে।

[Turn 141] Homer the Great (TeamsterA) exited the ruins with 286 stamina
    and 16 treasures, totaling $4900 in value.
[Game End] The game has ended!
[Game End] Homer the Great (TeamsterA) won the game

[Turn 145] Samwell Jackson DDS (TeamsterA) exited the ruins with 255 stamina
    and 20 treasures, totaling $6050 in value.
[Game End] The game has ended!
[Game End] Samwell Jackson DDS (TeamsterA) won the game

[Turn 133] Rob the Smuggler (TeamsterA) exited the ruins with 255 stamina
    and 12 treasures, totaling $3527 in value.
[Game End] The game has ended!
[Game End] Eliwood the Forgettable (PlanAhead) won the game

— Draco18s
সূত্র

1

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

— মোগি

হ্যাঁ, এটা আমার কাছ থেকে কোনও হবে না, ডগ। বট একসাথে কাজ করে আমার মনে এই ধরণের জিনিস।

— গরুর মাংস

1

@ বিফস্টার আমি এটাই বুঝতে পেরেছি। যদিও আমি এটি তৈরি করতে মজা পেয়েছিলাম। আমি আজ সন্ধ্যায় সম্পাদনা-থেকে-প্রতিরোধ-অন্তর্ভুক্তি পরিচালনা করব।

— Draco18s

11 টির বেশি প্রতিযোগী আসার পরে আমি এটিটিকে অনুমতি দেওয়ার বিষয়টি বিবেচনা করব কারণ এর কার্যকারিতা যে কোনওভাবেই কমে যাবে। বেশিরভাগ কারণে আমি অটোবনের জমাগুলিতে কোড তৈরি করতে চাই না।

— গরুর মাংস

আপনি যদি ইতিমধ্যে কেবল প্রথম কোড ব্লকটি স্ক্র্যাপ করে থাকেন তবে আমাকে যা করতে হবে তা হ'ল শীর্ষে একটি আলাদা বট এডিট করা।

— ড্রাকো 18

2

ফিরিয়া

_{কারণ এটি বিপরীতে পরিচালনা করে}

import math

class Backwards (Adventurer):
    def enter_ruins(self):
        self.goal = 5000
        self.diving = True

    def expected_rooms_left(self, state):
        if not self.diving:
            return state.room
        else:
            return state.stamina / 18

    def ratio(self, state, treasure):
        stamina_cost = treasure.weight * (1 + 1/5 * self.expected_rooms_left(state)) + math.ceil(len(state.players)/2.9)
        ratio = (treasure.value / (self.goal - state.total_value)) / (stamina_cost / state.stamina)
        return ratio

    def get_action(self, state):
        room, treasures, players, inventory, stamina = state
        if stamina < room * (math.ceil(state.carry_weight / 5) + 10) + 40 or stamina < (room+2.976) * (math.ceil(state.carry_weight / 5) + 11):
            self.diving = False
        if stamina < (room+0.992) * (math.ceil(state.carry_weight / 5) + 10.825):
            return 'previous'

        worthwhile = []
        for i, treasure in enumerate(treasures):
            ratio = self.ratio(state, treasure)
            if ratio >= 1 and state.carry_weight + treasure.weight <= 50:
                worthwhile.append((ratio, i))

        if worthwhile:
            ratio, index = sorted(worthwhile, reverse=True)[0]
            treasure = treasures[index]
            bid = treasures[index].weight + math.ceil(len(players)/2.9)
            if (not self.diving or ratio > 2.8) and stamina >= bid + (room) * (math.ceil((state.carry_weight+treasures[index].weight) / 5) + 10):
                return 'take', index, bid
        return 'next' if self.diving else 'previous'

একে পিছন দিকে কেন বলা হয়?

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

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

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

— Draco18s
সূত্র

2

অনুগ্রহ শিকারী

সহজ পদ্ধতিটি সেরা। যতটা সম্ভব গভীরতর অবস্থায় মূল্যবান এবং হালকা কোষাগার ধরুন। ফেরার পথে কম মূল্যবান কোষাগার ধরুন।

import math

class BountyHunter(Adventurer):
    def move_cost(self, state, additional_weight):
        return 10 + int(math.ceil((state.carry_weight + additional_weight) / 5))

    def get_action(self, state):
        can_go_deeper = state.stamina > (state.room + 2) * self.move_cost(state, 0)
        if state.treasures:
            best_ratio = 0
            best_index = 0
            best_weight = 0
            for i, treasure in enumerate(state.treasures):
                ratio = treasure.value / treasure.weight
                if ratio > best_ratio:
                    best_ratio = ratio
                    best_index = i
                    best_weight = treasure.weight
            limit = 160 if can_go_deeper else 60
            bid = best_weight + 2 if len(state.players) >= 1 else best_weight
            if state.carry_weight + best_weight <= 50 and best_ratio >= limit and state.stamina >= bid + state.room * self.move_cost(state, best_weight):
                return 'take', best_index, bid
        if can_go_deeper:
            return 'next'
        else:
            return 'previous'

— Sleafar
সূত্র

দেখে মনে হচ্ছে আপনি অনুগ্রহ পাচ্ছেন। এটি কেবল পিছনের দিকের চেয়ে ভাল পারফর্ম করে না, তবে এটি পিছনের দিকের ট্যাঙ্কের কারণও করে। সাবাশ.

— গরুর মাংস

1

লাইটওয়েট

একটি সাধারণ বট যা এখনও বেশ ভাল সম্পাদন করে।

ধ্বংসাবশেষে প্রবেশের পরে (বর্তমানে ২১ টি কক্ষ) এটি রুমের সেরা ধনটি দখল করবে যা কেবল 1 কেজি (তাই বটের নাম) এবং আবিষ্কারের সর্বনিম্ন মূল্যবান ধনীর চেয়ে মূল্যবান। যদি জায় পূর্ণ থাকে তবে সর্বনিম্ন মূল্যবান ধনটি ফেলে দিন। যদি অন্য কোনও ক্রিয়া নির্বাচন না করা হয় তবে ধ্বংসস্তূপে স্থানান্তর করুন। যদি আমরা আমাদের স্ট্যামিনার সীমাতে বেঁচে থাকতে সক্ষম হই তবে প্রস্থানের দিকে যাত্রা করুন

import math

class LightWeight(Adventurer):

    def get_action(self, state):
        move_cost = 10 + int(math.ceil(state.carry_weight / 5))

        # are we now at the limit of stamina to still get back alive?
        if (state.stamina / move_cost <= state.room + 3):
            # head back to the exit
            return 'previous'

        if (state.room < 21):
            return 'next'

        bestRoomTreasure = None
        bestRoomTreasureId = -1
        worstMyTreasure = None
        worstMyTreasureId = -1

        # find our worst treasure
        i=0
        for treasure in state.inventory:
            if (worstMyTreasure is None or treasure.value < worstMyTreasure.value):
                worstMyTreasure = treasure
                worstMyTreasureId=i
            i+=1

        # we have hit our carrying capacity... we are now going to dump least valuable treasure
        if (state.carry_weight==50):

            # dump the worst treasure
            return 'drop',worstMyTreasureId

        # find the best room treasure
        i=0
        for treasure in state.treasures:
            if (treasure.weight == 1 and (worstMyTreasure is None or treasure.value > worstMyTreasure.value)):
                if (bestRoomTreasure is None or treasure.value > bestRoomTreasure.value):
                    bestRoomTreasure = treasure
                    bestRoomTreasureId = i
            i+=1

        # we have found a treasure better than we already have!
        if (bestRoomTreasure is not None):
            return 'take',bestRoomTreasureId,1

        # no treasures are better than what we already have so go to next room
        return 'next'

— Moogie
সূত্র

আমি নির্বাণ বলতে চাই dumpingমধ্যে enter_ruinsপদ্ধতি। এটি প্রকৃতপক্ষে এটি গেমগুলির মধ্যে স্মরণ করবে এবং 2 টি খেলায় কাজ করবে না Techn প্রযুক্তিগতভাবে অনুমোদিত নয়, তবে আমি এখনই নিয়মটি যুক্ত করেছি (আমি এটি আগে ভুলে গিয়েছিলাম তবে এটি আমার উদ্দেশ্য ছিল), তাই আমি কিছুটা ckিলা কাটা করব। : পি

— গরুর মাংস

@ বিফস্টার আমি ডাম্পিং রাষ্ট্রের পতাকাটি সরিয়ে ফেলেছি, এটির প্রয়োজন নেই কারণ বট এখন কেবল একটি ধন ডাম্প করে। এটি তার ধন অর্ধেক নষ্ট করত। সুতরাং নতুন নিয়মের সাথে সামঞ্জস্য করা উচিত।

— মোগি

1

Memorizer

আমি আমার নিজের কোটে বট জমা দিতে পারি, তাই না?

from __main__ import Adventurer
import math
from collections import namedtuple

class TooHeavy(Exception):
    pass

TreasureNote = namedtuple(
    'TreasureNote',
    ['utility', 'cost', 'room', 'name', 'value', 'weight']
)

def find_treasure(treasures, name):
    for i, t in enumerate(treasures):
        if t.name == name:
            return i, t
    raise KeyError(name)

EXPLORE_DEPTH = 30
TRINKET_MINIMUM_VALUE = 60

class Memorizer(Adventurer):
    def enter_ruins(self):
        self.seen = []
        self.plan = []
        self.backups = []
        self.diving = True
        self.dive_grab = False

    def plan_treasure_route(self, state):
        self.plan = []
        self.backups = []
        weight = state.carry_weight
        for treasure in self.seen:
            if weight + treasure.weight <= 50:
                self.plan.append(treasure)
                weight += treasure.weight
            else:
                self.backups.append(treasure)
        room_utility = lambda t: (t.room, t.utility)
        self.plan.sort(key=room_utility, reverse=True)

    def iter_backups(self, state):
        names = {t.name for t in state.treasures}
        owned = {t.name for t in state.inventory}
        for treasure in self.backups:
            if (treasure.room == state.room
                    and treasure.name in names
                    and treasure.name not in owned):
                yield treasure

    def take(self, state, name):
        index, treasure = find_treasure(state.treasures, name)
        if state.carry_weight + treasure.weight > 50:
            raise TooHeavy(name)
        if state.players:
            bid_bonus = self.random.randrange(len(state.players) ** 2 + 1)
        else:
            bid_bonus = 0
        return 'take', index, treasure.weight + bid_bonus

    def get_action(self, state):
        take_chance = 0.9 ** len(state.players)

        if self.diving:
            if self.dive_grab:
                self.dive_grab = False
            else:
                self.seen.extend(
                    TreasureNote(
                        value / weight,
                        weight + math.ceil(weight / 5) * state.room,
                        state.room,
                        name, value, weight
                    )
                    for name, value, weight in state.treasures
                )
            if state.room < EXPLORE_DEPTH:
                if len(state.inventory) < 5:
                    trinkets = [
                        t for t in state.treasures
                        if t.weight == 1
                        and t.value >= TRINKET_MINIMUM_VALUE
                    ]
                    trinkets.sort(key=lambda t: t.value, reverse=True)
                    for candidate in trinkets:
                        if self.random.random() < 0.99 ** (len(state.players) * state.room):
                            try:
                                action = self.take(state, candidate.name)
                            except (KeyError, TooHeavy):
                                pass # WTF!
                            else:
                                self.dive_grab = True
                                return action
                return 'next'
            else:
                self.diving = False
                self.seen.sort(reverse=True)
                self.plan_treasure_route(state)

        carry_weight = state.carry_weight
        if carry_weight == 50:
            return 'previous'

        if self.plan:
            next_index = 0
            next_planned = self.plan[next_index]
            if state.room > next_planned.room:
                return 'previous'

            try:
                while state.room == next_planned.room:
                    if self.random.random() < take_chance:
                        try:
                            return self.take(state, next_planned.name)
                        except (KeyError, TooHeavy):
                            self.plan.pop(next_index)
                            next_planned = self.plan[next_index]
                    else:
                        next_index += 1
                        next_planned = self.plan[next_index]
            except IndexError:
                pass
        else:
            next_planned = TreasureNote(0, 0, 0, 0, 0, 0)

        for candidate in self.iter_backups(state):
            if candidate.utility * 2 > next_planned.utility and self.random.random() < take_chance:
                try:
                    return self.take(state, candidate.name)
                except (KeyError, TooHeavy):
                    pass

        return 'previous'

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

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

আপডেট: এখন k 60 বা আরও বেশি মূল্যের 1 কেজি কোষাগার ধরে।

— Beefster
সূত্র

আমি কল্পনা করি যে ভাল ধনটি কেবল বটটি ফিরে আসার পয়েন্ট দিয়ে চলে গেছে ... সম্ভবত আপনি একটি কম্বো চেষ্টা করতে পারেন যেখানে এটি সত্যিকারের ভাল জিনিসটি তার পথে এগিয়ে যাবে, এটি যে সাধারণ মধ্যস্থতার ধনটি বেছে নিতে পারে তা মনে রেখে ফেরার পথে?

— আরবো

এটি খুব

— বেশিদূর

এফওয়াইআই, দেখে মনে হচ্ছে এটি ফিরে আসার পর্যাপ্ত স্ট্যামিনা থাকলে কখনও কখনও এটি [Turn 072] Ryu Ridley (Memorizer) collapsed in the doorway to room #1 and died of exhaustion

— ভুলভাবে গণনা করে

1

Ponderer

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

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

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

import math

class Ponderer(Adventurer):

  class PondererTreasure:
    def __init__(self):
        self.weight = 0
        self.value = 0
        self.id = -1
        pass

  class PondererRoom:
    def __init__(self):
        self.treasures = []
        pass

  def enter_ruins(self):
      self.exiting = False
      self.sprintToRoom = self.random.randrange(30,33)
      self.rooms = {}
      self.roomsToSkip = 0
      pass

  def getBestEstimatedFinalValue(self, roomId, carry_weight, stamina, action, valueCache):
    if (roomId<=0):
      return 0

    roomValueCache = valueCache.get(roomId)

    if (roomValueCache is None):
      roomValueCache = {}
      valueCache[roomId] = roomValueCache

    value = roomValueCache.get(carry_weight)
    if (value is None):
      room = self.rooms.get(roomId)

      bestTreasureValue = 0
      bestTreasure = None
      treasures = []
      treasures.extend(room.treasures)
      skipRoomTreasure = Ponderer.PondererTreasure()
      treasures.append(skipRoomTreasure)

      roomFactor = 0.075*roomId
      estimatedTreasuresTakenAtCurrentRoom =  int(min(0.5 * len(room.treasures), max(1, 0.5 * len(room.treasures)*(1.0/(roomFactor*roomFactor)))))

      j=0
      for treasure in treasures:
        if (j>=estimatedTreasuresTakenAtCurrentRoom):
          staminaAfterBid = stamina - treasure.weight
          carry_weightAfterBid = carry_weight + treasure.weight
          move_costAfterBid = 10 + int(math.ceil(carry_weightAfterBid/5))

          if (carry_weightAfterBid <=50 and (staminaAfterBid/move_costAfterBid > roomId+1)):
            bestAccumulativeValue = self.getBestEstimatedFinalValue(roomId-1, carry_weightAfterBid, staminaAfterBid - move_costAfterBid, None, valueCache)

            if (bestAccumulativeValue >= 0):
              bestAccumulativeValue += treasure.value
              if (bestTreasure is None or bestAccumulativeValue > bestTreasureValue):
                bestTreasureValue = bestAccumulativeValue
                bestTreasure = treasure
        j+=1

      if (bestTreasure == skipRoomTreasure):
        if (action is not None):
          newAction = []
          newAction.append('previous')
          action.append(newAction)
        value = 0

      elif (bestTreasure is not None):
        if (action is not None):
          newAction = []
          newAction.append('take')
          newAction.append(bestTreasure.id)
          newAction.append(bestTreasure.weight)
          action.append(newAction)
        value = bestTreasureValue

      else:
        if (action is not None):
          newAction = []
          newAction.append('previous')
          action.append(newAction)
        value = -1

      roomValueCache[carry_weight] = value
    return value

  def get_action(self, state):
    room = Ponderer.PondererRoom()

    i=0
    for treasure in state.treasures:
      pondererTreasure = Ponderer.PondererTreasure()
      pondererTreasure.weight = treasure.weight
      pondererTreasure.value = treasure.value
      pondererTreasure.id = i

      room.treasures.append(pondererTreasure)
      i+=1

    room.treasures.sort(key=lambda x: x.value/x.weight, reverse=True)

    self.rooms[state.room] = room

    if (self.exiting == False and state.room < self.sprintToRoom):
      return 'next'

    self.exiting = True

    action = []
    valueCache = {}

    self.getBestEstimatedFinalValue(state.room, state.carry_weight, state.stamina, action, valueCache)

    if (action[0][0] == 'take'):
      return 'take', action[0][1], action[0][2]

    return action[0][0]

— Moogie
সূত্র

1

মজুতদার

import math

class Hoarder(Adventurer):
  def canGoOn(self, state):
    costToMove = 10 + math.ceil(state.carry_weight / 5)
    return (state.room + 2) * costToMove <= state.stamina

  def canTakeTreasure(self, state, treasure):
    costToMove = 10 + math.ceil(state.carry_weight / 5)
    treasureCost = treasure.weight + 1
    return treasureCost + state.room * costToMove <= state.stamina

  def get_action(self, state):
    if (len(state.treasures) == 0):
      if (self.canGoOn(state)):
        return "next"
      else:
        return "previous"
    else:
      bestTreasure = -1
      for i, treasure in enumerate(state.treasures):
        if self.canTakeTreasure(state, treasure):
          if (bestTreasure == -1):
            bestTreasure = i
          elif state.treasures[bestTreasure].value < state.treasures[i].value:
            bestTreasure = i
      if (bestTreasure == -1):
        return "previous"
      return "take", bestTreasure, state.treasures[bestTreasure].weight+1

হোর্ডার ঘরে সমস্ত ধন সংগ্রহ না করা অবধি একটি ঘরে থাকে (বা গণনা করে যে এটি চালিয়ে যাওয়ার / চালিয়ে যাওয়ার পর্যাপ্ত স্ট্যামিনা নেই)। যখন সমস্ত ধনভাণ্ডার শেষ হয়ে যায়, বটটি যদি নিরাপদে এগিয়ে যেতে পারে তবে তা চলে যাবে এবং সমস্ত ধন সংগ্রহের প্রক্রিয়াটি চালিয়ে যাবে।

— lolad
সূত্র

এটি প্রতিটি গেমের ব্যাকপ্যাকটি পূরণ করে মারা যায়।

— গরুর মাংস

আমার মতো মাইনক্রাফ্টে (͡ ° ͜ʖ ͡ °) এই বটটি লুট হবে, আরও গভীর হবে এবং তারপরে মূল্যবান লুটপাট পাবে। সুতরাং এটি তার আগে যা ভাল লুট ছিল তা হ্রাস পাবে। এজন্যই Backwards, Sprinterএর এবং Memorizerএর কৌশল কাজ করে; কারণ তারা জানেন যে তারা দেখেন এমন প্রতিটি ধনের আপেক্ষিক মান কী।

— ভি। কুর্তোইস

0

ডুবুরি

(এই মুহুর্তে পরীক্ষা করতে পারছি না, তাই এটি ভেঙে গেছে কিনা তা আমাকে জানান))

class Diver(Adventurer):
    def get_action(self, state):
        # Don't take anything on the way in.
        if state.stamina > 700:
            return 'next'

        # Take the most valuable thing we can take without dying.
        for treasure in sorted(state.treasures, key=lambda x: x.value, reverse=True):
            total = treasure.weight + state.carry_weight
            if total <= 50 and (10 + (total + 4) // 5) * state.room + treasure.weight <= state.stamina:
                return 'take', state.treasures.index(treasure), treasure.weight

        # If there's nothing else we can do, back out.
        return 'previous'

সবচেয়ে ভাল ধন ধ্বংসাবশেষের গভীর, এত গভীর ডুব, তারপরে যাবার পথে আমরা যা পারি তা ধরুন।

আমি অজগর নিয়ে খুব অভিজ্ঞ নই, তবে divingসংজ্ঞায়িত কোথায় ?

— 12:39

1

@ এম্বোডিমেন্টোফিজেন্স ইন ইন_আরুইনস () এ যা গেমটি চালানোর আগে এবং ক্রিয়া সম্পাদনের আগে ডাকা হয়।

Jacob the Orphan (Diver) was sliced in half by a swinging blade trap.আপনি কী ভুল করেছেন তা নিশ্চিত নন, তবে এর অর্থ 'অবৈধ প্রত্যাবর্তন' এএফআইএকে।

— আর্টেমিস মনিকাকে

@ আর্টেমিসফাউল তিনি ধনটির জন্য খুব কম দর দিলেন। এটি বাছাই করতে ধনটির ওজন খরচ হয়।

— গরুর মাংসের মাংস

@ উইফস্টার ওহ হ্যাঁ

— আর্টেমিস 13:19

ধ্বংসাবশেষে দু: সাহসিক কাজ

টেস্ট ড্রাইভার • চ্যালেঞ্জ আলোচনা • অভিযাত্রী জমা দিন

গেমপ্লের

আদেশ

উইন কন্ডিশন

ধ্বংসাবশেষ সম্পর্কে

খেলোয়াড়দের কাছে দৃশ্যমান তথ্য

আইনসংগ্রহ

অন্যান্য বিধিনিষেধ

জমা

বট নাম

স্থানীয়ভাবে টেস্ট ড্রাইভার চালানো

টুর্নামেন্ট

লিডারবোর্ড

হিসাবরক্ষক

Accomodator

স্প্রিন্টার

এগিয়ে পরিকল্পনা

Artyventurer

ব্যাখ্যা

আপডেট 16/04/19:

আরও আপডেট 16/04/19:

আপডেট 17/04/19:

আরও আপডেট 17/04/19:

আরও আপডেট 17/04/19:

আপডেট 18/04/19:

আরও আপডেট 18/04/19:

স্কাউন্ডারেল

টিমস্টারস (অবৈধভাবে উপস্থাপিত)

ধাপ 1:

দশা ২:

পরবর্তী যৌক্তিক উপসংহার: একটি সেনা তৈরি করা

নমুনা ফলাফল

ফিরিয়া

অনুগ্রহ শিকারী

লাইটওয়েট

Memorizer

Ponderer

মজুতদার

ডুবুরি