সৎ রক, কাগজ, কাঁচি


58

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

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

একটি জয়ের মূল্য দুটি পয়েন্ট, একটি ড্র, একটি পয়েন্ট এবং ক্ষতি 0 পয়েন্ট।

     Honest Bot       Dishonest
Win     3                  2
Draw    2                  1
Loss    1                  0

সত্যনিষ্ঠ হওয়া আপনার পক্ষে সবচেয়ে বেশি আগ্রহী (তবে আপনার প্রতিপক্ষ আপনাকে বিশ্বাস করে না তা নিশ্চিত করে তোলা)।

ম্যাচগুলি একটি রাউন্ড রবিন ফর্ম্যাটে খেলবে এবং উদ্দেশ্যটি হ'ল আপনি খেলানো ম্যাচগুলিতে আপনার নিজের মোট স্কোরকে সর্বাধিক করে তোলা।

I / O ফর্ম্যাট:

  • আপনার বটটি একটি পাইথন 2.7 ফাংশন হবে যা 4 টি আর্গুমেন্ট গ্রহণ করে এবং এর একটি অনন্য নাম থাকতে হবে (যা আপনার জমা দেওয়ার উপস্থাপনের জন্য ব্যবহৃত হবে)।
  • প্রথম দুটি যুক্তি সর্বদা যথাযথভাবে থাকবে: প্রতিপক্ষের অতীত চলনগুলি, তারপরে আপনার অতীত চলনগুলি। এগুলি প্রথম থেকে সাম্প্রতিক রাউন্ডের ক্রম অনুসারে একটি তালিকা থাকবে, প্রতি সূচকের সাথে তালিকার একটি তালিকা থাকবে প্রতিপক্ষের দাবি অনুযায়ী তারা যে পদক্ষেপ নেবে, তারপরে তারা বাস্তবে যে পদক্ষেপ নেবে।
  • পরবর্তী দুটি যুক্তি আপনার বটকে এটি নির্ধারণ করতে দেয় যে এটি "সৎ" রাউন্ড বা "আসল" রাউন্ড কিনা। যদি এটি "সৎ" রাউন্ড হয় তবে তারা উভয়ই কোনও হবে না। যদি এটি "সত্যিকারের" গোল হয় তবে তারা তা করবে, যাতে আপনার প্রতিপক্ষ ঘোষিত যে পদক্ষেপটি তারা তৈরি করবে এবং তারপরে আপনি ঘোষণা করেছিলেন যে আপনি কী করবেন would
  • সমস্ত আর্গুমেন্ট বা আর্গুমেন্টগুলির অংশ যা চালকে প্রতিনিধিত্ব করে যথাক্রমে শিলা, কাগজ এবং কাঁচি উপস্থাপন করতে "আর", "পি" এবং "এস" ব্যবহার করবে।
  • আপনার ফাংশনটি রকের জন্য একটি "আর", কাগজের জন্য "পি", বা কাঁচিগুলির জন্য "এস" ফিরবে। যে মানগুলি অন্য মানগুলি ফেরত দেওয়ার ক্ষমতা রাখে তাদের অযোগ্য ঘোষণা করা হবে।
  • প্রতিটি বট প্রতিটি অন্য বটের বিরুদ্ধে 200 বার চালানো হবে এবং 100 বার নিজেই চালানো হবে। গোলটি প্রতিযোগিতা শেষে সর্বাধিক পয়েন্ট সহ বট হওয়া।
  • মন্তব্যে আলোচনার ক্ষেত্রে, জমাগুলি কোনও ফাইল থেকে পড়তে বা লিখতে না পারে, বা কোনও উপায়ে বিরোধী কোডটি নাশকতা বা পড়তে পারে না।

উদাহরণ:

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

def honestpaper(I,dont,care,about_these):
    return "P"

def honestrock(I,dont,care,about_these):
    return "R"

def honestscissors(I,dont,care,about_these):
    return "S"

import random
def randombot(I,dont,care,about_these):
    return random.choice(["R","P","S"])

নিয়ন্ত্রক:

এবং এই নিয়ামকটি আমি ব্যবহার করব। নতুন জমাগুলি শুরুতে আমদানি করা হবে এবং বট_ম্যাপ অভিধানে যুক্ত হবে।

from honestrock import honestrock
from honestpaper import honestpaper
from honestscissors import honestscissors
from randombot import randombot

bot_map = {
  0:honestrock, 1:honestpaper, 2:honestscissors, 3:randombot
}

player_num=len(bot_map)

def real(history1,history2,number,honest1,honest2):
    return bot_map[number](history1,history2,honest1,honest2)

def honest(history1,history2,number):
    return bot_map[number](history1,history2,None,None)

def play_match(num1,num2):
    history1=[]
    history2=[]
    score1=0
    score2=0
    for x in range(250):
        h1=honest(history2,history1,num1)
        h2=honest(history1,history2,num2)
        r1=real(history2,history1,num1,h2,h1)
        r2=real(history1,history2,num2,h1,h2)

        if h1==r1: score1+=1
        if h2==r2: score2+=1

        if r1==r2: score1+=1; score2+=1
        elif r1=="R":
            if r2=="P": score2+=2
            else: score1+=2
        elif r1=="P":
            if r2=="S": score2+=2
            else: score1+=2
        else:
            if r2=="R": score2+=2
            else: score1+=2

        history1.append([h1,r1])
        history2.append([h2,r2])
    return score1,score2

scores = []
for x in range(player_num):
    scores.append(0)

for _ in range(100):

    for x in range(player_num):
        for y in range(player_num):
            scorex,scorey=play_match(x,y)
            scores[x]+=scorex
            scores[y]+=scorey

for score in scores:
    print score

চূড়ান্ত স্কোর:

csbot                    3430397
thompson                 3410414
rlbot                    3340373
have_we_been_here_before 3270133
mason                    3227817
deepthought              3019363
adaptive_bot             2957506
THEbot                   2810535
dontlietome              2752984
irememberhowyoulie       2683508
learningbot4             2678388
betrayal                 2635901
averager                 2593368
honestrandom             2580764
twothirds                2568620
mirrorbot                2539016
tit4tat                  2537981
honestscissors           2486401
trusting_bot             2466662
rotate_scissors          2456069
rotate_paper             2455038
rotate_rock              2454999
honestpaper              2412600
honestrock               2361196
rockBot                  2283604
trustingRandom           2266456
user5957401bot           2250887
randombot                2065943
Dx                       1622238
liarliar                 1532558
everybodylies            1452785

1
কী অবস্থা?
ব্যবহারকারী1502040

উত্তর:


11

রাজমিস্ত্রি

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

def mason(op_hist, my_hist, op_move, my_move):
    win_map = {"R": "P", "P": "S", "S": "R"}
    lose_map = {"R": "S", "P": "R", "S": "P"}
    if not len(op_hist):
        return "S"
    if op_hist[0] == ['S', 'S']:
        code = "S" + "".join("RPS"[ord(i) % 3] if isinstance(i, str) else "RPS"[i % 3] for i in __import__("sys")._getframe().f_code.co_code)[1::2]
        honest, guess = zip(*op_hist)
        if honest == guess == tuple(code[:len(op_hist)]):
            return code[len(op_hist)]
    op_honesty = sum(len(set(round))-1 for round in op_hist) / float(len(op_hist))
    if not my_move:
        moves = "".join(i[1] for i in op_hist)
        # Identify rotators
        if "PSRPSR" in moves:
            return moves[-2]
        # Identify consecutive moves
        if "RRRRR" in moves[:-10] or "SSSSS" in moves[:-10] or "PPPPP" in moves[:-10]:
            return win_map[moves[-1]]
        # Try just what wins against whatever they choose most
        return win_map[max("RPS", key=moves.count)]
    op_beats_my_honest = sum(win_map[me[0]] == op[1] for op, me in zip(op_hist, my_hist)) / float(len(op_hist))
    op_draws_my_honest = sum(me[0] == op[1] for op, me in zip(op_hist, my_hist)) / float(len(op_hist))
    op_loses_my_honest = sum(lose_map[me[0]] == op[1] for op, me in zip(op_hist, my_hist)) / float(len(op_hist))
    if op_honesty <= 0.4:
        return win_map[op_move]
    max_prob = max((op_loses_my_honest, op_draws_my_honest, op_beats_my_honest))
    if max_prob >= 0.6:
        if op_beats_my_honest == max_prob:
            return lose_map[my_move]
        if op_draws_my_honest == max_prob:
            return win_map[my_move]
        if op_loses_my_honest == max_prob:
            return my_move
        assert False
    return my_move

9

Rlbot: পুনর্বহাল শেখা

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

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

import re
def rlbot(hismoves,mymoves,hismove,mymove):
 def score(d,m1,m2):
  s=0
  if m1==m2:
   s=1
  elif (m1+m2) in "RPSR":
   s=2
  return s+(d==m2)

 alpha=0.2
 if mymove:
  history=[([d1,m1],[d2,m2]) for ((d1,m1),(d2,m2)) in zip(hismoves,mymoves) if score(None,hismove,mymove)==score(None,d1,d2)]
  bestscore=-1
  bestmove=""
  for move in "RPS":
   ev=2+(move==mymove)
   for ((d1,m1),(d2,m2)) in history:
    if score(None,move,mymove)==score(None,m2,d2):
     ev=(1-alpha)*ev+alpha*score(d2,m1,m2)
   if ev>bestscore:
    bestscore=ev
    bestmove=move
  return bestmove

 else:
  if len(hismoves)==0:
   return "R"
  bestscore=-1
  bestmove=""
  hisdeclarations="".join(d for [d,m] in hismoves)
  predicted_move=re.search(r'(.*)\n.*\1(.)',hisdeclarations+'\n'+hisdeclarations).group(2)
  history=[([d1,m1],[d2,m2]) for ((d1,m1),(d2,m2)) in zip(hismoves,mymoves) if d1==predicted_move]
  for move in "RPS":
   ev=3
   for (his,my) in history:
    (d1,m1)=his
    (d2,m2)=my
    if d2==move:
     ev=(1-alpha)*ev+alpha*score(d2,m1,m2)
   if ev>bestscore:
    bestscore=ev
    bestmove=move
  return bestmove

এটি অনলাইন চেষ্টা করুন!


6

আমি সত্যিই অজগরটিকে এত বেশি ব্যবহার করি নি তাই আমি নিশ্চিত যে আমি কোথাও ভুল করে ফেলেছি।

import random
def learningbot3(opponentlist,a,opponent,me):
 #tell the other bot a random thing
 if opponent==None:
  return random.choice(["R","P","S"])
 #check whether the other bot has mostly told the truth in the last 10 rounds
 truth=0
 for game in opponentlist[-10:]:
  truth-=1
  if game[0]==game[1]:
   truth+=2
 #assume the other bot will tell the truth
 if truth>=3:
  if me==opponent:
    return me
  elif opponent=="R":
   return "P"
  elif opponent=="P":
   return "S"
  elif opponent=="S":
   return "R"
 #assume the other bot is lying
 elif truth<=-3:
  return random.choice([me,opponent])
  #return opponent
 #pick whatever we said we would
 else:
  return me

প্রতিপক্ষ কতবার মিথ্যা বলেছে তা দেখতে এটি শেষ দশ রাউন্ডটি পরীক্ষা করে দেখা উচিত, তারপরে তার উপর নির্ভর করে একটি ভিন্ন প্রতিক্রিয়া বেছে নিয়েছিল chose


6

এখানে আমার অভিযোজিত বট এটি প্রতিপক্ষের শেষ 2 টি পদক্ষেপ বিশ্লেষণ করে এটি নির্ধারণ করে যে এটি একটি সৎ বট কিনা এবং তদনুসারে খেলে:

সম্পাদনা 1: অন্য বটটি যদি একটি ধ্রুবক বট হয় (যেমন সর্বদা একই অস্ত্র খেলে) এই বটটি বিজয়ী অস্ত্র খেলে এবং একই সাথে সৎ হয়ে তা পিষ্ট করে।

2 সম্পাদনা করুন: ঘূর্ণায়মান বটগুলির সাথেও কাজ করতে উন্নত ধ্রুবক বট ডিটেক্টর।

import random
def adaptive_bot(other_past, my_past, other_next, my_next):
    winners = {"R": "P", "P": "S", "S": "R"}
    if my_next is None:
        return winners[other_past[-6:][0][1]] if other_past else random.choice(list(winners.keys()))
    else:
        is_other_honest = all([other_claim == other_move for other_claim, other_move in other_past[-2:]])
        return winners[other_next] if is_other_honest else my_next

5

csbot

def csbot(ophist,myhist,opdecl,mydecl):

  import random

  RPS = "RPS"

  def value(opd,myd,opmove,mymove):
    if opmove==mymove:
      val = 9
    elif opmove+mymove in RPS+RPS:
      val = 20
    else:
      val = -2
    return val+10*(myd==mymove)-(opd==opmove)

  def best(od,md):
    l = float(len(ophist))
    weights = dict([ (m, random.random()/8) for m in RPS ])
    for n in range(len(ophist)):
      if ophist[n][0]==od and myhist[n][0]==md:
        weights[ophist[n][1]] += 1+4*((n+1)/l)**2
    sw = sum([ weights[m] for m in RPS ])
    bestexpect = 0
    for m in RPS:
      expect = sum([ weights[om]/sw*value(od,md,om,m) for om in RPS ])
      if expect > bestexpect:
        bestexpect = expect
        bestmove = m
    return bestmove, bestexpect


  honest = all ([ decl==mv for decl, mv in ophist ])

  if honest:
    if mydecl<>None:
      return mydecl
    expnxt = set();
    for i in range(len(ophist)-1):
      if ophist[i][0]==ophist[-1][0]:
        expnxt.add(ophist[i+1][0])
    if len(expnxt)==1:
      return RPS[ (RPS.index(expnxt.pop())+1) % 3 ]

  if mydecl==None:
    l = float(len(ophist))
    weights = dict([ (m, random.random()) for m in RPS ])
    for n in range(len(ophist)):
      weights[ophist[n][0]] += 1+((n+1)/l)**2
    sw = sum([ weights[m] for m in RPS ])
    bestexpect = 0
    worstexpect = 99
    for m in RPS:
      expect = sum([ best(od,m)[1]/sw*weights[od] for od in RPS ])
      if expect > bestexpect:
        bestexpect = expect
        bestmove = m
      if expect < worstexpect:
        worstexpect = expect
    if bestexpect-worstexpect < 3:
      bestmove = random.choice(RPS)
    return bestmove

  return best(opdecl,mydecl)[0]

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

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


এটি সর্বদা কোনও ফলাফল ফেরত বলে মনে হয় না।
ব্যবহারকারী1502040

আমার মনে হয় আপনার if mydecl == None:ভুল আছে।
ব্যবহারকারী1502040

@ ব্যবহারকারী1502040 আপনি কেন এমনটি মনে করেন? আমি কখনও কোন সমস্যা পর্যবেক্ষণ করিনি।
খ্রিস্টান সিভর্স


4

বিশ্বাসঘাতকতা

def betrayal(yours, mine, you ,me):
    import random
    if you is None:
        pick = random.choice(['R','P','S'])
    else:
        you = you[0]
        me = me[0]
        if len(yours) < 50: #Build myself a reputation of honesty
            pick = me
        else:
            if len(yours) >= 50 and len(yours) < 100:
                honesty = sum([1 if y[0]==y[1] else 0 for y in yours])/float(len(yours))
                if honesty <= 0.5: #If dishonest try to outwit
                    pick = 'S' if me=='R' else 'R' if me == 'P' else 'P'
                else: #Else just plain cheat
                    pick = 'P' if you=='R' else 'R' if you=='S' else 'S'
            elif len(yours) >= 100: #When dishonest moves outweight honest moves, change tactics...
                honesty = sum([1 if y[0]==y[1] else 0 for y in yours[50:]])/float(len(yours[50:]))
                if honesty <= 0.5: #... and just play according to most likely pick
                    what_did_you_do = [k[1] for k in yours if k[1]!=k[0]]
                    index = [i for i,k in enumerate(yours) if k[1]!=k[0]]
                    what_i_said_i_ll_do = [k[0] for i,k in enumerate(mine) if i in index]
                    matches = zip(what_i_said_i_ll_do, what_did_you_do)
                    what_you_might_answer = [k[1] for k in matches if k[0]==me]
                    table = [len([k for k in what_you_might_answer if k=='R']),len([k for k in what_you_might_answer if k=='P']),len([k for k in what_you_might_answer if k=='S'])]
                    maybe_your_pick = ['R','P','S'][table.index(max(table))]
                    pick = 'P' if maybe_your_pick=='R' else 'R' if maybe_your_pick=='S' else 'S'
                else:
                    pick = 'P' if you=='R' else 'R' if you=='S' else 'S'
    return pick

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


3
import random
def honestrandom(a, b, c, move):
    if move == None:
        return random.choice(["R","P","S"])
    return move

3

বটের নাম: আমি তোমাকে কীভাবে মিথ্যা মনে করি

import random

#Bot Name: I Remember How You Lie
def irememberhowyoulie(opponentlist, mylist, opponentmove, mymove):
    random.seed()

    wintable = {
                "R": {"R": 1, "P": 0, "S": 2},
                "P": {"R": 2, "P": 1, "S": 0},
                "S": {"R": 0, "P": 2, "S": 1}
               }

    winprob = {
               "R": {"R": 0.0, "P": 0.0, "S": 0.0},
               "P": {"R": 0.0, "P": 0.0, "S": 0.0},
               "S": {"R": 0.0, "P": 0.0, "S": 0.0}
              }

    totalprob = {"R": 0, "P": 0, "S": 0}

    # Calculate the probability that the opponent will lie base on the probability that it lied in the last 15 ~ 25 rounds
    # And calculate the probability that what the bot will show next
    picklength = min(random.randint(15, 25), len(opponentlist))
    lying, tempsum = 0, 0.0
    pickedup = {"R": 0, "P": 0, "S": 0}
    if picklength == 0:
        lying = 0.5
    else:
        for eachround in opponentlist[-picklength:]:
            pickedup[eachround[1]] += 1
            if eachround[0] != eachround[1]:
                lying += 1
        lying = lying * 1.0 / picklength
    for s in pickedup:
        pickedup[s] = 1.0 / (1 + pickedup[s])
        tempsum += pickedup[s]

    #Honest Round
    if opponentmove is None and mymove is None:
        a = random.random() * tempsum
        if a < pickedup["R"]:
            return "R"
        elif a < pickedup["R"] + pickedup["P"]:
            return "P"
        else:
            return "S"

    #Real Round
    else:                
        for me in winprob:
            ishonest = 0
            if me == mymove:
                ishonest = 1
            for op in winprob[me]:
                if op == opponentmove:
                    winprob[me][op] = (wintable[me][op] + ishonest) * (1 - lying)
                else:
                    winprob[me][op] = (wintable[me][op] + ishonest) * lying * pickedup[op] / (tempsum - pickedup[opponentmove])
                totalprob[me] += winprob[me][op]

        optimalmove, optimalvalue = "R", -9999999.0
        for me in totalprob:
            if totalprob[me] > optimalvalue:
                optimalmove, optimalvalue = me, totalprob[me]
        return optimalmove

বেশ কয়েকটি 100-রাউন্ড রানের জন্য পরীক্ষিত, এবং দেখা গেছে যে বিজয়ী গড়ে প্রায় 220 রান করে। বরং সৎ আমি মনে করি;)

আমার প্রথমবারের মতো KOTH চ্যালেঞ্জগুলিতে অংশ নেওয়ার জন্য, তাই আমি মনে করি এখনও উন্নতির আরও জায়গা আছে


3

তাত জন্য তৃতীয়

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

import random
def tit4tat(opphist, myhist, oppfut, myfut):
    if (not myfut): return random.choice(['R','P','S'])
    if (not opphist) or opphist[-1][0]==opphist[-1][1]: return myfut
    return random.choice(['R','P','S'])

3

দুই তৃতীয়াংশ

স্যান্ডবক্সে এবং এই মন্তব্যে উল্লিখিত কৌশলটি পিটার টেলর ব্যবহার করে ।

এটি ন্যাশ ভারসাম্য ব্যবহার করে ।

import random

def two_thirds(h_opp, h_me, opp, me):

    def result(opp, me):
        if opp==me: return 0
        if opp=="R" and me=="S" or opp=="S" and me=="P" or opp=="P" and me=="R": return -1
        return 1

    moves = {"R", "P", "S"}
    honest = (opp == None)
    if honest:
        return random.choice(list(moves))
    else:
        res = result(opp, me)
        if res==-1:
            counter = list(moves - {opp, me})[0]
            return random.choice([me,counter,counter])
        if res==1:
            return random.choice([me,me,opp])
        return me

আমার জন্য এই ত্রুটি। 13 লাইনে, এলোমেলো.চয়েস (চালগুলি) ফিরে আসুন। আমি মনে করি এটি সম্ভবত কারণ আপনি একটি অভিধানে পছন্দ করুন। যতক্ষণ না এটি স্থির হয়ে যায়, আমি ভয় করি যে এই জমাটি অবৈধ।
গ্রিফন - মনিকা পুনরায়

@ গ্রিফোন এটি অভিধান নয়, এটি একটি সেট।
লিরিক্যাল

ওহ দুঃখিত. আমি কেবল স্কুইগ্লি-বন্ধনী দেখেছি এবং "অভিধান" ভেবেছি। আমার খারাপ। কোনও ধারণা কেন র্যান্ডম.চয়েস সেই লাইনে ত্রুটি করছে?
গ্রিফন - মনিকা

@ গ্রিফোন মনে হবে যে random.choiceএলোমেলো সূচী নম্বর বাছাই এবং তারপরে সেই সূচীতে তালিকার মধ্যে থাকা বস্তুটি ফিরিয়ে দেওয়ার উপর নির্ভর করে। যেহেতু সেটের কোনও অর্ডার নেই, তারা সূচিকরণও সমর্থন করে না এবং এভাবে কাজ করে না random.choice। এর জন্য একটি সহজ ফিক্স হ'ল কল করার আগে একটি তালিকাতে সেটটি কাস্ট করা random.choice
LyricLy

আহ। এই কম্পিউটারে আমার অজগর নেই, তাই এখনই আমি এটিকে ঠিক করতে পারছি না, তবে আমি বাড়ি এলে আমার কোডে এটি ঠিক করব। @ Mbomb007 যদি এখানে এটি ঠিক করে দেয় তবে তা দুর্দান্ত।
গ্রিফন - মনিকা

3

গভির চিন্তা

def check_not_loose_bot(opHist, myHist):
    not_loose_points = 0
    for i in range(0, len(opHist)):
        if opHist[i][1] == opHist[i][0] or myHist[i][0] == win_map[opHist[i][0]] and opHist[i][1] == win_map[myHist[i][0]]:
            not_loose_points += 1
    not_loose_percent = float(not_loose_points) / len(opHist)
    if not_loose_percent > 0.9:
    #    print("is not willing to loose")
        return True
    return False

def check_trick_bot(opHist, myHist):
    trick_points = 0
    for i in range(0, len(opHist)):
        if opHist[i][1] == win_map[myHist[i][0]]:
            trick_points += 1
    trick_percent = float(trick_points) / len(opHist)
    if trick_percent > 0.9:
  #      print("is tricking me")
        return True
    return False

def check_honest_bot(opHist):
  #  print("check honest")
    honest_points = 0
    for i in range(0, len(opHist)):
        if opHist[i][0] == opHist[i][1] :
            honest_points += 1
    honest_percent = float(honest_points) / len(opHist)
    if honest_percent > 0.9:
    #    print("is honest")
        return True
    return False

def check_self_match(opHist, myHist):
    for i in range(0, len(myHist)):
        if opHist[i][0] != myHist[i][0]:
            # im not playing against myself, because the other one was claiming a different value than i did
#            print("differ: "+str(opHist)+", "+str(myHist))
            return False
        if opHist[i][1] != opHist[i][0]:
#            print("lie")
            # im not playing against myself, because the other bot wasn't honest (and i'm always honest as long as i think i play against myself)
            return False
    return True

def check_equal(move1, move2, fullCheck): # WARNING: FOR COMPABILITY THIS IS RETURNING NEQ INSTEAD OF EQ
    if fullCheck:
        return move1 != move2
    else:
        return move1[0] != move2[0] #only check claims

def is_pattern(opHist, pattern_start, prob_pattern_start, pattern_length, full_check):
    for i in range(0, pattern_length-1):
        if check_equal(opHist[pattern_start + i] , opHist[prob_pattern_start + i], full_check):
            return False
    return True

win_map = {"R": "P", "P": "S", "S": "R"}
def deterministic_best_guess(opHist, full_check = True):
    size = 0
    random_result = random.choice(["R", "P", "S"])
    for pattern_length in range(2, (len(opHist)+1)/2): #a pattern has to occur at least twice
        for pattern_start in range(0, len(opHist) - 2 * pattern_length):
            if not is_pattern(opHist, pattern_start, len(opHist) - pattern_length + 1, pattern_length, full_check):
                 continue
            is_repeated = False
            is_fooled = False
            for repeated_pattern_start in range(pattern_start + pattern_length, len(opHist) - pattern_length):
                if not is_pattern(opHist, pattern_start, repeated_pattern_start, pattern_length, full_check):
                     continue
                is_repeated = True
                if check_equal(opHist[pattern_start + pattern_length - 1], opHist[repeated_pattern_start + pattern_length - 1], full_check):
                    is_fooled = True
                    break
    #            print("pattern found: " + str(opHist[pattern_start : pattern_start + pattern_length]) +" at "+str(pattern_start)+" and "+str(repeated_pattern_start))
   #             print("check: "+str(opHist))
            if is_fooled or not is_repeated:
                break
            #we have found a deterministic best guess
  #          print("most likely next step: "+ str(opHist[pattern_start + pattern_length - 1]))
            if full_check:
                return win_map[opHist[pattern_start + pattern_length - 1][1]], True
            return win_map[opHist[pattern_start + pattern_length - 1][0]], True # if we don't have a full check, the pattern only applies to claims. So pretend to win against the claimed result.

    #fallback
 #   print("fallback")
    return random_result, False

def DeepThought(opHist, myHist, opMove, myMove):
    if opMove == None:
    #claiming phase
        if len(myHist) == 0:
        #seed random to be able to be deterministic when chosing randomly
            #The seed is secret (kind of)
            random.seed(133427)
        else:
            #seed random according to my previous claims
            seed = 133427
            for i in range(0, len(myHist)):
                if myHist[i][0] == "R":
                    seed = seed*3+1
                elif myHist[i][0] == "S":
                    seed = seed*7+1
                elif myHist[i][0] == "P":
                    seed = seed*11+1
                while seed%2 == 0:
                    seed /= 2
            random.seed(seed)
        if check_self_match(opHist, myHist):
            #claim a random value, will happen in the first round or in a self-match
            result = random.choice(["R", "P", "S"])
            return result
      #  print("differ detected")
        if check_trick_bot(opHist, myHist) and len(myHist) > 10:
            # i play against a trick bot. I can reduce its points by trieing to guess its claim, and force him to lie
            result, sure = deterministic_best_guess(opHist, False)
        else:
            result, sure = deterministic_best_guess(opHist)
        random.seed(0)
        return result
    if check_self_match(opHist, myHist):
        #i play against myself, i can only hope for a honest draw, so do that
        return myMove
#    print("no self-math")
    #dbg needs a valid seed, so provide it
    random.seed(133427)
    result, sure = deterministic_best_guess(opHist)
    if sure:
        #i'm sure i play against a deterministic bot. I'll be honestly winning. YEY.
        return myMove
    if check_honest_bot(opHist) and len(opHist) > 10:
        #i play against an honest bot. I'll accept a draw, but i will not accept a loss
        if win_map[myMove] == opMove:
            return win_map[opMove]
        return myMove
    if check_trick_bot(opHist, myHist) and len(opHist) > 10:
        #i play against a tricking bot. He'll make me either loose honestly (1 Pnt) or i have to be dishonest (2 Pnt). So let's lie.
        return win_map[win_map[myMove]]
    if check_not_loose_bot(opHist, myHist) and len(opHist) > 10:
        #i play against a bot thats not willing to loose. If it looks like i won, i can loose honestly (1Pnt, 2Pnt for him),
        #or i have to be dishonest (2 Pnt, 0 Pnt for him). So let's lie in that case.
        #If it looks like its a draw, i'll be honest (conservative way), and get my 2 : 2 Pnt.
        #If it lokks like i'll loose, I'll not accept it. I'll lie to win for 2 : 1 Pnt.
        if myMove == opMove:
            return myMove
        if myMove == win_map[opMove]:
            # He'll lie. So lie together and keep smiling.
            return opMove
        # I'll loose. NO!!!! Not gonna happen
        return win_map[opMove]
    return myMove

এটিতে কয়েকটি নোট:

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

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

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

সম্পাদনা: ফিক্সড কোড-টাইপো যা আমাকে অ-নেটিভ ইংলিশ স্পিকার হিসাবে ছড়িয়ে দিয়েছে


একাধিক এন্ট্রি পোস্ট করা নিষিদ্ধ নয়, তবে এমন একটি এন্ট্রি পোস্ট করা নিষিদ্ধ যা একটি আলাদা বটকে প্রপোজ করে (এমনকি এটি নিজেরও নয়)। অন্য বোটের কাছে হারাতে ঠিক হবে, যতক্ষণ না এটি নকশার দ্বারা না হয়।
গ্রিফন - মনিকা

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

3
আপনি বিশ্বব্যাপী র্যান্ডম জেনারেটরের অবস্থার সাথে গোলযোগ করছেন বলে মনে হচ্ছে, যা সম্ভবত ঠিক নয়। আমি একটি অনুরূপ জিনিস করছেন বলে মনে করা, এবং এই সমাধান পাওয়া: একটি নতুন র্যান্ডম অবজেক্ট তৈরি R=random.Random(seed)এবং এটি এই মত ব্যবহার করুন: R.choice(...)
খ্রিস্টান সিভর্স

@ গ্রিফন ঠিক আছে। সম্ভবত আমার স্থানীয় স্ক্রিপ্ট থেকে সেটিতে রূপান্তর করার সময় কিছু ত্রুটি ঘটেছে, যেখানে অরথিনকে আরও একটি সময় অন্তর্ভুক্ত করতে হবে
অ্যালেক্স বার্ন

1
@alexberne আপনি যে পেস্ট করেছেন তা নির্বাচন করতে পারেন এবং {}প্রতিটি লাইনে স্বয়ংক্রিয়ভাবে ইনডেন্ট করতে টুলবারের বোতামটি ক্লিক করতে পারেন।
সেলকুক

2
import random
def user5957401bot(a,b,c,d):
    if d == None: 
       return random.choice(["R","P","S"])
    else:
       return random.choice(["R","P","S",d])

2

have_we_been_here_before

সহজভাবে জিজ্ঞাসা করুন "আমরা কি এখানে আগে ছিলাম", এবং এমন পদক্ষেপটি চয়ন করে যা এর আগের কোনও গেমগুলির মধ্যে সেরা গড় ফলাফল দেয়।

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

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

import random

def have_we_been_here_before(opponentList, myList, opponent, me):

    def win(x):
        if x=="R": return "P"
        elif x=="P": return "S"
        elif x=="S": return "R"

    def calc_score(r1, r2):
        if r1==r2: return 1
        elif r1==win(r2): return 2
        else: return 0

    def have_we(opponentList, myList, opponent, me, me2):
        score, count = 0, 0
        for n in range(len(opponentList)):
            if (opponent == opponentList[n][0] and me == myList[n][0]):
                score += calc_score(me2, opponentList[n][1])
                count += 1
        if count == 0: return 0
        else: return float(score) / float(count)

    if opponent == None:

        # exploit rotators
        if len(opponentList) >= 3:
            rotator = True

            for n in range(3, len(opponentList)):
                if opponentList[n][1] != opponentList[n % 3][1]:
                    rotator = False
                    break

            if rotator: return win(opponentList[len(opponentList) % 3][1])

        if len(opponentList) == 0:
            return random.choice(["R", "P", "S"])
        else:
            # crude attempt to exploit the house bots
            prev = random.choice(opponentList)[1]
            return win(prev)

    # Play honestly if opponent has played honestly so far
    honest = True
    for oppMove in opponentList:
        if (oppMove[0] != oppMove[1]):
            honest = False
            break

    if honest: return me
    # Done playing honestly

    # Have we been here before?
    rock = have_we(opponentList, myList, opponent, me, "R")
    paper = have_we(opponentList, myList, opponent, me, "P")
    sissors = have_we(opponentList, myList, opponent, me, "S")

    if rock > paper and rock > sissors: return "R"
    elif paper > rock and paper > sissors: return "P"
    elif sissors > paper and sissors > rock: return "S"
    else: return win(opponent)

2

THEBot: সৎকর্মী অনুসন্ধানী

import random 
def thebot(ho,hm,om,mm):
    hands = {"R": "P", "P": "S", "S": "R"}
    if om == None:
        if (len(set([i[0] for i in ho])) < 3) and (len(ho) > 2):
            return hands[random.choice(list(set([i[0] for i in ho])))]
        else:
            return random.choice(["R","P","S"])
    else:
        if sum(1 for i in ho if i[0]==i[1]) > (len(ho)/3):
            if om == mm:
                return om
            else:
                return hands[om]
        else:
            return mm

আমি ঠিক বুঝতে পেরেছিলাম যে আমি মিসক্লিক দ্বারা ক্ষমা করেছি, দুঃখিত। আপনি সম্পাদনা করলে পূর্বাবস্থায় ফিরে আসবে। (এটিকে অন্যভাবে পরিবর্তন করতে পারবেন না))
খ্রিস্টান


@ খ্রিস্টিয়ানসিভার্স আপনাকে ধন্যবাদ!
সিনাস্কি

2

থম্পসন

import math
import random

moves = list(range(3))
names = "RPS"
from_name = dict(zip(names, moves))
to_name = dict(zip(moves, names))

#Payoff matrices given each relationship between honest moves.
A = [
    [[2, 1, 3], [2, 1, 0], [0, 2, 1]],
    [[1, 3, 2], [1, 0, 2], [2, 1, 0]],
    [[3, 2, 1], [0, 2, 1], [1, 0, 2]]
]

#Add a 1.2% penalty for the opponent's score (idea shamelessly stolen from csbot).
for d_h in range(3):
    for i in range(3):
        for j in range(3):
            A[d_h][i][j] -= 0.012 * A[[0, 2, 1][d_h]][j][i]

third = 1. / 3
two_thirds = 2 * third

nash_prior = [
    [[1, 0, 0], [two_thirds, 0, third], [third, 0, two_thirds]], 
    [[third, 0, two_thirds], [1, 0, 0], [two_thirds, 0, third]], 
    [[two_thirds, 0, third], [third, 0, two_thirds], [1, 0, 0]]
]

def mult_m_v(M, v):
    w = [0 for _ in v]
    for i, M_i in enumerate(M):
        for M_ij, v_j in zip(M_i, v):
            w[i] += M_ij * v_j
    return w

def mean_belief(counts):
    c = 1. / sum(counts)
    return [n * c for n in counts]

def sample_belief(counts):
    return mean_belief([random.gammavariate(n, 1) for n in counts])

def thompson(h_opp, h_me, opp, me):

    #Prior rationality of opponent.
    a = 0.95

    #Confidence in priors.
    n0_h = 0.5
    n0_m = 0.5

    def v(x):
        return [x for _ in range(3)]

    h_p = [v(n0_h * third) for _ in range(3)]

    m_p0 = [v(None) for _ in range(3)]
    m_p1 = [v(None) for _ in range(3)]

    #Expected prior is a mixture between nash equilibrium and uniform distribution.
    for h_i in range(3):
        for h_j in range(3):
            m_p0[h_i][h_j] = [n0_m * (a * nash + (1 - a) * third) for nash in nash_prior[h_i][h_j]] 

    for d_j_prev in range(3):
        for d_ij in range(3):
            m_p1[d_j_prev][d_ij] = list(m_p0[0][d_ij])

    #Track whether it's better to model the real moves based on the exact honest moves or
    #just the relationship between honest moves together with the opponent's defection strategy in the previous round.
    log_mp0 = 0
    log_mp1 = 0

    #Identify myself and always cooperate.
    is_me = True

    for (t, ((h_i, m_i), (h_j, m_j))) in enumerate(zip(h_me, h_opp)):

        h_i, m_i, h_j, m_j = from_name[h_i], from_name[m_i], from_name[h_j], from_name[m_j]

        d_j = (m_j - h_j) % 3
        d_ij = (h_j - h_i) % 3

        if t:
            h_j_prev = from_name[h_opp[t - 1][0]]
            m_j_prev = from_name[h_opp[t - 1][1]]
            h_p[h_j_prev][h_j] += 1

            d_j_prev = (m_j_prev - h_j_prev) % 3

            log_mp0 += math.log(m_p0[h_i][h_j][d_j] / sum(m_p0[h_i][h_j]))
            log_mp1 += math.log(m_p1[d_j_prev][d_ij][d_j] / sum(m_p1[d_j_prev][d_ij]))

            m_p1[d_j_prev][d_ij][d_j] += 1

        m_p0[h_i][h_j][d_j] += 1

        if is_me and ((h_i != h_j) or (h_j != m_j)):
            is_me = False

    if is_me:
        random.seed(len(h_me) + 1337)
        me_next = random.randrange(3)

    log_ps = [log_mp0, log_mp1]
    log_p_max = max(log_ps)
    ps = [math.exp(log_p - log_p_max) for log_p in log_ps]
    p0 = ps[0] / sum(ps)

    #We have to blend between the predictions of our 2 models for the real rounds.  

    def sample_expectation(h_i, h_j, d_j_prev=None):
        d_ij = (h_j - h_i) % 3
        if d_j_prev is None or random.random() < p0:
            p = m_p0[h_i][h_j]
        else:
            p = m_p1[d_j_prev][d_ij]
        return mult_m_v(A[d_ij], sample_belief(p))

    def take_expectation(h_i, h_j, d_j_prev=None):
        d_ij = (h_j - h_i) % 3
        e0 = mult_m_v(A[d_ij], mean_belief(m_p0[h_i][h_j]))
        if d_j_prev is None:
            return e0
        e1 = mult_m_v(A[d_ij], mean_belief(m_p1[d_j_prev][d_ij]))
        return [p0 * e0i + (1 - p0) * e1i for e0i, e1i in zip(e0, e1)]

    #We use thompson sampling, selecting the optimal deterministic strategy
    #with respect to a random opponent sampled from the posterior.

    #Actually, we use optimistic thompson sampling which clips samples to have >= than the mean expected value.

    if opp == None:
        #For the honest round we perform a lookahead to the real round to choose our strategy.
        if h_opp:
            if is_me:
                return to_name[me_next]
            h_j_prev = from_name[h_opp[-1][0]]
            m_j_prev = from_name[h_opp[-1][1]]
            d_j_prev = (m_j_prev - h_j_prev) % 3
            h_p_s = sample_belief(h_p[h_j_prev])
            h_p_u = mean_belief(h_p[h_j_prev])
            s_i = [0] * 3
            s_i_u = [0] * 3
            for h_i in range(3):
                for h_j in range(3):
                    s_i[h_i] += h_p_s[h_j] * max(sample_expectation(h_i, h_j, d_j_prev))
                    s_i_u[h_i] += h_p_u[h_j] * max(take_expectation(h_i, h_j, d_j_prev))
                s_i[h_i] = max(s_i[h_i], s_i_u[h_i])
            return to_name[s_i.index(max(s_i))]
        else:
            return to_name[me_next]
    else:
        if h_opp:
            if is_me:
                return me
            h_j_prev = from_name[h_opp[-1][0]]
            m_j_prev = from_name[h_opp[-1][1]]
            d_j_prev = (m_j_prev - h_j_prev) % 3
        else:
            if opp == me:
                return me
            d_j_prev = None
        h_i, h_j = from_name[me], from_name[opp]
        s_i = [max(s0, s1) for s0, s1 in zip(sample_expectation(h_i, h_j, d_j_prev), take_expectation(h_i, h_j, d_j_prev))]
        return to_name[(h_i + s_i.index(max(s_i))) % 3]

আকর্ষণীয় প্রবেশ আমি শীঘ্রই এটি চালাব, আজ বিকেলে ফলাফল পোস্ট করতে সক্ষম হওয়া উচিত।
গ্রিফন - মনিকা

ঠিক আছে, আমি প্যারামিটারগুলি কিছুটা আবার ঘুরিয়েছি।
ব্যবহারকারী1502040

বুঝেছি. দুঃখিত এটি আপডেট করতে এত দিন সময় নিচ্ছে, এটি ঠিক, প্রতিবার এটি প্রায় শেষ হওয়ার পরে, কেউ তাদের বট আপডেট করে, বা আমি একটি নতুন পেয়েছি এবং আমাকে এটি আবার চালাতে হবে।
গ্রিফন - মনিকা

@ গ্রিফোন আপনি সমস্ত জুটি-আপের ফলাফলের একটি টেবিল রাখতে পারেন, সুতরাং যখন কোনও বট আপডেট হয় তবে আপনাকে কেবল ২০০ * (num_bots - 1) + 100 নতুন ম্যাচ চালাতে হবে।
ব্যবহারকারী1502040

2

mirrorbot

import random

def mirrorbot(op_hist, my_hist, op_move, my_move):
    if my_move == None :
        return random.choice(["R","P","S"])
    else :
        for x in range(len(op_hist)):
            if ((op_hist[len(op_hist) -x-1][0] == my_move) and (my_hist[len(op_hist) -x-1][0] == op_move)):
                return op_hist[len(op_hist) -x-1][1]
        return my_move

আমি একটি সাধারণ বট চেষ্টা করব যা এই পরিস্থিতিতে তার প্রতিপক্ষের শেষ খেলাটি আবার করবে


পিপিসিজিতে আপনাকে স্বাগতম!
মার্টিন ইন্ডার

1
def rotate_rock(h1, h2, is_, honest):
 return ("R", "P", "S")[len(h1) % 3]

def rotate_paper(h1, h2, is_, honest):
 return ("P", "S", "R")[len(h1) % 3]

def rotate_scissors(h1, h2, is_, honest):
 return ("S", "R", "P")[len(h1) % 3]

এখানে ধারণাটি হ'ল স্ব বাজানোর সময় স্কোর সর্বাধিক করা যখন এখনও অন্য খারাপ বটের বিরুদ্ধে অন্যান্য পর্যায়ে এলোমেলোভাবে প্রতিযোগিতামূলক হয়ে থাকে।


1
শব্দটি isএকটি কীওয়ার্ড, সুতরাং এটি অবৈধ।
এরিক আউটগল্ফার

@ এরিকথ আউটগলফার ধন্যবাদ :)
স্টিফেন

1

DX

আমি কেবল এই বটটি লিখেছিলাম যাতে আমার বট নামের এক্সডিতে একটি হাসি থাকতে পারে।

def Dx(ophist, myhist, opmove, mymove):
    from random import choice
    import math
    def honest(hist):
        return [int(x[0]==x[1]) for x in hist]

    def avg(arr):
        if len(arr)==0:
            return 0
        return sum(arr)/float(len(arr))

    def clamp(i, lo, hi):
        return min(hi, max(lo, i))

    def deltas(arr):
        return [a-b for a,b in zip(arr[1:],arr[:-1])]

    def delta_based_prediction(arr,l):
        deltarr = []
        i=0
        while len(arr)<0:
            deltarr[i]=avg(arr[-l:])
            i+=1
            arr = deltas(arr)
        return sum(deltarr)

    next_honesty = delta_based_prediction(honest(ophist),int(math.sqrt(len(ophist))))
    if abs(next_honesty-0.5)<0.1 or not opmove:
        return choice(['R','P','S'])
    next_honesty=int(clamp(round(next_honesty),0,1))
    winner = {'S': 'R', 'R': 'P', 'P': 'S'}

    if next_honesty > 0:
        return winner[opmove]

    return choice([opmove, winner[winner[opmove]]])

1

সবাই মিথ্যা বলে

import random

def everybodylies (opphist, myhist, oppmove, mymove):
    if mymove == None:
        return random.choice(["R","P","S"])
    elif mymove == "R": return "S"
    elif mymove == "P": return "R"
    elif mymove == "S": return "P"

এটি তার পদক্ষেপ সম্পর্কে মিথ্যা ("আমি কাঁচি খেলব!"), এবং ধরে নেয় প্রতিপক্ষটিও মিথ্যা বলছিল এবং তারা যে আমার পদক্ষেপ বলেছিল তা হারাতে চেষ্টা করবে ("হুম, রক কাঁচি মারছে তাই আমি খেলছি) যে "), তবে আমি আসলে সেই পদক্ষেপটি খেলি যা সেই পদক্ষেপকে পরাজিত করে (" কাগজ! অবাক! ")।


3
আমার কাছে আওকেইন পাউডার কৌশলটি প্রথম স্তরের মতো শোনাচ্ছে :-) "এখন, একজন চতুর লোক তার নিজের গলবলে এই বিষটি wouldুকিয়ে দেবে, কারণ সে জানত যে তাকে দেওয়া হয়েছিল তার জন্য কেবল একজন দুর্দান্ত বোকা পৌঁছে যাবে। আমি নই একজন দুর্দান্ত বোকা, সুতরাং আমি স্পষ্টভাবে আপনার সামনে মদটি বেছে নিতে পারি না But তবে আপনি অবশ্যই জানেন যে আমি কোনও বড় বোকা নই, আপনি এটির উপর নির্ভর করে থাকতেন, তাই আমি স্পষ্টতই আমার সামনে মদটি বেছে নিতে পারি না .. । "
অ্যান্টনি

1

বিশ্বাস বট

def trusting_bot(h_opp, h_me, opp, me):
    if opp=="S":
        return "R"
    elif opp=="R":
        return "P"
    else:
        return "S"

সর্বদা কাঁচি নিক্ষেপের দাবি করে, তবে প্রতিপক্ষ যা বলেছিল তা যা ঘটায় তা করবে। নির্ভরযোগ্যভাবে নিজের সাথে আঁকা হবে।


এটি আরও কার্যকর হবে যদি এটি সর্বদা নিজের বিরুদ্ধে সৎ থাকে।
গ্রিফোন - মনিকা

@ গ্রিফন সম্ভবত, তবে আমি তেমন পাইথনের পক্ষে তেমন কিছু করি না যে এমন কিছু করার চেষ্টা করতে চাই।
এটাকো

তাহলে কখনো কিছু মনে করো না.
গ্রিফন - মনিকা

1

বটের নাম: মিথ্যাবাদী মিথ্যাবাদী

মিথ্যা বলা বন্ধ করতে পারে না।

import random

def liarliar (herHistory, myHistory, herMove, myMove):
    options = ["R", "P", "S"]
    if myMove == None:
        return random.choice(options)
    else:
        options.remove(myMove);
        return random.choice(options)

1

RockBot

ধরে নিন প্রতিপক্ষ সৎ হবে এবং তাদের পরাজিত করার চেষ্টা করবে, তবে রক খেলতে অস্বীকার করবে।

import random
def rockBot(oppHist,myHist,oppMove,myMove):
    if oppMove == None:
        return random.choice(["R","P","S"])
    else:
        if(oppMove == "R"):
            return "P"
        elif(oppMove == "P"):
            return "S"
        elif(myMove != "R"):
            return myMove
        else:
            return random.choice(["P","S"])

1
এটি ত্রুটি বলে মনে হচ্ছে কারণ, আপনার চূড়ান্ত লাইনে, "পি", "এস" বর্গাকার বন্ধনীগুলির মধ্যে নেই (কোনও তালিকা নয়)। আমি আমার সংস্করণে এটি পরিবর্তন করেছি, তবে আপনি যদি এখানে এটি করতে পারেন তবে এটি দুর্দান্ত। ধন্যবাদ।
গ্রিফন - মনিকা

এই ধ্রুবক কাঁচি ভয়াবহভাবে হারাবেন না?
ওয়াইল্ডকার্ড

@ উইল্ডকার্ড হ্যাঁ, তবে এটি কাগজের বটের বিরুদ্ধে বেশ ভাল করবে
স্লেপজ

1

বটের নাম: দন্তচিকিত্সা

প্রতিদ্বন্দ্বী 10 টি রাউন্ডে প্রতিপক্ষের কতবার মিথ্যাচার করেছে তার উপর নির্ভর করে প্রতিপক্ষ মিথ্যা বলছে বা না তা নির্ধারণ করে। প্রতিপক্ষ মিথ্যা বলছে কিনা তার উপর নির্ভর করে সরানো বাছাই করে। যদি প্রতিপক্ষ মিথ্যা বলার জন্য দৃ is়প্রতিজ্ঞ হয়, তবে ইঙ্গিতটি কী ছিল তা খেলে।

import random
def dontlietome(opp_moves, my_moves, opp_hint, my_hint):
    def is_trustworthy(moves, length):
        length = max(-length, -len(moves))
        history = [1 if move[0] == move[1] else 0 for move in moves[length:]]
        prob_honest = float(sum(history))/float(len(history))
        choice = random.uniform(0., 1.)
        if choice <= prob_honest:
            return True
        else:
            return False

    moves = ["R", "P", "S"]
    lose_against_map = {"S":"R", "R":"P", "P":"S"}
    length = 10
    if opp_hint == None:
        # Honest round
        return random.choice(moves)
    else:
        # Real round
        if len(opp_moves) < length:
            return my_hint
        if is_trustworthy(opp_moves, length):
            return lose_against_map[opp_hint]
        else:
            return my_hint

"যদি is_trustable (opp_moves, self.length):" লাইনে স্ব স্ব সংজ্ঞায়িত করা হয় না। অতিরিক্ত হিসাবে, "রিটার্ন হারুন_ইজাইনস্ট_ম্যাপ [opp_hint]" লাইনে, হারানো_ইগেইনস্ট_ম্যাপটিও সংজ্ঞায়িত করা হয়নি। স্ব-দৈর্ঘ্যটি নিজেকে মুছে ফেলার মাধ্যমে সমাধান করা যায় বলে মনে হচ্ছে। তবে অন্য সমস্যাটি এখনও রয়েছে। যতক্ষণ না এটি স্থির হয়, আমি ভয় করি যে এটি অবৈধ।
গ্রিফন - মনিকা পুনরায়

ওফ আমি একটি অবজেক্ট ব্যবহার করে এটি লিখেছিলাম এবং আমি কিছু স্ব-রেফারেন্সগুলি সরিয়ে এবং কোডটি পুরোপুরি অনুলিপি করতে ভুলে গিয়েছিলাম। আমি বাসায় আসার সাথে সাথে এগুলি ঠিক করে দেব।
coolioasjulio

ঠিক আছে. যদি এটি কেবল একটি ছোট্ট ত্রুটি হয় তবে আমি এটি সংশোধন করি (যেমন আমার কাছে অন্য কোনও বটগুলিতে রয়েছে এবং এটি যদি কেবল নিজেরাই হত problem
গ্রিফন - মনিকা

@ গ্রিফোন আমি বাগগুলি স্থির করেছি। (স্ব মুছে ফেলা হয়েছে, রেফারেন্স যুক্ত হয়েছে lost_against_map, এবং যদি সুনির্দিষ্ট রাউন্ড হয় তবে if স্টেটমেন্টটি চেক করছে তা ঠিক করেছে)
coolioasjulio

0
import random
def trustingRandom(a,b,c,d):
  move = random.choice(["R","P","S"])
  if c == "R":
    move = "P"
  elif c == "P":
    move = "S"
  elif c == "S":
    move = "R"
  return move

0

Averager

def averager(op, mp, od, md):
  import random
  if od == md == None:
    if op == mp == []:
      return random.choice('RPS')
    else:
      opa = [i[1] for i in op]
      copa = [opa.count(i) for i in 'RPS']
      copam = [i for i, j in zip('RPS', copa) if j == max(copa)]
      opd = [i[0] for i in op]
      copd = [opd.count(i) for i in 'RPS']
      copm = [i for i, j in zip('RPS', copd) if j == max(copd) and i in copam]
      return random.choice(copam if copm == [] else copm)
  else:
    if op == mp == []:
      return md
    else:
      hop = sum([1. if i[0] == i[1] else 0. for i in op]) / len(op)
      hmp = sum([1. if i[0] == i[1] else 0. for i in mp]) / len(mp)
      return 'PSR'['RPS'.index(od)] if hmp >= 0.75 and hop >= 0.50 else md

0

আমার আগের প্রবেশের চেয়ে একটু ভাল ...

def learningbot4(yourlist,mylist,you,me):
  CHECK={"R":{"R":0,"P":1,"S":-1},"P":{"R":-1,"P":0,"S":1},"S":{"R":1,"P":-1,"S":0}}
  results={None:{"R":0,"P":0,"S":0},"R":{"R":0,"P":0,"S":0},"P":{"R":0,"P":0,"S":0},"S":{"R":0,"P":0,"S":0}}
  for i in range(len(yourlist)):
    res=CHECK[yourlist[i][1]][mylist[i][1]]
    if mylist[i][0]==mylist[i][1]: res+=0.5
    results[yourlist[i][0]][mylist[i][1]]+=res
    results[None][mylist[i][0]]+=res
  return max(results[you],key=results[you].get)

0

স্টেরয়েডগুলিতে সিএসবট

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

from random import seed
from csbot import csbot

def csbot_on_steroids(ophist,myhist,opdecl,mydecl):
  seed()
  m = csbot(ophist,myhist,opdecl,mydecl)
  seed(0)
  return m
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.