Every program is written to solve a problem. And a specific algorithm is implemented to solve the problem. In the Strategy pattern, the part that implements the algorithm can be exchanged. A pattern that makes it easy to switch algorithms and solve the same problem differently.
The role that defines the interface for using the strategy.
package strategy;
public interface Strategy {
//Decide what to do next
public abstract Hand nexHand();
//Learn if you won with the last hand
public abstract void study(boolean win);
}
The role that actually implements the interface of the Strategy role. Here, the strategy (strategy, method, policy, algorithm) is actually programmed.
package strategy;
import java.util.Random;
public class WinningStrategy implements Strategy{
private Random random;
private boolean won = false;
private Hand prevHand;
public WinningStrategy(int seed) {
random = new Random(seed);
}
/**
*If you win last time, you will get the same move, and if you lose, you will randomly decide your move.
*/
@Override
public Hand nextHand() {
if (!won) {
prevHand = Hand.getHand(random.nextInt(3));
}
return prevHand;
}
@Override
public void study(boolean win) {
won = win;
}
}
package strategy;
import java.util.Random;
public class ProbStrategy implements Strategy {
private Random random;
private int prevHandValue = 0;
private int currentHandValue = 0;
//Table for probability calculation that reflects past wins and losses
//[The last hand][Hands to put out this time]
private int[][] history = {
{1,1,1,},
{1,1,1,},
{1,1,1,},
};
public ProbStrategy(int seed) {
random = new Random(seed);
}
/**
*Calculate with probability from the value of history
*For example, history[0][0]The value of is 3, history[0][1]The value of is 5, history[0][2]If the value of is 7
*Goo, choki, par 3:5:Determine the next move as 7.
*0 or more and less than 15(15 is 3+5+Total value of 7)Get the random value of
*Goo if 0 or more and less than 3
*Choki if 3 or more and less than 8
*Par if 8 or more and less than 15
*To
*/
@Override
public Hand nextHand() {
int bet = random.nextInt(getSum(currentHandValue));
int handValue = 0;
if (bet < history[currentHandValue][0]) {
handValue = 0;
} else if (bet < history[currentHandValue][0] + history[currentHandValue][1]) {
handValue = 1;
} else {
handValue = 2;
}
prevHandValue = currentHandValue;
currentHandValue = handValue;
return Hand.getHand(handValue);
}
private int getSum(int hv) {
int sum = 0;
for (int i = 0; i < 3; i++) {
sum += history[hv][i];
}
return sum;
}
/**
*Update the contents of the history field based on the win or loss of the hand returned by the nextHand method
*
*/
@Override
public void study(boolean win) {
if (win) {
history[prevHandValue][currentHandValue]++;
} else {
history[prevHandValue][(currentHandValue + 1) % 3]++;
history[prevHandValue][(currentHandValue + 2) % 3]++;
}
}
}
A role that uses the Strategy role. I have an instance of the ConcreateStrategy role and use it as needed. It is the interface that plays the role of Strategy.
package strategy;
public class Player {
private String name;
private Strategy strategy;
private int winCount;
private int loseCount;
private int gameCount;
public Player(String name, Strategy strategy) {
this.name = name;
this.strategy = strategy;
}
public Hand nextHand() {
//It is your "strategy" that actually decides your next move
return strategy.nextHand();
}
public void win() {
//Change the internal state of the strategy
strategy.study(true);
winCount++;
gameCount++;
}
public void lose() {
//Change the internal state of the strategy
strategy.study(false);
loseCount++;
gameCount++;
}
public void even() {
gameCount++;
}
public String toString() {
return "[" + name + ":" + gameCount + " games, " + winCount + " win, " +
loseCount + " lose" + "]";
}
}
package strategy;
public class Main {
public static void main(String[] args) {
if (args.length != 2) {
System.out.println("Usage: java Main randmeseed1 randomeseed2");
System.out.println("Example: java Main 314 15");
System.exit(0);
}
int seed1 = Integer.parseInt(args[0]);
int seed2 = Integer.parseInt(args[1]);
Player p1 = new Player("Jiro", new WinningStrategy(seed1));
Player p2 = new Player("Taro", new ProbStrategy(seed2));
for (int i = 0; i < 10000; i++) {
Hand nexHand1 = p1.nextHand();
Hand nexHand2 = p2.nextHand();
if (nexHand1.isStrongerThan(nexHand2)) {
System.out.println("Winner:" + p1);
p1.win();
p2.lose();
} else if (nexHand2.isStrongerThan(nexHand1)) {
System.out.println("Winner:" + p2);
p1.lose();
p2.win();
} else {
System.out.println("Even…");
p1.even();
p2.even();
}
}
System.out.println("Total result:");
System.out.println(p1);
System.out.println(p2);
}
}
https://github.com/aki0207/strategy
I used this as a reference. Augmented and Revised Introduction to Design Patterns Learned in Java Language
Recommended Posts