A multiple-choice test consists of 22 questions with possible answers of a, b, c, d, e, f. Estimate the probability that with random guessing, the number of correct answers is at least 11. the answer is not 0.0016 or 0.21

Let X be the random variable for the number of heads obtained when three fair coins are tossed:

(1) What is the probability function?

(2) What is the mean?

(3) What is the variance?

(4) What is the mode?

The number of computers per household in a small town Computers 0 1 2 3 Households 298 284 97 18

Find probability distribution

Graph using a histogram

Describe distribution shape

Prove "The Birthday Problem" in this regard,

Suppose there are some number of people in a room and we need need to consider all possible pairwise combinations of those people to compare their birthdays and look for matches.Prove the probability of the matches.

Suppose that the average number of Facebook friends users have is normally distributed with a mean of 144 and a standard deviation of about 52. Assume fourteen individuals are randomly chosen. Answer the following questions. Round all answers to 4 decimal places where possible.

1. For the group of 14, find the probability that the average number of friends is less than 145.
2. Find the first quartile for the average number of Facebook friends.
3. For part b), is the assumption that the distribution is normal necessary?

Given the following data (2, 5, 1, 0, 5, 0, 7, 2, 3)

Calculate the 3rd quartile from your "data".

1. What's the probability that a randomly selected number from your data is even?
2. Consider the events A = "a randomly selected number from your data is even" and B = "a randomly selected number from your data is above the 3rd quartile". Are these events disjoint, independent, neither, or both? Show your work.

Create a file named StudentArrayList.java,within the file create a class named StudentArrayList. This class is meant to mimic the ArrayList data structure. It will hold an ordered list of items. This list should have a variable size, meaning an arbitrary number of items may be added to the list. Most importantly this class should implement the interface SimpleArrayList provided. Feel free to add as many other functions and methods as needed to your class to accomplish this task. In other words, the class StudentArrayList must implement the interface SimpleArrayList. You have to write the code for each of the functions specified in the SimpleArrayList interface. Make sure the class that implements SimpleArrayList is named "StudentArrayList" or else the test code will not compile.

You are not allowed to use any 3rd party data structures or libraries such as Java.Utils.ArrayList or Java.awt.ArrayList.

Hints:

• Make an object array (Object[]) as a field. Use the array to store elements added to the class. If an item is removed from the StudentArrayList all items to the left of the item that is removed must be shifted over one place to the left. When the array reaches capacity, you must augment the size of the object array by creating a larger empty array and copying elements from the old array into the new array.
• Use .equals() to test the equality of elements in the Object array.
• The size() function should return the total number of added items to the class not the total capacity of the internal array.

public interface SimpleArrayList<E> {

   /**
   * Returns the number of elements in this list. If this list contains more
   * than <tt>Integer.MAX_VALUE</tt> elements, returns
   * <tt>Integer.MAX_VALUE</tt>.
   *
   * @return the number of elements in this list
   */
   int size();

   /**
   * Returns <tt>true</tt> if this list contains no elements.
   *
   * @return <tt>true</tt> if this list contains no elements
   */
   boolean isEmpty();

   /**
   * Returns <tt>true</tt> if this list contains the specified element. More
   * formally, returns <tt>true</tt> if and only if this list contains at
   * least one element <tt>e</tt>
   *
   * @param o
   * element whose presence in this list is to be tested
   * @return <tt>true</tt> if this list contains the specified element
   */
   boolean contains(E o);

   /**
   * Returns an array containing all of the elements in this list in proper
   * sequence (from first to last element).
   *
   * <p>
   * The returned array will be "safe" in that no references to it are
   * maintained by this list. (In other words, this method must allocate a new
   * array even if this list is backed by an array). The caller is thus free
   * to modify the returned array.
   *
   * <p>
   * This method acts as bridge between array-based and student.SimpleArrayList-based
   * APIs.
   *
   * @return an array containing all of the elements in this list in proper
   * sequence
   */
   E[] toArray();

   /**
   * Appends the specified element to the end of this list
   *
   * @param e
   * element to be appended to this list
   */
   void add(E e);

   /**
   * Removes the first occurrence of the specified element from this list, if
   * it is present (optional operation). If this list does not contain the
   * element, it is unchanged.
   *
   * @param o
   * element to be removed from this list, if present
   */
   void remove(E o);

   /**
   * Returns <tt>true</tt> if this list contains all of the elements of the
   * specified student.SimpleArrayList.
   *
   * @param c
   * student.SimpleArrayList to be checked for containment in this list
   * @return <tt>true</tt> if this list contains all of the elements of the
   * specified student.SimpleArrayList
   */
   boolean containsAll(SimpleArrayList<E> c);

   /**
   * Appends all of the elements in the specified student.SimpleArrayList to the end
   * of this list, in the order that they are returned by the specified
   * student.SimpleArrayList.
   *
   * @param c
   * student.SimpleArrayList containing elements to be added to this list
   * @return <tt>true</tt> if this list changed as a result of the call
   */
   boolean addAll(SimpleArrayList<E> c);

   /**
   * Inserts all of the elements in the specified student.SimpleArrayList into this
   * list at the specified position. Shifts the element currently at that
   * position (if any) and any subsequent elements to the right (increases
   * their indices). The new elements will appear in this list in the order
   * that they are returned by the specified student.SimpleArrayList's iterator. The
   * behavior of this operation is undefined if the specified student.SimpleArrayList
   * is modified while the operation is in progress.
   *
   * @param index
   * index at which to insert the first element from the specified
   * student.SimpleArrayList
   * @param c
   * student.SimpleArrayList containing elements to be added to this list
   * @return <tt>true</tt> if this list changed as a result of the call
   */
   boolean addAll(int index, SimpleArrayList<E> c);

   /**
   * Removes from this list all of its elements that are contained in the
   * specified student.SimpleArrayList.
   *
   * @param c
   * student.SimpleArrayList containing elements to be removed from this
   * list
   * @return <tt>true</tt> if this list changed as a result of the call
   */
   boolean removeAll(SimpleArrayList<E> c);

   /**
   * Retains only the elements in this list that are contained in the
   * specified student.SimpleArrayList. In other words, removes from this list all of
   * its elements that are not contained in the specified student.SimpleArrayList.
   *
   * @param c
   * student.SimpleArrayList containing elements to be retained in this
   * list
   * @return <tt>true</tt> if this list changed as a result of the call
   */
   boolean retainAll(SimpleArrayList<E> c);

   /**
   * Removes all of the elements from this list (optional operation). The list
   * will be empty after this call returns.
   *
   */
   void clear();

   /**
   * Compares the specified object with this list for equality. Returns
   * <tt>true</tt> if and only if the specified object is also a list, both
   * lists have the same size, and all corresponding pairs of elements in the
   * two lists are <i>equal</i>. In other words, two lists are defined to be
   * equal if they contain the same elements in the same order. This
   * definition ensures that the equals method works properly across different
   * implementations of the <tt>student.SimpleArrayList</tt> interface.
   *
   * @param o
   * the object to be compared for equality with this list
   * @return <tt>true</tt> if the specified object is equal to this list
   */
   @Override
   boolean equals(Object o);

To calculate the following probability, would you use Theoretical, Empirical, or Subjective probability:

Probability that you mow the yard today?