Project 21 solution

Author: lukemcguire

21_tictactoe/test.py

@@ -7,24 +7,24 @@
 import re
 import string
 
-prg = './tictactoe.py'
+PRG = "./tictactoe.py"
 
 
 # --------------------------------------------------
 def test_exists():
     """exists"""
 
-    assert os.path.isfile(prg)
+    assert os.path.isfile(PRG)
 
 
 # --------------------------------------------------
 def test_usage():
     """usage"""
 
-    for flag in ['-h', '--help']:
-        rv, out = getstatusoutput(f'{prg} {flag}')
+    for flag in ["-h", "--help"]:
+        rv, out = getstatusoutput(f"python {PRG} {flag}")
         assert rv == 0
-        assert out.lower().startswith('usage')
+        assert out.lower().startswith("usage")
 
 
 # --------------------------------------------------
@@ -42,7 +42,7 @@ def test_no_input():
 No winner.
 """.strip()
 
-    rv, out = getstatusoutput(prg)
+    rv, out = getstatusoutput(f"python {PRG}")
     assert rv == 0
     assert out.strip() == board
 
@@ -53,8 +53,8 @@ def test_bad_board():
 
     expected = '--board "{}" must be 9 characters of ., X, O'
 
-    for bad in ['ABC', '...XXX', 'XXXOOOXX']:
-        rv, out = getstatusoutput(f'{prg} --board {bad}')
+    for bad in ["ABC", "...XXX", "XXXOOOXX"]:
+        rv, out = getstatusoutput(f"python {PRG} --board {bad}")
         assert rv != 0
         assert re.search(expected.format(bad), out)
 
@@ -63,8 +63,8 @@ def test_bad_board():
 def test_bad_player():
     """dies on bad player"""
 
-    bad = random.choice([c for c in string.ascii_uppercase if c not in 'XO'])
-    rv, out = getstatusoutput(f'{prg} -p {bad}')
+    bad = random.choice([c for c in string.ascii_uppercase if c not in "XO"])
+    rv, out = getstatusoutput(f"python {PRG} -p {bad}")
     assert rv != 0
     expected = f"-p/--player: invalid choice: '{bad}'"
     assert re.search(expected, out)
@@ -75,17 +75,17 @@ def test_bad_cell_int():
     """dies on bad cell"""
 
     for bad in [0, 10]:
-        rv, out = getstatusoutput(f'{prg} --cell {bad}')
+        rv, out = getstatusoutput(f"python {PRG} --cell {bad}")
         assert rv != 0
-        assert re.search(f'-c/--cell: invalid choice: {bad}', out)
+        assert re.search(f"-c/--cell: invalid choice: {bad}", out)
 
 
 # --------------------------------------------------
 def test_bad_cell_str():
     """dies on bad cell string value"""
 
     bad = random.choice(string.ascii_letters)
-    rv, out = getstatusoutput(f'{prg} --cell {bad}')
+    rv, out = getstatusoutput(f"python {PRG} --cell {bad}")
     assert rv != 0
     assert re.search(f"-c/--cell: invalid int value: '{bad}'", out, re.I)
 
@@ -94,10 +94,10 @@ def test_bad_cell_str():
 def test_both_player_and_cell():
     """test for both --player and --cell"""
 
-    player = random.choice('XO')
-    rv, out = getstatusoutput(f'{prg} --player {player}')
+    player = random.choice("XO")
+    rv, out = getstatusoutput(f"python {PRG} --player {player}")
     assert rv != 0
-    assert re.search('Must provide both --player and --cell', out)
+    assert re.search("Must provide both --player and --cell", out)
 
 
 # --------------------------------------------------
@@ -115,7 +115,7 @@ def test_good_board_01():
 No winner.
 """.strip()
 
-    rv, out = getstatusoutput(f'{prg} -b .........')
+    rv, out = getstatusoutput(f"python {PRG} -b .........")
     assert rv == 0
     assert out.strip() == board
 
@@ -135,7 +135,7 @@ def test_good_board_02():
 No winner.
 """.strip()
 
-    rv, out = getstatusoutput(f'{prg} --board ...OXX...')
+    rv, out = getstatusoutput(f"python {PRG} --board ...OXX...")
     assert rv == 0
     assert out.strip() == board
 
@@ -155,7 +155,7 @@ def test_mutate_board_01():
 No winner.
 """.strip()
 
-    rv, out = getstatusoutput(f'{prg} -b ......... --player X -c 1')
+    rv, out = getstatusoutput(f"python {PRG} -b ......... --player X -c 1")
     assert rv == 0
     assert out.strip() == board
 
@@ -175,7 +175,7 @@ def test_mutate_board_02():
 O has won!
 """.strip()
 
-    rv, out = getstatusoutput(f'{prg} --board XXO...OOX --p O -c 5')
+    rv, out = getstatusoutput(f"python {PRG} --board XXO...OOX --p O -c 5")
     assert rv == 0
     assert out.strip() == board
 
@@ -184,11 +184,11 @@ def test_mutate_board_02():
 def test_mutate_cell_taken():
     """test for a cell already taken"""
 
-    rv1, out1 = getstatusoutput(f'{prg} -b XXO...OOX --player X --cell 9')
+    rv1, out1 = getstatusoutput(f"python {PRG} -b XXO...OOX --player X --cell 9")
     assert rv1 != 0
     assert re.search('--cell "9" already taken', out1)
 
-    rv2, out2 = getstatusoutput(f'{prg} --board XXO...OOX --p O -c 1')
+    rv2, out2 = getstatusoutput(f"python {PRG} --board XXO...OOX --p O -c 1")
     assert rv2 != 0
     assert re.search('--cell "1" already taken', out2)
 
@@ -197,30 +197,37 @@ def test_mutate_cell_taken():
 def test_winning():
     """test winning boards"""
 
-    wins = [('PPP......'), ('...PPP...'), ('......PPP'), ('P..P..P..'),
-            ('.P..P..P.'), ('..P..P..P'), ('P...P...P'), ('..P.P.P..')]
+    wins = [
+        ("PPP......"),
+        ("...PPP..."),
+        ("......PPP"),
+        ("P..P..P.."),
+        (".P..P..P."),
+        ("..P..P..P"),
+        ("P...P...P"),
+        ("..P.P.P.."),
+    ]
 
-    for player in 'XO':
-        other_player = 'O' if player == 'X' else 'X'
+    for player in "XO":
+        other_player = "O" if player == "X" else "X"
 
         for board in wins:
-            board = board.replace('P', player)
-            dots = [i for i in range(len(board)) if board[i] == '.']
+            board = board.replace("P", player)
+            dots = [i for i in range(len(board)) if board[i] == "."]
             mut = random.sample(dots, k=2)
-            test_board = ''.join([
-                other_player if i in mut else board[i]
-                for i in range(len(board))
-            ])
-            out = getoutput(f'{prg} -b {test_board}').splitlines()
-            assert out[-1].strip() == f'{player} has won!'
+            test_board = "".join(
+                [other_player if i in mut else board[i] for i in range(len(board))]
+            )
+            out = getoutput(f"python {PRG} -b {test_board}").splitlines()
+            assert out[-1].strip() == f"{player} has won!"
 
 
 # --------------------------------------------------
 def test_losing():
     """test losing boards"""
 
-    losing_board = list('XXOO.....')
+    losing_board = list("XXOO.....")
     for i in range(10):
         random.shuffle(losing_board)
-        out = getoutput(f'{prg} -b {"".join(losing_board)}').splitlines()
-        assert out[-1].strip() == 'No winner.'
+        out = getoutput(f'python {PRG} -b {"".join(losing_board)}').splitlines()
+        assert out[-1].strip() == "No winner."

21_tictactoe/tictactoe.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+Author : Luke McGuire <[email protected]>
+Date   : 2024-07-03
+Purpose: Tic-Tac-Toe
+"""
+
+import argparse
+
+
+# --------------------------------------------------
+def get_args():
+    """Get command-line arguments"""
+
+    parser = argparse.ArgumentParser(
+        description="Tic-Tac-Toe",
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    parser.add_argument(
+        "-b",
+        "--board",
+        help="The state of the board",
+        metavar="board",
+        type=str,
+        default="." * 9,
+    )
+
+    parser.add_argument(
+        "-p",
+        "--player",
+        help="Player",
+        metavar="player",
+        type=str,
+        choices=["X", "O"],
+        default=None,
+    )
+
+    parser.add_argument(
+        "-c",
+        "--cell",
+        help="Cell 1-9",
+        metavar="cell",
+        type=int,
+        choices=range(1, 10),
+        default=None,
+    )
+
+    args = parser.parse_args()
+
+    if len(args.board) != 9 or any(c not in "XO." for c in args.board):
+        parser.error(f'--board "{args.board}" must be 9 characters of ., X, O')
+
+    if any([args.player, args.cell]) and not all([args.player, args.cell]):
+        parser.error("Must provide both --player and --cell")
+
+    if args.cell and args.board[args.cell - 1] != ".":
+        parser.error(f'--cell "{args.cell}" already taken')
+
+    return args
+
+
+# --------------------------------------------------
+def format_board(board: str) -> str:
+    """Formats the board string as a tic-tac-toe grid"""
+
+    row_divider = "-------------"
+    cells = [str(i) if c == "." else c for i, c in enumerate(board, start=1)]
+
+    cells_templ = "| {} | {} | {} |"
+
+    return "\n".join(
+        [
+            row_divider,
+            cells_templ.format(*cells[:3]),
+            row_divider,
+            cells_templ.format(*cells[3:6]),
+            row_divider,
+            cells_templ.format(*cells[6:9]),
+            row_divider,
+        ]
+    )
+
+
+# --------------------------------------------------
+def find_winner(board):
+    """Determine if there is a winner"""
+
+    wins = [
+        ("PPP......"),
+        ("...PPP..."),
+        ("......PPP"),
+        ("P..P..P.."),
+        (".P..P..P."),
+        ("..P..P..P"),
+        ("P...P...P"),
+        ("..P.P.P.."),
+    ]
+
+    for player in "XO":
+        for winning_board in wins:
+            if is_winning(board, winning_board, player):
+                return player
+
+    return None
+
+
+# --------------------------------------------------
+def is_winning(board, condition, player):
+    """Check if the board matches a win condition"""
+    condition = condition.replace("P", player)
+    for win_cell, board_cell in zip(condition, board):
+        if win_cell not in (".", board_cell):
+            return False
+    return True
+
+
+# --------------------------------------------------
+
+
+def main():
+    """Make a jazz noise here"""
+
+    args = get_args()
+    board = args.board
+    if args.cell:
+        board = board[: args.cell - 1] + args.player + board[args.cell :]
+
+    winner = find_winner(board)
+    print(format_board(board))
+    print(f"{winner} has won!" if winner else "No winner.")
+
+
+# --------------------------------------------------
+if __name__ == "__main__":
+    main()