Construct a java method. This method chooses the number of sti.pdf

Construct a java method.
* This method chooses the number of sticks to pick up based on the
* sticksRemaining and actionRanking parameters.
*
* Algorithm: If there are less than Config.MAX_ACTION sticks remaining
* then the chooser must pick the minimum number of sticks (Config.MIN_ACTION).
* For Config.MAX_ACTION or more sticks remaining then pick based on the
* actionRanking parameter.
*
* The actionRanking array has one element for each possible action. The 0
* index corresponds to Config.MIN_ACTION and the highest index corresponds
* to Config.MAX_ACTION. For example, if Config.MIN_ACTION is 1 and
* Config.MAX_ACTION is 3, an action can be to pick up 1, 2 or 3 sticks.
* actionRanking[0] corresponds to 1, actionRanking[1] corresponds to 2, etc.
* The higher the element for an action in comparison to other elements,
* the more likely the action should be chosen.
*
* First calculate the total number of possibilities by summing all the
* element values. Then choose a particular action based on the relative
* frequency of the various rankings.
* For example, if Config.MIN_ACTION is 1 and Config.MAX_ACTION is 3:
* If the action rankings are {9,90,1}, the total is 100. Since
* actionRanking[0] is 9, then an action of picking up 1 should be chosen
* about 9/100 times. 2 should be chosen about 90/100 times and 1 should
* be chosen about 1/100 times. Use Config.RNG.nextInt(?) method to
* generate appropriate random numbers.
*
* @param sticksRemaining
* The number of sticks remaining to be picked up.
* @param actionRanking
* The counts of each action to take. The 0 index corresponds to
* Config.MIN_ACTION and the highest index corresponds to
* Config.MAX_ACTION.
* @return The number of sticks to pick up. 0 is returned for the following
* conditions: actionRanking is null, actionRanking has a length of

* 0, or sticksRemaining is <= 0.
Solution
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
String userName = "";
String intialStringError = "";
int intialSticks = 0;
String prompt = "How many sticks are there on the table initially (10-100)? ";
//Max number of tries
int[] numSticksArray = new int[100];
boolean intialBooleanError = false;
boolean userChoiceDone = false;
int userChoice = 0;
String userError = "";
String friendName = "";
int userStickNum = 0;
String userStickError = "";
String friendStickError = "";
boolean friendTurnOver = true;
boolean userTurnOver = true;
int z = 0;
System.out.print(" What is your name? ");
userName = input.nextLine();
System.out.println("Hello " + userName.trim() + ".");
intialSticks = promptUserForNumber(input, prompt, Config.MIN_STICKS,
Config.MAX_STICKS);
System.out.println(" Would you like to:");
System.out.println(" 1) Play against a friend");
System.out.println(" 2) Play against computer (basic)");
System.out.println(" 3) Play against computer with AI");
do{
System.out.print("Which do you choose (1,2,3)? ");
if(input.hasNextInt())
{

userChoice = input.nextInt();
//input.nextLine();
if (userChoice >= 1 && userChoice <= 3) {
userChoiceDone = true;
}
else{
System.out.println("Please enter a number between 1 and 3.");
userChoiceDone = false;
}
}
else
{
userError = input.nextLine();
System.out.println("Error: expected a number between 1 and 3 but found: " + userError);
userChoiceDone = false;
}
} while(!userChoiceDone);
if(userChoice == 1) {
System.out.print(" What is your friend's name? ");
friendName = input.next();
System.out.println("Hello " + friendName.trim() + ".");
playAgainstFriend(input, intialSticks, userName, friendName);
}
System.out.println(" =========================================");
System.out.println("Thank you for playing the Game of Sticks!");
input.close();
}
static int promptUserForNumber(Scanner input, String prompt,
int min, int max) {
boolean intialBooleanError = false;
int intialSticks = 0;
int sticksTest;
String stringError = "";
do{
System.out.print(prompt);
if(input.hasNextInt())

{
sticksTest = input.nextInt();
//read to end of line then ignore
input.nextLine();
if (sticksTest >= min && sticksTest <= max) {
intialBooleanError = true;
intialSticks = sticksTest;
}
else{
System.out.println("Please enter a number between " + min +
" and " + max + ".");
intialBooleanError = false;
}
}
else
{
stringError = input.nextLine();
System.out.println("Error: expected a number between " + min +
" and " + max +" but found: " + stringError);
intialBooleanError = false;
}
} while(!intialBooleanError);
return intialSticks; //TODO change to return valid user input.
}
/**
* This method has one person play the Game of Sticks against another
* person.
*
* @param input
* An instance of Scanner to read user answers.
* @param startSticks
* The number of sticks to start the game with.
* @param player1Name
* The name of one player.
* @param player2Name
* The name of the other player.

*
* As a courtesy, player2 is considered the friend and gets to
* pick up sticks first.
*
*/
static void playAgainstFriend(Scanner input, int startSticks,
String player1Name, String player2Name) {
//player1Name = input.nextLine();
// System.out.print(" What is your friend's name? ");
//player2Name = input.nextLine();
//System.out.println("Hello " + player2Name.trim() + ".");
//TODO when sticksLeft is equal to 2, it prompts the friend to take sticks again
int userStickNum = 0;
boolean friendTurnOver = true;
boolean userTurnOver = true;
String userStickError = "";
String friendStickError = "";
// int z = 0;
System.out.print(" There are " + startSticks + " sticks on the board.");
int sticksLeft = startSticks;
for (int z = 0; sticksLeft > 0; z++) {
//Friend's turn
if (z % 2 == 0)
{
do {
String statement = " " + player2Name.trim() + ": How many sticks do you take (" +
Config.MIN_ACTION +
"-" + Math.min(Config.MAX_ACTION, sticksLeft) + ")?";
userStickNum = promptUserForNumber(input, statement, Config.MIN_ACTION,
Math.min(Config.MAX_ACTION, sticksLeft));
sticksLeft = sticksLeft - userStickNum;
if (sticksLeft == 0)
{
System.out.println(player1Name.trim() + " wins. " + player2Name.trim() + " loses.");
friendTurnOver = true;
break;

}
{
System.out.print("There is " + sticksLeft + " stick on the board.");
//break;
}
else
{
System.out.print("There are " + sticksLeft + " sticks on the board.");
//break;
}
} while(!friendTurnOver);
}
//user turn
else if (z % 2 == 1)
{
do
{
String statement = " " + player1Name.trim() + ": How many sticks do you take (" +
Config.MIN_ACTION +
"-" + Math.min(Config.MAX_ACTION, sticksLeft) + ")?";
userStickNum = promptUserForNumber(input, statement, Config.MIN_ACTION,
Math.min(Config.MAX_ACTION, sticksLeft));
sticksLeft = sticksLeft - userStickNum;
{
System.out.println(player2Name.trim() + " wins. " + player1Name.trim() + " loses.");
userTurnOver = true;
break;
}
{
System.out.print("There is " + sticksLeft + " stick on the board.");

//break;
}
else
{
System.out.print("There are " + sticksLeft + " sticks on the board.");
//break;
}
} while(!userTurnOver);
}
}
//TODO
}
/**
* Make a choice about the number of sticks to pick up when given the number
* of sticks remaining.
*
* Algorithm: If there are less than Config.MAX_ACTION sticks remaining,
* then pick up the minimum number of sticks (Config.MIN_ACTION).
* If Config.MAX_ACTION sticks remain, randomly choose a number between
* Config.MIN_ACTION and Config.MAX_ACTION. Use Config.RNG.nextInt(?)
* method to generate an appropriate random number.
*
* The number of sticks remaining in the game.
* @return The number of sticks to pick up, or 0 if sticksRemaining is <= 0.
*/
static int basicChooseAction(int sticksRemaining) {
if(sticksRemaining < Config.MAX_ACTION){
if(sticksRemaining <= 0){
sticksRemaining = 0;
}
else{
sticksRemaining = Config.MIN_ACTION;
}
}

else if ( sticksRemaining >= Config.MAX_ACTION){
sticksRemaining = Config.RNG.nextInt(Config.MAX_ACTION) + Config.MIN_ACTION ;
}
return sticksRemaining;
}
/**
* This method has a person play against a computer.
* Call the promptUserForNumber method to obtain user input.
* Call the aiChooseAction method with the actionRanking row
* for the number of sticks remaining.
*
* If the strategyTable is null, then this method calls the
* basicChooseAction method to make the decision about how
* many sticks to pick up. If the strategyTable parameter
* is not null, this method makes the decision about how many sticks to
* pick up by calling the aiChooseAction method.
*
* @param input
* An instance of Scanner to read user answers.
* @param playerName
* The name of one player.
* @param strategyTable
* An array of action rankings. One action ranking for each stick
* that the game begins with.
*
*/
static void playAgainstComputer(Scanner input, int startSticks,
String playerName, int[][] strategyTable) {
//TODO
}
/**
* This method chooses the number of sticks to pick up based on the
* sticksRemaining and actionRanking parameters.
*

* Algorithm: If there are less than Config.MAX_ACTION sticks remaining
* then the chooser must pick the minimum number of sticks (Config.MIN_ACTION).
* For Config.MAX_ACTION or more sticks remaining then pick based on the
* actionRanking parameter.
*
* The actionRanking array has one element for each possible action. The 0
* index corresponds to Config.MIN_ACTION and the highest index corresponds
* to Config.MAX_ACTION. For example, if Config.MIN_ACTION is 1 and
* Config.MAX_ACTION is 3, an action can be to pick up 1, 2 or 3 sticks.
* actionRanking[0] corresponds to 1, actionRanking[1] corresponds to 2, etc.
* The higher the element for an action in comparison to other elements,
* the more likely the action should be chosen.
*
* First calculate the total number of possibilities by summing all the
* element values. Then choose a particular action based on the relative
* frequency of the various rankings.
* For example, if Config.MIN_ACTION is 1 and Config.MAX_ACTION is 3:
* If the action rankings are {9,90,1}, the total is 100. Since
* actionRanking[0] is 9, then an action of picking up 1 should be chosen
* about 9/100 times. 2 should be chosen about 90/100 times and 1 should
* be chosen about 1/100 times. Use Config.RNG.nextInt(?) method to
* generate appropriate random numbers.
*
* The number of sticks remaining to be picked up.
* @return The number of sticks to pick up. 0 is returned for the following
* conditions: actionRanking is null, actionRanking has a length of
* 0, or sticksRemaining is <= 0.
*
*/
static int aiChooseAction(int sticksRemaining, int[] actionRanking) {
return -1; //TODO change to appropriate value

}
/**
* This method initializes each element of the array to 1. If actionRanking
* is null then method simply returns.
*
* The counts of each action to take. Use the length of the
* actionRanking array rather than rely on constants for the
* function of this method.
*/
static void initializeActionRanking(int []actionRanking) {
//TODO
}
/**
* This method returns a string with the number of sticks left and the
* ranking for each action as follows.
*
* An example: 10 3,4,11
*
* The string begins with a number (number of sticks left), then is followed
* by 1 tab character, then a comma separated list of rankings, one for each
* action choice in the array. The string is terminated with a newline ( )
* character.
*
* @param sticksLeft
* The number of sticks left.
* The counts of each action to take. Use the length of the
* actionRanking array rather than rely on constants for the
* function of this method.
* @return A string formatted as described.
*/
static String actionRankingToString(int sticksLeft, int[]actionRanking) {
return ""; //TODO change to return a String with the specified format.
}
/**

* This method updates the actionRanking based on the action. Since the game
* was lost, the actionRanking for the action is decremented by 1, but not
* allowing the value to go below 1.
*
* @param action
* A specific action between and including Config.MIN_ACTION and
*/
static void updateActionRankingOnLoss(int []actionRanking, int action) {
//TODO
}
/**
* This method updates the actionRanking based on the action. Since the game
* was won, the actionRanking for the action is incremented by 1.
*
* @param action
* A specific action between and including Config.MIN_ACTION and
*/
static void updateActionRankingOnWin(int []actionRanking, int action) {
//TODO
}
/**
* Allocates and initializes a 2 dimensional array. The number of rows
* corresponds to the number of startSticks. Each row is an actionRanking
* with an element for each possible action. The possible actions range from
* Config.MIN_ACTION to Config.MAX_ACTION. Each actionRanking is initialized
* with the initializeActionRanking method.

*
* The number of sticks the game is starting with.
* @return The two dimensional strategyTable, properly initialized.
*/
static int[][] createAndInitializeStrategyTable(int startSticks) {
return null; //TODO change to return the array
}
/**
* This formats the whole strategyTable as a string utilizing the
* actionRankingToString method. For example:
*
* Strategy Table
* Sticks Rankings
* 10 3,4,11
* 9 6,2,5
* 8 7,3,1 etc.
*
* The title "Strategy Table" should be proceeded by a .
*
* An array of actionRankings.
* @return A string containing the properly formatted strategy table.
*/
static String strategyTableToString(int[][] strategyTable) {
return ""; //TODO change to return the formatted String
}
/**
* This updates the strategy table since a game was won.
*
* The strategyTable has the set of actionRankings for each number of sticks
* left. The actionHistory array records the number of sticks the user took
* when a given number of sticks remained on the table. Remember that
* indexing starts at 0. For example, if actionHistory at index 6 is 2,
* then the user took 2 sticks when there were 7 sticks remaining on the
* table.

* For each action noted in the history, this calls the
* updateActionRankingOnWin method passing the corresponding action
* and actionRanking. After calling this method, the actionHistory is
* cleared (all values set to 0).
*
*
* @param actionHistory
* An array where the index indicates the sticks left and the
* element is the action that was made.
*/
static void updateStrategyTableOnWin(int[][] strategyTable, int[] actionHistory) {
//TODO
}
/**
* This updates the strategy table for a loss.
*
* The strategyTable has the set of actionRankings for each number of sticks
* left. The actionHistory array records the number of sticks the user took
* when a given number of sticks remained on the table. Remember that
* indexing starts at 0. For example, if actionHistory at index 6 is 2,
* then the user took 2 sticks when there were 7 sticks remaining on the
* table.
* For each action noted in the history, this calls the
* updateActionRankingOnLoss method passing the corresponding action
* and actionRanking. After calling this method, the actionHistory is
* cleared (all values set to 0).
*
* @param actionHistory
* An array where the index indicates the sticks left and the
* element is the action that was made.
*/
static void updateStrategyTableOnLoss(int[][] strategyTable, int[] actionHistory) {

//TODO
}
/**
* This method simulates a game between two players using their
* corresponding strategyTables. Use the aiChooseAction method
* to choose an action for each player. Record each player's
* actions in their corresponding history array.
* This method doesn't print out any of the actions being taken.
* Player 1 should make the first move in the game.
*
* @param player1StrategyTable
* @param player1ActionHistory
* An array for recording the actions that occur.
* @param player2StrategyTable
* @param player2ActionHistory
* An array for recording the actions that occur.
* @return 1 or 2 indicating which player won the game.
*/
static int playAiVsAi(int startSticks, int[][] player1StrategyTable,
int[] player1ActionHistory, int[][] player2StrategyTable,
int[] player2ActionHistory) {
return -1; //TODO change to return the winning player.
}
/**
* This method has the computer play against itself many times. Each time
* it plays it records the history of its actions and uses those actions
* to improve its strategy.
*
* Algorithm:
* 1) Create a strategy table for each of 2 players with
* createAndInitializeStrategyTable.
* 2) Create an action history for each player. An action history is a

* single dimension array of int. Each index in action history
* corresponds to the number of sticks remaining where the 0 index is
* 1 stick remaining.
* 3) For each game,
* 4) Call playAiVsAi with the return value indicating the winner.
* 5) Call updateStrategyTableOnWin for the winner and
* 6) Call updateStrategyTableOnLoss for the loser.
* 7) After the games are played then the strategyTable for whichever
* strategy won the most games is returned. When both players win the
* same number of games, return the first player's strategy table.
*
* The number of sticks to start with.
* @param numberOfGamesToPlay
* The number of games to play and learn from.
* @return A strategyTable that can be used to make action choices when
* playing a person. Returns null if startSticks is less than
* Config.MIN_STICKS or greater than Config.MAX_STICKS. Also returns
* null if numberOfGamesToPlay is less than 1.
*/
static int[][] trainAi(int startSticks, int numberOfGamesToPlay) {
return null; //TODO return the strategy table of the winning player
}
}

Construct a java method. This method chooses the number of sti.pdf

More Related Content

More from arihantmobilepoint15 (20)

Recently uploaded (20)

Construct a java method. This method chooses the number of sti.pdf