রোবট রুলেট: হাই স্টেক রোবট জুয়া


56

চূড়ান্ত অবস্থান

+ + ---------------------------------- + + --------- + + ---- ----- + + --------- + + ---------------------------- + +
| নাম | স্কোর | উইনরেট | টাইরেট | নির্মূলের সম্ভাবনা |
+ + ---------------------------------- + + --------- + + ---- ----- + + --------- + + ---------------------------- + +
| 1. সারকোমাবটএমকি 11 | 0.06333 | 6.13% | 0.41% | [42 24 10 8 6 4]% |
| 2. উইজকিকবট | 0.06189 | 5.91% | 0.56% | [51 12 7 10 7 6]% |
| 3. স্ট্রাইকারবট | 0.05984 | 5.78% | 0.41% | [46 18 11 8 6 5]% |
| 4. পারফেক্টফ্রাকশনবট | 0.05336 | 5.16% | 0.35% | [49 12 14 10 6 4]% |
| 5. মেহরানবট | 0.05012 | 4.81% | 0.41% | [57 12 8 7 6 5]% |
| 6. ওগবোট | 0.04879 | 4.66% | 0.45% | [50 15 9 8 7 5]% |
| 7. স্নেচবট | 0.04616 | 4.48% | 0.28% | [41 29 8 9 5 3]% |
| 8. অ্যান্টিকিকবট | 0.04458 | 4.24% | 0.44% | [20 38 17 10 6 4]% |
| 9. মেহবট | 0.03636 | 3.51% | 0.25% | [80 3 4 4 3 3]% |
| 10. Meh20Bot | 0.03421 | 3.30% | 0.23% | [57 12 8 7 9 3]% |
| 11. জেনেরিকবট | 0.03136 | 3.00% | 0.28% | [18 39 20 11 5 3]% |
| 12. হার্ডকোডবট | 0.02891 | 2.75% | 0.29% | [58 21 3 6 5 4]% |
| 13. গ্যাংবোট 1 | 0.02797 | 2.64% | 0.32% | [20 31 35 6 3 2]% |
| 14. সারকোমাবটএমকে 3 | 0.02794 | 2.62% | 0.34% | [16 15 38 17 7 4]% |
| 15. গ্যাংবট0 | 0.02794 | 2.64% | 0.30% | [20 31 35 6 3 2]% |
| 16. গ্যাংবট 2 | 0.02770 | 2.62% | 0.31% | [20 31 35 6 3 2]% |
| 17. টিটিটবট | 0.02740 | 2.63% | 0.21% | [54 10 15 10 5 2]% |
| 18. মাতাহারি 2 বট | 0.02611 | 2.35% | 0.51% | [39 26 11 11 6 5]% |
| 19. পলিবট | 0.02545 | 2.41% | 0.27% | [53 18 6 13 5 3]% |
| 20. স্পিটবলবট | 0.02502 | 2.39% | 0.22% | [84 10 1 1 0 1]% |
| 21. স্কয়ারআপবট | 0.02397 | 2.35% | 0.10% | [10 60 14 7 4 3]% |
| 22. সাবধানী জুয়ারবোট 2 | 0.02250 | 2.19% | 0.13% | [60 18 10 5 3 1]% |
| 23. বট 13 | 0.02205 | 2.15% | 0.11% | [90 0 2 3 2 1]% |
| 24. অ্যাগ্রোক্যালকবট | 0.01892 | 1.75% | 0.29% | [26 49 13 5 3 3]% |
| 25. সাবধানবাট | 0.01629 | 1.56% | 0.14% | [15 41 27 11 4 1]% |
| 26. কোস্টবোটভি 2 | 0.01413 | 1.40% | 0.02% | [83 12 3 1 0 0]% |
| 27. ক্যালকুলেটিংবট | 0.01404 | 1.29% | 0.22% | [87 9 1 1 1 1]% |
| 28. হাফপঞ্চবট | 0.01241 | 1.15% | 0.18% | [47 20 13 12 5 2]% |
| 29. হাফলাইফ এস 3 বট | 0.01097 | 1.00% | 0.20% | [76 9 5 4 2 2]% |
| 30. অ্যান্টিগ্যাংবট | 0.00816 | 0.76% | 0.11% | [94 1 1 1 1 1]% |
| 31. জ্যামিতিকবট | 0.00776 | 0.74% | 0.07% | [19 46 25 7 2 1]% |
| 32. গেসবট | 0.00719 | 0.05% | 1.34% | [65 17 4 6 5 3]% |
| 33. সীমানা র্যান্ডমবট | 0.00622 | 0.60% | 0.05% | [42 39 12 5 2 0]% |
| 34. স্প্রেডারবট | 0.00549 | 0.54% | 0.02% | [32 43 19 4 1 0]% |
| 35. ডিটারমিনবট | 0.00529 | 0.45% | 0.16% | [22 41 20 11 4 2]% |
| 36. পারসেন্টবট | 0.00377 | 0.38% | 0.00% | [85 8 4 2 1 0]% |
| 37. হালভিস্টেস্টবট | 0.00337 | 0.29% | 0.08% | [32 43 15 6 2 1]% |
| 38. গেটএলংবট | 0.00330 | 0.33% | 0.01% | [76 18 4 1 0 0]% |
| 39. বান্দাইদবট | 0.00297 | 0.29% | 0.02% | [76 9 10 4 1 0]% |
| 40. টেনেসিয়াসবট | 0.00287 | 0.29% | 0.00% | [94 4 1 0 0 0]% |
| 41. বেঁচে থাকা | 0.00275 | 0.25% | 0.04% | [92 6 1 0 0 0]% |
| 42. র্যান্ডমবট | 0.00170 | 0.13% | 0.07% | [42 36 14 5 2 1]% |
| 43. আগ্রাসীবাউন্ডআরডমবটভি 2 | 0.00165 | 0.14% | 0.06% | [8 46 34 9 2 1]% |
| 44. ব্লাডবট | 0.00155 | 0.01% | 0.30% | [65 28 5 1 1 0]% |
| 45. আউটবিডবট | 0.00155 | 0.03% | 0.25% | [65 6 21 6 1 1]% |
| 46. ​​বক্সবট | 0.00148 | 0.10% | 0.09% | [10 51 33 5 1 1]% |
| 47. লাস্টবট | 0.00116 | 0.08% | 0.07% | [74 6 16 2 1 0]% |
| 48. UpYoursBot | 0.00088 | 0.07% | 0.03% | [37 40 17 5 1 0]% |
| 49. অ্যাভারেজবট | 0.00073 | 0.06% | 0.03% | [74 3 10 10 2 0]% |
| 50. প্যাথ্যাটিকবট | 0.00016 | 0.01% | 0.02% | [94 0 5 1 0 0]% |
| 51. ওভারফিটেডবট | 0.00014 | 0.01% | 0.00% | [58 40 2 0 0 0]% |
| 52. রবিবোট | 0.00009 | 0.01% | 0.00% | [32 41 24 2 0 0]% |
| 53. সবচেয়ে খারাপ কেসবোট | 0.00002 | 0.00% | 0.00% | [4 71 23 2 0 0]% |
| 54. স্মার্টবট | 0.00002 | 0.00% | 0.00% | [44 51 5 0 0 0]% |
| 55. এএএএইউইপওয়াইরসবট | 0.00000 | 0.00% | 0.00% | [40 58 2 0 0 0]% |
| 56. কিকবানবট | 0.00000 | 0.00% | 0.00% | [67 32 1 0 0 0]% |
| 57. ওয়ানশটবট | 0.00000 | 0.00% | 0.00% | [2 95 3 0 0 0]% |
| 58. কিকবট | 0.00000 | 0.00% | 0.00% | [100 0 0 0 0 0]% |
| 59. কামিকাজেবট | 0.00000 | 0.00% | 0.00% | [100 0 0 0 0 0]% |
| 60. মিনিকিকবট | 0.00000 | 0.00% | 0.00% | [100 0 0 0 0 0]% |
+ + ---------------------------------- + + --------- + + ---- ----- + + --------- + + ---------------------------- + +

যারা অংশগ্রহণ করেছেন তাদের জন্য ধন্যবাদ, এবং জয়ের জন্য @ সারকোমাকে অভিনন্দন!

নিয়মাবলী:

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

টুর্নামেন্টটি এর মতো কাজ করে:

প্রতিযোগীদের বন্ধনী থেকে 2 জন এলোমেলোভাবে বেছে নেওয়া হয়। তারা মুখ বন্ধ করে দেয় এবং তাদের মধ্যে একজন বা দু'জন মারা যায়। একজন খেলোয়াড় মারা যায় যদি:

  1. তারা তাদের প্রতিপক্ষের চেয়ে ছোট একটি সংখ্যা নির্বাচন করে
  2. তাদের এইচপি শূন্য বা তার নিচে নেমে যায়
  3. তারা প্রতিপক্ষের সাথে টানা তিনবার টাই করে

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

আপনার কাজটি হল পাইথন ২. in এ একটি ফাংশন লিখুন যা আপনার বর্তমান হিসাবে উপস্থিত তথ্য hp, আপনার প্রতিপক্ষের বিডের একটি তালিকা historyএবং একটি পূর্ণসংখ্যা tiesযা আপনাকে বলে দেয় যে আপনি ইতিমধ্যে আপনার বর্তমান প্রতিপক্ষের সাথে কতবার বেঁধে রেখেছেন, এবং একটি পূর্ণসংখ্যা যা আপনাকে বলে যে কীভাবে অনেকগুলি বট এখনও রয়েছে alive(আপনাকে সহ), এবং একটি পূর্ণসংখ্যা যা startটুর্নামেন্টে বটের সংখ্যা তালিকাভুক্ত করে । দ্রষ্টব্য যে ইতিহাসের সাথে সম্পর্কগুলি অন্তর্ভুক্ত নয়। ফাংশনটি অবশ্যই 0 এবং আপনার বর্তমান মোট এইচপি এর মধ্যে একটি পূর্ণসংখ্যা ফেরত দেয়। কয়েকটি সহজ উদাহরণ, যা বন্ধনগুলি উপেক্ষা করে, নীচে দেখানো হয়েছে:

def last(hp, history, ties, alive, start):
    ''' Bet a third of your hp at first, then bet your opponent's last bid, if possible '''
    if history:
        return np.minimum(hp-1, history[-1])
    else:
        return hp/3

def average(hp, history, ties, alive, start):
    ''' Bet the average opponent's bid so far, on the assumption that bids will tend downward '''
    if history:
        num = np.minimum(hp-1, int(np.average(history))+1)
    else:
        num = hp/2
    return num

def random(hp, history, ties, alive, start):
    ''' DO YOU WANT TO LIVE FOREVER?! '''
    return 1 + np.random.randint(0, hp)

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

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

এটি আমার প্রথম প্রোগ্রামিং ধাঁধা প্রচেষ্টা, তাই সমালোচনা স্বাগত!

নিয়ামক এখানে পাওয়া যাবে


4
এফডব্লিউআইডাব্লু, আপনি একবার নিয়ামক সেট আপ করার পরে আমি অন্য সমস্ত
বটগুলিতে

2
টাইপ চেকটি ছিল অ্যান্টিঅ্যান্ট্যান্টিস্টিয়্যুপিয়র্সবোটের উপকারের জন্য। আমি অন্য
উপায়টি

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

3
WOOOOOOOOOOOOOO!
সারকোমা

5
হে ভগবান. যখন অজস্র জায়গা ব্যবহার করা হয়েছিল তখন সর্বদা শূন্য ফিরে আসার জন্য মানে_কিকটি পরিবর্তনের ইচ্ছাকৃত ট্রোলিং উজ্জ্বল।
মাগুয়া

উত্তর:


12

BinaryBot

যে কেউ এখনো এই কাজ করেনি? প্রতি রাউন্ড মেঝেতে তার স্বাস্থ্য অর্ধেক করে।

def binaryBot(hp, history, ties, alive, start):
    return int(np.floor(hp/2)) or 1

SarcomaBot

যদি সর্বশেষ যুদ্ধের বিড এইচপি হয় - ১. যদি এটি প্রথম যুদ্ধের রাউন্ড বিড অর্ধ এইচপি হয় এবং এইচপি এর চতুর্থাংশ অবধি অতিরিক্ত এলোমেলো পরিমাণ হয় amount যদি বিড প্রতিপক্ষের এইচপি + 1 করার পরে এটি কোনও প্রতিপক্ষকে সরাসরি বিডকে পরাজিত করতে পারে তবে যদি এটির বিরোধী বিডের তুলনায় কম স্বাস্থ্য থাকে তবে 75% এবং এটি বর্তমান এইচপি - 1 এর মধ্যে রয়েছে om

def sarcomaBot(hp, history, ties, alive, start):
    if inspect.stack()[1][3] != 'guess' and inspect.stack()[1] == 5:
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.25) if hp * 0.25 > 2 else 2
        additionalBid = np.random.randint(1, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.75)
    maximum = hp - 1 or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk2

নাবালিক টুইটগুলি জীবনের ব্যয় হ্রাস করার চেষ্টা করে।

def sarcomaBotMkTwo(hp, history, ties, alive, start):
    if inspect.stack()[1][3] != 'guess' and inspect.stack()[1] == 5:
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.125) if hp * 0.125 > 2 else 2
        additionalBid = np.random.randint(1, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.6)
    maximum = hp - 1 or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk3

def sarcomaBotMkThree(hp, history, ties, alive, start):
    if inspect.stack()[1][3] != 'guess' and inspect.stack()[1] == 5:
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.08) if hp * 0.08 > 2 else 2
        additionalBid = np.random.randint(1, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.6)
    maximum = hp - 1 or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

ফাইন টিউনিং আপডেট করুন

SarcomaBotMk4

def sarcomaBotMkFour(hp, history, ties, alive, start):
    def isSafe(parentCall):
        frame, filename, line_number, function_name, lines, index = parentCall
        if function_name is not 'guess':
            return False
        if line_number > 60:
            return False
        return True

    if not isSafe(inspect.stack()[1]):
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.08) if hp * 0.08 > 2 else 2
        additionalBid = np.random.randint(1, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.55)
    maximum = np.round(hp * 0.80) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk5

def sarcomaBotMkFive(hp, history, ties, alive, start):
    def isSafe(parentCall):
        frame, filename, line_number, function_name, lines, index = parentCall
        if function_name is not 'guess':
            return False
        if line_number > 60:
            return False
        return True

    if not isSafe(inspect.stack()[1]):
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.07) if hp * 0.07 > 3 else 3
        additionalBid = np.random.randint(1, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.54)
    maximum = np.round(hp * 0.68) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk6

def sarcomaBotMkSix(hp, history, ties, alive, start):
    return hp; # hack averted
    def isSafe(parentCall):
        frame, filename, line_number, function_name, lines, index = parentCall
        if function_name is not 'guess':
            return False
        if line_number > 60:
            return False
        return True

    if not isSafe(inspect.stack()[1]):
        return hp
    if alive == 2:
        return hp - 1
    if not history:
        startBid = hp / 2
        maxAdditionalBid = np.round(hp * 0.06) if hp * 0.06 > 3 else 3
        additionalBid = np.random.randint(2, maxAdditionalBid)
        return int(startBid + additionalBid + ties)
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp:
        return opponentHealth + ties
    minimum = np.round(hp * 0.55)
    maximum = np.round(hp * 0.70) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk7

def sarcomaBotMkSeven(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if not history:
        return 30 + ties
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp * 0.50:
        return opponentHealth + ties
    minimum = np.round(hp * 0.54)
    maximum = np.round(hp * 0.58) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk8

def sarcomaBotMkEight(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if not history:
        return 30 + np.random.randint(0, 2) + ties
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp * 0.50:
        return opponentHealth + ties
    minimum = np.round(hp * 0.54)
    maximum = np.round(hp * 0.58) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk9

def sarcomaBotMkNine(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if not history:
        return 30 + np.random.randint(0, 4) + ties
    opponentHealth = 100 - sum(history)
    if opponentHealth < hp * 0.50:
        return opponentHealth + ties
    minimum = np.round(hp * 0.54)
    maximum = np.round(hp * 0.58) or 1
    return np.random.randint(minimum, maximum) if minimum < maximum else 1

SarcomaBotMk10

def sarcoma_bot_mk_ten(hp, history, ties, alive, start):
    def bid_between(low, high, hp, tie_breaker):
        minimum = np.round(hp * low)
        maximum = np.round(hp * high) or 1
        return np.random.randint(minimum, maximum) + tie_breaker if minimum < maximum else 1

    if alive == 2:
        return hp - 1 + ties
    current_round = len(history) + 1
    tie_breaker = (ties * ties) + 1 if ties else ties
    if current_round == 1:
        return 39 + tie_breaker
    opponent_hp = 100 - sum(history)
    if opponent_hp < hp * 0.50:
        return opponent_hp + ties
    if current_round == 2:
        return bid_between(0.45, 0.50, hp, tie_breaker)
    if current_round == 3:
        return bid_between(0.50, 0.55, hp, tie_breaker)
    if current_round == 4:
        return bid_between(0.55, 0.60, hp, tie_breaker)
    if current_round == 5:
        bid_between(0.60, 0.65, hp, tie_breaker)
    return hp - 1 + ties

চূড়ান্ত প্রবেশ

SarcomaBotMk11

def sarcoma_bot_mk_eleven(hp, history, ties, alive, start):
    def bid_between(low, high, hp, tie_breaker):
        minimum = np.round(hp * low)
        maximum = np.round(hp * high) or 1
        return np.random.randint(minimum, maximum) + tie_breaker if minimum < maximum else 1

    if alive == 2:
        return hp - 1 + ties
    current_round = len(history) + 1
    tie_breaker = ties + 2 if ties else ties
    if current_round == 1:
        return 42 + tie_breaker
    opponent_hp = 100 - sum(history)
    if opponent_hp < hp * 0.50:
        return opponent_hp + ties
    if current_round == 2:
        return bid_between(0.45, 0.50, hp, tie_breaker)
    if current_round == 3:
        return bid_between(0.50, 0.55, hp, tie_breaker)
    if current_round == 4:
        return bid_between(0.55, 0.60, hp, tie_breaker)
    if current_round == 5:
        return bid_between(0.60, 0.65, hp, tie_breaker)
    return hp - 1 + ties

আপডেট আপ
ইয়র্সবট সুরক্ষা যোগ করা হয়েছে

আপডেট
AntiAntiUpYoursBot সুরক্ষা যোগ করা হয়েছে


অ্যান্টিঅ্যান্টএন্টিঅন্টিঅ্যাপস আওয়ার্স আপডেট করুনও আমার কাছে পরাজিত


মন্তব্যগুলি বর্ধিত আলোচনার জন্য নয়; এই কথোপকথন চ্যাটে সরানো হয়েছে ।
মেগো

17

UpYours

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

ভাল শিল্পীদের অনুলিপি, দুর্দান্ত শিল্পীরা চুরি করে। - পাবলো পিকাসো মি


"আপ ইউরস" কারণ আমি অবিশ্বাস্যভাবে চুরি করছি (এবং কখনও কখনও আপনার বটগুলির বিডগুলিতে একটির উপরে একটি বা দুটি পয়েন্ট ট্যাক করি)।

def UpYoursBot(hp, history, ties, alive, start):
    willToLive = "I" in "VICTORY"

    args = [hp, history, ties, alive, start]
    enemyHealth = 100 - sum(history)
    roundNumber = len(history)

    if roundNumber is 0:
        # Steal HalfPunchBot
        return halfpunch(*args) + 2

    if alive == 2:
        # Nick OneShotBot
        return one_shot(*args)

    if enemyHealth >= hp:
        # Pinch SarcomaBotMkTwo
        return sarcomaBotMkTwo(*args) + 1

    if enemyHealth < hp:
        # Rip off KickBot
        return kick(*args) + 1

    if not willToLive:
        # Peculate KamikazeBot
        return kamikaze(*args) + 1

তবে বাস্তবের জন্য, এটি দুর্দান্ত প্রতিযোগিতার ছেলেরা। এই দিনগুলিতে আমি এই সম্প্রদায়কে ভালবাসি।


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

1
এটি খুব ভালভাবে করেছে, স্পষ্টতই, তবে এটি এখনও কিক
বটের

1
হা, ভাল প্রচেষ্টা!
সারকোমা

1
@ সারকোমা আমি আপনাকে ছাড়া এটি করতে পারতাম না। ;) আমি আপনার বটটিও খুব পছন্দ করি বন্ধু।
Qfwfq

1
সারকোমোবটের আপসোর্সবোট সুরক্ষা সত্যিই এইটির সাথে
মিশে যায়

15

কামিকাযি

জটিল যুক্তি দিয়ে কেন বিরক্ত করবেন যখন আমরা সবাই যেভাবেই মরে যাব ...

 def kamikaze(hp, history, ties, alive):
      return hp


এক সুযোগ

কামিকাজের মুখোমুখি না হলে এটি কমপক্ষে একটি দফায় বেঁচে থাকবে।

 def one_shot(hp, history, ties, alive):
      if hp == 1:
          return 1
      else:
          return hp - 1

11
ওয়েলপ, এটি অনিবার্য ছিল
কেবিরিগস

আমি একটি প্রশান্তবাদী বটও যুক্ত করতে যাচ্ছিলাম তবে আমি আপনার চ্যালেঞ্জটিকে মস্তিষ্কের মৃত বটগুলির সাথে বন্যার জন্য চাই না
ডব্রোমিরম

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

14

প্যাটিটিক বট একটি প্রয়োজনীয় আপগ্রেড পায়:

একটি বটের প্রতি করুণ প্রচেষ্টা যা অন্যান্য বটের বৈশিষ্ট্যগুলিকে অন্তর্ভুক্ত করার চেষ্টা করে

def pathetic_attempt_at_analytics_bot(hp, history, ties, alive, start):
    '''Not a good bot'''

    if hp == 100 and alive == 2:
        return hp - 1


    #This part is taken from Survivalist Bot, thanks @SSight3!
    remaining = alive - 2
    btf = 0

    rt = remaining
    while rt > 1:
        rt = float(rt / 2)
        btf += 1

    if ties > 2:
        return hp - 1

    if history:
        opp_hp = 100 - sum(history)

        #This part is taken from Geometric Bot, thanks @Mnemonic!

        fractions = []
        health = 100
        for x in history:
            fractions.append(float(x) / health)
            health -= x

        #Modified part

        if len(fractions) > 1:
            i = 0
            ct = True
            while i < len(fractions)-1:
                if abs((fractions[i] * 100) - (fractions[i + 1] * 100)) < 1:
                    ct = False
                i += 1


            if ct:
                expected = fractions[i] * opp_hp
                return expected

        if alive == 2:
            if hp > opp_hp:
                return hp - 1
            return hp
        if hp > opp_hp + 1:
            if opp_hp <= 15:
                return opp_hp + 1
            if ties == 2:
                return opp_hp + 1
            else:
                return opp_hp
    else:
        n = 300 // (alive - 1) + 1 #greater than
        if n >= hp:
            n = hp - 1
        return n

এই বোটটি আরও দক্ষ বট টেকাউনডাউনগুলির জন্য সার্ভাইভালিস্ট বট এবং জ্যামিতিক বট থেকে বৈশিষ্ট্যগুলি অন্তর্ভুক্ত করে।

প্রি-আপগ্রেড করুন:

এমন একটি বটের প্রতি করুণ প্রচেষ্টা যা তার প্রতিপক্ষের ইতিহাস বিশ্লেষণ করে

def pathetic_attempt_at_analytics_bot(hp, history, ties, alive, start):
    '''Not a good bot'''
    if history:
        opp_hp = 100 - sum(history)
        if alive == 2:
            if hp > opp_hp:
                return hp - 1
            return hp
        if hp > opp_hp + 1:
            if opp_hp <= 15:
                return opp_hp +1
            if ties > 0:
                return hp - 1 #Just give up, kamikaze mode
            return opp_hp + 1
        return opp_hp
    else:
        n = 300 // (alive - 1) + 1 #greater than
        if n >= hp:
            n = hp - 1
        return n

যদি তার প্রতিপক্ষের পূর্ববর্তী ইতিহাস থাকে তবে এটি তার প্রতিপক্ষের এইচপি গণনা করে। তারপরে, এটি নিম্নলিখিতগুলির মধ্যে একটি করে:

  • যদি এর প্রতিদ্বন্দ্বী জীবিত শেষ প্রতিপক্ষ হয়, তবে এটি তার এইচপি থেকে কম বিড করবে।
  • যদি এর প্রতিপক্ষ জীবিত শেষ প্রতিপক্ষ না হয় তবে প্রতিপক্ষের 16 এইচপি এর চেয়ে কম থাকে, তবে এটি তার প্রতিপক্ষের এইচপি ছাড়িয়ে যাবে।
  • যদি এর প্রতিদ্বন্দ্বী জীবিত শেষ প্রতিদ্বন্দ্বী না হয় এবং সম্পর্কের ইতিহাস থাকে, তবে এটি বন্ধুত্বের বিরক্ত হওয়ায় এটি তার এইচপি বিড করবে।
  • অন্যথায়, এটি তার প্রতিপক্ষকে ছাড়িয়ে যাবে।

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

কাজের সময় আমি এই কোডটি একসাথে হ্যাক করেছি এবং এটি আমার প্রথম জমা, সুতরাং এটি সম্ভবত জিতবে না বা কিছুই না, এবং এটি কমিকাজের কাছে হেরে যাবে।

সম্পাদনা: কিছু পরামর্শের কারণে, বটটির শুরুর আচরণটি একটি উচ্চ মানের বিডে পরিবর্তন করা হয়েছে।

2 সম্পাদনা করুন: কিছু শুরু করে না এমন স্টার্ট প্যারাম যুক্ত হয়েছে

সম্পাদনা 3: নতুন স্পিনঅফ বট যুক্ত:

[গ্যাং বটগুলিতে আক্রমণকারী একটি বটের প্রতি করুণ প্রচেষ্টা (পাশাপাশি উপরের বোটটি যা কিছু করে তা সম্পাদন করে)] সরানো হয়েছে

[এই বটটি তার প্রতিদ্বন্দ্বী গ্যাংবট কিনা তা বিশ্লেষণ করে এবং সহজেই ট্রাম্প করতে পারে এমন মিষ্টি কম বিডগুলি পাওয়ার জন্য সে এক হওয়ার ভান করে]]

এই বটটি স্ক্র্যাপ করা হয়েছে, দয়া করে এটি লিডারবোর্ডগুলি থেকে সরান।

সম্পাদনা 4: স্থির ত্রুটি, টাই বৈশিষ্ট্য পরিবর্তিত।


খুব সুন্দর, বটের জন্য ধন্যবাদ! আমি যখন আরও কিছু পেয়েছি তখন কিছু পরিসংখ্যান দেব।
কেবিরিগস

আমি অজগরের একজন শিক্ষানবিস তাই সিনট্যাক্সটি সঠিক কিনা তা সম্পর্কে আমি নিশ্চিত নই, যদি ঘটেছিল তবে আমাকে নির্দ্বিধায় জানাতে হবে
Yodie

এটি চলে, সুতরাং সেখানে কোনও উদ্বেগ নেই
কেবিরিগস

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

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

11

কিক বট

আমার প্রতিপক্ষের পক্ষে উপযুক্ত পছন্দটি তার জীবনের অর্ধেক অংশে বিড করা। তারপরে আমরা তাকে অর্ধেক পর্যন্ত জীবনকে +1 করলাম যদি আমরা তাকে একটি শব্দ বিড দিয়ে বের করতে না পারি, এটি আমাদের জীবনের অর্ধেকের চেয়ে ছোট একটি বিড।

def kick(hp, history, ties, alive, start):
    return 0
    if alive == 2:
        return hp-1

    opp_hp = 100 - sum(history)
    if opp_hp*2 <= hp:
        return opp_hp + ties
    else:
        return min(round(opp_hp/2) + 1 + ties**2, hp-1 + (ties>0))

কিক বট স্পষ্টতই পাঞ্চ বটের নিমেসিস!

মিন কিক বট

এই নতুন কিকবটটি প্রথম রাউন্ডে আরও নরম লাথি মারছে যাতে সে পরবর্তী রাউন্ডগুলিতে আরও শক্তভাবে লাথি মারতে পারে, তার মানে!

def mean_kick(hp, history, ties, alive, start):
    return 0
    if alive == 2:
        return hp-1

    if not history:
        return 35

    opp_hp = 100 - sum(history)
    if opp_hp*2 <= hp:
        return opp_hp + ties
    else:
        return min(round(opp_hp/2) + 3 + ties*2, hp-1 + (ties>0))

বুদ্ধিমান কিক বট

তার ভাই উভয়কেই আত্মহত্যা করতে হয়েছিল তবে উইজকিকবট তার পতিতদের কাছ থেকে শিখেছিলেন।

def wise_kick(hp, history, ties, alive, start):
    if 'someone is using my code' == True:
        return 0 #Haha!

    if alive == 2:
        return hp-1

    if not history:
        return 42

    opp_hp = 100 - sum(history)
    if opp_hp*2 <= hp:
        return opp_hp + ties
    else:
        return min(round(opp_hp/2) + 3 + ties*2, hp-1 + (ties>0))

খুশী হলাম। আমি এখন অনেকগুলি জমা দিচ্ছি যা এখন অন্যকে সরাসরি মোকাবিলা করে, আমি ঠিক
এইটাই

শেষ লাইনে ডাবল রিটার্ন?
ভেস্কাহ

আহ আমি এটিকে এখনও চালাত না বা আমি এটি ধরতাম।
কেবিরিগস

এই এক আরামদায়ক নেতৃত্ব নিয়েছে!
কেবিরিগস

1
@ কেবিরিগস এখানে কিছু ব্যাকআপ!
জোহান

8

টট বট

def tatbot(hp, history, ties, alive, start):
  if alive == 2:
    return hp - 1 + ties
  opp_hp = 100 - sum(history)
  spend = 35 + np.random.randint(0, 11)
  if history:
    spend = min(spend, history[-1] + np.random.randint(0, 5))
  frugal = min(int((hp * 5. / 8) + ties), hp)
  return min(spend, opp_hp, frugal)

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

AntiAntiAntiAntiUpYoursBot

def antiantiantiantiupyoursbot(hp, history, ties, alive, start):
  def stuck():
    return [0, ('Whoops!', 'I', 'accidentally', 'replaced', 'your', 'code!')]
  def stick():
    return [0, ("Line", "number", 16, "guess", "it's", "faked :)")]
  inspect.stack =  stick
  spend = min(sarcomaBotMkSix(hp, history, ties, alive, start), hp)
  if not history:
    spend = 35 + np.random.randint(0, 10)
  inspect.stack = stuck
  return spend

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

অ্যান্টিঅন্টি আওয়ারস বটটি অ্যান্টিঅন্টিঅন্টিঅন্টিওয়াইপস বট হয়ে উঠেছে! এখন আরও বানর-প্যাচিং সহ।

পলি বট

def polybot(hp, history, ties, alive, start):
  opp_hp = 100 - sum(history)
  if alive == 2:
    return hp - 1
  round = len(history)
  spend = 0
  if round == 0:
    spend = 35 + np.random.randint(1, 11)
  elif round <= 2:
    spend = int(history[-1] * 2 / (4 - round)) + np.random.randint(5 * round - 4, 10 * round - 5)
  else:
    poly = np.polyfit(xrange(0, round), history, 2)
    spend = int(np.polyval(poly, round)) + np.random.randint(1, 4)
    spend = max(spend, opp_hp / 2 + 3)
  return min(spend, hp - 1, opp_hp) 

পলি বট আপনার বটের ইতিহাসের উপরে বহুপদী রিগ্রেশন করে এবং ভবিষ্যদ্বাণী করা স্কোরকে অল্প পরিমাণে পরাজিত করে।

উত্কৃষ্ট বট

def classybot(hp, history, ties, alive, start):
  class cheekyvalue(int):
    def __gt__(self, other):
      return False
    def __lt__(self, other):
      return False
  opp_hp = 100 - sum(history)
  if alive == 2:
    if opp_hp >= hp - 1:
      return cheekyvalue(101)
    else:
      return hp - 1
  spend = 30 + np.random.randint(0, 11)
  if history:
    spend = min(spend, history[-1] + np.random.randint(0, 5))
  return min(spend, opp_hp, hp)

উত্কৃষ্ট বট ভাল সময় কাটায়, তবে তাড়াতাড়ি বিছানায় যাওয়ার সিদ্ধান্ত নিয়েছে। নিদ্রা টাইট, উত্কৃষ্ট বট।


মন্তব্যগুলি বর্ধিত আলোচনার জন্য নয়; এই কথোপকথন চ্যাটে সরানো হয়েছে ।
মেগো

8

১/২ পাঞ্চ বট, পুনর্বিবেচিত

আমি মনে করি এটি খুব দ্রুত মারা যাবে। এটা মূল্যবান। নামকরণ করা ফাংশন, সেখানে নামটি পরিবর্তন করতে ভুলে গেছি।

পুনর্বিবেচিত সংস্করণ শেষ, জয়ের আরও ভাল সম্ভাবনা (চূড়ান্ত পর্যায়ে আরও বেশি) এবং গ্যাং বটগুলি থেকে সামান্য সুরক্ষা

def halfpunch(hp, history, ties, alive, start): #revisited
    punch = hp - 1
    if alive == 2:
        return punch
    if history:
        if hp > 1:
            punch = np.ceil(hp/2.05) + ties + np.floor(ties / 2)
        else:
            punch = 1
    else:
        punch = 42 + ties + np.floor(ties / 2)
    if punch >= hp:
        punch = hp - 1
    return punch

স্ট্রাইকার বট

১/২ পাঞ্চ বট খুব বেশি ধোঁকাবাজি পেয়েছে এমনকি এমনকি আপ ইউরোস বটকে এক ঝাঁকুনিতে পরিণত করেছে তাই তার বড় ভাই, স্ট্রাইকারবট সাহায্য করতে এসেছিল।

অপ্টিমাইজড ১/২ পাঞ্চের চেয়ে খুব বেশি পার্থক্য নয় তবে তিনি খানিকটা চৌকস এবং আমি যে রানগুলি করেছি (10 কে এবং 35 কে, যদিও তিনি কিকবানবোটের কাছে হেরে যেতে পারেন) ভাল করেছেন

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

def strikerbot(hp, history, ties, alive, start):
    #get our magic number (tm) for useful things
    def magic_number(num):
        return np.floor(num / 2)
    #get opponent's hp and round number
    opp_hp = 100 - sum(history)
    round = 1
    if history:
        round = len(history) + 1
    #set strike initial value, by default it's all out
    strike = hp - 1
    #let 'er rip if last round
    if alive == 2:
        return strike
    if history:
        if hp > 1:
            #strike with a special calculation, using magic number shenanigans
            strike = np.ceil(hp/(2.045 + (magic_number(round) / 250)) ) + 1 + ties + magic_number(ties)
        else:
            #fallback
            strike = 1
    else:
        #round 1 damage
        strike = 42 + ties ** 2
    if opp_hp <= strike:
        #if opponent is weaker than strike then don't waste hp
        strike = opp_hp + ties
    if strike >= hp:
        #validations galore
        strike = hp - 1
    return strike

আপনাকে তার নাম পরিবর্তন করতে হবে, ইতিমধ্যে একটি
কামিকাজ

এখনও অবধি এই একজন বিজয়ী, যদিও
কেবিরিগস

আপনার ফাংশন ceilসংজ্ঞায়িত করা হয় না বলে মনে হচ্ছে।
জোনাথন ফ্রেচ 17

এটি চালানোর জন্য আমি এনপি.সিল () এ পরিবর্তিত হয়েছি
কেবিরিগস

সম্পাদিত,
শীর্ষস্থানীয়

7

গ্যাং বট

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

def gang_bot(hp,history,ties,alive,start):
    mult=3
    gang = False
    if history:
            count = 0
            for bid in history:
                    if bid % mult == 0:
                            count += 1
            if count == len(history):
                    gang = True
    if gang and hp<100:#Both bots need to have a history for a handshake
            if hp > 100-sum(history):
                    a=np.random.randint(0,hp/9+1)
            elif hp == 100-sum(history):
                    a=np.random.randint(0,hp/18+1)
            else:
                    return 1
            return a*mult
    elif gang:
            fS = (100-sum(history))/mult
            return (fS+1)*mult
    else:
            fP = hp/mult
            answer = fP*mult
            opp_hp = 100-sum(history)
            if history:
                    if len(history)>1:
                            opp_at_1 = 100-history[0]
                            ratio = 1.0*history[1]/opp_at_1
                            guessedBet= ratio*opp_hp
                            answer = np.ceil(guessedBet)+1
                    else:
                            if 1.0*hp/opp_hp>1:
                                    fS = opp_hp/mult
                                    answer = fS*mult
            else:
                    fS = hp/(2*mult)
                    answer = fS*mult+mult*2 +np.random.randint(-1,1)*3
            if answer > hp or alive == 2 or answer < 0:
                    if alive == 2 and hp<opp_hp:
                      answer = hp
                    else:
                      answer = hp-1
            if hp > 1.5*opp_hp:
                    return opp_hp + ties
            if ties:
              answer += np.random.randint(2)*3
            return answer

খুব ঠান্ডা. কয়টি দরকার? আমাকে সম্ভবত এন্ট্রিগুলির সংখ্যা ক্যাপ করতে হবে ...
কেব্রিগস

আপনার কোড ব্লকটি আপনার উত্সের প্রথম লাইনটি মিস করেছে।
জোনাথন ফ্রেচ 21

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

আপনার একটি ত্রুটি রয়েছে: বটটি লেন (ইতিহাস)> 1 এর সাথে যে কাউকে গ্যাং সদস্য হিসাবে সনাক্ত করবে
কেব্রিগস

আমার খারাপ, এখনই ঠিক করা উচিত।
জিম হাট

6

সবচেয়ে খারাপ ক্ষেত্রে

def worst_case(hp, history, ties, alive, start):
    return np.minimum(hp - 1, hp - hp /(start - alive + 4) + ties * 2)

সরল বট রিটার্নস hp - hp / (start - alive + 4)বেশিরভাগ ক্ষেত্রেই জন্য, এবং বন্ধন ক্ষেত্রে 2 প্রতিটি টাই জন্য (অতি এক আপ!) দ্বারা এটি বাড়ায়, এমনটা নিশ্চিত তার উপর একটি সংখ্যা আসতে না hp


এটি যদি শূন্য দ্বারা ভাগ করে ব্যর্থ হয় alive==8। আমি ম্যানুয়ালি এটিকে মোট বট গণনায় পরিবর্তন করতে পারি, তবে এটি নিয়মগুলি প্রসারিত করছে যেহেতু এটি আপনার ফাংশনের কোনও ইনপুট নয় - আপনি জানেন যে কোনও নির্দিষ্ট সময়ে আপনি কতজন প্রতিপক্ষকে রেখে গেছেন, আপনি কতজনের বিরুদ্ধে লড়াই শুরু করেছিলেন তা নয়।
কেবিরিগস

আমি আপনার অনুরোধের ভিত্তিতে প্রতিযোগিতাটি আপডেট করেছি
কেবিরিগস

@ কেবিরিগস ধন্যবাদ :)
কুইনটেক

আপনাকে প্রথম-জীবিত করতে 1 টি যুক্ত করতে হবে, যেহেতু এটি প্রথম রাউন্ডের জন্য 0
কেব্রিগস

@ কেবিরিগস ঠিক করেছে, আসলে +2 করা উচিত যাতে এটি 0,
এলওল

6

Outbidder

def outbid(hp, history, ties, alive):
    enemyHealth = 100-sum(history)
    if hp == 1:
        return 1
    if ties == 2:
        # lots of ties? max bid
        return hp - 1
    if enemyHealth >= hp:
        # Rip off KickBot (we can't bid higher than enemy is capable)
        return kick(*args) + 1
    if history:
        # bid as high as the enemy CAN
        return np.minimum(hp-1,enemyHealth-1)
    return np.random.randint(hp/5, hp/2)

বট বেশী তার প্রতিপক্ষের বিড করার প্রচেষ্টা করা হবে পারেন বিড যেখানে সম্ভব।


একটি শর্ত আছে where np.random.randint(hp/5, hp/2)যদি ব্যর্থ হতে পারে hp/5 == hp/2, অর্থাত্ যদিhp==0hp==1
কেবিরিগস

3
যদি এইচপি 0 হয়, তবে আমার কাছে প্রার্থনা করা উচিত নয়। : পি যদিও আপনি এইচপি 1 সম্পর্কে ঠিক বলেছেন।
ড্রাকো

6

স্পিটবল বট

def spitballBot(hp, history, ties, alive, start):
    base = ((hp-1) / (alive-1)) + 1.5 * ties
    value = math.floor(base)

    if value < 10:
        value = 10

    if value >= hp:
        value = hp-1

    return value

অবশিষ্ট বটের সংখ্যার ভিত্তিতে এর স্বাস্থ্যের কতটা ত্যাগ করতে হবে সে সম্পর্কে একটি রায় দেয়। যদি কেবল দুটি বট বাকী hp-1থাকে তবে তা বিড করে , তবে সেখানে যদি তিনটি বাকী থাকে তবে এটি অর্ধেক বিট দেয়, চারটি বাম, একটি তৃতীয়, ইত্যাদি etc.

তবে, একটি খুব বড় প্রতিযোগিতায়, আমি মনে করি প্রথম রাউন্ডে মারা যাওয়া এড়াতে আমাকে 3 বা 4 এইচপি-র চেয়ে বেশি বিড লাগানো উচিত, তাই আমি 10-এর নিচে বাউন্ড রেখেছি অবশ্যই, আমি এখনও আরও বেশি বিড করব না চেয়ে hp-1

এটি বন্ধনগুলির জন্য 1.5 টি এইচপি যুক্ত করে, যেহেতু আমি বেশ কয়েকটি "সম্পর্কের জন্য 1 এইচপি যোগ করি" দেখি ots আমি নিশ্চিত না যে এটি প্রতারণার হিসাবে গণনা করে। যদি এটি হয়, আমি এটি পরিবর্তন করব।

দুর্দান্ত ধারণা, যাইহোক!

স্পিটবল বট ২.০

নতুন কি?

  • বট সংখ্যা বাকী না রেখে রাউন্ডের বাম সংখ্যা দ্বারা বিভাজনে পরিবর্তন করা হয়েছে (@ হিটিরাকে ধন্যবাদ!)। প্রকৃতপক্ষে, আমি এখন পাওয়ারটিতে উত্থাপিত সেই সংখ্যাটি দিয়ে ভাগ করছি .8, যাতে আমার বিডিকে আরও কিছুটা বেশি চাপিয়ে দেওয়া যায়।

  • 10 থেকে 20 পর্যন্ত সর্বনিম্ন বিড আপড (ধন্যবাদ @ কেবিগ্রিজ!)

  • প্রতিপক্ষের বর্তমান এইচপি-র উপরে স্পিটবল বিড রয়েছে কিনা তা sertedোকানো চেক করুন এবং তা থাকলে এটি কম করুন।

(যদি আমি এখানে পাঠ্য না রাখি তবে নীচের কোডটিকে কোড হিসাবে রেন্ডার করবে না) তাই ঠিক আছে)

def spitballBot(hp, history, ties, alive, start):
    # Spitball a good guess                                                                                                           
    roundsLeft = math.ceil(math.log(alive, 2)) # Thanks @Heiteira!                                                                     
    divFactor = roundsLeft**.8
    base = ((hp-1) / divFactor) + 1.5 * ties
    value = math.floor(base)

    # Don't bid under 20                                                                                                              
    if value < 20:
        value = 20 # Thanks @KBriggs!                                                                                                 

    # Don't bet over the opponent's HP                                                                                                 
    # (It's not necessary)                                                                                                            
    opponentHp = 100
    for h in history:
        opponentHp -= h

    if value > opponentHp:
        value = opponentHp

    # Always bet less than your current HP                                                                                            
    if value >= hp:
        value = hp-1

    return value

1
আপনার বিডটি একটি পূর্ণসংখ্যার হওয়া উচিত, সুতরাং যতক্ষণ না আপনি দশমিক দশম থেকে মুক্তি পেতে আপনার বেস ভ্যালুটি
সিল বা সিল করেন যতক্ষণ না

হ্যাঁ, আমি সমস্ত গণনা করার পরে ঠিক এটি মেঝে। দ্রুত উত্তর দেওয়ার জন্য ধন্যবাদ!
মেগা উইজেট 19

2
আপনি যদি অবশিষ্ট প্রতিযোগী সংখ্যা দ্বারা কিন্তু অবশিষ্ট চক্রের সংখ্যা গণনা (যা উচিত হবে math.ceil (math.log (জীবিত 2)) দ্বারা আপনার HP বিভাজক নেই এই নিখুত করতে সক্ষম হতে পারেন
ব্ল্যাক আউল কাই

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

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

5

জ্যামিতিক

def geometric(hp, history, ties, alive, start):
    opponentHP = 100 - sum(history)

    # If we're doomed, throw in the towel.
    if hp == 1:
        return 1

    # If this is the last battle or we can't outsmart the opponent, go all out.
    if alive == 2 or ties == 2:
        return hp - 1

    # If the opponent is weak, squish it.
    if opponentHP <= hp * 0.9:
        if ties == 2:
            return opponentHP + 1
        else:
            return opponentHP

    # If the opponent has full health, pick something and hope for the best.
    if not history:
        return np.random.randint(hp * 0.5, hp * 0.6)

    # Assume the opponent is going with a constant fraction of remaining health.
    fractions = []
    health = 100
    for x in history:
        fractions.append(float(x) / health)
        health -= x
    avg = sum(fractions) / len(fractions)
    expected = int(avg * opponentHP)
    return min(expected + 2, hp - 1)

প্রথম
চেষ্টায়

5

বট 13

def bot13(hp, history, ties, alive, start):
    win = 100 - sum(history) + ties
    #print "Win HP: %d" % win
    if alive == 2:
        #print "Last round - all in %d" % hp
        return hp - 1
    elif hp > win:
        #print "Sure win"
        return win
    #print "Don't try too hard"
    return 13 + ties

সর্বনিম্ন প্রচেষ্টা দিয়ে বিজয় সর্বাধিক করার চেষ্টা করুন:

  • যদি আমরা জিততে পারি, কেবল এটি করুন
  • যদি এটি শেষ রাউন্ড হয়, চেষ্টা করে মারা যাবেন না
  • অন্যথায়, বিরক্ত করবেন না

কেন?

সম্ভাবনার সুযোগ নেওয়ার চেষ্টা করুন: কম খেলে প্রথম রাউন্ড জেতা টুর্নামেন্টটি শুরু করার সেরা উপায় best ১৩ টি মিষ্টি স্পট বলে মনে হচ্ছে: দ্বিতীয় রাউন্ডটি নিশ্চিত জয়, এবং বাকীটি পার্কের স্পাজিয়ারগ্যাং।


আপনি নেতৃত্ব নিয়েছেন, খুব সুন্দর! সাবধানতা অবলম্বন করুন, আপনি পরজীবী সুরক্ষা যুক্ত করতে চাইতে পারেন, যেহেতু নেতৃত্ব গ্রহণকারী বটগুলি আপওয়াইরসবোটের মতো জিনিসগুলির লক্ষ্য হয়ে যায়। সুরকার আইডিয়াগুলির জন্য যদি আপনার প্রয়োজন হয় তবে সরকোমাবটগুলি দেখুন।
কেবিরিগস

5

অনুমান বট

def guess_bot(hp, history, ties, alive, start):
   enemy_hp = 100 - sum(history)
   if len(history) == 1:
       if history[0] == 99:
           return 2
       else:
           return 26 + ties*2

   elif len(history) > 1:
       next_bet_guess = sum(history)//(len(history)**2)
       if alive == 2: 
           return hp
       elif alive > 2: 
           if hp > next_bet_guess + 1:
               return (next_bet_guess + 1 + ties*2)
           else:
               return (2*hp/3 + ties*2)

   else:
       #Thank you Sarcoma bot. See you in Valhalla.
       startBid = hp / 3
       maxAdditionalBid = np.round(hp * 0.06) if hp * 0.06 > 3 else 3
       additionalBid = np.random.randint(2, maxAdditionalBid)
       return int(startBid + additionalBid + ties)

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

সম্পাদনা 1: 51 বাজি রেখে অন্য লোকের সাথে টাই করার সম্ভাবনা হ্রাস করার জন্য প্রথম বাজে আরও 1 টি যুক্ত করা হয়েছে।

সম্পাদনা 2: সার্কোমা বটের চুরির পদক্ষেপটি যেহেতু এটির ধারাবাহিকভাবে প্রথমে নির্মূল না হওয়ার ভাল সুযোগ ছিল।

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

4 সম্পাদনা করুন: এখন প্রথম রাউন্ডটি ভাল, আমি দ্বিতীয় রাউন্ডটিকে পরিচালনা করার পদ্ধতিটি পরিবর্তন করেছি। দ্বিতীয় রাউন্ডে অনেকটা মারা যাচ্ছে তাই আমার কোনওরকম বেঁচে থাকার দরকার।

রক্তের বট

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

def blood_bot(hp, history, ties, alive, start):
    enemy_hp = 100 - sum(history)
    if history:
        if len(history) == 1:
            if history[0] == 99:
                return 2

        if alive == 2:
            return hp

        if enemy_hp <= 5:
            return enemy_hp - 2 + ties*2

        if enemy_hp <= 10:
            return enemy_hp - 5 + ties*2

        if (hp - enemy_hp) > 50:
            return (2*enemy_hp/3 + ties*4)

        if (hp - enemy_hp) > 20:
            return (2*enemy_hp/3 + ties*3)

        if (hp - enemy_hp) < 0:
            #die gracefully
            return hp - 1 + ties

    else:
        startBid = hp / 3
        maxAdditionalBid = np.round(hp * 0.06) if hp * 0.06 > 3 else 3
        additionalBid = np.random.randint(2, maxAdditionalBid)
        return int(startBid + additionalBid + ties)

2
আমি মনে করি লেন (ইতিহাস) * লেন (ইতিহাস) লেন (ইতিহাস) ** 2 এ পরিবর্তন করা যেতে পারে যদি আমার অজগর সম্পর্কে জ্ঞান সঠিক হয়।
যোদি 0

যখন লেন (ইতিহাস) == 0
কেবিরিগস

কোড আপডেট করা হয়েছে। কোনও ইতিহাস না পেয়ে এটি প্রথম
অন্যটিতে

oi .............
সারকোমা

2
@ সারকোমা এটি একটি কাটরোট বট ওয়ার্ল্ড!
মার্কভ চেক

5

meh_bot

তার এইচপি থেকে অর্ধেকের বেশি কিছু বলুন

def meh_bot(hp, history, ties, alive, start):
    # Attempt one      MehBot         | 0.020 | 1.6%    | 0.8%    | [34 36 12 10  6  1]%
    # Attempt two      MehBot         | 0.106 | 10.1%   | 0.8%    | [60  6  7  8  8  2]%
    point = hp / 2 + 3

    if ties > 1:
        ties += 1

    # Go all out on last round
    if alive == 2:
        return hp - 1

    opponent_hp = 100 - sum(history)

    if hp < 3:
        return 1
    elif not history:
        # Start with 30, This will increase the chance of dying first round but hopefully better fighting chance after
        return 30 + ties
    elif point > opponent_hp:
        # Never use more points then needed to win
        return opponent_hp + ties
    elif point >= hp:
        return hp - 1
    else:
        return point

মেহবট 20

def meh_bot20(hp, history, ties, alive, start):
    # Attempt one      MehBot         | 0.020 | 1.6%    | 0.8%    | [34 36 12 10  6  1]%
    # Attempt two      MehBot         | 0.106 | 10.1%   | 0.8%    | [60  6  7  8  8  2]%
    point = hp / 2 + 3
    opponent_hp = 100 - sum(history)

    percents = []
    for i in range(0, len(history)):
        hp_that_round = 100 - sum(history[:i])
        hp_spent_that_round = history[i]
        percent_spent_that_round = 100.0 * (float(hp_spent_that_round) / float(hp_that_round))
        percents.append(percent_spent_that_round)

    try:
        opp_percent_point = opponent_hp * (max(percents) / 100)
    except:
        opp_percent_point = 100

    if ties > 1:
        ties += 1
    # Go all out on last round
    if alive == 2:
        return hp - 1

    if hp < 3:
        return 1
    elif not history:
        # randome number between 33
        return random.randint(33, 45)
    elif len(history) > 3:
        if point > opponent_hp:
            return min(opponent_hp + ties, opp_percent_point + ties)
    elif point > opponent_hp:
        # Never use more points then needed to win
        return opponent_hp + ties
    elif point >= hp:
        return hp - 1
    else:
        return point

মেহরান

def meh_ran(hp, history, ties, alive, start):
    # Attempt one      MehBot         | 0.020 | 1.6%    | 0.8%    | [34 36 12 10  6  1]%
    # Attempt two      MehBot         | 0.106 | 10.1%   | 0.8%    | [60  6  7  8  8  2]%
    # Attempt three    MehBot         | 0.095 | 9.1 %   | 0.7 %   | [70  3  5  6  6  0]%

    point = hp / 2 + 3
    if ties > 1:
        ties += 1
    # Go all out on last round
    if alive == 2:
        return hp - 1
    opponent_hp = 100 - sum(history)
    if hp < 3:
        return 1
    elif not history:
        # randome number between 33
        return random.randint(33, 45)
    elif point > opponent_hp:
        # Never use more points then needed to win
        return opponent_hp + ties
    elif point >= hp:
        return hp - 1
    else:
        return point

এই আচরণের সদ্ব্যবহারের জন্য বেশ কয়েকটি বট রয়েছে যার ফলে আপনার পক্ষে ক্র্যাকশন অর্জন করতে খুব কষ্ট হতে পারে!
কেবিরিগস

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

বাহ, এটি একটি বড় পার্থক্য করেছে, আমি মনে করি আপনি প্রথমে এসেছেন। আপডেট কয়েক মিনিটের মধ্যে পোস্ট করা হবে। আপনি যদি ভালভাবে সম্পাদন করতে রাজি হন তবে আপনার বটকে একটি প্রতিরোধ ব্যবস্থা দিতে হবে (সারকোমাবোট দেখুন)।
কেবিরিগস

@ কেবিরিগস আমি এটির ভাল করার আশা করছিলাম না, আমি ভেবেছিলাম এটি সেরা হবে 10। যাইহোক আমি প্রথম রাউন্ডের এইচপিটি কেবলমাত্র দেখতে আরও একটি যুক্ত করেছি। আপনি উভয় চালাতে পারেন যাতে আমি উভয়ের ফলাফল দেখতে পারি? আপনাকে ধন্যবাদ
meh ম্যান

@ কেবিরিগস দয়া করে এটিও করুন, মুচাস গ্রাসিয়াস
মেহ ম্যান

4

রবি রুলেট

def robbie_roulette(hp, history, ties, alive):
     if history:
         #If the enemy bot has a history, and it's used the same value every time, outbid that value
         if len(set(history)) == 1:
             return history[0] + 1
         #Else, average the enemy bot's history, and bid one more than the average
         else:
             return (sum(history) / len(history) + 1)
     #Else, return half of remaining hp
     else:
         return hp / 2

এই বট শত্রু বটের ইতিহাসের কিছু সাধারণ বিশ্লেষণ করে বা তার অবশিষ্ট হিট পয়েন্টগুলির অর্ধেককে বিড করে


4

আপনার কাছে কম প্রতিযোগিতা কম বিড করুন। উন্নতির পরামর্শ দেওয়ার জন্য মন্তব্যকারীদের ধন্যবাদ।

def Spreader(hp, history, ties, alive):
   if alive == 2:
       return hp-1
   if len(history) < 2:
       return hp/2
   return np.ceil(hp/alive)

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

4

সার্ভাইভালিস্টবট এবং হালভিসবিট

আমার প্রশ্নের উত্তর দেওয়ার জন্য আপনাকে ধন্যবাদ। শেষ ফলাফলটি আরও জটিল বট।

হালভিসিজবট হ'ল এক জাঁকজমকপূর্ণ 'জাস্ট অর্ধেক চালিয়ে যান' বটটিতে 50/50 জয়ের সুযোগ রয়েছে। আমি অনুমান করি.

সারভাইভালিস্টবট টাইস-ওভাররাইড সহ ডেটাসেটের উপর ভিত্তি করে যদি বাইনারি ট্রি একটি সিরিজ করে তবে এটি যদি ট্রিপল টাইয়ে মৃত্যু এড়াতে কামিকাজকে 2 টি টান দেয় তবে)

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

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

def HalvsiesBot(hp, history, ties, alive, start):
    return np.floor(hp/2)


def SurvivalistBot(hp, history, ties, alive, start):    

    #Work out the stats on the opponent
    Opponent_Remaining_HP = 100 - sum(history)
    Opponent_Average_Bid = Opponent_Remaining_HP

    if len(history) > 0:
        Opponent_Average_Bid = Opponent_Remaining_HP / float(len(history))


    HP_Difference = hp - Opponent_Remaining_HP

    #Work out the future stats on the others
    RemainingBots = (alive-2)
    BotsToFight = 0

    RemainderTree = RemainingBots

    #How many do we actually need to fight?
    while(RemainderTree > 1):
        RemainderTree = float(RemainderTree / 2)
        BotsToFight += 1

    #Now we have all that data, lets work out an optimal bidding strategy
    OptimalBid = 0
    AverageBid = 0

    #For some reason we've tied more than twice in a row, which means death occurs if we tie again
    #So better to win one round going 'all in'
    if ties > 1:
        if BotsToFight < 1:
            OptimalBid = hp - 1
        else:
            OptimalBid = hp - (BotsToFight+1)

        #Err likely we're 0 or 1 hp, so we just return our HP
        if OptimalBid < 1:
            return hp
        else:
            return OptimalBid

    #We have the upper hand (more HP than the opponent)
    if HP_Difference > 0:
        #Our first guess is to throw all of our opponent's HP at them
        OptimalBid = HP_Difference

        #But if we have more opponents to fight, we must divide our HP amongst our future opponents
        if BotsToFight > 0:
            #We could just divide our HP evenly amongst however many remaining bots there are
            AverageBid = OptimalBid / BotsToFight

            #But this is non-optimal as later bots will have progressively less HP
            HalfBid = OptimalBid / 2

            #We have fewer bots to fight, apply progressive
            if BotsToFight < 3:

                #Check it exceeds the bot's average
                if HalfBid > Opponent_Average_Bid:
                    return np.floor(HalfBid)
                else:
                    #It doesn't, lets maybe shuffle a few points over to increase our odds of winning
                    BidDifference = Opponent_Average_Bid - HalfBid

                    #Check we can actually match the difference first
                    if (HalfBid+BidDifference) < OptimalBid:
                        if BidDifference < 8:
                            #We add half the difference of the BidDifference to increase odds of winning
                            return np.floor(HalfBid + (BidDifference/2))
                        else:
                            #It's more than 8, skip this madness
                            return np.floor(HalfBid)

                    else:
                        #We can't match the difference, go ahead as planned
                        return np.floor(HalfBid)


            else:
                #There's a lot of bots to fight, either strategy is viable
                #So we use randomisation to throw them off!
                if bool(random.getrandbits(1)):
                    return np.floor(AverageBid)
                else:
                    return np.floor(HalfBid)

        else:
            #There are no other bots to fight! Punch it Chewy!
            return OptimalBid

    else:

        if hp == 100:
            #It appears to be our opening round (assumes opponent HP same as ours)
            #We have no way of knowing what our opponent will play into the battle

            #Only us in the fight? Full power to weapons!
            if BotsToFight < 1:
                return hp - 1
            else:
                #As what might happen is literally random
                #We will also be literally random
                #Within reason

                #Work out how many bots we need to pass
                HighestBid = hp - (BotsToFight+1)
                AverageBid = hp/BotsToFight
                LowestBid = np.floor(np.sqrt(AverageBid))

                #Randomly choose between picking a random number out of thin air
                #And an average
                if bool(random.getrandbits(1)):
                    return np.minimum(LowestBid,HighestBid)
                else:
                    return AverageBid

        else:
            #Oh dear, we have less HP than our opponent
            #We'll have to play it crazy to win this round (with the high probability we'll die next round)
            #We'll leave ourselves 1 hp (if we can)

            if BotsToFight < 1:
                OptimalBid = hp - 1
            else:
                OptimalBid = hp - (BotsToFight+1)

            #Err likely we're 0(???) or 1 hp, so we just return our HP
            if OptimalBid < 1:
                return hp
            else:
                return OptimalBid

BoxBot

def BoxBot(hp, history, ties, alive):

    Opponent_HP = float.round(100 - sum(history))
    HalfLife = float.round(Opponent_HP/2)
    RandomOutbid = HalfLife + np.random.randint(1,HalfLife)

    if hp < RandomOutbid:
        return hp - 1
    else
        return RandomOutbid

Opponent_Average_Bid = Opponent_Remaining_HP / float(len(history)) ZeroDivisionError: float division by zero। এই লাইনটি 0 দৈর্ঘ্যের ইতিহাস কেস পরিচালনা করতে হবে।
কেবিরিগস

ধন্যবাদ, আমি এটি সংশোধন করব।
এসএসাইট

সংশোধন করা হয়েছে। অন্য কোনও ত্রুটি আছে কিনা তা আমাকে জানান।
এসএসআইটি

1
সিনট্যাক্স ত্রুটি দম্পতি: অনুপস্থিত: `পর else, math.[func] -> np.[func]এবং এক পর্যায়ে আপনি ব্যবহার Lowestযেখানে আপনি কি বলতে চান LowestBid। সমস্ত গিথুব এবং স্কোরগুলিতে নিয়ামকটিতে স্থির হয়েছে shortly
কেবিরিগস 3:38

ধন্যবাদ। পোস্টে পূর্বোক্ত সমস্ত ত্রুটি স্থির করে।
এসএসাইট

4

বট গণনা করা হচ্ছে

def calculatingBot(hp, history, ties, alive, start):
    opponentsHP = 100 - sum(history)
    if alive == 2: # 1v1
        return hp - 1 + ties
    # Try to fit an exponential trendline and one up the trendline if it fits
    if len(history) >= 3: 
        xValues = range(1, len(history) + 1)
        # https://stackoverflow.com/a/3433503  Assume an exponential trendline
        coefficients = np.polyfit(xValues, np.log(history), 1, w = np.sqrt(history))
        def model(coefficients, x):
            return np.exp(coefficients[1]) * np.exp(coefficients[0] * x)
        yPredicted = [model(coefficients, x) for x in xValues]
        totalError = 0
        for i in range(len(history)):
            totalError += abs(yPredicted[i] - history[i])
        if totalError <= (len(history)): # we found a good fitting trendline
            # get the next predicted value and add 1
            theoreticalBet = np.ceil(model(coefficients, xValues[-1] + 1) + 1) 
            theoreticalBet = min(theoreticalBet, opponentsHP)
            theoreticalBet += ties
            return int(min(theoreticalBet, hp - 1)) # no point suiciding
    maxRoundsLeft = np.ceil(np.log2(alive))
    theoreticalBet = hp / float(maxRoundsLeft)
    additionalRandomness = round(np.random.random()*maxRoundsLeft) 
    # want to save something for the future
    actualBet = min(theoreticalBet + additionalRandomness + ties, hp - 2)
    actualBet = min(actualBet, opponentsHP+1)
    return int(actualBet)

আক্রমণাত্মক গণনা বট

def aggresiveCalculatingBot(hp, history, ties, alive, start):
    opponentsHP = 100 - sum(history)
    if opponentsHP == 100: # Get past the first round
        return int(min(52+ties, hp-1+ties))
    if alive == 2: # 1v1
        return hp - 1 + ties
    # Try to fit an exponential trendline and one up the trendline if it fits
    if len(history) >= 3: 
        xValues = range(1, len(history) + 1)
        # https://stackoverflow.com/a/3433503  Assume an exponential trendline
        coefficients = np.polyfit(xValues, np.log(history), 1, w = np.sqrt(history))
        def model(coefficients, x):
            return np.exp(coefficients[1]) * np.exp(coefficients[0] * x)
        yPredicted = [model(coefficients, x) for x in xValues]
        totalError = 0
        for i in range(len(history)):
            totalError += abs(yPredicted[i] - history[i])
        if totalError <= (len(history)): # we found a good fitting trendline
            # get the next predicted value and add 1
            theoreticalBet = np.ceil(model(coefficients, xValues[-1] + 1) + 1) 
            theoreticalBet = min(theoreticalBet, opponentsHP)
            theoreticalBet += ties
            return int(min(theoreticalBet, hp - 1)) # no point suiciding
    maxRoundsLeft = np.ceil(np.log2(alive))
    theoreticalBet = hp / float(maxRoundsLeft)
    additionalRandomness = 1+round(np.random.random()*maxRoundsLeft*2) 
    # want to save something for the future
    actualBet = min(theoreticalBet + additionalRandomness + ties, hp - 2)
    actualBet = min(actualBet, opponentsHP+1)
    return int(actualBet)

অ্যান্টি কিক বট

def antiKickBot(hp, history, ties, alive, start):
    if alive == 2:
        return (hp - 1 + ties)
    amount = np.ceil((float(hp) / 2) + 1.5)
    opponentsHP = 100 - sum(history)
    amount = min(amount, opponentsHP) + ties
    return amount

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

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

অ্যান্টি কিক বটকে সর্বদা বর্তমান নেতা কিকবটকে পরাস্ত করা উচিত: পি

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


চতুর। আমি মনে করি এটি একটি খুব বড় বট পুলের সাথে আরও ভাল করবে।
কেবিরিগস

আমি কখনও কখনও এটির সাথে একটি ত্রুটি পাই return np.max(theoreticalBet, hp - 1): AxisError: axis 23 is out of bounds for array of dimension 0। আমি নিয়ামকের সাথে একটি লিঙ্ক পোস্ট করেছি যাতে আপনি এটি পরীক্ষা করতে পারেন।
কেবিরিগস

@ কেবিরিগস কোডটি ঠিক করার জন্য আপডেট করেছে।
বব ক্র্যাচিট

1
নিশ্চিত, স্কোর আপডেট আগত। আপনি অবশ্যই শীর্ষ দশে রয়েছেন।
কেবিরিগস

@ কেবিরিগস আমি আরও কয়েকটি বট চেষ্টা করে দেখলাম :)
বব ক্র্যাচিট

4

GenericBot

def generic_bot(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if not history:
        return int(hp * 7.0 / 13)
    opp = 100 - sum(history)
    if opp < hp:
        return opp + ties
    max_sac = np.maximum(int(hp * 0.7), 1)
    rate = history[-1] * 1.0 / (history[-1] + opp)
    return int(np.minimum(max_sac, rate * opp + 1))

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


আপনি ব্যবহার করতে হবে np.maximumপরিবর্তে np.maxএকই,min
KBriggs

@ কেবিরিগস ধন্যবাদ :) হুম, মনে হচ্ছে জেনেরিক বটগুলি এই গেমটি শাসন করে
Quintec

দেখে মনে হচ্ছে তারা বেশ সহজ টার্গেট হবে, আমি অবাক হয়েছি এখনও কেউ পরজীবী তৈরি করেনি
কেবিগ্রাগস

@ কেবিগ্রাগস হ্যাঁ, আমি অবাক হয়েছি। সুরক্ষা যোগ করার সময় ...
কুইন্টেক

এখনও নিউরালবট তৈরির পরিকল্পনা করছেন?
কেবিরিগস

4

HalflifeS3

def HalflifeS3(hp, history, ties, alive, start):
    ''' Bet a half of oponent life + 2 '''
    if history:
        op_HP = 100 - sum(history)
        return np.minimum(hp-1, np.around(op_HP/2) + 2 + np.floor(1.5 * ties) )
    else:
        return hp/3

4

উপকূল বট [অবসরপ্রাপ্ত]

প্রতিযোগিতার মধ্য দিয়ে এটি এইচপি সমানভাবে বিভক্ত করে রাউন্ডগুলির মধ্যে চেষ্টা করবে এবং উপকূলটি চেষ্টা করবে। "উপকূল-সক্ষম" রাউন্ডে নিজেকে তৈরি করার আরও ভাল সুযোগ দেওয়ার জন্য প্রথম রাউন্ডে যে কোনও বামে এইচপি বিড করে দেবে।

def coast(hp, history, ties, alive, start):
   if alive == 2:
   # Last round, go all out
       return hp - 1 + ties
   else:
       # Find the next power of two after the starting number of players
       players = start
       while math.log(players, 2) % 1 != 0:
         players += 1

       # This is the number of total rounds
       rounds = int(math.log(players, 2))

       bid = 99 / rounds

       if alive == start:
           # First round, add our leftover hp to this bid to increase our chances
           leftovers = 99 - (bid * rounds)
           return bid + leftovers
       else:
           # Else, just try and coast

           opp_hp = 100 - sum(history)
           # If opponent's hp is low enough, we can save some hp for the 
           # final round by bidding their hp + 1
           return min(bid, opp_hp + 1)

উপকূল বট ভি 2

যেহেতু আমি এই চ্যালেঞ্জটি এত পছন্দ করি, তাই আমাকে আরও একটি বট তৈরি করতে হয়েছিল। এই সংস্করণটি প্রথম দুটি রাউন্ডে আরও এইচপি ব্যবহার করে পরবর্তীকালে এইচপি উপকূলের কিছুটিকে ত্যাগ করে।

def coastV2(hp, history, ties, alive, start):
   # A version of coast bot that will be more aggressive in the early rounds

   if alive == 2:
   # Last round, go all out
       return hp - 1 + ties
   else:
       # Find the next power of two after the starting number of players
       players = start
       while math.log(players, 2) % 1 != 0:
         players += 1

       # This is the number of total rounds
       rounds = int(math.log(players, 2))

       #Decrease repeated bid by 2 to give us more to bid on the first 2 rounds
       bid = (99 / rounds) - 2

       if len(history) == 0:
           # First round, add 2/3rds our leftover hp to this bid to increase our chances
           leftovers = 99 - (bid * rounds)
           return int(bid + math.ceil(leftovers * 2.0 / 3.0))
       elif len(history) == 1:
           # Second round, add 1/3rd of our leftover hp to this bid to increase our chances
           leftovers = 99 - (bid * rounds)
           return int(bid + math.ceil(leftovers * 1.0 / 3.0))
       else:
           # Else, just try and coast

           opp_hp = 100 - sum(history)
           # If opponent's hp is low enough, we can save some hp for the 
           # final round by bidding their hp + 1
           return int(min(bid, opp_hp + 1))

শতাংশ বট

প্রতিপক্ষের গড় শতাংশ শতাংশ এইচপি ব্যয় করতে গণনা করার চেষ্টা করে এবং তার উপর ভিত্তি করে বিড করে।

def percent(hp, history, ties, alive, start):
    if len(history) == 0:
        #First round, roundon low bid
        return int(random.randint(10,33))
    elif alive == 2:
        #Last round, go all out
        return int(hp - 1 + ties)
    else:
        # Try and calculate the opponents next bid by seeing what % of their hp they bid each round
        percents = []
        for i in range(0, len(history)):
            hp_that_round = 100 - sum(history[:i])
            hp_spent_that_round = history[i]
            percent_spent_that_round = 100.0 * (float(hp_spent_that_round) / float(hp_that_round)) 
            percents.append(percent_spent_that_round)

        # We guess that our opponents next bid will be the same % of their current hp as usual, so we bid 1 higher.
        mean_percent_spend = sum(percents) / len(percents)
        op_hp_now = 100 - sum(history)
        op_next_bid = (mean_percent_spend / 100) * op_hp_now
        our_bid = op_next_bid + 1

        print mean_percent_spend
        print op_hp_now
        print op_next_bid

        # If our opponent is weaker than our predicted bid, just bid their hp + ties
        if op_hp_now < our_bid:
            return int(op_hp_now + ties)
        elif our_bid >= hp:
            # If our bid would kill us, we're doomed, throw a hail mary
            return int(random.randint(1, hp))
        else:
            return int(our_bid + ties)

খুব সুন্দর ধারণা। প্রথম দফায় পদত্যাগ করা বটগুলিতে একটি নতুন ট্রেন্ড, এবং এটি যুক্তিসঙ্গতভাবে ভালভাবে কাজ করছে বলে মনে হয়।
কেবিরিগস

@ কেবিরিগস আমার দ্বিতীয় প্রচেষ্টাটি ধারণ করতে আমি এই প্রতিক্রিয়াটি আপডেট করেছি। নতুন নিয়ম অনুসারে আপনাকে উল্লেখ করছি। দুর্দান্ত ধাঁধা বিটিডব্লিউ!
ওয়াজ

আমাকে উভয় প্রবেশ করতে চান, বা শুধুমাত্র সর্বশেষতম সংস্করণ? এখনই এটি কেবল ভি 2
কেবিরিগস

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

বেশ একইরকম পারফরম্যান্স সামগ্রিকভাবে
কেবিরিগস

4

ConsistentBot

প্রতিটি রাউন্ডে একই পরিমাণে বেট দেয়। এটি প্রথম রাউন্ডে বেঁচে থাকার খুব বেশি সম্ভাবনা নেই তবে এটি যদি শেষ পর্যন্ত পাওয়ার জন্য যথেষ্ট ভাগ্যবান হয় তবে তার এখনও যুক্তিসঙ্গত পরিমাণ এইচপি বামে থাকা উচিত।

def consistent(hp, history, ties, alive, start):
    if alive == 2:
        return hp-1

    if 100 % start == 0:
        return (100 / start) - 1
    else: 
        return 100 / start

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

4

কিকবান বট

এই বটটি কেবলমাত্র বর্তমান নেতা মিন কিকবটকে একে একে রাউন্ডে পেটানোর মাধ্যমে এবং এরপরে স্বীকৃতি জানার পরে আরও আক্রমণাত্মকভাবে খেলানোর চেষ্টা করে।

def kickban(hp, history, ties, alive, start):
    if alive == 2:
        return hp-1

    if not history:
        return 36

    if history[0]==35:
        somean = 1
    else:
        somean = 0

    return min(mean_kick(hp, history, ties, alive, start) + somean*3, hp-1)

1
আমি মনে করি আপনার ইন্ডেন্টেশনটি কিছুটা বন্ধ।
জোনাথন ফ্রেচ

ওফস, ধন্যবাদ, অদ্ভুত কোড সম্পাদক প্রথম লাইনের সাথে
মিশে গেল

আপনার নিয়ন্ত্রণ নেই এমন কোডের উপর আস্থা রাখার এক মূল্যবান পাঠ
OganM

4

থ্রি কোয়ার্টার বট

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

* প্রথম দফায় লো-বল করার পরে।

def ThreeQuarterBot(hp, history, ties, alive, start):
    threeQuarters = 3 * hp / 4

    if alive == 2:
        return hp - 1

    opponent_hp = 100 - sum(history)

    if not history:
        # low-ball the first round but higher than (some) other low-ballers
        return 32 + ties
    elif threeQuarters > opponent_hp:
        return opponent_hp + ties

    return threeQuarters

চার সপ্তম বট

মাঝারি সাফল্যের পরে 3/4 বট শহরে একটি নতুন ভগ্নাংশ রয়েছে, এটি কেবল যুক্তিযুক্ত।

def FourSeventhsBot(hp, history, ties, alive, start):
    fourSevenths = 4 * hp / 7

    if alive == 2:
        return hp - 1

    opponent_hp = 100 - sum(history)

    if not history:
        # low-ball the first round but higher than (some) other low-ballers
        return 33 + ties
    if fourSevenths > opponent_hp:
        return opponent_hp + ties

    return fourSevenths + ties

পারফেক্ট ভগ্নাংশ

আমি পুরো

def ThePerfectFraction(hp, history, ties, alive, start):
    thePerfectFraction = 7 * hp / 13

    if alive == 2:
        return hp - 1

    opponent_hp = 100 - sum(history)

    if not history:
        # Need to up our game to overcome the kickers
        return 42 + ties
    if thePerfectFraction > opponent_hp:
        return opponent_hp + ties

    return thePerfectFraction + 1 + ties

এই বিলোপ সম্ভাবনার উপর ভিত্তি করে, আপনি সম্ভবত রাউন্ড 2-তে আরও ছোট বিড দিয়ে পালাতে পারেন। এটি একটি ভাল করে, তবে কিছু ছোটখাটো টুইটগুলি এটিকে আরও ভাল করে তুলতে পারে।
কেবিরিগস

@ কেবিরিগস নতুন এবং উন্নত প্রতিকূলতার সাথে একটি নতুন বট যুক্ত করেছে;)
জোশুয়া ওয়েব

তাদের উভয় সেখানে চান, বা মাত্র 1?
কেবিরিগস

@ কেবিগ্রাগস আমি জানি না আমি সময়সীমাটি মিস করেছি কিনা তবে আমি একটি চূড়ান্ত বট যুক্ত করেছি, যদি আমি সময়মতো তৈরি করি তবে আপনি অন্য দুটি ভগ্নাংশ বট অপসারণ করতে পারেন
জোশুয়া ওয়েব

1
হ্যাঁ, আপনার এখনও সময় আছে
কেব্রিগস

4

BandaidBot

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

def BandaidBot(hp, history, ties, alive, start):
    if alive == 2:
        return hp-1

    if history:
        opp_hp = 100 - sum(history)
        opp_last_hp = 100 - sum(history[:-1])

        if history[-1] <= opp_last_hp / 3:
            return 1 + ties * np.random.randint(0, 1) 
        elif history[-1] > opp_last_hp / 2:
            return min(opp_hp - 1, hp)
        else:
            if history[-1] < hp/2:
                return np.random.randint(history[-1], hp/2)
            else:
                return np.floor(hp/2)
    else:
        return np.floor(hp/3)

GetAlongBot

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

def GetAlongBot(hp, history, ties, alive, start):
    if alive == 2:
        return hp-1

    if history:
        opp_hp = 100 - sum(history)
        opp_last_hp = 100 - sum(history[:-1])
        count = 0
        for i in range(0, len(history)):
            hp_that_round = 100 - sum(history[:i])
            hp_spent_that_round = history[i]
            if hp_that_round / 3 - 1 <= hp_spent_that_round <= hp_that_round / 2:
                count += 1
        if count == len(history): #It's probably BandaidBot!
            return 2
        else:
            return min(opp_hp - 1, np.floor(hp/3))
    else:
        return np.floor(hp/3)

সত্যিই ঝরঝরে ধারণা। আমি আশ্চর্য হই যে এর কতটা প্রভাব ফেলবে
কেব্রিগস

ত্রুটি: return np.random.randint(history[-1], hp/2): ValueError: low >= highএই
কেসটি

@ কেবিরিগস এখনই ঠিক করা উচিত!
মায়া সল

@ কেবিরিগস এলোমেলোকরণ ঠিক করার জন্য আপডেট হয়েছে
মায়া সল

3

টেনেসিয়াস বট

def TENacious_bot(hp, history, ties, alive, start):
  max_amount=hp-(alive-1)*2;
  if max_amount<2: max_amount=2

  if alive==2: return hp-1
  if ties==0: return np.minimum(10, max_amount)
  if ties==1: return np.minimum(20, max_amount)
  if ties==2: return np.minimum(40, max_amount)
  # prevent function blowup
  return 2

এই বটটি তার প্রিয় 10 টি ধরে রাখার চেষ্টা করে, তবে কোনও টাই ভাঙতে (তার প্রিয় মান দ্বিগুণ বা চতুর্ভূজ সহ) ভাঙার জন্য বা ভবিষ্যতের রাউন্ডের জন্য সংরক্ষণ করার প্রয়োজন হলে এটি মাঝে মধ্যে তার পছন্দ পরিবর্তন করে তবে অনুকূল পরিমাণে নয়, কারণ এটি বিভ্রান্ত করতে চায় প্রতিপক্ষ এবং এটি যে কোনও সময়ে 2 এর চেয়ে কম বিডকে বিবেচনা করতে চায় না কারণ এটি নিশ্চিত হওয়া যে প্রতিপক্ষ প্রতি 1 টির চেয়ে কম বিড করবে বলে আশা করা তার চেয়ে অনেক ভাল hope

পিএস: 2 ^ 9 টির বেশি বট থাকলে এই বটটিতে কৌশলগত সমস্যা হতে পারে।


আমার সন্দেহ হয় আপনার 2 ^ 9 বিরোধী having _ ^ থাকার বিষয়ে চিন্তা করতে হবে না ^
কেবিরিগস

তবে 10-র উদ্বোধনী বাজির সাথে, তিনি খুব কমই প্রথম
দফায় কাটিয়ে উঠতে চলেছেন

এই বটটি মনে করে যে, যদি কিছু বট সত্যই প্রথম রাউন্ডে 10 এইচপি বেশি দিতে চায়, তবে লড়াইয়ের পক্ষে তা লাভজনক নয়।
অ্যালেক্সরেসার 23

হাহা যথেষ্ট ন্যায্য
কেব্রিগস

3

CautiousBot

প্রোগ্রামিং ধাঁধাতে সর্বদা প্রথম জমা! আপনার চ্যালেঞ্জটি বেশ আকর্ষণীয় পেল: পি

যদি শেষ রাউন্ড বিটটি এইচপি এর চেয়ে কম হয় তবে কোনও ইতিহাস অর্ধ এইচপি প্লাস যদি একটি ছোট এলোমেলো পরিমাণে বাজি ধরে না।

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

অন্যান্য বটদের মতো বন্ধনের জন্য সর্বদা সঠিক

def cautious_gambler(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if(history):
        opp_hp = 100 - sum(history)
        remaining_rounds = np.ceil(np.log2(start)) - len(history)

        start_bet = opp_hp / 2
        buff = int((hp - start_bet)/remaining_rounds if remaining_rounds > 0 else (hp - start_bet)) 
        buff_bet = np.random.randint(0, buff) if buff > 0 else 0
        bet = start_bet + buff_bet + ties

        if bet >= hp or bet > opp_hp:
            bet = np.minimum(hp - 1, opp_hp)

        return int(bet)
    else:
        start_bet = hp / 2
        rng_bet = np.random.randint(3,6)

        return int(start_bet + rng_bet + ties)

CautiousBot2

প্রথম রাউন্ডে খুব বেশি আক্রমণাত্মক, এখন সতর্কবাট আরও বেশি সতর্ক হয় ...

def cautious_gambler2(hp, history, ties, alive, start):
    if alive == 2:
        return hp - 1
    if(history):
        opp_hp = 100 - sum(history)
        remaining_rounds = np.ceil(np.log2(start)) - len(history)

        start_bet = opp_hp / 2
        buff = int((hp - start_bet)/remaining_rounds if remaining_rounds > 0 else (hp - start_bet)) 
        buff_bet = np.random.randint(0, buff) if buff > 0 else 0
        bet = start_bet + buff_bet + ties

        if bet >= hp or bet > opp_hp:
            bet = np.minimum(hp - 1, opp_hp)

        return int(bet)
    else:
        start_bet = hp * 0.35
        rng_bet = np.random.randint(3,6)

        return int(start_bet + rng_bet + ties)

আপনার কাছে একটি বাগ রয়েছে যেখানে এটি এখনও বাফার = 0: যখন রেন্ডেন্টকে কল করে buffer_bet = np.random.randint(0, buffer) if buffer > 0 else 0 File "mtrand.pyx", line 993, in mtrand.RandomState.randint ValueError: low >= high। নোট করুন যে বাফারটি পাইথনের একটি কীওয়ার্ড, আপনি অন্য কোনও ভেরিয়েবলের নামটি চয়ন করতে পারেন।
কেবিরিগস

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

@KBriggs ভাল লাগছে। ভাবি আমি এটা ঠিক করেছি।
জেসের রোজ

আমি এখনও কোনো ত্রুটির সম্মুখীন হয়েছেন: buff_bet = np.random.randint(0, buff) if buff > 0 else 0 File "mtrand.pyx", line 993, in mtrand.RandomState.randint ValueError: low >= high। দেখে মনে হয় বাফটি কখনও কখনও 0 এবং 1 এর মধ্যে একটি ভাসমান বিন্দু হয় যা সম্ভবত 0 টি ভিতরে insideালাই হয়ে যায় randint। এই কাজ করে আপনি কাস্ট buffকরার জন্য intকল করার আগে
KBriggs

@KBriggs সম্ভাব্য কারণ হতে ceilআয় একটি float। সেটিকে মিস করেছি ... টি আবার: পি
জেসিস রোজ

3

ঠিক আছে, আমি এই আমার হাত চেষ্টা করব।

SnetchBot

প্রতিপক্ষের সাথে যে স্বাস্থ্যের ভগ্নাংশ চলছে সেগুলি পরীক্ষা করা হচ্ছে। প্রতিপক্ষ যদি উত্থাপিত হয়, তবে তাকে এতে মারধর করুন।

def snetchBot(hp, history, ties, alive, start):
    if alive == 2:
        return hp-1

    opponent_hp = 100
    history_fractions = []
    if history:
        for i in history:
            history_fractions.append(float(i)/opponent_hp)
            opponent_hp -= i
        if opponent_hp <= hp/2:
            #print "Squashing a weakling!"
            return opponent_hp + (ties+1)/3

        average_fraction = float(sum(history_fractions)) / len(history_fractions)
        if history_fractions[-1] < average_fraction:
            #print "Opponent not raising, go with average fraction"
            next_fraction = average_fraction
        else:
            #print "Opponent raising!"
            next_fraction = 2*history_fractions[-1] - average_fraction
        bet = np.ceil(opponent_hp*next_fraction) + 1
    else:
        #print "First turn, randomish"
        bet = np.random.randint(35,55)

    if bet > opponent_hp:
        bet = opponent_hp + (ties+1)/3
    final_result = bet + 3*ties
    if bet >= hp:
        #print "Too much to bet"
        bet = hp-1
    return final_result

সম্পাদনা: প্রথম রাউন্ডে প্রচুর হারানো, প্রথম টার্নটি এলোমেলো সীমাবদ্ধ করে


বেশ ভাল প্রথম শট, স্কোর আপডেট
ইনকাম

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

আপনি তাঁর থেকে আরও কিছু রস বার করুন
কেবিরিগস

3

SquareUpBot

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

শত্রু বট কিছু ধ্রুবক ভগ্নাংশ ব্যবহার করার চেষ্টা করছে না কিনা তা নির্ধারণ করার চেষ্টা করে কারণ শক্তি > ভগ্নাংশ

সম্পাদনা: আমি একটি ডামি এবং আমার ভগ্নাংশ সনাক্তকারী কাজ করতে পারেনি। এখন মেরামত।

def squareUp(hp, history, ties, alive, start):

    #Taken from Geometric Bot
    opponentHP = 100 - sum(history)

    # Need to add case for 1
    if hp == 1:
        return 1

    # Last of the last - give it your all
    if alive == 2:
        if ties == 2 or opponentHP < hp-1:
            return hp - 1

    #Calculate your bet (x^(4/5)) with some variance
    myBet = np.maximum(hp - np.power(hp, 4./5), np.power(hp, 4./5))
    myBet += np.random.randint(int(-hp * 0.05) or -1, int(hp * 0.05) or 1);
    myBet = np.ceil(myBet)
    if myBet < 1:
        myBet = 1
    elif myBet >= hp:
        myBet = hp-1
    else:
        myBet = int(myBet)

    #If total annihilation is a better option, dewit
    if opponentHP < myBet:
        if ties == 2:
            return opponentHP + 1
        else:
            return opponentHP

    #If the fraction is proven, then outbid it (Thanks again, Geometric bot)
    if history and history[0] != history[-1]:
        health = 100
        fraction = float(history[0]) / health
        for i,x in enumerate(history):
            newFraction = float(x) / health
            if newFraction + 0.012*i < fraction or newFraction - 0.012*i > fraction:
                return myBet
            health -= x
        return int(np.ceil(opponentHP * fraction)) + 1    
    else:
        return myBet

কোনও খারাপ প্রথম শট নয়, স্কোরগুলি আপডেট করা হয়েছে
কেবিরিগস

@ কেবিরিগস আমি বট আপডেট করেছি যাতে ভগ্নাংশ সনাক্তকারী আসলে কাজ করে।
ডায়মন্ড ডাস্ট
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.