কোথ - আরপিএস লোড হয়েছে

12

প্রতিযোগিতা স্থায়ীভাবে খোলা - 10 আগস্ট 10 ই আগস্ট আপডেট হয়েছে

যদিও 5 ই জুন 2017 এ আমি বিজয়ী ঘোষণা করেছি (যাকে সেরা উত্তর হিসাবে রাখা হবে) আমি নতুন বটগুলি rnning করব এবং ফলাফলগুলি আপডেট করব।

জুন 5 ফলাফল

অভিনন্দন ব্যবহারকারী 1502040

যেহেতু কোনও সম্পর্ক নেই, আমি কেবলমাত্র ম্যাচগুলির%% দেখিয়েছি।

Statistician2- 95.7%
Fitter- 89.1%
Nash- 83.9%
Weigher- 79.9%
ExpectedBayes- 76.4%
AntiRepeater- 72.1%
Yggdrasil- 65.0%
AntiGreedy- 64.1%
Reactor- 59.9%
NotHungry- 57.3%
NashBot- 55.1%
Blodsocer- 48.6%
BestOfBothWorlds- 48.4%
GoodWinning- 43.9%
Rockstar- 40.5%
ArtsyChild- 40.4%
Assassin- 38.1 %
WeightedRandom- 37.7%
Ensemble- 37.4%
UseOpponents- 36.4%
GreedyPsychologist- 36.3%
TheMessenger- 33.9%
Copycat- 31.4%
Greedy- 28.3%
SomewhatHungry- 27.6%
AntiAntiGreedy- 21.0%
Cycler- 20.3%
Swap- 19.8%
RandomBot- 16.2%

আমি প্রতিটি জুড়ির ফলাফলের গ্রিড সহ একটি গুগল শীট তৈরি করেছি: https://docs.google.com/spreadsheets/d/1KrMvcvWMkK-h1Ee50w0gWLh_L6rCFOgLhTN_QlEXHyk/edit?usp=singing

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

খেলাাটি

গেমটি একটি মোড় সহ একটি সাধারণ "রক-পেপার-কাঁচি": পয়েন্টগুলি ম্যাচের সময় প্রতিটি বিজয় বৃদ্ধির সাথে অর্জন করে (আপনার আর, পি বা এস বোঝা হয়ে যায়)।

  • কাগজ রক জিতেছে
  • কাঁচি পেপার জিতল
  • রক কাঁচি জিতেছে

বিজয়ী তার খেলায় বোঝা হিসাবে অনেক পয়েন্ট পায়

হারা তার খেলায় লোড 1 বাড়ায়।

টাই করার ক্ষেত্রে, প্রতিটি খেলোয়াড় তার খেলার লোডটি 0.5 দ্বারা বৃদ্ধি করে।

100 টি নাটকের পরে, আরও পয়েন্টের সাথে বিজয়ী হয়।

উদাহরণস্বরূপ: পি 1 এর মধ্যে লোড রয়েছে [10,11,12] (রক, পেপার, কাঁচি) এবং পি 2 [7,8,9]। পি 1 আর খেলে, পি 2 খেলেন পি পি 2 জিতে এবং 8 পয়েন্ট পায়। পি 1 লোডগুলি [11,11,12] হয়ে যায়, পি 2 লোডগুলি একই থাকে।

চ্যালেঞ্জ স্পেসিফিকেশন

আপনার প্রোগ্রামটি অবশ্যই পাইথনে লেখা উচিত (দুঃখিত, আমি জানি না কীভাবে এটি পরিচালনা করতে হয়)। আপনাকে এমন একটি ক্রিয়াকলাপ তৈরি করতে হবে যা এই প্রতিটি ভেরিয়েবলকে প্রতিটি মৃত্যুদণ্ডের জন্য যুক্তি হিসাবে গ্রহণ করে:

my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history

points - বর্তমান পয়েন্ট (আপনার এবং আপনার বিপরীতে)

loaded- লোড সহ অ্যারে (ক্রম আরপিএসে) (আপনার এবং আপনার বিপরীতে)

history- সমস্ত নাটকের সাথে স্ট্রিং, শেষ চরিত্রটি সর্বশেষ নাটক (আপনার এবং আপনার বিপরীতে)

আপনাকে অবশ্যই ফিরে যেতে হবে "R", "P"বা "S"। আপনি যদি অন্যরকম কিছু ফিরিয়ে দেন তবে এটি ম্যাচের একটি স্বয়ংক্রিয় হার হবে।

বিধি

আপনি অন্তর্নির্মিত কার্যগুলি পরিবর্তন করতে পারবেন না।

পরীক্ষামূলক

আমি কোডটি এবং সমস্ত বট সংকেত সহ একটি গিট আপডেট করব: https://github.com/Masclins/LoadedRPS

বিচার করা

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

আপনি 5 টি পর্যন্ত বট জমা দিতে পারেন।

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

এটি যেহেতু এটি আমার প্রথম কোথ, তাই আমি উন্নতির জন্য যে কোনও পরিবর্তন করার জন্য 100% উন্মুক্ত, যেমন প্রতিটি বটের বিরুদ্ধে ম্যাচের সংখ্যা।

1000 টি ম্যাচে সম্পাদিত, যেহেতু আমি দেখছি সেখানে সত্যিই বেশ জড়িত রয়েছে।

king-of-the-hill  python 
— Masclins
সূত্র
কিছু এলোমেলো বট সহ, আপনি আসলে একাধিক রাউন্ডের একাধিক গেম
— ধ্বংসাত্মক লেবু
@ ডিসট্রাকটিবললমন আমি প্রতিটি বট একবারের পরিবর্তে একে অপরের বিরুদ্ধে তিনবার খেলার কথা ভেবেছিলাম। আপনাকে একইভাবে ভাবতে দেখে, আমি এটি করব।
— মাসক্লিনস
1
(সত্যিই আপনার ন্যায্য সংখ্যক দরকার, যেহেতু কিছু প্রব্যাবিলিটগুলি একাধিক ম্যাচের চেয়ে অনেক বেশি বাড়িয়ে দেয় my আমার বট দেখুন, যেখানে এটি উত্তেজনা পেতে পারে, তবে সম্ভবত ন্যায্য পরিমাণ ম্যাচ না থাকলে)
— ধ্বংসাত্মক লেবু
1
আমি খুশি যে আমার প্রশ্ন আপনাকে এটি চালাতে সক্ষম হতে সাহায্য করেছে, @ অ্যালবার্টম্যাসক্লানস!
— গ্রিফোন
2
@ অ্যালবার্টম্যাসক্লানস আপনি কি পুরো টেস্টস্ক্রিপ্ট পোস্ট করতে পারেন (সহ runcodeএবং সহ bots)?
— ক্যালকুলেটরফলাইন

উত্তর:

8

পরিসংখ্যানবিদ (আর খেলছেন না)

import random
import collections

R, P, S = moves = range(3)
move_idx = {"R": R, "P": P, "S": S}
name = "RPS"
beat = (P, S, R)
beaten = (S, R, P)

def react(_0, _1, _2, _3, _4, opp_history):
    if not opp_history:
        return random.randrange(0, 3)
    return beat[opp_history[-1]]

def anti_react(_0, _1, _2, _3, _4, opp_history):
    if not opp_history:
        return random.randrange(0, 3)
    return beaten[opp_history[-1]]

def random_max(scores):
    scores = [s + random.normalvariate(0, 1) for s in scores]
    return scores.index(max(scores))

def greedy_margin(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    scores = [my_loaded[move] - opp_loaded[beat[move]] for move in moves]
    return random_max(scores)

def anti_greedy(my_points, opp_pints, my_loaded, opp_loaded, my_history, opp_history):
    scores = [-my_loaded[move] for move in moves]
    return random_max(scores)

def recent_stats(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    opp_history = opp_history[-10:-1]
    counts = collections.Counter(opp_history)
    scores = [(counts[beaten[move]] + 1) * my_loaded[move] - 
              (counts[beat[move]] + 1) * opp_loaded[move] for move in moves]
    return random_max(scores)

def statistician(_0, _1, _2, _3, my_history, opp_history):
    m1 = []
    o1 = []
    my_loaded = [0] * 3
    opp_loaded = [0] * 3
    my_points = 0
    opp_points = 0
    strategies = [react, anti_react, greedy_margin, anti_greedy, recent_stats]
    strategy_scores = [0 for _ in strategies]
    for i, (mx, ox) in enumerate(zip(my_history, opp_history)):
        mx = move_idx[mx]
        ox = move_idx[ox]
        for j, strategy in enumerate(strategies):
            strategy_scores[j] *= 0.98
            move = strategy(my_points, opp_points, my_loaded, opp_loaded, m1, o1)
            if move == beat[ox]:
                strategy_scores[j] += my_loaded[move]
            elif move == beaten[ox]:
                strategy_scores[j] -= opp_loaded[ox]
        m1.append(mx)
        o1.append(ox)
        if mx == beat[ox]:
            opp_loaded[ox] += 1
            my_points += my_loaded[mx]
        elif mx == beaten[ox]:
            my_loaded[mx] += 1
            opp_points += opp_loaded[ox]
        else:
            my_loaded[mx] += 0.5
            opp_loaded[ox] += 0.5
    strategy = strategies[random_max(strategy_scores)]
    return name[strategy(my_points, opp_points, my_loaded, opp_loaded, m1, o1)]

প্রত্যাশিত অতীত পারফরম্যান্সের ভিত্তিতে কয়েকটি সাধারণ কৌশলগুলির মধ্যে স্যুইচ

পরিসংখ্যানবিদ 2

import random
import collections
import numpy as np

R, P, S = moves = range(3)
move_idx = {"R": R, "P": P, "S": S}
names = "RPS"
beat = (P, S, R)
beaten = (S, R, P)

def react(my_loaded, opp_loaded, my_history, opp_history):
    if not opp_history:
        return random.randrange(0, 3)
    counts = [0, 0, 0]
    counts[beat[opp_history[-1]]] += 1
    return counts

def random_max(scores):
    scores = [s + random.normalvariate(0, 1) for s in scores]
    return scores.index(max(scores))

def argmax(scores):
    m = max(scores)
    return [s == m for s in scores]

def greedy_margin(my_loaded, opp_loaded, my_history, opp_history):
    scores = [my_loaded[move] - opp_loaded[beat[move]] for move in moves]
    return argmax(scores)

recent_counts = None

def best_move(counts, my_loaded, opp_loaded):
    scores = [(counts[beaten[move]] + 0.5) * my_loaded[move] - 
              (counts[beat[move]] + 0.5) * opp_loaded[move] for move in moves]
    return argmax(scores)

def recent_stats(my_loaded, opp_loaded, my_history, opp_history):
    if len(opp_history) >= 10:
        recent_counts[opp_history[-10]] -= 1
    recent_counts[opp_history[-1]] += 1
    return best_move(recent_counts, my_loaded, opp_loaded)

order2_counts = None

def order2(my_loaded, opp_loaded, my_history, opp_history):
    if len(my_history) >= 2:
        base0 = 9 * my_history[-2] + 3 * opp_history[-2]
        order2_counts[base0 + opp_history[-1]] += 1
    base1 = 9 * my_history[-1] + 3 * opp_history[-1]
    counts = [order2_counts[base1 + move] for move in moves]
    return best_move(counts, my_loaded, opp_loaded)

def nash(my_loaded, opp_loaded, my_history, opp_history):
    third = 1.0 / 3
    p = np.full(3, third)
    q = np.full(3, third)
    u = np.array(my_loaded)
    v = np.array(opp_loaded)
    m0 = np.zeros(3)
    m1 = np.zeros(3)
    lr = 0.2
    for _ in range(10):
        de0 = u * np.roll(q, 1) - np.roll(v * q, 2)
        de1 = v * np.roll(p, 1) - np.roll(u * p, 2)
        m0 = 0.9 * m0 + 0.1 * de0
        m1 = 0.9 * m1 + 0.1 * de1
        p += lr * m0
        q += lr * m1
        p[p < 0] = 0
        q[q < 0] = 0
        tp, tq = np.sum(p), np.sum(q)
        if tp == 0 or tq == 0:
            return np.full(3, third)
        p /= tp
        q /= tq
        lr *= 0.9
    return p

strategies = [react, greedy_margin, recent_stats, order2, nash]

predictions = strategy_scores = mh = oh = None

def statistician2func(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    global strategy_scores, history, recent_counts, mh, oh, predictions, order2_counts
    if not opp_history:
        strategy_scores = [0 for _ in strategies]
        recent_counts = collections.Counter()
        order2_counts = collections.Counter()
        mh, oh = [], []
        predictions = None
        return random.choice(names)
    my_move = move_idx[my_history[-1]]
    opp_move = move_idx[opp_history[-1]]
    if predictions is not None:
        for j, p in enumerate(predictions):
            good = beat[opp_move]
            bad = beaten[opp_move]
            strategy_scores[j] += (my_loaded[good] * p[good] - opp_loaded[opp_move] * p[bad]) / sum(p)
    mh.append(my_move)
    oh.append(opp_move)
    predictions = [strategy(my_loaded, opp_loaded, mh, oh) for strategy in strategies]
    strategy = random_max(strategy_scores)
    p = predictions[strategy]
    r = random.random()
    for i, pi in enumerate(p):
        r -= pi
        if r <= 0:
            break
    return names[i]

ন্যাশ

import numpy as np
import random

def nashfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    third = 1.0 / 3
    p = np.full(3, third)
    q = np.full(3, third)
    u = np.array(my_loaded)
    v = np.array(opp_loaded)
    m0 = np.zeros(3)
    m1 = np.zeros(3)
    lr = 0.2
    for _ in range(10):
        de0 = u * np.roll(q, 1) - np.roll(v * q, 2)
        de1 = v * np.roll(p, 1) - np.roll(u * p, 2)
        m0 = 0.9 * m0 + 0.1 * de0
        m1 = 0.9 * m1 + 0.1 * de1
        p += lr * m0
        q += lr * m1
        p[p < 0] = 0
        q[q < 0] = 0
        tp, tq = np.sum(p), np.sum(q)
        if tp == 0 or tq == 0:
            return random.choice("RPS")
        p /= tp
        q /= tq
        lr *= 0.9
    r = random.random()
    for i, pi in enumerate(p):
        r -= pi
        if r <= 0:
            break
    return "RPS"[i]

গ্রেডিয়েন্ট বংশোদ্ভূত দ্বারা আনুমানিক ন্যাশ ভারসাম্য গণনা করে।

— user1502040
সূত্র
1
আমি সত্যিই এই পদ্ধতির পছন্দ করি এবং আপনি কেন রাষ্ট্রকে চক্রের মধ্যে রাখতে সক্ষম হতে চান তা বুঝতে পারি। যদিও আমি দেখছি এটি জমা দেওয়ার সংখ্যাটি দিয়ে এটিকে পরিবর্তন করতে একটি বিশাল সমস্যা problem আমি আরও চ্যালেঞ্জের জন্য এটি বিবেচনায় নেব (যা শেষ হওয়ার পরে আমি কী করব)।
— মাসক্লিনস 25:58
5

কয়াল

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

def weigher(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    idx = {"R": 0, "P": 1, "S": 2}
    sc = [0, 0, 0]
    for i, m in enumerate(reversed(opp_history[-3:])):
        sc[idx[m]] += (1 / (1 + i))

    for i in range(3):
        sc[i] *= (opp_loaded[i] ** 2)

    return "PSR"[sc.index(max(sc))]

শয়তান

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

def satan(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    import inspect, types
    f = inspect.currentframe()
    s = f.f_code.co_name
    try:
        for v in f.f_back.f_locals.values():
            if isinstance(v, types.FunctionType) and v.__name__ != s:
                try:
                    return "PSR"[{"R": 0, "P": 1, "S": 2}[
                        v(opp_points, my_points, opp_loaded, my_loaded, opp_history, my_history)]]
                except:
                    continue
    finally:
        del f
— প্রদর্শন নাম
সূত্র
কোনও সন্দেহ ছাড়াই সরলতা-ফলাফলের দিক থেকে সেরা এক
— মাসক্লিনস 25:38
যাইহোক, ব্যবহার my_loadedকরতে আপনি এমন একটি ওজন যুক্ত করতে পারেন যা আপনার শেষ পদক্ষেপের (গুলি) বিপরীতে হারাতে পারে এমন পদক্ষেপের মূল্য দেয়। এটি ধরে নেওয়ার মতো যা আপনার প্রতিদ্বন্দ্বী আপনি যা করেছেন তার অনুরূপ কিছু করবে এবং তাই আপনি একইভাবে চালিয়ে যাবেন এই ধারণা নিয়ে তাকে শাস্তি প্রদান করা। এর মতো কিছু:for i, m in enumerate(reversed(my_history[-3:])): sc[(idx[m]+1)%3] += (K / (1 + i))
— মাসক্লিনস
@ অ্যালবার্টম্যাসক্লানস আরও একটি সমাধান যুক্ত করেছেন
— নামটি
1
আমি সত্যই শয়তানকে পছন্দ করি। তবে আপনি যেমন বলেছিলেন, আমি বিশ্বাস করি এটির যোগ্যতা অর্জন করা উচিত নয়: এমনকি এটি কোনও স্পষ্ট নিয়ম না ভঙ্গ করলেও এটি স্পষ্টতই গেমের চেতনার বিরুদ্ধে। তবুও, আপনার ধারণার জন্য অভিনন্দন!
— মাসক্লিনস 23 '14
4

ফিটার

এই বট প্যাটার্ন উন্নত করে এবং এটি অর্থনীতিবিদ দিয়ে ফিউজ করে (প্যাটার্ন এবং অর্থনীতিবিদ আর অংশ নেবে না)

প্যাটার্নটির উন্নতি হ'ল বট এখন দুটি ধরণের প্যাটার্ন সন্ধান করে: প্রতিপক্ষ তার শেষ খেলার প্রতি প্রতিক্রিয়া জানায় এবং প্রতিদ্বন্দ্বী আমার শেষ নাটকটিতে প্রতিক্রিয়া জানায়। তারপরে উভয় ভবিষ্যদ্বাণীকে সবচেয়ে ভাল মানায় এমনটি ব্যবহার করতে মূল্যায়ন করে।

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

import random
import numpy as np
def fitterfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        t = len(opp_history)
        RPS = ["R","P","S"]
        if t <= 2:
                return RPS[t]
        elif t == 3:
                return random.choice(RPS)

        def n(c): return RPS.index(c)

        total_me = np.zeros(shape=(3,3))
        total_opp= np.zeros(shape=(3,3))
        p_me = np.array([[1/3]*3]*3)
        p_opp = np.array([[1/3]*3]*3)

        for i in range(1, t):
                total_me[n(my_history[i-1]), n(opp_history[i])] += 1
                total_opp[n(opp_history[i-1]), n(opp_history[i])] += 1
        for i in range(3):
                if np.sum(total_me[i,:]) != 0:
                        p_me[i,:] = total_me[i,:] / np.sum(total_me[i,:])
                if np.sum(total_opp[i,:]) != 0:
                        p_opp[i,:] = total_opp[i,:] / np.sum(total_opp[i,:])

        error_me = 0
        error_opp = 0

        for i in range(1, t):
                diff = 1 - p_me[n(my_history[i-1]), n(opp_history[i])]
                error_me += diff * diff
                diff = 1 - p_opp[n(opp_history[i-1]), n(opp_history[i])]
                error_opp += diff * diff

        if error_me < error_opp:
                p = p_me[n(my_history[-1]),:]
        else:
                p = p_opp[n(opp_history[-1]),:]


# From here, right now I weight values, though not 100% is the best idea, I leave the alternative in case I'd feel like changing it
        value = [(p[2]*my_loaded[0] - p[1]*opp_loaded[1], "R"), (p[0]*my_loaded[1] - p[2]*opp_loaded[2], "P"), (p[1]*my_loaded[2] - p[0]*opp_loaded[0], "S")]
        value.sort()

        if value[-1][0] > value[-2][0]:
                return value[-1][1]
        elif value[-1][0] > value[-3][0]:
                return random.choice([value[-1][1], value[-2][1]])
        else:
                return random.choice(RPS)

#       idx = p.tolist().index(max(p))
#       return ["P", "S", "R"][idx]

এখানে দুটি পুরানো কোড রয়েছে

প্যাটার্ন (আর খেলছে না)

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

import random
import numpy as np
def patternfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        if len(opp_history) == 0:
                return random.choice(["R","P","S"])
        elif len(opp_history) == 1:
                if opp_history == "R":
                        return "P"
                elif opp_history == "P":
                        return "S"
                elif opp_history == "S":
                        return "R"

        p = np.array([1/3]*3)
        c = opp_history[-1]
        for i in range(1, len(opp_history)):
                c0 = opp_history[i-1]
                c1 = opp_history[i]
                if c0 == c:
                        p *= .9
                        if c1 == "R":
                                p[0] += .1
                        elif c1 == "P":
                                p[1] += .1
                        elif c1 == "S":
                                p[2] += .1

        idx = p.tolist().index(max(p))
        return ["P", "S", "R"][idx]

অর্থনীতিবিদ (আর খেলছেন না)

ইকোনমিস্ট নিম্নলিখিতটি করেন: প্রতিপক্ষের প্রতিটি নাটকটির সম্ভাবনা অনুমান করে যে তিনি শেষ 9 টার্নটি কী খেলেন watching এর থেকে, প্রতিটি নাটকের প্রত্যাশিত সুবিধার গণনা করে এবং সেরা প্রত্যাশিত মানটির সাথে চলে।

import random
def economistfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        if len(opp_history) == 0:
                return random.choice(["R","P","S"])
        if len(opp_history) > 9:
                opp_history = opp_history[-10:-1]
        p = [opp_history.count("R"), opp_history.count("P"), opp_history.count("S")]

        value = [(p[2]*my_loaded[0] - p[1]*opp_loaded[1], "R"), (p[0]*my_loaded[1] - p[2]*opp_loaded[2], "P"), (p[1]*my_loaded[2] - p[0]*opp_loaded[0], "S")]
        value.sort()

        if value[-1][0] > value[-2][0]:
                return value[-1][1]
        elif value[-1][0] > value[-3][0]:
                return random.choice([value[-1][1], value[-2][1]])
        else:
                return random.choice(["R","P","S"])
— Masclins
সূত্র
4

Yggdrasil এর

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

def yggdrasil(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    cache = {}
    def get(turn, ml, ol):
        key = str(turn) + str(ml) + str(ol)
        if not key in cache:
            cache[key] = State(turn, ml, ol)
        return cache[key]

    def wrand(opts):
        total = sum(abs(w) for c,w in opts.items())
        while True:
            r = random.uniform(0, total)
            for c, w in opts.items():
                r -= abs(w)
                if r < 0:
                    return c
            print("error",total,r)

    class State():
        turn = 0
        ml = [1,1,1]
        ol = [1,1,1]
        val = 0
        strat = [1/3, 1/3, 1/3]
        depth = -1
        R = 0
        P = 1
        S = 2
        eps = 0.0001
        maxturn = 1000

        def __init__(self, turn, ml, ol):
            self.turn = turn
            self.ml = ml
            self.ol = ol
        def calcval(self, depth):
            if depth <= self.depth:
                return self.val
            if turn >= 1000:
                return 0
            a = 0
            b = -self.ol[P]
            c = self.ml[R]
            d = self.ml[P]
            e = 0
            f = -self.ol[S]
            g = -self.ol[R]
            h = self.ml[S]
            i = 0
            if depth > 0:
                a += get(self.turn+1,[self.ml[R]+1,self.ml[P],self.ml[S]],[self.ol[R]+1,self.ol[P],self.ol[S]]).calcval(depth-1)
                b += get(self.turn+1,[self.ml[R]+2,self.ml[P],self.ml[S]],[self.ol[R],self.ol[P],self.ol[S]]).calcval(depth-1)
                c += get(self.turn+1,[self.ml[R],self.ml[P],self.ml[S]],[self.ol[R],self.ol[P],self.ol[S]+2]).calcval(depth-1)
                d += get(self.turn+1,[self.ml[R],self.ml[P],self.ml[S]],[self.ol[R]+2,self.ol[P],self.ol[S]]).calcval(depth-1)
                e += get(self.turn+1,[self.ml[R],self.ml[P]+1,self.ml[S]],[self.ol[R],self.ol[P]+1,self.ol[S]]).calcval(depth-1)
                f += get(self.turn+1,[self.ml[R],self.ml[P]+2,self.ml[S]],[self.ol[R],self.ol[P],self.ol[S]]).calcval(depth-1)
                g += get(self.turn+1,[self.ml[R],self.ml[P],self.ml[S]+2],[self.ol[R],self.ol[P],self.ol[S]]).calcval(depth-1)
                h += get(self.turn+1,[self.ml[R],self.ml[P],self.ml[S]],[self.ol[R],self.ol[P]+2,self.ol[S]]).calcval(depth-1)
                i += get(self.turn+1,[self.ml[R],self.ml[P],self.ml[S]+1],[self.ol[R],self.ol[P],self.ol[S]+1]).calcval(depth-1)
            self.val = -9223372036854775808
            for pr in range(0,7):
                for pp in range(0,7-pr):
                    ps = 6-pr-pp
                    thisval = min([pr*a+pp*d+ps*g,pr*b+pp*e+ps*h,pr*c+pp*f+ps*i])
                    if thisval > self.val:
                        self.strat = [pr,pp,ps]
                        self.val = thisval
            self.val /= 6


            if depth == 0:
                self.val *= min(self.val, self.maxturn - self.turn)
            return self.val

    turn = len(my_history)
    teststate = get(turn, [x * 2 for x in my_loaded], [x * 2 for x in opp_loaded])
    teststate.calcval(1)
    return wrand({"R":teststate.strat[R],"P":teststate.strat[P],"S":teststate.strat[S]})
— PhiNotPi
সূত্র
দয়া করে এমন মন্তব্যগুলি সরিয়ে ফেলুন যা কোডটি আরও বোধগম্য করে না
— প্রদর্শনীর নাম
@ সার্জবর্চ সম্পন্ন করেছেন
— ফিনটটপি
1
@ ফিলনটপিআই আমি জানি যে আমি কোনও সময়সীমাবদ্ধতা পোস্ট করি নি, তবে ইগড্রেসিল প্রতিটি প্রতিপক্ষের বিরুদ্ধে এক মিনিটেরও বেশি সময় নিচ্ছেন। এটাকে কি একটু অপ্টিমাইজ করা সম্ভব হবে?
— মাসক্লিনস
হ্যাঁ এটি অসহনীয়ভাবে ধীর
— প্রদর্শন নামটি
প্রতিপক্ষের প্রতি মিনিটে অ্যালবার্টম্যাসক্লানস বলতে কি আপনার প্রতিপক্ষের বিরুদ্ধে সমস্ত গেমের জন্য মোট 1 মিনিট মানে? এছাড়াও আমি এটির গতি বাড়ানোর চেষ্টা করতে পারি তবে এটি কীভাবে করা যায় তা আমি সত্যিই জানি না, এটি কেবল 1 টি এগিয়ে যাওয়ার মতো দেখায়।
— ফিনোটপিআই
4

এন্টি-কারক

from random import choice
def Antirepeaterfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    s = opp_history.count("S")
    r = opp_history.count("R")
    p = opp_history.count("P")

    if s>p and s>r:
        return "R"
    elif p>s and p>r:
        return "S"
    else:
        return "P"

প্রথম টার্নে কাগজ বাছাই করে, তারপরে এটি প্রতিপক্ষের সবচেয়ে বেশি যেটি মারবে তা ফেরত দেয়, টাইয়ের ক্ষেত্রে কাগজ বাছাই করে।

copycat

import random
def copycatfunc(I,dont,care,about,these,enmoves):
    if not enmoves:
        return random.choice(["R","P","S"])
    else:
        return enmoves[len(enmoves)-1]

কেবল বিরোধীদের শেষ পদক্ষেপের অনুলিপি করুন।

এন্টি-এন্টি-লোলুপ

from random import choice
def antiantigreedy(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    if opp_loaded[0] > opp_loaded[1] and opp_loaded[0] > opp_loaded[2]:
        return "S"
    if opp_loaded[1] > opp_loaded[0] and opp_loaded[1] > opp_loaded[2]:
        return "R"
    if opp_loaded[2] > opp_loaded[0] and opp_loaded[2] > opp_loaded[1]:
        return "P"
    else:
        return choice(["R","P","S"])

প্রতিপক্ষের সবচেয়ে ভারী ওজনযুক্ত পছন্দে যা হারায় তা বেছে নিন।

কিছুটা ক্ষুধার্ত

from random import choice
def somewhathungryfunc(blah, blah2, load, blah3, blah4, blah5):
    if load[0] > load[1] and load[0] < load[2] or load[0] < load[1] and load[0] > load[2]:
        return "R"
    if load[1] > load[0] and load[1] < load[2] or load[1] < load[0] and load[1] > load[2]:
        return "P"
    if load[2] > load[1] and load[2] < load[0] or load[2] < load[1] and load[2] > load[0]:
        return "S"
    else:
        return choice(["R","P","S"])
— গ্রিফন
সূত্র
3

বার্তাবহ

Def থিমসেন্টফ্যাঙ্ক (আমি, না, প্রয়োজন, এগুলি, যুক্তিগুলি): "পি" ফিরিয়ে দিন

সঙ্গীত তারকা

Def Rockstarfunc (আমি, না, প্রয়োজন, এগুলি, যুক্তিগুলি): "আর" ফিরে আসুন

গুপ্তঘাতক

ডিফ ক্যারিনফুনক (আমি, এইগুলি দরকার, এর দরকার নেই): ফিরে এস "এস"

ব্যাখ্যা

এখন, আপনি ভাবতে পারেন যে এই বটগুলি সম্পূর্ণ বোকা।

পুরোপুরি সত্য নয়, এগুলি আসলে ধারণার উপর ভিত্তি করে, একটি বিশাল বোনাস সংগ্রহ করার, এবং শত্রু একটি মিসটপ তৈরি করে এবং এটির সাথে প্রাচীরযুক্ত হয়ে যায়।

এখন, এই বটগুলি লোভীদের সাথে খুব একইভাবে খেলছে, তবে এগুলি সহজ and

আরেকটি বিষয় লক্ষণীয়: এরা প্রতিটি সময় অর্ধেক সময় ধরে লোভকে মারবে, সময়ের তৃতীয়াংশ আঁকবে এবং সময়ের ষষ্ঠটি হারাবে। যখন তারা জিতবে, তখন তাদের অনেকটা জয়ের ঝোঁক থাকবে। কেন?

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

লোভী ধরে নিলে সর্বদা দুর্দান্ত সুযোগের মাধ্যমে বিজয়ী অস্ত্র বেছে নেওয়া হয় না, এর অর্থ হ'ল সম্ভাবনাগুলি হ'ল:

1/3: {1/2 জয় (মোট 1/3)) ১/২ হারা (মোট ১/6) }

1/3 ড্র

২/৩ জয়

সুতরাং: আঁকার 1/3 সুযোগ, হেরার 1/6 সুযোগ, জয়ের 1/2 সুযোগ।

এটি সম্ভবত দেখায় যে আপনার একাধিক রাউন্ডের একাধিক গেমগুলি করা দরকার

এগুলি মূলত চ্যালেঞ্জের রোলিং পেতে

— ধ্বংসাত্মক লেবু
সূত্র
3

পারমাণবিক চুল্লী

এমন নাটক তৈরি করে যা আগের রাউন্ডে জিতত।

import random
def reactfunc(I, dont, need, all, these, opp_history):
    if not opp_history:
        return random.choice(["R","P","S"])
    else:
        prev=opp_history[len(opp_history)-1]
        if prev == "R":
            return "P"
        if prev == "P":
            return "S"
        else:
            return "R"
— KSmarts
সূত্র
1
আপনি প্রতিস্থাপন করতে পারেন opp_history[len(opp_history)-1]সঙ্গে opp_history[-1]।
— ক্যালকুলেটরফলাইনে
3

আর্টসি চাইল্ড

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

import random
def artsychildfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    if len(opp_history) == 0:
            return "P"
    elif opp_history[-1] == "R":
            return "R"
    elif my_history[-1] != "P":
            return "P"
    else:
            return random.choice(["P", "S"])
— TitusLucretius
সূত্র
2

আমি পরীক্ষার জন্য যে তিনটি বট তৈরি করেছি তা এখানে:

RandomBot

import random
def randombotfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        return random.choice(["R","P","S"])

লোভী

কেবল তার সর্বাধিক লোড করা বিকল্পটি চয়ন করে।

import random
def greedyfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        if my_loaded[0] > my_loaded[1]:
                if my_loaded[0] > my_loaded[2]:
                        return "R"
                elif my_loaded[0] < my_loaded[2]:
                        return "S"
                else:
                        return random.choice(["R","S"])
        elif my_loaded[0] < my_loaded[1]:
                if my_loaded[1] > my_loaded[2]:
                        return "P"
                elif my_loaded[1] < my_loaded[2]:
                        return "S"
                else:
                        return random.choice(["P","S"])
        else:
                if my_loaded[0] > my_loaded[2]:
                        return random.choice(["R","P"])
                elif my_loaded[0] < my_loaded[2]:
                        return "S"
                else:
                        return random.choice(["R","P","S"])

Antigreedy

ধরে নিন প্রতিপক্ষ লোভী খেলবে এবং বিজয়ী বিকল্প খেলবে।

import random
def antigreedyfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
        if opp_loaded[0] > opp_loaded[1]:
                if opp_loaded[0] > opp_loaded[2]:
                        return "P"
                elif opp_loaded[0] < opp_loaded[2]:
                        return "R"
                else:
                        return "R"
        elif opp_loaded[0] < opp_loaded[1]:
                if opp_loaded[1] > opp_loaded[2]:
                        return "S"
                elif opp_loaded[1] < opp_loaded[2]:
                        return "R"
                else:
                        return "S"
        else:
                if opp_loaded[0] > opp_loaded[2]:
                        return "P"
                elif opp_loaded[0] < opp_loaded[2]:
                        return "R"
                else:
                        return random.choice(["R","P","S"])
— Masclins
সূত্র
1

ক্ষুধার্ত নয়

def nothungryfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    if my_loaded[0] < my_loaded[1]:
            if my_loaded[0] < my_loaded[2]:
                    return "R"
            elif my_loaded[0] > my_loaded[2]:
                    return "S"
            else:
                    return random.choice(["R","S"])
    elif my_loaded[0] > my_loaded[1]:
            if my_loaded[1] < my_loaded[2]:
                    return "P"
            elif my_loaded[1] > my_loaded[2]:
                    return "S"
            else:
                    return random.choice(["P","S"])
    else:
            if my_loaded[0] < my_loaded[2]:
                    return random.choice(["R","P"])
            elif my_loaded[0] > my_loaded[2]:
                    return "S"
            else:
                    return random.choice(["R","P","S"])

এটি আক্ষরিক অর্থে লোভী, এটি উপলব্ধ সর্বনিম্ন পয়েন্ট বিকল্প চয়ন করে choo

— টিল পেলিক্যান
সূত্র
1

প্রতিপক্ষের প্রিয় ব্যবহার করুন

from collections import Counter
import random
def useopponents(hi, my, name, is, stephen, opp_history):
  if opp_history:
    data = Counter(opp_history)
    return data.most_common(1)[0][0]
  else:
    return random.choice(["R","P","S"])

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

// আমি এখান থেকে কোড চুরি করেছি

জিতাই ভাল

import random
def goodwinning(no, yes, maybe, so, my_history, opp_history):
  if opp_history:
    me = my_history[len(my_history)-1]
    you = opp_history[len(opp_history)-1]
    if you == me:
      return goodwinning(no, yes, maybe, so, my_history[:-1], opp_history[:-1])
    else:
      if me == "R":
        if you == "P":
          return "P"
        else:
          return "R"
      elif me == "P":
        if you == "S":
          return "S"
        else:
          return "R"
      else:
        if you == "R":
          return "R"
        else:
          return "P"
  else:
    return random.choice(["R","P","S"])

আগের রাউন্ডের বিজয়ীর পছন্দটি ফেরত দেয়। পূর্ববর্তী রাউন্ডটি যদি টাই হয় তবে পুনরাবৃত্তভাবে তার আগে রাউন্ডটি পরীক্ষা করে। যদি এটি কেবল বন্ধন হয়, বা এটি প্রথম রাউন্ড হয়, এলোমেলো পছন্দ দেয়।

— স্টিফেন
সূত্র
1

দুই ভুবনের সেরা

এই বটটি মূলত অ্যান্টি-লোভী এবং লোভীর (সুতরাং নাম) একত্রিত করে।

def bobwfunc(a, b, my_loaded, opp_loaded, c, d):
    opp_max = max(opp_loaded)
    opp_play = "PSR"[opp_loaded.index(opp_max)]

    my_max = max(my_loaded)
    my_play = "RPS"[my_loaded.index(my_max)]

    if opp_play == my_play:
        return opp_play
    else:
        return my_play if opp_max < my_max else opp_play
— clismique
সূত্র
এটি এন্টিগ্রেডি, উদাহরণ হিসাবে ইতিমধ্যে পোস্ট করা।
— মাসক্লিনস
অ্যালবার্টম্যাসক্লানস এটির অন্য একটি বোটে পরিবর্তন করেছে।
— ক্লিমেজিক
findস্ট্রিং জন্য হয়। my_loadedএবং opp_loadedউভয় তালিকা। indexআপনি যা চান তার জন্য ভাল হওয়া উচিত
— মাসক্লিনস
অ্যালবার্টম্যাসক্লানস ওফস, এখনই ঠিক করা হয়েছে। ধরার জন্য ধন্যবাদ! আমি আশা করি এটি আর কোনও দ্বিধা নয় ... আমি আর এই পোস্টটি মুছতে চাই না।
— ক্লিমেজিক
এটি ঠিক আছে, খেলার জন্য ধন্যবাদ
— মাসক্লিনস 25:57
1

NashBot

import random
def nashbotfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    r = opp_loaded[0] * opp_loaded[2]
    p = opp_loaded[0] * opp_loaded[1]
    s = opp_loaded[1] * opp_loaded[2]
    q = random.uniform(0, r + p + s) - r
    return "R" if q < 0 else "P" if q < p else "S"

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

— নিল
সূত্র
1

Expectedbayes

সম্পাদনা করুন: আপডেট করা র‌্যাঙ্কিং

এক্সপেক্টবেডেস অন্তর্ভুক্তির পরে এটিই নতুন শীর্ষ র‌্যাঙ্কিং:

  • পরিসংখ্যানবিদ 2func 91.89%
  • ফিটারফ্যাঙ্ক 85.65%
  • ন্যাশফঙ্ক 80.40%
  • ওয়েইগারফুঙ্ক 76.39%
  • প্রত্যাশিত বেইসফুঙ্ক .3৩.৩৩%
  • anterypeaterfunc 68.52%
  • ...

ব্যাখ্যা

(এনবি: পোস্ট 05/06/2017 জমা)

এই বটটি এর পরবর্তী পদক্ষেপের প্রত্যাশিত মানটিকে আরও বেশি করে চেষ্টা করে:

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

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

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

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

আমি 100 টার্ন এবং কেবলমাত্র সীমিত সংখ্যক বট দিয়ে একটি চটজলদি চেষ্টা করেছি এবং ফলাফল_স্ট্যান্ডিং থেকে আমি এটি পেয়েছি:

  • randombotfunc 35
  • nashbotfunc, 333
  • greedyfunc, 172
  • antigreedyfunc, 491
  • themessengerfunc, 298
  • rockstarfunc, 200
  • statistician2func, 748
  • fitterfunc, 656
  • expectedbayesfunc, 601

কোনটা খারাপ না!

from sklearn.naive_bayes import MultinomialNB
import random

#Number of past moves used to compute the probability of next move
#I did not really try to make such thing as a cross-validation, so this number is purely random
n_data = 10

#Some useful data structures
choices = ['R','P','S']
choices_dic = {'R':0,'P':1,'S':2}
point_dic = {(0,0):0,(1,1):0,(2,2):0, #Same choices
             (0,1):-1,(0,2):1, #me = rock
             (1,0):1,(1,2):-1, #me = paper
             (2,0):-1,(2,1):1} #me = scissor

def compute_points(my_choice,opp_choice,my_load,opp_load):
    """
    Compute points
    @param my_choice My move as an integer
    @param opp_choice Opponent choice as an integer
    @param my_load my_load array
    @param opp_load opp_load array
    @return A signed integer (+ = points earned, - = points losed)
    """
    points = point_dic[(my_choice,opp_choice)] #Get -1, 0 or 1
    if points > 0:
        return points*my_load[my_choice] 
    else:
        return points*opp_load[opp_choice]

#This use to be a decision tree, before I changed it to something else. Nevertheless, I kept the name
class Decision_tree:
    def __init__(self):
        self.dataX = []
        self.dataY = []
        self.clf = MultinomialNB()

    def decide(self,my_load,opp_load,my_history,opp_history):
        """
        Returns the decision as an integer

        Done through a try (if a prediction could be made) except (if not possible)
        """
        try:
            #Let's try to predict the next move
            my_h = list(map(lambda x: choices_dic[x],my_history[-n_data:-1]))
            opp_h = list(map(lambda x: choices_dic[x],opp_history[-n_data:-1]))
            pred = self.clf.predict_proba([my_h+opp_h])
            #We create a points array where keys are the available choices
            pts = []
            for i in range(3):
                #We compute the expected gain/loss for each choice
                tmp = 0
                for j in range(3):
                    tmp += compute_points(i,j,my_load,opp_load)*pred[0][j]
                pts.append(tmp)
            return pts.index(max(pts)) #We return key for the highest expected value
        except:
            return random.choice(range(3))

    def append_data(self,my_history,opp_history):
        if my_history == "":
            self.clf = MultinomialNB()
        elif len(my_history) < n_data:
            pass
        else:
            my_h = list(map(lambda x: choices_dic[x],my_history[-n_data:-1]))
            opp_h = list(map(lambda x: choices_dic[x],opp_history[-n_data:-1]))
            self.dataX = self.dataX + [my_h+opp_h]
            self.dataY = self.dataY + [choices_dic[opp_history[-1:]]]

            if len(self.dataX) >= 10:
                self.clf.partial_fit(self.dataX,self.dataY,classes=[0,1,2])

                self.dataX = []
                self.dataY = []


#Once again, this is not actually a decision tree
dt = Decision_tree()

#There we go:
def expectedbayesfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    dt.append_data(my_history,opp_history)
    choice = choices[dt.decide(my_loaded,opp_loaded,my_history,opp_history)]
    return choice
— lesibius
সূত্র
পিপিসিজিতে স্বাগতম, এবং প্রথম প্রথম পোস্ট!
— জাকারি
অনেক ধন্যবাদ! আমি দীর্ঘদিন ধরে পিপিসিজিতে অংশ নিতে চেয়েছিলাম। এখন এটি স্থির!
— লেসবিয়াস
0

সাইকেল-আরোহী

def cycler(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    return "RPS"[len(myhistory)%3]

0

— CalculatorFeline
সূত্র
0

আঁসাঁব্ল

from random import *
def f(I):
    if I==0:return "R"
    if I==1:return "P"
    return "S"
def b(I):
    if I=="R":return 0
    if I=="P":return 1
    return 2
def Ensemble(mp,op,ml,ol,mh,oh):
    A=[0]*3
    B=[0]*3
    if(len(oh)):
        k=b(oh[-1])
        A[k-2]+=0.84
        A[k]+=0.29
        for x in range(len(oh)):
            g=b(oh[x])
            B[g-2]+=0.82
            B[g]+=0.22
        s=sum(B)
        for x in range(len(B)):
            A[x]+=(B[x]*1.04/s)
        r=max(A)
    else:
        r=randint(0,3)
    return f(r)

বেশ কয়েকটি প্রতিযোগিতামূলক অ্যালগরিদম সেরা সমাধানটিতে ভোট দেয়।

বিনিময়

from random import *
def f(I):
    if I==0:return "R"
    if I==1:return "P"
    return "S"
def b(I):
    if I=="R":return 0
    if I=="P":return 1
    return 2
def Swap(mp,op,ml,ol,mh,oh):
    A=[0]*3
    B=[0]*3
    if(len(mh)):
        r=(b(mh[-1])+randint(1,2))%3
    else:
        r=randint(0,3)
    return f(r)

একটি এলোমেলো পদক্ষেপ করে তবে শেষ চালনাটি পুনরাবৃত্তি না করে এটি করে।

— ম্যাজেন্টা রঙ্
সূত্র
0

blodsocer

socery

আমি এটি একটি স্থির দিয়েছি, তাই সম্ভবত এটি এখন কাজ করা উচিত আশা করি

আমি আবার কিছু গণ্ডগোল করেছি তাই আমি মুছে ফেলেছি এবং মুছে ফেলেছি। আমি অনেক গণ্ডগোল করছি।

def blodsocerfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    import random
    # tuned up an ready to go hopeful
    # s o c e r y
    if len(my_history) > 40 and len(set(opp_history[-30:])) == 1:
        if opp_history[-1] == "S":
            return "R"
        elif opp_history[-1] == "R":
            return "P"
        else:
            return "S"
        # against confused bots that only do one thing most of the time.
    elif len(my_history)>30 and min(opp_history.count(i) for i in "RPS")/max(opp_history.count(i) for i in "RPS") >0.8:
        return "RPS"[my_loaded.index(max(my_loaded))] # This is so if the other bot is acting errratic
                                                      # the max bonus is used for advantage
    elif len(my_history) < 10:
        if len(my_history) > 2 and all(i == "S" for i in opp_history[1:]):
            if len(my_history) > 5: return "S"
            return "P"
        return "S" # Be careful, because scissors are SHARP
    elif len(set(opp_history[1:10])) == 1 and len(my_history) < 20:
        if opp_history[1] == "S":
            return "R"
        elif opp_history[1] == "R":
            return "R"
        else:
            return "P"
    elif len(opp_history) -  max(opp_history.count(i) for i in "RPS") < 4 and len(my_history) < 30:
        if opp_history.count("R") > max(opp_history.count(i) for i in "PS"):
            return "P"
        if opp_history.count("P") > max(opp_history.count(i) for i in "RS"):
            return "S"
        if opp_history.count("S") > max(opp_history.count(i) for i in "RP"):
            return "R"
    elif len(my_history) < 15:
        if max(opp_loaded)<max(my_loaded):
            return "RPS"[len(my_history)%3]
        else:
            return "RPS"[(my_loaded.index(max(my_loaded))+len(my_history)%2)%3]
    elif len(my_history) == 15:
        if max(opp_loaded)<max(my_loaded):
            return "RPS"[(len(my_history)+1)%3]
        else:
            return "RPS"[(my_loaded.index(max(my_loaded))+ (len(my_history)%2)^1)%3]
    else:
        if max(opp_loaded)<max(my_loaded):
            return random.choice("RPS")
        else:
            return "RPS"[(my_loaded.index(max(my_loaded))+ (random.randint(0,1)))%3]
— ধ্বংসাত্মক লেবু
সূত্র
1
if opp_history[1] == "S": return "R" elif opp_history[1] == "R": return "R" else: return "P" এটা কি ধরণের প্রসন্নতা?
— রবার্ট ফ্রেজার
এই টুইটটি 0 দ্বারা বিভাজন: elif min(opp_history.count(i) for i in "RPS")/max(opp_history.count(i) for i in "RPS") >0.8 and len(my_history)>30:
— মাসক্লিনস
@ অ্যালবার্টম্যাসক্লান্স আমি এটি স্থির করেছি।
— ধ্বংসাত্মক লেবু
পছন্দ করেছেন
— ধ্বংসাত্মক লেবু
আপনি এখানে কি করতে চান তা আমি সম্পূর্ণরূপে নিশ্চিত নই: "RPS"[my_loaded.index(max(my_loaded))+len(my_history)%2]তবে এটি সীমার বাইরে দেখা যাচ্ছে না (এবং আরও লাইনগুলি হবে)।
— মাসক্লিনস
0

ভারী র্যান্ডম

র‌্যান্ডমবটের মতো, তবে প্রতিবার যখন এটি চাওয়া হয় তখন ফেলে দেওয়ার জন্য এটি কেবল 2 টি করে। কখনও কখনও রকস্টার বা অ্যাসাসিনকে পরাজিত করবে, তবে অন্য একটির সংখ্যা বাড়িয়ে তুলবে (উদাহরণস্বরূপ, যদি এটি রকস্টারকে পরাজিত করে তবে এটি আসসিনকে একটি পয়েন্ট বাড়িয়ে তোলে)।

import random

selection_set = ["R", "P", "S"]
selection_set.pop(random.randint(0,2))
def weightedrandombotfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    return random.choice(selection_set)
— অ্যান্ড্রু ইউ বাকের
সূত্র
0

লোভী মনোবিজ্ঞানী

নামকরণ করা হয়েছে কারণ এটি লোভীদের কাছে খেলাপি, কিন্তু যদি এটি সিদ্ধান্ত নিতে না পারে তবে তারা যদি লোভী কৌশলটি ব্যবহার করে তবে প্রতিপক্ষের যা কিছু করবে তা মোকাবেলা করে। এটি এখনও সিদ্ধান্ত নিতে না পারলে এলোমেলোভাবে যায়।

from random import choice

def greedypsychologistfunc(my_points, opp_points, my_loaded, opp_loaded, my_history, opp_history):
    greedy = get_my_move(my_loaded)
    combined = list(set(greedy) & set(get_opp_counter(opp_loaded)))

    if len(combined) == 0:
        return choice(greedy)
    return choice(combined)

def get_indexes(lst, value):
    return [i for i,x in enumerate(lst) if x == value]

def get_my_move(my_loaded):
    return ["RPS"[i] for i in get_indexes(my_loaded, max(my_loaded))]

def get_opp_counter(opp_loaded):
    return ["PSR"[i] for i in get_indexes(opp_loaded, max(opp_loaded))]
— সলোমন উকো
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.