Question: Working on a number guessing game in java 1) I should store prior guesses in a linked list, and the nodes in the list must

Working on a number guessing game in java

1) I should store prior guesses in a linked list, and the nodes in the list must follow the order of prior guesses. For example, if the prior guesses are 1000, 2111, 3222 in that order, the nodes must follow the same order.

2) I should store the candidate numbers also in a linked list, and the nodes must follow the order of numbers (i.e. from the smallest to the largest).

LinkedListGame.java:

package guessme;

/**

* A LinkedList-based implementation of the Guess-A-Number game

public class LinkedListGame {

// TODO: declare data members as necessary

/********************************************************

* NOTE: for this project you must use linked lists

* implemented by yourself. You are NOT ALLOWED to use

* Java arrays of any type, or any class in the java.util

* package (such as ArrayList).

*******************************************************/

/********************************************************

* NOTE: you are allowed to add new methods if necessary,

* but DO NOT remove any provided method, and do NOT add

* new files (as they will be ignored by the autograder).

*******************************************************/

// LinkedListGame constructor method

public LinkedListGame() {

// TODO

}

// Resets data members and game state so we can play again

public void reset() {

// TODO

}

// Returns true if n is a prior guess; false otherwise.

public boolean isPriorGuess(int n) {

// TODO

return false;

}

// Returns the number of guesses so far.

public int numGuesses() {

// TODO

return 0;

}

/**

* Returns the number of matches between integers a and b.

* You can assume that both are 4-digits long (i.e. between 1000 and 9999).

* The return value must be between 0 and 4.

* A match is the same digit at the same location. For example:

* 1234 and 4321 have 0 match;

* 1234 and 1114 have 2 matches (1 and 4);

* 1000 and 9000 have 3 matches (three 0's).

public static int numMatches(int a, int b) {

// TODO

return 0;

}

/**

* Returns true if the game is over; false otherwise.

* The game is over if the number has been correctly guessed

* or if no candidate is left.

public boolean isOver() {

// TODO

return false;

}

/**

* Returns the guess number and adds it to the list of prior guesses.

* The insertion should occur at the end of the prior guesses list,

* so that the order of the nodes follow the order of prior guesses.

public int getGuess() {

// TODO: add guess to the list of prior guesses.

return 0;

}

/**

* Updates guess based on the number of matches of the previous guess.

* If nmatches is 4, the previous guess is correct and the game is over.

* Check project description for implementation details.

* Returns true if the update has no error; false if no candidate

* is left (indicating a state of error);

public boolean updateGuess(int nmatches) {

// TODO

return false;

}

// Returns the head of the prior guesses list.

// Returns null if there hasn't been any prior guess

public LLIntegerNode priorGuesses() {

// TODO

return null;

}

/**

* Returns the list of prior guesses as a String. For example,

* if the prior guesses are 1000, 2111, 3222, in that order,

* the returned string should be "1000, 2111, 3222", in the same order,

* with every two numbers separated by a comma and space, except the

* last number (which should not be followed by either comma or space).

* Returns an empty string if here hasn't been any prior guess

public String priorGuessesString() {

// TODO

return "";

}

LLIntegerNode.java which I already finished:

package guessme;

/**

* This class defines a linked list node storing an integer.

* Use primitive type int (do not use wrapper class Integer)

* You must provide the following methods:

* - a constructor

* - a setInfo method and a getInfo method

* - a setLink method and a getLink method

public class LLIntegerNode {

// TODO

private int info;

private LLIntegerNode link;

public LLIntegerNode(int info,LLIntegerNode link) {

this.info = info;

this.link = link;

}

public int getInfo(){

return info;

}

public LLIntegerNode getLink(){

return link;

}

public void setInfo(int info){

this.info = info;

}

public void setLink (LLIntegerNode link){

this.link = link;

}

LinkedListGamePublicTest.java which is the JUnit test for this project:

package guessme;

import static org.junit.Assert.*;

import org.junit.Before;

import org.junit.Test;

public class LinkedListGamePublicTest {

private LinkedListGame gamerA, gamerB;

@Before

public void before() {

gamerA = new LinkedListGame();

gamerB = new LinkedListGame();

}

@Test(timeout = 1000)

public void testReset() {

gamerA.getGuess();

gamerA.updateGuess(0);

gamerA.reset();

assertEquals("numGuesses after reset", 0, gamerA.numGuesses());

assertFalse("isOver after reset", gamerA.isOver());

assertEquals("priorGuesses after reset", null, gamerA.priorGuesses());

assertEquals("priorGuessesString after reset", "", gamerA.priorGuessesString());

}

@Test(timeout = 1000)

public void testFirstGuessAndUpdate() {

gamerA.reset();

assertEquals("test first guess", 1000, gamerA.getGuess());

assertEquals("test first guess", 1, gamerA.numGuesses());

assertEquals("test first guess", 1000, gamerA.priorGuesses().getInfo());

assertEquals("test first guess", null, gamerA.priorGuesses().getLink());

assertEquals("test first guess", "1000", gamerA.priorGuessesString());

gamerA.updateGuess(0);

assertFalse("isOver after first update", gamerA.isOver());

}

@Test(timeout = 1000)

public void testIsOver() {

gamerA.reset();

gamerB.reset();

assertFalse("gameB not over yet", gamerB.isOver());

assertEquals("gameB 1st guess", 1000, gamerB.getGuess());

gamerB.updateGuess(4);

assertTrue("gameB is over", gamerB.isOver());

assertFalse("gameA not over yet", gamerA.isOver());

}

@Test(timeout = 1000)

public void testIsPriorGuess() {

gamerA.reset();

int g1 = gamerA.getGuess();

assertTrue("is prior guess", gamerA.isPriorGuess(g1));

assertFalse("not prior guess", gamerA.isPriorGuess(9999));

gamerA.updateGuess(0);

int g2 = gamerA.getGuess();

assertTrue("is prior guess", gamerA.isPriorGuess(g2));

assertFalse("not prior guess", gamerA.isPriorGuess(9999));

}

@Test(timeout = 1000)

public void testNumGuesses() {

gamerB.reset();

assertEquals("number of guesses shold be 0", 0, gamerB.numGuesses());

gamerB.getGuess();

assertEquals("number of guesses shold be 1", 1, gamerB.numGuesses());

gamerB.updateGuess(0);

gamerB.getGuess();

assertEquals("number of guesses shold be 2", 2, gamerB.numGuesses());

gamerB.updateGuess(4);

gamerB.getGuess();

assertEquals("number of guesses shold be 3", 3, gamerB.numGuesses());

}

@Test(timeout = 1000)

public void testUpdateGuessTrivial() {

gamerB.reset();

// ground truth number is 1000

assertEquals("gamerB first guess", 1000, gamerB.getGuess());

assertTrue("gamerB first update", gamerB.updateGuess(4));

assertTrue("gamerB game over", gamerB.isOver());

}

@Test(timeout = 1000)

public void testUpdateGuess() {

gamerA.reset();

// ground truth number is 3242

assertEquals("gamerA first guess", 1000, gamerA.getGuess());

assertTrue("gamerA first update", gamerA.updateGuess(0));

assertEquals("gamerA second guess", 2111, gamerA.getGuess());

assertTrue("gamerA second update", gamerA.updateGuess(0));

assertEquals("gamerA third guess", 3222, gamerA.getGuess());

assertTrue("gamerA third update", gamerA.updateGuess(3));

assertEquals("gamerA fourth guess", 3223, gamerA.getGuess());

assertTrue("gamerA fourth update", gamerA.updateGuess(2));

assertEquals("gamerA fifth guess", 3232, gamerA.getGuess());

assertTrue("gamerA fifth update", gamerA.updateGuess(3));

assertEquals("gamerA sixth guess", 3242, gamerA.getGuess());

assertTrue("gamerA sixth update", gamerA.updateGuess(4));

assertTrue("gamerA game over", gamerA.isOver());

}

@Test(timeout = 1000)

public void testUpdateGuessError() {

gamerA.reset();

gamerA.getGuess(); // should be 1000

gamerA.updateGuess(3);

gamerA.getGuess(); // should be 1001

assertFalse("state of error", gamerA.updateGuess(1)); // this number does not exist

// updateGuess should return false

gamerA.reset();

gamerA.getGuess(); // should be 1000

gamerA.updateGuess(3);

gamerA.getGuess(); // should be 1001

gamerA.updateGuess(2);

gamerA.getGuess(); // should be 1010

assertFalse("state of error", gamerA.updateGuess(1)); // this number does not exist

// updateGuess should return false

}

@Test(timeout = 1000)

public void testPriorGuesses() {

gamerB.reset();

assertEquals("test prior guesses", null, gamerB.priorGuesses());

int g1 = gamerB.getGuess();

LLIntegerNode pl = gamerB.priorGuesses();