Add the K86R (MoreGrofman) Strategy

axelrod/strategies/_strategies.py

@@ -7,7 +7,7 @@
 from .axelrod_first import (
     Davis, RevisedDowning, Feld, Grofman, Nydegger, Joss, Shubik, Tullock,
     UnnamedStrategy, SteinAndRapoport, TidemanAndChieruzzi)
-from .axelrod_second import Champion, Eatherley, Tester, Gladstein
+from .axelrod_second import Champion, Eatherley, Tester, Gladstein, MoreGrofman
 from .backstabber import BackStabber, DoubleCrosser
 from .better_and_better import BetterAndBetter
 from .calculator import Calculator
@@ -197,6 +197,7 @@
     MindReader,
     MindWarper,
     MirrorMindReader,
+    MoreGrofman,
     Negation,
     NiceAverageCopier,
     NTitsForMTats,

axelrod/strategies/axelrod_second.py

@@ -199,3 +199,62 @@ def strategy(self, opponent: Player) -> Action:
         else:
             # Play TFT
             return opponent.history[-1]
+
+
+class MoreGrofman(Player):
+    '''
+    Submitted to Axelrod's second tournament by Bernard Grofman.
+
+    This strategy has 3 phases:
+    1. First it cooperates on the first two rounds
+    2. For rounds 3-7 inclusive, it plays the same as the opponent's last move
+    3. Thereafter, it applies the following logic
+      - If its own previous move was C and the opponent has defected less than
+        twice in the last 7 rounds, cooperate
+      - If its own previous move was C and the opponent has defected twice or
+        more in the last 7 rounds, defect
+      - If its own previous move was D and the opponent has defected only once
+        or not at all in the last 7 rounds, cooperate
+      - If its own previous move was D and the opponent has defected more than
+        once in the last 7 rounds, defect
+
+    Names:
+    - Grofman's strategy: [Axelrod1980b]_
+    '''
+    name = 'MoreGrofman'
+    classifier = {
+        'memory_depth': 7,
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def __init__(self) -> None:
+        super().__init__()
+
+    def strategy(self, opponent: Player) -> Action:
+        # Cooperate on the first two moves
+        if not self.history or len(self.history) in [1]:
+            return C
+        # For rounds 3-7, play the opponent's last move
+        elif 2 <= len(self.history) <= 6:
+            return opponent.history[-1]
+        # Logic for the rest of the game
+        else:
+            opponent_defections_last_7_rounds = 0
+            for action in opponent.history[-7:]:
+                if action == D:
+                    opponent_defections_last_7_rounds += 1
+            if self.history[-1] == C:
+                if opponent_defections_last_7_rounds < 2:
+                    return C
+                else:
+                    return D
+            else:
+                if opponent_defections_last_7_rounds in [0, 1]:
+                    return C
+                else:
+                    return D

axelrod/tests/strategies/test_axelrod_second.py

@@ -158,3 +158,56 @@ def test_strategy(self):
         actions = [(D, C), (C, C), (C, D), (C, D), (D, D)]
         self.versus_test(opponent, expected_actions=actions,
                          attrs={'patsy': False})
+
+
+class TestMoreGrofman(TestPlayer):
+
+    name = "MoreGrofman"
+    player = axelrod.MoreGrofman
+    expected_classifier = {
+        'memory_depth': 7,
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        # Cooperate for the first two rounds
+        actions = [(C, C), (C, C)]
+        self.versus_test(axelrod.Cooperator(), expected_actions=actions)
+
+        # Cooperate for the first two rounds, then play tit for tat for 3-7
+        actions = [(C, C), (C, D), (D, C), (C, D), (D, C), (C, D), (D, C)]
+        self.versus_test(axelrod.Alternator(), expected_actions=actions)
+
+        # Demonstrate MoreGrofman Logic
+        # Own previous move was C, opponent defected less than twice in last 7
+        moregrofman_actions = [C] * 7 + [C]
+        opponent_actions = [C] * 6 + [D] * 2
+        opponent = axelrod.MockPlayer(actions=opponent_actions)
+        actions = list(zip(moregrofman_actions, opponent_actions))
+        self.versus_test(opponent, expected_actions=actions)
+
+        # Own previous move was C, opponent defected more than twice in last 7
+        moregrofman_actions = ([C] * 3 + [D] * 3 + [C]) + [D]
+        opponent_actions = ([C] * 2 + [D] * 3 + [C] * 2) + [D]
+        opponent = axelrod.MockPlayer(actions=opponent_actions)
+        actions = list(zip(moregrofman_actions, opponent_actions))
+        self.versus_test(opponent, expected_actions=actions)
+
+        # Own previous move was D, opponent defected once in last 7
+        moregrofman_actions = ([C] * 6 + [D]) + [C]
+        opponent_actions = ([C] * 5 + [D] * 1 + [C]) + [D]
+        opponent = axelrod.MockPlayer(actions=opponent_actions)
+        actions = list(zip(moregrofman_actions, opponent_actions))
+        self.versus_test(opponent, expected_actions=actions)
+
+        # Own previous move was D, opponent defected more than twice in last 7
+        moregrofman_actions = ([C] * 2 + [D] * 5) + [D]
+        opponent_actions = ([D] * 7) + [D]
+        opponent = axelrod.MockPlayer(actions=opponent_actions)
+        actions = list(zip(moregrofman_actions, opponent_actions))
+        self.versus_test(opponent, expected_actions=actions)