challenge マルバツゲーム

マルバツゲームは3×3の格子に交互に○と×を書き込み、先に縦・横・斜めに記号をそろえたほうが勝ちというおなじみのゲームです。

「毎ターン乱数を使って手を決めるランダムプレイヤー同士を対戦させる」というのが今回のお題です。 1万回対戦させ、勝ち・負け・引き分けの数を表示してください。 そして先手が有利であることを確かめてください。

良い手を思考するプレイヤーについては別のお題にしようと思っています。 プレイヤーを簡単に差し換えることができる設計を目指してください。

Posted feedbacks - Java

Playerを実装すれば、実装を置き換えられます。
しかし、Scalaと比べてだいぶ長くなっちゃいました。
とりあえず、3回実行してみた結果です。

Result:
Player1 won: 5214
Player2 won: 2355
draw game  : 2431

Result:
Player1 won: 5211
Player2 won: 2444
draw game  : 2345

Result:
Player1 won: 5174
Player2 won: 2404
draw game  : 2422
  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
import java.util.Random;

public class TicTacToe {
    public static final int SIZE = 3;

    private final Mark[][] fields_ = new Mark[SIZE][SIZE];
    private final Pair[][] lines_ = new Pair[][] {
            {new Pair(0,0), new Pair(0,1), new Pair(0,2)},
            {new Pair(1,0), new Pair(1,1), new Pair(1,2)},
            {new Pair(2,0), new Pair(2,1), new Pair(2,2)},
            {new Pair(0,0), new Pair(1,0), new Pair(2,0)},
            {new Pair(0,1), new Pair(1,1), new Pair(2,1)},
            {new Pair(0,2), new Pair(1,2), new Pair(2,2)},
            {new Pair(0,0), new Pair(1,1), new Pair(2,2)},
            {new Pair(2,2), new Pair(1,1), new Pair(0,0)},
    };


    public TicTacToe() {
        for (int x = 0; x < SIZE; x++) {
            for (int y = 0; y < SIZE; y++) {
                fields_[x][y] = Mark.E;
            }
        }
    }

    public Mark getMark(Pair pair) {
        return fields_[pair.x][pair.y];
    }
    public void setMark(Pair pair, Mark mark) {
        fields_[pair.x][pair.y] = mark;
    }

    public boolean nextStep(Pair pair, Mark mark) {
        if (getMark(pair) != Mark.E) return false;
        setMark(pair, mark);
        return true;
    }

    public Mark isEndGame() {
        for (Pair[] row: lines_) {
            Mark m = null;
            boolean isSame = true;
            for (Pair cell: row) {
                Mark mark = fields_[cell.x][cell.y];
                if (m == null) {
                    m = mark;
                    continue;
                }
                if (m != mark) {
                    isSame = false;
                    break;
                }
            }
            if (isSame) return m;
        }
        return Mark.E;
    }


    public static void main(String[] args) {
        Player player1 = new RandomPlayer(Mark.O, "Player1");
        Player player2 = new RandomPlayer(Mark.X, "Player2");

        int maxTurn = TicTacToe.SIZE * TicTacToe.SIZE;
        int[] result = new int[3];
        for (int round = 0; round < 10000; round++) {
            TicTacToe game = new TicTacToe();
            for (int turn = 0; turn <= maxTurn; turn++) {
                if (turn == maxTurn) {
                    result[2]++;
                    break;
                } else if (turn % 2 == 0) {
                    player1.put(game);
                } else {
                    player2.put(game);
                }
                Mark mark = game.isEndGame();
                if (mark == Mark.O) {
                    result[0]++;
                    break;
                } else if (mark == Mark.X) {
                    result[1]++;
                    break;
                }
            }
        }

        System.out.println("Result:");
        System.out.printf("%s won: %d%n", player1.name, result[0]);
        System.out.printf("%s won: %d%n", player2.name, result[1]);
        System.out.printf("draw game  : %d%n", result[2]);
    }
}

enum Mark {
    E { @Override public Mark getOpponent() { return E; } },
    O { @Override public Mark getOpponent() { return X; } },
    X { @Override public Mark getOpponent() { return O; } };

    public abstract Mark getOpponent();
}
class Pair {
    public final int x;
    public final int y;

    public Pair(int x, int y) {
        this.x = x;
        this.y = y;
    }
}


abstract class Player {
    public final Mark mark;
    public final String name;

    public Player(Mark mark, String name) {
        this.mark = mark;
        this.name = name;
    }

    public abstract void put(TicTacToe game);
}

class RandomPlayer extends Player {
    private final Random random_ = new Random();

    public RandomPlayer(Mark mark, String name) {
        super(mark, name);
    }

    @Override
    public void put(TicTacToe game) {
        for (;;) {
            Pair pair = getNextPair();
            boolean res = game.nextStep(pair, mark);
            if (res) break;
        }
    }
    private Pair getNextPair() {
        return new Pair(random_.nextInt(TicTacToe.SIZE), random_.nextInt(TicTacToe.SIZE));
    }
}

Index

Feed

Other

Link

Pathtraq

loading...