Assume that random guesses are made for

ninenine

multiple choice questions on an SAT​ test, so that there are

nequals=99

​trials, each with probability of success​ (correct) given by

pequals=0.450.45.

Find the indicated probability for the number of correct answers.

Find the probability that the number x of correct answers is fewer than

P(X<4)=

Let Z be the number of the flipping when first Head appears, and M be the number of flipping when second head appears. We know the probability of getting a head is p and probability of getting a tail is then 1-p.

The questions are: a) Find the probability distribution of Z and M. b) Are Z and M independent? Give the reason

Let Z be the number of the flipping when first Head appears, and M be the number of flipping when second head appears. We know the probability of getting a head is p and probability of getting a tail is then 1-p.

The questions are: a) Find the probability distribution of Z and M. b) Are Z and M independent? Give the reason

The mean number of students who went to examinations is 450 students with a standard deviation of 75 students. The distribution of the number of students is normal.

1. What number of students who correspond to the last 15%.
2. Fin the probability that less than 430 students want on campus examinations.
3. Calculate the probability that more than 400 students wanted on campus examinations
4. Determine the probability that between 452 and 463 students wanted on campus examinations

PUT DIAGRAMS PLEASE

1.         You are going to toss one coin and roll one die. Using a tree diagram determine how many outcomes are possible and list the sample space. (6 points).

Then based on your sample space answer the following questions: (2 points each)

a.         What is the probability you will toss a tail and roll a composite number?

b.         What is the probability you will toss a head or roll a number greater than 3?

c.         What is the probability you will toss a tail AND not roll number less than 3?

d.         What is the probability you will toss a tail and roll a divisible by 3?

e.         What are the odds in favor you will toss a head or roll a number less than 4?

You are provided with a partial implementation of a templated singly-linked list in LinkedList.h, with some missing functionality. It contains a templated Node class and a templated LinkedList class. Do not modify the class definitions.

The linked list class contains the following methods:

• LinkedList – Constructor of a linked list with a head pointing to null (implemented).

• ~LinkedList – Destructor of a linked list.

• deleteFromHead – Removes and returns content of the first node of the list. (If the list is empty, does nothing.)

• deleteFromTail – Removes and returns content of last node of the list. (If the list is empty, does nothing.)

• deleteNode – Removes node with provided data from the list.

• InsertToHead – Inserts node with provided data at the head (implemented).

• InsertToTail – Inserts node with provided data at the tail. • getSize – Returns the number of nodes in the linked list.

• print - Prints the linked list (implemented).

Notice that while the declaration and implementation of classes are typically split between .cpp and .h files, some compilers cannot handle templates in separate files, which is why we include both the declaration and implementation in a single .h file. The main.cpp file consists of sample test code for each of the tasks below. Your code, which should be added to the provided LinkedList.h will be compiled and run with variations of this file. Submit your modified LinkedList.h file only

LinkedList.h:

#ifndef LinkedList_h
#define LinkedList_h

#include <iostream>

using namespace std;

template <class T = int>
class Node {
public:
    Node();                                         // default constructor
    Node(const T& data, Node<T>* next = nullptr);   // donstructor
    T data;                                         // node data
    Node<T>* next;                                  // node next pointer
};

template <class T = int>
class LinkedList {
public:
    LinkedList();                                   // constructor
    ~LinkedList();                                  // destructor
    T deleteFromHead();                             // removes and returns content of head
    T deleteFromTail()                              // removes and returns content of tail
    void deleteNode(T data)                         // removes node with specified data
    void InsertToHead(T data);                      // insert node with data at the head
    void InsertToTail(T data);                      // insert node with data at the tail
    int getSize();                                  // returns size of linked list
    void print();                                   // prints linked list
private:
    Node<T>* head;                                  // head of linked list
};


/******* From here down is the content of the LinkedList.cpp file: ***********************/

 /* Implementation of Node */

 // default constructor
 template<class T>
 Node<T>::Node()
 {
 }
 
 // constructor
 template<class T>
 Node<T>::Node(const T& data, Node<T>* next)
 {
     this->data = data;
     this->next = next;
 }
 
 /* Implementation of linked list */

 // constructor
 template <class T>
 LinkedList<T>::LinkedList()
 {
     head = nullptr;
 }

 // destructor
 template <class T>
 LinkedList<T>::~LinkedList()
 {
    /*** to be implemented ***/
 }

 template <class T>
 T LinkedList<T>::deleteFromHead()
 {
    /*** to be implemented ***/
 }


 template <class T>
 T LinkedList<T>::deleteFromTail()
 {
    /*** to be implemented ***/
 }
 

 template <class T>
 void LinkedList<T>::deleteNode(T data)
 {
    /*** to be implemented ***/
 }
 

 template <class T>
 void LinkedList<T>::InsertToHead(T data)
 {
     Node<T> * newNode = new Node<T>(data, nullptr);
     
     if (head == nullptr)
         head = newNode;
     else
     {
         newNode->next = head;
         head = newNode;
     }
 }


 template <class T>
 void LinkedList<T>::InsertToTail(T data)
 {
     /*** to be implemented ***/
 }


 template <class T>
 int LinkedList<T>::getSize()
 {
     /*** to be implemented ***/
 }


 template <class T>
 void LinkedList<T>::print()
 {
     if (head == nullptr)
     {
         cout << "Linked list is empty" << endl;;
         return;
     }
     
     cout << head->data << " ";
     
     if (head->next == nullptr)
     {
         cout << endl;
         return;
     }
 
     Node<T>* currNode = head->next;
     Node<T>* prevNode = head;
 
     
     while (currNode->next != nullptr)
     {
         cout << currNode->data << " ";
         prevNode = currNode;
         currNode = currNode->next;
     }
 
     cout << currNode->data << endl;
     return;
 }
     
     
#endif /* LinkedList_h */

The table below lists the frequency of wins for different post positions in the Kentucky Derby horse race.

Use a 0.05 significance level to test the claim that the likelihood of winning is the same for the different post positions.

What is the critical value (the X2 value)? [Round to the nearest thousandths place]

Steam undergoes an isentropic compression in an insulated piston–cylinder assembly from an initial state where T₁ = 120°C, p₁ = 1 bar to a final state where the pressure p₂ = 30 bar.


Determine the final temperature, in °C, and the work, in kJ per kg of steam.

Nitrogen (N2) contained in a piston–cylinder arrangement, initially at 9.9 bar and 421 K, undergoes an expansion to a final temperature of 300 K, during which the pressure–volume relationship is pV1.1 = constant. Assuming the ideal gas model for the N2, determine the heat transfer in kJ/kg.