Question

Suppose that you have several numbered billiard balls on a pool table. The smallest possible number on the ball is “1”. At each step, you remove a billiard ball from the table. If the ball removed is numbered n, you replace it with n balls randomly numbered less than n. For example, if you remove the “5” ball, you replace it with balls numbered “2”, “1”, “1”, “4”, and “3”, where numbers 2, 1, 1, 4, and 3 were randomly generated. If you remove the “1” ball, no new balls will be added.

Write a program that simulates this process. Start with only one ball on the table with the number on it selected by the user. Use the class ResizableBag in your implementation as defined in the UML diagram below. You only need to finish the Billiard.java class that contains main. Please note the sample run below.

need help with TODO sections

public class Billiard
{
    private BagInterface poolTable;

    /**
     * constructor creates this.poolTable object as ResizableArrayBag
     */
    public Billiard()
    {
        this.poolTable = new ResizableArrayBag<>();
    }

    /**
     * prompts the user for the first numbered ball and adds it to this.poolTable
     */
    public void addFirstElement()
    {
        final int SMALLEST_BALL = 1;
        final int LARGEST_BALL = 6;
        Scanner keyboard = new Scanner(System.in);
        int start;
        do
        {
            System.out.println("What is the first numbered ball to start with? (must be between " + SMALLEST_BALL
                    + " and " + LARGEST_BALL + " inclusive)");
            start = keyboard.nextInt();
        } while (!(start >= SMALLEST_BALL && start <= LARGEST_BALL));

        System.out.println("The first ball is: \"" + start + "\"");
        this.poolTable.add(start);
    }

    /**
     * Removes balls from this.poolTable until all are gone.
     */
    public void removeBallsFromTable()
    {
        System.out.println("\n*** Removing balls from the poolTable ***\n");
        Random random = new Random(17);
        // TODO Project1

        System.out.println("\nThe poolTable is empty!!!");
    } // end removeBallsFromTable

    /**
     * Displays the content of this.poolTable
     */
    private void DisplayContentOfPoolTable()
    {
        Object[] content = this.poolTable.toArray();
        System.out.println(Arrays.toString(content));
        System.out.println();
    } // end DisplayContentOfPoolTable

    public static void main(String args[])
    {
        Billiard billiard = new Billiard();
        billiard.addFirstElement();

        long startTime = Calendar.getInstance().getTime().getTime(); // get current time in miliseconds

        billiard.removeBallsFromTable();

        long stopTime = Calendar.getInstance().getTime().getTime();

        System.out.println("\nThe time required was " + (stopTime - startTime) + " milliseconds");
    } // end main
} // end Billiard

public final class ResizableArrayBag<T> implements BagInterface<T>
{
    private T[] bag; // Cannot be final due to doubling
    private int numberOfEntries;
    private boolean initialized = false;
    private static final int DEFAULT_CAPACITY = 25; // Initial capacity of bag
    private static final int MAX_CAPACITY = 10000;

    /**
     * Creates an empty bag whose initial capacity is 25.
     */
    public ResizableArrayBag()
    {
        this(DEFAULT_CAPACITY);
    } // end default constructor

    /**
     * Creates an empty bag having a given initial capacity.
     *
     * @param initialCapacity The integer capacity desired.
     */
    public ResizableArrayBag(int initialCapacity)
    {
        checkCapacity(initialCapacity);

        // The cast is safe because the new array contains null entries
        @SuppressWarnings("unchecked")
        T[] tempBag = (T[]) new Object[initialCapacity]; // Unchecked cast
        this.bag = tempBag;
        this.numberOfEntries = 0;
        this.initialized = true;
    } // end constructor

    /**
     * Creates a bag containing given entries.
     *
     * @param contents An array of objects.
     */
    public ResizableArrayBag(T[] contents)
    {
        checkCapacity(contents.length);
        this.bag = Arrays.copyOf(contents, contents.length);
        this.numberOfEntries = contents.length;
        this.initialized = true;
    } // end constructor

    /**
     * Adds a new entry to this bag.
     *
     * @param newEntry The object to be added as a new entry.
     * @return True.
     */
    public boolean add(T newEntry)
    {
        checkInitialization();
        if (isArrayFull())
        {
            doubleCapacity();
        } // end if

        this.bag[this.numberOfEntries] = newEntry;
        this.numberOfEntries++;

        return true;
    } // end add

    /**
     * Retrieves all entries that are in this bag.
     *
     * @return A newly allocated array of all the entries in this bag.
     */
    public T[] toArray()
    {
        checkInitialization();

        // The cast is safe because the new array contains null entries.
        @SuppressWarnings("unchecked")
        T[] result = (T[]) new Object[this.numberOfEntries]; // Unchecked cast
        for (int index = 0; index < this.numberOfEntries; index++)
        {
            result[index] = this.bag[index];
        } // end for

        return result;
    } // end toArray

    /**
     * Sees whether this bag is empty.
     *
     * @return True if this bag is empty, or false if not.
     */
    public boolean isEmpty()
    {
        return this.numberOfEntries == 0;
    } // end isEmpty

    /**
     * Gets the current number of entries in this bag.
     *
     * @return The integer number of entries currently in this bag.
     */
    public int getCurrentSize()
    {
        return this.numberOfEntries;
    } // end getCurrentSize

    /**
     * Counts the number of times a given entry appears in this bag.
     *
     * @param anEntry The entry to be counted.
     * @return The number of times anEntry appears in this ba.
     */
    public int getFrequencyOf(T anEntry)
    {
        checkInitialization();
        int counter = 0;

        for (int index = 0; index < this.numberOfEntries; index++)
        {
            if (anEntry.equals(this.bag[index]))
            {
                counter++;
            } // end if
        } // end for

        return counter;
    } // end getFrequencyOf

    /**
     * Tests whether this bag contains a given entry.
     *
     * @param anEntry The entry to locate.
     * @return True if this bag contains anEntry, or false otherwise.
     */
    public boolean contains(T anEntry)
    {
        checkInitialization();
        return getIndexOf(anEntry) > -1; // or >= 0
    } // end contains

    /**
     * Removes all entries from this bag.
     */
    public void clear()
    {
        while (!isEmpty())
            remove();
    } // end clear

    /**
     * Removes one unspecified entry from this bag, if possible.
     *
     * @return Either the removed entry, if the removal
     * was successful, or null.
     */
    public T remove()
    {
        checkInitialization();
        T result = removeEntry(this.numberOfEntries - 1);
        return result;
    } // end remove

    /**
     * Removes one occurrence of a given entry from this bag.
     *
     * @param anEntry The entry to be removed.
     * @return True if the removal was successful, or false if not.
     */
    public boolean remove(T anEntry)
    {
        checkInitialization();
        int index = getIndexOf(anEntry);
        T result = removeEntry(index);
        return anEntry.equals(result);
    } // end remove

    // Locates a given entry within the array bag.
    // Returns the index of the entry, if located,
    // or -1 otherwise.
    // Precondition: checkInitialization has been called.
    private int getIndexOf(T anEntry)
    {
        int where = -1;
        boolean found = false;
        int index = 0;

        while (!found && (index < this.numberOfEntries))
        {
            if (anEntry.equals(this.bag[index]))
            {
                found = true;
                where = index;
            } // end if
            index++;
        } // end while

        // Assertion: If where > -1, anEntry is in the array bag, and it
        // equals bag[where]; otherwise, anEntry is not in the array.

        return where;
    } // end getIndexOf

    // Removes and returns the entry at a given index within the array.
    // If no such entry exists, returns null.
    // Precondition: 0 <= givenIndex < numberOfEntries.
    // Precondition: checkInitialization has been called.
    private T removeEntry(int givenIndex)
    {
        T result = null;

        if (!isEmpty() && (givenIndex >= 0))
        {
            result = this.bag[givenIndex];          // Entry to remove
            int lastIndex = this.numberOfEntries - 1;
            this.bag[givenIndex] = this.bag[lastIndex];  // Replace entry to remove with last entry
            this.bag[lastIndex] = null;             // Remove reference to last entry
            this.numberOfEntries--;
        } // end if

        return result;
    } // end removeEntry

    // Returns true if the array bag is full, or false if not.
    private boolean isArrayFull()
    {
        return this.numberOfEntries >= this.bag.length;
    } // end isArrayFull

    // Doubles the size of the array bag.
    // Precondition: checkInitialization has been called.
    private void doubleCapacity()
    {
        int newLength = 2 * this.bag.length;
        checkCapacity(newLength);
        this.bag = Arrays.copyOf(this.bag, newLength);
    } // end doubleCapacity

    // Throws an exception if the client requests a capacity that is too large.
    private void checkCapacity(int capacity)
    {
        if (capacity > MAX_CAPACITY)
            throw new IllegalStateException("Attempt to create a bag whose capacity exceeds " +
                    "allowed maximum of " + MAX_CAPACITY);
    } // end checkCapacity

    // Throws an exception if receiving object is not initialized.
    private void checkInitialization()
    {
        if (!this.initialized)
            throw new SecurityException("Uninitialized object used " +
                    "to call an ArrayBag method.");
    } // end checkInitialization
} // end ResizableArrayBag

Answer 1

I have answered this question before. Here is the completed code for this problem. Comments are included, go through it, learn how things work and let me know if you have any doubts or if you need anything to change. If you are satisfied with the solution, please rate the answer. Thanks

// Billiard.java

import java.util.Arrays;

import java.util.Calendar;

import java.util.Random;

import java.util.Scanner;

public class Billiard {

      private BagInterface<Integer> poolTable;

      /**

      * constructor creates this.poolTable object as ResizableArrayBag

      */

      public Billiard() {

            this.poolTable = new ResizableArrayBag<Integer>();

      }

      /**

      * prompts the user for the first numbered ball and adds it to

      * this.poolTable

      */

      public void addFirstElement() {

            final int SMALLEST_BALL = 1;

            final int LARGEST_BALL = 6;

            Scanner keyboard = new Scanner(System.in);

            int start;

            do {

                  System.out

                              .println("What is the first numbered ball to start with? (must be between "

                                           + SMALLEST_BALL

                                           + " and "

                                           + LARGEST_BALL

                                           + " inclusive)");

                  start = keyboard.nextInt();

            } while (!(start >= SMALLEST_BALL && start <= LARGEST_BALL));

            System.out.println("The first ball is: \"" + start + "\"");

            this.poolTable.add(start);

      }

      /**

      * Removes balls from this.poolTable until all are gone.

      */

      public void removeBallsFromTable() {

            System.out.println("\n*** Removing balls from the poolTable ***\n");

            Random random = new Random(17);

            /**

            * since you did not provide the sample output, I'm writing this based

            * on assumptions only. The working of the below code is correct, but

            * the output format may not be same as what you expect. In that case,

            * provide your sample run and I'll modify the code accordingly.

            */

            // looping until pool is empty

            while (!poolTable.isEmpty()) {

                  // removing a ball from poolTable

                  int n = poolTable.remove();

                  // displaying removed ball

                  System.out.println("\n" + n + " is removed from poolTable\n");

                  // if n is not 1, adding n random balls under n to the poolTable

                  if (n != 1) {

                        for (int i = 0; i < n; i++) {

                              // generating a ball numbered between 1 and n-1

                              int randNum = random.nextInt(n - 1) + 1;

                              poolTable.add(randNum);

                        }

                  }

                  // displaying poolTable after each iteration

                  DisplayContentOfPoolTable();

            }

            System.out.println("\nThe poolTable is empty!!!");

      } // end removeBallsFromTable

      /**

      * Displays the content of this.poolTable

      */

      private void DisplayContentOfPoolTable() {

            Object[] content = this.poolTable.toArray();

            System.out.println(Arrays.toString(content));

            System.out.println();

      } // end DisplayContentOfPoolTable

      public static void main(String args[]) {

            Billiard billiard = new Billiard();

            billiard.addFirstElement();

            long startTime = Calendar.getInstance().getTime().getTime(); // get

                                                                                                              // current

                                                                                                              // time

                                                                                                              // in

                                                                                                              // miliseconds

            billiard.removeBallsFromTable();

            long stopTime = Calendar.getInstance().getTime().getTime();

            System.out.println("\nThe time required was " + (stopTime - startTime)

                        + " milliseconds");

      } // end main

} // end Billiard

/*OUTPUT*/

What is the first numbered ball to start with? (must be between 1 and 6 inclusive)

5

The first ball is: "5"

*** Removing balls from the poolTable ***

5 is removed from poolTable

[3, 4, 3, 3, 1]

1 is removed from poolTable

[3, 4, 3, 3]

3 is removed from poolTable

[3, 4, 3, 1, 2, 2]

2 is removed from poolTable

[3, 4, 3, 1, 2, 1, 1]

1 is removed from poolTable

[3, 4, 3, 1, 2, 1]

1 is removed from poolTable

[3, 4, 3, 1, 2]

2 is removed from poolTable

[3, 4, 3, 1, 1, 1]

1 is removed from poolTable

[3, 4, 3, 1, 1]

1 is removed from poolTable

[3, 4, 3, 1]

1 is removed from poolTable

[3, 4, 3]

3 is removed from poolTable

[3, 4, 2, 1, 2]

2 is removed from poolTable

[3, 4, 2, 1, 1, 1]

1 is removed from poolTable

[3, 4, 2, 1, 1]

1 is removed from poolTable

[3, 4, 2, 1]

1 is removed from poolTable

[3, 4, 2]

2 is removed from poolTable

[3, 4, 1, 1]

1 is removed from poolTable

[3, 4, 1]

1 is removed from poolTable

[3, 4]

4 is removed from poolTable

[3, 3, 3, 1, 1]

1 is removed from poolTable

[3, 3, 3, 1]

1 is removed from poolTable

[3, 3, 3]

3 is removed from poolTable

[3, 3, 1, 2, 2]

2 is removed from poolTable

[3, 3, 1, 2, 1, 1]

1 is removed from poolTable

[3, 3, 1, 2, 1]

1 is removed from poolTable

[3, 3, 1, 2]

2 is removed from poolTable

[3, 3, 1, 1, 1]

1 is removed from poolTable

[3, 3, 1, 1]

1 is removed from poolTable

[3, 3, 1]

1 is removed from poolTable

[3, 3]

3 is removed from poolTable

[3, 2, 1, 2]

2 is removed from poolTable

[3, 2, 1, 1, 1]

1 is removed from poolTable

[3, 2, 1, 1]

1 is removed from poolTable

[3, 2, 1]

1 is removed from poolTable

[3, 2]

2 is removed from poolTable

[3, 1, 1]

1 is removed from poolTable

[3, 1]

1 is removed from poolTable

[3]

3 is removed from poolTable

[2, 1, 1]

1 is removed from poolTable

[2, 1]

1 is removed from poolTable

[2]

2 is removed from poolTable

[1, 1]

1 is removed from poolTable

[1]

1 is removed from poolTable

[]

The poolTable is empty!!!

The time required was 16 milliseconds