Question

In java just need work in the billards class it is in bold everything else is...

In java

just need work in the billards class it is in bold everything else is done just the sections marked TODO

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

Homework Answers

Answer #1

/*************************************Billiard.java******************************/

import java.util.Arrays;
import java.util.Calendar;
import java.util.Random;
import java.util.Scanner;

public class Billiard {
   private BagInterface<Object> 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();

       Scanner scan = new Scanner(System.in);

       System.out.print("Which ball you want to remove: ");
       int n = scan.nextInt();

       if (!this.poolTable.isEmpty()) {
           if (n > 1 && n <= 6) {
               int ball = 1;
               this.poolTable.remove(n);
               System.out.println("The ball " + n + " is removed and replace with: ");
               for (int i = 0; i < n; i++) {
                   ball = random.nextInt(n) + 1;
                   this.poolTable.add(ball);
                   System.out.print(ball + " ");
               }

           }
       } else {
           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");

       billiard.DisplayContentOfPoolTable();
   } // 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 ***

Which ball you want to remove: 5
The ball 5 is removed and replace with:
1 4 4 1 3
The time required was 1365 milliseconds
[1, 4, 4, 1, 3]

Please let me know if you have any doubt or modify the answer, Thanks :)

Know the answer?
Your Answer:

Post as a guest

Your Name:

What's your source?

Earn Coins

Coins can be redeemed for fabulous gifts.

Not the answer you're looking for?
Ask your own homework help question
Similar Questions
this is the book name. Data Structures and Abstractions with Java 1) Description: The sample programs...
this is the book name. Data Structures and Abstractions with Java 1) Description: The sample programs in Chapter 1 of your textbook are not complete. They are used for illustration purpose only. The implementation of Listing 1-1 on page 39 is explained in Chapter 2. And, in order to see the result of using it, we will need the following set of files: i. BagInteface.java – the specification only. ii. ArrayBag.java – the implementation of BagInerface.java. iii. ArrayBagDemo.java – a...
Task 1: You will modify the add method in the LinkedBag class.Add a second parameter to...
Task 1: You will modify the add method in the LinkedBag class.Add a second parameter to the method header that will be a boolean variable: public boolean add(T newEntry, boolean sorted) The modification to the add method will makeit possible toadd new entriesto the beginning of the list, as it does now, but also to add new entries in sorted order. The sorted parameter if set to false will result in the existing functionality being executed (it will add the...
Lab 02, Data Abstractions and Structures, CSE 274, Fall 2019 Linked Bag In this lab, we...
Lab 02, Data Abstractions and Structures, CSE 274, Fall 2019 Linked Bag In this lab, we will implement the Linked Bag. The bag will contain a sequence of strings. First, you need to design the Node class (Node.java). It will contain an integer data and a reference to the next Node. The constructor of Node class receives an integer and assigns it to the data field. It also has a default constructor. Then we will design another class named LinkedBag...
Please solve this problem in java. import java.util.Arrays; public class PriorityQueue { /* This class is...
Please solve this problem in java. import java.util.Arrays; public class PriorityQueue { /* This class is finished for you. */ private static class Customer implements Comparable { private double donation; public Customer(double donation) { this.donation = donation; } public double getDonation() { return donation; } public void donate(double amount) { donation += amount; } public int compareTo(Customer other) { double diff = donation - other.donation; if (diff < 0) { return -1; } else if (diff > 0) { return...
I have a 2 class code and it works everything is fine and runs as it...
I have a 2 class code and it works everything is fine and runs as it supposed too. What will the UML be for both classes. Here's the code, any help will be awsome, Thanks. import java.util.Scanner; public class PayRollDemo { public static void main(String[] args) { double payRate; int hours; PayRoll pr = new PayRoll(); Scanner keyboard = new Scanner(System.in); for (int index = 0; index < 7 ; index++ ) { System.out.println(); System.out.println("EmployeeID:" + pr.getEmployeeID(index)); System.out.println(); System.out.println("Enter the...
Language: Java Topic: Deques Using the following variables/class: public class ArrayDeque<T> { /** * The initial...
Language: Java Topic: Deques Using the following variables/class: public class ArrayDeque<T> { /** * The initial capacity of the ArrayDeque. * * DO NOT MODIFY THIS VARIABLE. */ public static final int INITIAL_CAPACITY = 11; // Do not add new instance variables or modify existing ones. private T[] backingArray; private int front; private int size; Q1: write a method that constructs a new arrayDeque called "public ArrayDeque()" Q2: write a method called "public void addFirst(T data)" that adds an element...
Assignment 1 - ITSC 2214 I have to complete the array list for a shopping list...
Assignment 1 - ITSC 2214 I have to complete the array list for a shopping list code and can't figure out how to complete it: Below is the code Complete the three empty methods (remove(), find(), and contains()) in the ShoppingListArrayList.java file. These methods are already implemented in the ShoppingListArray class. /////////////////////////////////////////////////////////////////////////////////////////////////////////// Grocery Class (If this helps) package Shopping; public class Grocery implements Comparable<Grocery> { private String name; private String category; private int aisle; private float price; private int quantity;...
Q: Implement an equals method for the ADT list that returns true when the entries in...
Q: Implement an equals method for the ADT list that returns true when the entries in one list equal the entries in a second list. In particular, add this method to the class AList. The following is the method header: public boolean equals (Object other) public class AList<T>{ private T list[]; private int capacity = 100; private int numOfEnteries =0; public AList(){ list = (T[])new Object[capacity + 1]; } public void add(T element){ numOfEnteries++; if (numOfEnteries >capacity) System.out.println ("Exceed limit");...
In the attached FlexArray Java class, implement a method public int delete (int location) { }...
In the attached FlexArray Java class, implement a method public int delete (int location) { } that deletes the integer value stored at location in the array, returns it, and ensures that the array values are contiguous.  Make sure to handle the array empty situation.  What is the time-complexity of the method, if the array size is n. ***************************************************************************************************************************** public class FlexArray { int [] array; private int size; private int capacity; public FlexArray() { capacity=10; size=0; array=new int[10]; } public FlexArray(int...
Create a class StacktwoPopArr using Arrays, Change the pop function so that two elements get popped...
Create a class StacktwoPopArr using Arrays, Change the pop function so that two elements get popped everytime instead of the one. If there is only one element in the stack, just pop the one element and report that the stack is now empty. If stack is empty, it should just report that stack is empty. All other functions for StackArray remain the same. using java StackArray.java: public class StackArray {       private final int size = 20; //Size of...