EvaluaterBot

class EvaluaterBot:

    def __init__(self):

        self.c2i = {"C":0, "N":1, "D":2}

        self.i2c = {0:"C", 1:"N", 2:"D"}

        self.history = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]

        self.last = [None, None]



    def round(self, last):

        if self.last[0] == None:

            ret = 2

        else:

            # Input the latest enemy action (the reaction to my action 2 rounds ago)

            # into the history

            self.history[self.last[0]][self.c2i[last]] += 1

            # The enemy will react to the last action I did

            prediction,_ = max(enumerate(self.history[self.last[1]]), key=lambda l:l[1])

            ret = (prediction - 1) % 3

        self.last = [self.last[1], ret]

        return self.i2c[ret]

Wins against all previously submitted bots except (maybe) the random bot (but it could have an advantage, because it picks D in a draw and D should optimal) and plays a constant draw against themself.

TatForTit

class TatForTit:

    def round(self, last):

        if(last == "C"):

            return "N"

        return "D"

This bot will alternate picking D N D N while TitForTat alternates C D C D, for an average net gain of 3 points per round if I have read the payout matrix correctly. I think this might be optimal against TitForTat. Obviously it could be improved to detect a non-TFT opponent and adopt other strategies, but I was just aiming for the original bounty.

NashEquilibrium

This bot has taken a game theory class in college but was lazy and didn't go to the class where they covered iterated games. So he only plays single game mixed nash equilibrium. Turns out 1/5 2/5 2/5 is the mixed NE for the payoffs.

class NashEquilibrium:

    def round(self, _):

        a = random.random()

        if a <= 0.2:

            return "C"

        elif a <= 0.6:

            return "N"

        else:

            return "D" 

Constant Abusing Nash Equilibrium

This bot picked up a lesson or two from his lazy brother. His lazy brother's problem was that he didn't take advantage of fixed strategies. This version checks if the opponent is a constant player or titfortat and plays accordingly, else it plays the regular nash equilibrium.

It's only downside is that it averages 2.2 points per turn playing against itself.

class NashEquilibrium2:



    def __init__(self):

        self.opphistory = [None, None, None]

        self.titfortatcounter = 0

        self.titfortatflag = 0

        self.mylast = "C"

        self.constantflag = 0

        self.myret = "C"



    def round(self, last):

        self.opphistory.pop(0)

        self.opphistory.append(last)



        # check if its a constant bot, if so exploit

        if self.opphistory.count(self.opphistory[0]) == 3:

            self.constantflag = 1

            if last == "C":

                 self.myret = "D"

            elif last == "N":

                 self.myret = "C"

            elif last == "D":

                 self.myret = "N"



        # check if its a titfortat bot, if so exploit

        # give it 2 chances to see if its titfortat as it might happen randomly

        if self.mylast == "D" and last == "D":

            self.titfortatcounter = self.titfortatcounter + 1



        if self.mylast == "D" and last!= "D":

            self.titfortatcounter = 0



        if self.titfortatcounter >= 3:

            self.titfortatflag = 1



        if self.titfortatflag == 1:

            if last == "C":

                 self.myret = "D"

            elif last == "D":

                 self.myret = "N"    

            elif last == "N":

                # tit for tat doesn't return N, we made a mistake somewhere

                 self.titfortatflag = 0

                 self.titfortatcounter = 0



        # else play the single game nash equilibrium

        if self.constantflag == 0 and self.titfortatflag == 0:

            a = random.random()

            if a <= 0.2:

                self.myret = "C"

            elif a <= 0.6:

                self.myret = "N"

            else:

                self.myret = "D"





        self.mylast = self.myret

        return self.myret

Jade

class Jade:

    def __init__(self):

        self.dRate = 0.001

        self.nRate = 0.003



    def round(self, last):

        if last == 'D':

            self.dRate *= 1.1

            self.nRate *= 1.2

        elif last == 'N':

            self.dRate *= 1.03

            self.nRate *= 1.05

        self.dRate = min(self.dRate, 1)

        self.nRate = min(self.nRate, 1)



        x = random.random()

        if x > (1 - self.dRate):

            return 'D'

        elif x > (1 - self.nRate):

            return 'N'

        else:

            return 'C'

Starts out optimistic, but gets progressively more bitter as the opponent refuses to cooperate. Lots of magic constants that could probably be tweaked, but this probably isn't going to do well enough to justify the time.

PatternFinder

class PatternFinder:

    def __init__(self):

        import collections

        self.size = 10

        self.moves = [None]

        self.other = 

        self.patterns = collections.defaultdict(list)

        self.counter_moves = {"C":"D", "N":"C", "D":"N"}

        self.initial_move = "D"

        self.pattern_length_exponent = 1

        self.pattern_age_exponent = 1

        self.debug = False

    def round(self, last):

        self.other.append(last)

        best_pattern_match = None

        best_pattern_score = None

        best_pattern_response = None

        self.debug and print("match so far:",tuple(zip(self.moves,self.other)))

        for turn in range(max(0,len(self.moves)-self.size),len(self.moves)):

            # record patterns ending with the move that just happened

            pattern_full = tuple(zip(self.moves[turn:],self.other[turn:]))

            if len(pattern_full) > 1:

                pattern_trunc = pattern_full[:-1]

                pattern_trunc_result = pattern_full[-1][1]

                self.patterns[pattern_trunc].append([pattern_trunc_result,len(self.moves)-1])

            if pattern_full in self.patterns:

                # we've seen this pattern at least once before

                self.debug and print("I've seen",pattern_full,"before:",self.patterns[pattern_full])

                for [response,turn_num] in self.patterns[pattern_full]:

                    score = len(pattern_full) ** self.pattern_length_exponent / (len(self.moves) - turn_num) ** self.pattern_age_exponent

                    if best_pattern_score == None or score > best_pattern_score:

                        best_pattern_match = pattern_full

                        best_pattern_score = score

                        best_pattern_response = response

                    # this could be much smarter about aggregating previous responses

        if best_pattern_response:

            move = self.counter_moves[best_pattern_response]

        else:

            # fall back to playing nice

            move = "C"

        self.moves.append(move)

        self.debug and print("I choose",move)

        return move

This bot looks for previous occurrences of the recent game state to see how the opponent responded to those occurrences, with a preference for longer pattern matches and more recent matches, then plays the move that will "beat" the opponent's predicted move. There's a lot of room for it to be smarter with all the data it keeps track of, but I ran out of time to work on it.

OldTitForTat

Old school player is too lazy to update for the new rules.

class OldTitForTat:

    def round(self, last):

        if(last == None)

            return "C"

        if(last == "C"):

            return "C"

        return "D"

NeverCOOP

class NeverCOOP:

    def round(self, last):

        try:

            if last in "ND":

                return "D"

            else:

                return "N"

        except:

            return "N"

If the opposing bot defects or is neutral, choose defect. Otherwise if this is the first turn or the opposing bot cooperates, choose neutral. I'm not sure how good this will work...

LastOptimalBot

class LastOptimalBot:

    def round(self, last):

        return "N" if last == "D" else ("D" if last == "C" else "C")

Assumes that the opposing bot will always play the same move again, and chooses the one that has the best payoff against it.

Averages:

Me   Opp

2.6  2    vs TitForTat

5    0    vs AllC

4    1    vs AllN

3    2    vs AllD

3.5  3.5  vs Random

3    2    vs Grudger

2    2    vs LastOptimalBot

1    3.5  vs TatForTit

4    1    vs NeverCOOP

1    4    vs EvaluaterBot

2.28 2.24 vs NashEquilibrium



2.91 average overall

CopyCat

class CopyCat:

    def round(self, last):

        if last:

            return last

        return "C"

Copies the opponent's last move.

I don't expect this to do well, but no one had implemented this classic yet.

Ensemble

This runs an ensemble of related models. The individual models consider different amounts of history, and have the option of either always choosing the move that will optimize the expected payout difference, or will randomly select a move in proportion to expected payout difference.

Each member of the ensemble then votes on their preferred move. They get a number of votes equal to how much more they've won than the opponent (which means that terrible models will get negative votes). Whichever move wins the vote is then selected.

(They should probably split their votes among the moves in proportion to how much they favor each, but I don't care enough to do that right now.)

It beats everything posted so far except EvaluaterBot and PatternFinder. (One-on-one, it beats EvaluaterBot and loses to PatternFinder).

from collections import defaultdict

import random

class Number6:

    class Choices:

        def __init__(self, C = 0, N = 0, D = 0):

            self.C = C

            self.N = N

            self.D = D



    def __init__(self, strategy = "maxExpected", markov_order = 3):

        self.MARKOV_ORDER = markov_order;

        self.my_choices = "" 

        self.opponent = defaultdict(lambda: self.Choices())

        self.choice = None # previous choice

        self.payoff = {

            "C": { "C": 3-3, "N": 4-1, "D": 0-5 },

            "N": { "C": 1-4, "N": 2-2, "D": 3-2 },

            "D": { "C": 5-0, "N": 2-3, "D": 1-1 },

        }

        self.total_payoff = 0



        # if random, will choose in proportion to payoff.

        # otherwise, will always choose argmax

        self.strategy = strategy

        # maxExpected: maximize expected relative payoff

        # random: like maxExpected, but it chooses in proportion to E[payoff]

        # argmax: always choose the option that is optimal for expected opponent choice



    def update_opponent_model(self, last):

        for i in range(0, self.MARKOV_ORDER):

            hist = self.my_choices[i:]

            self.opponent[hist].C += ("C" == last)

            self.opponent[hist].N += ("N" == last)

            self.opponent[hist].D += ("D" == last)



    def normalize(self, counts):

        sum = float(counts.C + counts.N + counts.D)

        if 0 == sum:

            return self.Choices(1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0)

        return self.Choices(

            counts.C / sum, counts.N / sum, counts.D / sum)



    def get_distribution(self):

        for i in range(0, self.MARKOV_ORDER):

            hist = self.my_choices[i:]

            #print "check hist = " + hist

            if hist in self.opponent:

                return self.normalize(self.opponent[hist])



        return self.Choices(1.0 / 3.0, 1.0 / 3.0, 1.0 / 3.0)



    def choose(self, dist):

        payoff = self.Choices()

        # We're interested in *beating the opponent*, not

        # maximizing our score, so we optimize the difference

        payoff.C = (3-3) * dist.C + (4-1) * dist.N + (0-5) * dist.D

        payoff.N = (1-4) * dist.C + (2-2) * dist.N + (3-2) * dist.D

        payoff.D = (5-0) * dist.C + (2-3) * dist.N + (1-1) * dist.D



        # D has slightly better payoff on uniform opponent,

        # so we select it on ties

        if self.strategy == "maxExpected":

            if payoff.C > payoff.N:

                return "C" if payoff.C > payoff.D else "D"

            return "N" if payoff.N > payoff.D else "D"

        elif self.strategy == "randomize":

            payoff = self.normalize(payoff)

            r = random.uniform(0.0, 1.0)

            if (r < payoff.C): return "C"

            return "N" if (r < payoff.N) else "D"

        elif self.strategy == "argMax":

            if dist.C > dist.N:

                return "D" if dist.C > dist.D else "N"

            return "C" if dist.N > dist.D else "N"



        assert(0) #, "I am not a number! I am a free man!")



    def update_history(self):

        self.my_choices += self.choice

        if len(self.my_choices) > self.MARKOV_ORDER:

            assert(len(self.my_choices) == self.MARKOV_ORDER + 1)

            self.my_choices = self.my_choices[1:]



    def round(self, last):

        if last: self.update_opponent_model(last)



        dist = self.get_distribution()

        self.choice = self.choose(dist)

        self.update_history()

        return self.choice



class Ensemble:

    def __init__(self):

        self.models = 

        self.votes = 

        self.prev_choice = 

        for order in range(0, 6):

            self.models.append(Number6("maxExpected", order))

            self.models.append(Number6("randomize", order))

            #self.models.append(Number6("argMax", order))

        for i in range(0, len(self.models)):

            self.votes.append(0)

            self.prev_choice.append("D")



        self.payoff = {

            "C": { "C": 3-3, "N": 4-1, "D": 0-5 },

            "N": { "C": 1-4, "N": 2-2, "D": 3-2 },

            "D": { "C": 5-0, "N": 2-3, "D": 1-1 },

        }



    def round(self, last):

        if last:

            for i in range(0, len(self.models)):

                self.votes[i] += self.payoff[self.prev_choice[i]][last]



        # vote. Sufficiently terrible models get negative votes

        C = 0

        N = 0

        D = 0

        for i in range(0, len(self.models)):

            choice = self.models[i].round(last)

            if "C" == choice: C += self.votes[i]

            if "N" == choice: N += self.votes[i]

            if "D" == choice: D += self.votes[i]

            self.prev_choice[i] = choice



        if C > D and C > N: return "C"

        elif N > D: return "N"

        else: return "D"

Test Framework

In case anyone else finds it useful, here's a test framework for looking at individual matchups. Python2. Just put all the opponents you're interested in in opponents.py, and change the references to Ensemble to your own.

import sys, inspect

import opponents

from ensemble import Ensemble



def count_payoff(label, them):

    if None == them: return

    me = choices[label]

    payoff = {

        "C": { "C": 3-3, "N": 4-1, "D": 0-5 },

        "N": { "C": 1-4, "N": 2-2, "D": 3-2 },

        "D": { "C": 5-0, "N": 2-3, "D": 1-1 },

    }

    if label not in total_payoff: total_payoff[label] = 0

    total_payoff[label] += payoff[me][them]



def update_hist(label, choice):

    choices[label] = choice



opponents = [ x[1] for x 

    in inspect.getmembers(sys.modules['opponents'], inspect.isclass)]



for k in opponents:

    total_payoff = {}



    for j in range(0, 100):

        A = Ensemble()

        B = k()

        choices = {}



        aChoice = None

        bChoice = None

        for i in range(0, 100):

            count_payoff(A.__class__.__name__, bChoice)

            a = A.round(bChoice)

            update_hist(A.__class__.__name__, a)



            count_payoff(B.__class__.__name__, aChoice)

            b = B.round(aChoice)

            update_hist(B.__class__.__name__, b)



            aChoice = a

            bChoice = b

    print total_payoff

Improved Dirichlet Dice

import random



class DirichletDice2:

    def __init__(self):



        self.alpha = dict(

                C = {'C' : 1, 'N' : 1, 'D' : 1},

                N = {'C' : 1, 'N' : 1, 'D' : 1},

                D = {'C' : 1, 'N' : 1, 'D' : 1}

        )

        self.myLast = [None, None]

        self.payoff = dict(

                C = { "C": 0, "N": 3, "D": -5 },

                N = { "C": -3, "N": 0, "D": 1 },

                D = { "C": 5, "N": -1, "D": 0 }

        )



    def DirichletDraw(self, key):

        alpha = self.alpha[key].values()

        mu = [random.gammavariate(a,1) for a in alpha]

        mu = [m / sum(mu) for m in mu]

        return mu



    def ExpectedPayoff(self, probs):

        expectedPayoff = {}

        for val in ['C','N','D']:

            payoff = sum([p * v for p,v in zip(probs, self.payoff[val].values())])

            expectedPayoff[val] = payoff

        return expectedPayoff



    def round(self, last):

        if last is None:

            self.myLast[0] = 'D'

            return 'D'



        #update dice corresponding to opponent's last response to my

        #outcome two turns ago

        if self.myLast[1] is not None:

            self.alpha[self.myLast[1]][last] += 1



        #draw probs for my opponent's roll from Dirichlet distribution and then return the optimal response

        mu = self.DirichletDraw(self.myLast[0])

        expectedPayoff = self.ExpectedPayoff(mu)

        res = max(expectedPayoff, key=expectedPayoff.get)



        #update myLast

        self.myLast[1] = self.myLast[0]

        self.myLast[0] = res



        return res    

This is an improved version of Dirichlet Dice. Instead of taking the expected multinomial distribution from the Dirichlet distribution, it draws a Multinomial distribution randomly from the Dirichlet distribution. Then, instead of drawing from the Multinomial and giving the optimal response to that, it gives the optimal expected response to the given Multinomial using the points. So the randomness has essentially been shifted from the Multinomial draw to the Dirichlet draw. Also, the priors are more flat now, to encourage exploration.

It's "improved" because it now accounts for the points system by giving the best expected value against the probabilities, while maintaining its randomness by drawing the probabilities themselves. Before, I tried simply doing the best expected payoff from the expected probabilities, but that did badly because it just got stuck, and didn't explore enough to update its dice. Also it was more predictable and exploitable.

Original submission:

Dirichlet Dice

import random



class DirichletDice:

    def __init__(self):



        self.alpha = dict(

                C = {'C' : 2, 'N' : 3, 'D' : 1},

                N = {'C' : 1, 'N' : 2, 'D' : 3},

                D = {'C' : 3, 'N' : 1, 'D' : 2}

        )



        self.Response = {'C' : 'D', 'N' : 'C', 'D' : 'N'}

        self.myLast = [None, None]



    #expected value of the dirichlet distribution given by Alpha

    def MultinomialDraw(self, key):

        alpha = list(self.alpha[key].values())

        probs = [x / sum(alpha) for x in alpha]

        outcome = random.choices(['C','N','D'], weights=probs)[0]

        return outcome



    def round(self, last):

        if last is None:

            self.myLast[0] = 'D'

            return 'D'



        #update dice corresponding to opponent's last response to my

        #outcome two turns ago

        if self.myLast[1] is not None:

            self.alpha[self.myLast[1]][last] += 1



        #predict opponent's move based on my last move

        predict = self.MultinomialDraw(self.myLast[0])

        res = self.Response[predict]



        #update myLast

        self.myLast[1] = self.myLast[0]

        self.myLast[0] = res



        return res

Basically I'm assuming that the opponent's response to my last output is a multinomial variable (weighted dice), one for each of my outputs, so there's a dice for "C", one for "N", and one for "D". So if my last roll was, for example, a "N" then I roll the "N-dice" to guess what their response would be to my "N". I begin with a Dirichlet prior that assumes that my opponent is somewhat "smart" (more likely to play the one with the best payoff against my last roll, least likely to play the one with the worst payoff). I generate the "expected" Multinomial distribution from the appropriate Dirichlet prior (this is the expected value of the probability distribution over their dice weights). I roll the weighted dice of my last output, and respond with the one with the best payoff against that dice outcome.

Starting in the third round, I do a Bayesian update of the appropriate Dirichlet prior of my opponent's last response to the thing I played two rounds ago. I'm trying to iteratively learn their dice weightings.

I could have also simply picked the response with the best "expected" outcome once generating the dice, instead of simply rolling the dice and responding to the outcome. However, I wanted to keep the randomness in, so that my bot is less vulnerable to the ones that try to predict a pattern.

Kevin

class Kevin:

    def round(self, last):      

        return {"C":"N","N":"D","D":"C",None:"N"} [last]

Picks the worst choice. The worst bot made.

Useless

import random



class Useless:

    def __init__(self):

        self.lastLast = None



    def round(self, last):

        tempLastLast = self.lastLast

        self.lastLast = last



        if(last == "D" and tempLastLast == "N"):

            return "C"

        if(last == "D" and tempLastLast == "C"):

            return "N"



        if(last == "N" and tempLastLast == "D"):

            return "C"

        if(last == "N" and tempLastLast == "C"):

            return "D"



        if(last == "C" and tempLastLast == "D"):

            return "N"

        if(last == "C" and tempLastLast == "N"):

            return "D"



        return random.choice("CND")

It looks at the last two moves done by the opponent and picks the most not done else it picks something random. There is probably a better way of doing this.

Historic Average

class HistoricAverage:

    PAYOFFS = {

        "C":{"C":3,"N":1,"D":5},

        "N":{"C":4,"N":2,"D":2},

        "D":{"C":0,"N":3,"D":1}}

    def __init__(self):

        self.payoffsum = {"C":0, "N":0, "D":0}

    def round(this, last):

        if(last != None):

            for x in this.payoffsum:

               this.payoffsum[x] += HistoricAverage.PAYOFFS[last][x]

        return max(this.payoffsum, key=this.payoffsum.get)

Looks at history and finds the action that would have been best on average. Starts cooperative.

Weighted Average

class WeightedAverageBot:

  def __init__(self):

    self.C_bias = 1/4

    self.N = self.C_bias

    self.D = self.C_bias

    self.prev_weight = 1/2

  def round(self, last):

    if last:

      if last == "C" or last == "N":

        self.D *= self.prev_weight

      if last == "C" or last == "D":

        self.N *= self.prev_weight

      if last == "N":

        self.N = 1 - ((1 - self.N) * self.prev_weight)

      if last == "D":

        self.D = 1 - ((1 - self.D) * self.prev_weight)

    if self.N <= self.C_bias and self.D <= self.C_bias:

      return "D"

    if self.N > self.D:

      return "C"

    return "N"

The opponent's behavior is modeled as a right triangle with corners for C N D at 0,0 0,1 1,0 respectively. Each opponent move shifts the point within that triangle toward that corner, and we play to beat the move indicated by the point (with C being given an adjustably small slice of the triangle). In theory I wanted this to have a longer memory with more weight to previous moves, but in practice the current meta favors bots that change quickly, so this devolves into an approximation of LastOptimalBot against most enemies. Posting for posterity; maybe someone will be inspired.

Tetragram

import itertools



class Tetragram:

    def __init__(self):

        self.history = {x: ['C'] for x in itertools.product('CND', repeat=4)}

        self.theirs = 

        self.previous = None



    def round(self, last):

        if self.previous is not None and len(self.previous) == 4:

            self.history[self.previous].append(last)

        if last is not None:

            self.theirs = (self.theirs + [last])[-3:]



        if self.previous is not None and len(self.previous) == 4:

            expected = random.choice(self.history[self.previous])

            if expected == 'C':

                choice = 'C'

            elif expected == 'N':

                choice = 'C'

            else:

                choice = 'N'

        else:

            choice = 'C'



        self.previous = tuple(self.theirs + [choice])

        return choice

Try to find a pattern in the opponent's moves, assuming they're also watching our last move.

Handshake

class HandshakeBot:

  def __init__(self):

    self.handshake_length = 4

    self.handshake = ["N","N","C","D"]

    while len(self.handshake) < self.handshake_length:

      self.handshake *= 2

    self.handshake = self.handshake[:self.handshake_length]

    self.opp_hand = 

    self.friendly = None

  def round(self, last):

    if last:

      if self.friendly == None:

        # still trying to handshake

        self.opp_hand.append(last)

        if self.opp_hand[-1] != self.handshake[len(self.opp_hand)-1]:

          self.friendly = False

          return "D"

        if len(self.opp_hand) == len(self.handshake):

          self.friendly = True

          return "C"

        return self.handshake[len(self.opp_hand)]

      elif self.friendly == True:

        # successful handshake and continued cooperation

        if last == "C":

          return "C"

        self.friendly = False

        return "D"

      else:

        # failed handshake or abandoned cooperation

        return "N" if last == "D" else ("D" if last == "C" else "C")

    return self.handshake[0]

Recognizes when it's playing against itself, then cooperates. Otherwise mimics LastOptimalBot which seems like the best one-line strategy. Performs worse than LastOptimalBot, by an amount inversely proportional to the number of rounds. Obviously would do better if there were more copies of it in the field *cough**wink*.

ShiftingOptimalBot

class ShiftingOptimalBot:

    def __init__(self):

        # wins, draws, losses

        self.history = [0,0,0]

        self.lastMove = None

        self.state = 0

    def round(self, last):

        if last == None:

            self.lastMove = "C"

            return self.lastMove

        if last == self.lastMove:

            self.history[1] += 1

        elif (last == "C" and self.lastMove == "D") or (last == "D" and self.lastMove == "N") or (last == "N" and self.lastMove == "C"):

            self.history[0] += 1

        else:

            self.history[2] += 1



        if self.history[0] + 1 < self.history[2] or self.history[2] > 5:

            self.state = (self.state + 1) % 3

            self.history = [0,0,0]

        if self.history[1] > self.history[0] + self.history[2] + 2:

            self.state = (self.state + 2) % 3

            self.history = [0,0,0]



        if self.state == 0:

            self.lastMove = "N" if last == "D" else ("D" if last == "C" else "C")

        elif self.state == 1:

            self.lastMove = last

        else:

            self.lastMove = "C" if last == "D" else ("N" if last == "C" else "D")

        return self.lastMove

This bot uses LastOptimalBot's algorithm as long as it's winning. If the other bot starts predicting it, however, it will start playing whichever move its opponent played last (which is the move that beats the move that would beat LastOptimalBot). It cycles through simple transpositions of those algorithms as long as it continues to lose (or when it gets bored by drawing a lot).

Honestly, I'm surprised that LastOptimalBot is sitting in 5th as I post this. I'm fairly certain this will do better, assuming that I wrote this python correctly.

HandshakePatternMatch

from .patternfinder import PatternFinder

import collections



class HandshakePatternMatch:

    def __init__(self):

        self.moves = [None]

        self.other = 

        self.handshake = [None,"N","C","C","D","N"]

        self.friendly = None

        self.pattern = PatternFinder()

    def round(self, last):

        self.other.append(last)

        if last:

            if len(self.other) < len(self.handshake):

                # still trying to handshake

                if self.friendly == False or self.other[-1] != self.handshake[-1]:

                    self.friendly = False

                else:

                    self.friendly = True

                move = self.handshake[len(self.other)]

                self.pattern.round(last)

            elif self.friendly == True:

                # successful handshake and continued cooperation

                move = self.pattern.round(last)

                if last == "C":

                    move = "C"

                elif last == self.handshake[-1] and self.moves[-1] == self.handshake[-1]:

                    move = "C"

                else:

                    self.friendly = False

            else:

                # failed handshake or abandoned cooperation

                move = self.pattern.round(last)

        else:

            move = self.handshake[1]

            self.pattern.round(last)

        self.moves.append(move)

        return move

Why pattern match yourself? Handshake and cooperate away.

Hardcoded

class Hardcoded:

    sequence = "DNCNNDDCNDDDCCDNNNNDDCNNDDCDCNNNDNDDCNNDDNDDCDNCCNNDNNDDCNNDDCDCNNNDNCDNDNDDNCNDDCDNNDCNNDDCDCNNDNNDDCDNDDCCNNNDNNDDCNNDDNDCDNCNDDCDNNDDCCNDNNDDCNNNDCDNDDCNNNNDNDDCDNCDCNNDNNDDCDNDDCCNNNDNDDCNNNDNDCDCDNNDCNNDNDDCDNCNNDDCNDNNDDCDNNDCDNDNCDDCNNNDNDNCNDDCDNDDCCNNNNDNDDCNNDDCNNDDCDCNNDNNDDCDNDDCCNDNNDDCNNNDCDNNDNDDCCNNNDNDDNCDCDNNDCNNDNDDCNNDDCDNCNNDDCDNNDCDNDNCDDCNDNNDDCNNNDDCDNCNNDNNDDCNNDDNNDCDNCNDDCNNDCDNNDDCNNDDNCDCNNDNDNDDCDNCDCNNNDNDDCDCNNDNNDDCDNDDCCNNNDNNDDCNDNDNCDDCDCNNNNDNDDCDNCNDDCDNNDDCNNNDNDDCDNCNNDCNNDNDDNCDCDNNNDDCNNDDCNNDDNNDCDNCNDDCNNDDNDCDNNDNDDCCNCDNNDCNNDDNDDCNCDNNDCDNNNDDCNNDDCDCDNNDDCNDNCNNDNNDNDNDDCDNCDCNNNDNDDCDNCNNDDCDNNDCNNDDCNNDDCDCDNNDDCNDNCNNNDDCDNNDCDNDNCNNDNDDNNDNDCDDCCNNNDDCNDNDNCDDCDCNNNDNNDDCNDCDNDDCNNNNDNDDCCNDNNDDCDCNNNDNDDNDDCDNCCNNDNNDDCNNDDCDCNNDNNDDCNNDDNCNDDNNDCDNCNDDCNNDDNDCDNNDNDDCCNCDNNDCNNDNDDCNNDDNCDCDNNDCNNDNDDCDCDNNNNDDCNNDDNDCCNNDDNDDCNCDNNDCNNDDNDDCDNCNDDCNNNNDCDNNDDCNDNDDCDNCNNDCDNNDCNNDNDDNCDCNNDNDDCDNDDCCNNNNDNDDCNNDDCDCNNDNNDDCDCDNNDDC"

    def __init__(self):

        self.round_num = -1

    def round(self,_):

        self.round_num += 1

        return Hardcoded.sequence[self.round_num % 1000]

Just plays a hardcoded sequence of moves optimized to beat some of the top deterministic bots.