QUESTION 2 Group A has three scores, 32, 18, 28. Group B has three scores, 12, 40, 39. Group C has three scores, 37, 35, 45. Calculate the F-value. Round to one digit.

QUESTION 4 Group A has three scores, 11, 26, 22. Group B has three scores, 16, 28, 33. Group C has three scores, 21, 36, 25. Calculate the grand mean (round to two digits).

QUESTION 5 Group A has three scores, 11, 47, 27. Group B has three scores, 28, 50, 43. Group C has three scores, 29, 33, 40. Calculate MS effect (Mean squared error for the Effect). Round to one digit.

QUESTION 6 Group A has three scores, 20, 12, 18. Group B has three scores, 23, 36, 12. Group C has three scores, 44, 41, 19. Calculate MS error (Mean squared error for the error term). Round to one digit.

QUESTION 7 The df for an effect is 6, the df for an error term is 35, the F-value is 3, and the MSE for the error term is 65. What is the SS effect? (round to two digits)

QUESTION 9 Group A has three scores, 41, 25, 17. Group B has three scores, 36, 12, 42. Group C has three scores, 35, 43, 27. Calculate SS effect. Round to one digit.

QUESTION 10 Group A has three scores, 10, 25, 37. Group B has three scores, 11, 35, 43. Group C has three scores, 20, 16, 29. Calculate SS error. Round to one digit.

In Appendix B in your book there is a table of the ages of Best Actor and Best Actress Oscar award winners. Test the claim at � = 0.05 that proportion of male winners over age 40 is greater than the proportion of female winners over the age of 40.

a. State the proportion of Best Actors over age 40.

b. State the proportion of Best Actresses over age 40.

c. Perform the hypothesis test.

ACTRESSES
22
37
28
63
32
26
31
27
27
28
30
26
29
24
38
25
29
41
30
35
35
33
29
38
54
24
25
46
41
28
40
39
29
27
31
38
29
25
35
60
43
35
34
34
27
37
42
41
36
32
41
33
31
74
33
50
38
61
21
41
26
80
42
29
33
35
45
49
39
34
26
25
33
35
35
28
30
29
61
32
33
45
29
62
22
44
54

ACTORS
44
41
62
52
41
34
34
52
41
37
38
34
32
40
43
56
41
39
49
57
41
38
42
52
51
35
30
39
41
44
49
35
47
31
47
37
57
42
45
42
44
62
43
42
48
49
56
38
60
30
40
42
36
76
39
53
45
36
62
43
51
32
42
54
52
37
38
32
45
60
46
40
36
47
29
43
37
38
45
50
48
60
50
39
55
44
33

Wilson Publishing Company produces books for the retail market. Demand for a current book is expected to occur at a constant annual rate of 7,400 copies. The cost of one copy of the book is $11.50. The holding cost is based on an 18% annual rate, and production setup costs are $150 per setup. The equipment with which the book is produced has an annual production volume of 25,000 copies. Wilson has 250 working days per year, and the lead time for a production run is 15 days. Use the production lot size model to compute the following values. (Round your answers to two decimal places.)

(a)

Minimum cost production lot size

(b)

Number of production runs per year

(c)

Cycle time

(d)

Length of a production run (in days)

  days

(e)

Maximum inventory

(f)

Total annual cost (in $)

$

(g)

Reorder point

Write a function called 'make_triangle(char,n)' that uses a nested loop to return a string that forms a triangle. The return string should contain: one instance of char on the first line, two instances of char on the second line, and so on up to n instances of char on line n. Then n-1 instances of char on line n+1, and so on until the triangle is complete. Sample runs of the function looks as follows (this function called from IDLE, please note the end of line character at the end of the return string):

>>> make_triangle("+",6)
'+\n++\n+++\n++++\n+++++\n++++++\n+++++\n++++\n+++\n++\n+\n'

>>> make_triangle('*',3)
'*\n**\n***\n**\n*\n'

From IDLE, we could as print out the actual triangle as follows:

>>> print(make_triangle("+",6))
+
++
+++
++++
+++++
++++++
+++++
++++
+++
++
+

>>> print(make_triangle('*',3))
*
**
***
**
*

The birthday problem considers the probability that two people in a group of a given size have the same birth date. We will assume a 365 day year (no leap year birthdays).

Code set-up

Dobrow 2.28 provides useful R code for simulating the birthday problem. Imagine we want to obtain an empirical estimate of the probability that two people in a class of a given size will have the same birth date. The code

trial = sample(1:365, numstudents, replace=TRUE)

simulates birthdays from a group of numstudents students. So you can assign numstudents or just replace numstudents with the number of students in the class of interest.

If we store the list of birthdays in the variable trial, the code

2 %in% table(trial)

will create a frequency table of birthdays and then determine if there is a match (2 birthdays the same). We can use this code in an if-else statement to record whether a class has at least one pair of students with the same birth date. We then can embed the code within a for-loop to repeat the experiment, store successes in a vector, and then take the average number of successes (a birthday match) across the repeated tasks.

The problems

• Simulate the birthday problem to obtain an empirical estimate of the probability that two people in a class of 23 will have the same birth date. In particular, simulate birthdays for 1000 classes (for(i in 1:1000){...}) each of size 23 and compute the proportion of these classes in which at least one pair of students has the same birth date.

Recall that the true probability is 1-prod(seq(343,365))/(365)^23 which is approximately 50%.

• Using your simulation code, estimate the number of students needed in the class so that the probability of a match is 95%. (You may do this by trial and error.)
• Using your simulation code, find the approximate probability that three people have the same birthday in a class of 50 students.

# [Place code here]

Place your answers to the three items below here:

• [Ans 1]

  The birthday problem considers the probability that two people in a group of a given size have the same birth date. We will assume a 365 day year (no leap year birthdays).

  Code set-up

  Dobrow 2.28 provides useful R code for simulating the birthday problem. Imagine we want to obtain an empirical estimate of the probability that two people in a class of a given size will have the same birth date. The code

  trial = sample(1:365, numstudents, replace=TRUE)

  simulates birthdays from a group of numstudents students. So you can assign numstudents or just replace numstudents with the number of students in the class of interest.

  If we store the list of birthdays in the variable trial, the code

  2 %in% table(trial)

  will create a frequency table of birthdays and then determine if there is a match (2 birthdays the same). We can use this code in an if-else statement to record whether a class has at least one pair of students with the same birth date. We then can embed the code within a for-loop to repeat the experiment, store successes in a vector, and then take the average number of successes (a birthday match) across the repeated tasks.

  The problems

• Simulate the birthday problem to obtain an empirical estimate of the probability that two people in a class of 23 will have the same birth date. In particular, simulate birthdays for 1000 classes (for(i in 1:1000){...}) each of size 23 and compute the proportion of these classes in which at least one pair of students has the same birth date.

• Recall that the true probability is 1-prod(seq(343,365))/(365)^23 which is approximately 50%.

• Using your simulation code, estimate the number of students needed in the class so that the probability of a match is 95%. (You may do this by trial and error.)
• Using your simulation code, find the approximate probability that three people have the same birthday in a class of 50 students.

• # [Place code here]

  Place your answers to the three items below here:

• [Ans 1]

Match the definitions with one of the following two terms: transcutaneous, transvenous.

Definitions: through the skin, through a vein.

Using the terms above, which type of pacemaker is implanted permanently? Which type of pacemaker is used temporarily such as in emergencies? List the indications for permanent pacemaker insertion. List a few arrhythmias that might need to have pacing in an emergency.  

C++ sort a file with 140 integers where only 20 integers maybe placed into memory at any one time

Main idea: break data into blocks, sort blocks into runs, merge runs less. Call inFile1 our source file (the one with the initial 140 records to be sorted. You will also need an inFile2, and 2 other files outFile1 and outFile2. Break the file into blocks of size 20: in this case there will be 7 blocks ( 140/20 ) Sort the blocks by read a block, sort it, store in outFile1 read a block, sort it, store in outFile2 read a block, sort it, store in outFile1 ( in other words, sort a block and alternately place in the files outFile1, outFile2 ) By definition a run is a sorted block Note that each file outFile1 and outFile2 will have half of the runs Merge the runs Merge data from outFile1 and outFile2 to  inFile1 and inFile2. Merge the first run on outFile1 and the first run on outFile2, and store the result on inFile1: Read two records in main memory, compare, store the smaller on inFile1 Read the next record from either outFile1 or outFile2  the file that had its record moved/stored  to inFile1 Similarly merge the second run on outFile1 and the second run on outFile2, store the result on inFile2. Merge the third run on outFile1 and the third run on outFile2, store the result on inFile1... etc.    merging each run and storing the result alternatively on inFile1 and inFile2. At the end        inFile1 and inFile2 will contain sorted runs twice the size of the previous runs on outFile1 and outFile2 Now merge data from inFile1 and inFile2   to outFile1 and outFile2. Merge the first run on inFile1 and the first run on inFile2 and store the result on outFile1. Merge the second run on inFile1 and the second run on inFile2, store the result on outFile2 Etc, merge and store alternatively on inFile1 and inFile2. Repeat the process until only one run is obtained. This would be the sorted file

restrictions:

MUST use algorithms from sort_algorithms.t:

the algorithms may not be modified. - but you may assume an overloaded < operator exists. Thus you may remove the pointer to the function cmp ( obviously, the code will have to replace any reference to cmp, no puns intended, with < ) It is permissible to copy/paste any algorithms from sort_algorithms.t that you use to your own sort_alg.t Declare a variable MAX_MEM_SIZE, of type size_t. Initialize to 20 If you are really paying attention to the directions, you will realize that 2 arrays of 20 cannot both be in memory at the same time – depending on how you implement the above algorithm and which sort you use, you may need to break into blocks of size 10 a sample file to be sorted is provided.

Sort_algorithms.t

*****************************************************************************************

template

void mergesort1(T* arrayptr, const int& arraySize )

{

sortmerge1( arrayptr, arraySize, 0, arraySize - 1 );

}

*****************************************************************************************

template

void sortmerge1( T* arrayptr, const int& arraySize, int l, int r )

{

int mid, i, j, k;

if ( l < r )

    {

      mid = (r + l)/2;

      sortmerge1( arrayptr, arraySize, l, mid );

      sortmerge1( arrayptr, arraySize, mid + 1, r );

      T* temp = new T[ arraySize ];

      for ( i = mid + 1; i > l; i-- )

        temp[ i - 1 ]= arrayptr[ i - 1 ];

      for ( j = mid; j < r; j++ )

        temp[ r + mid - j ] = arrayptr[ j + 1 ];

      for ( k = l; k <= r; k++)

        arrayptr[k] = ( temp[i] < temp[j] ) ? temp[i++] : temp[j--];

    }

temp = 0;

delete [] temp;

}

*****************************************************************************************

template

void msSort( T* arrayptr, const int& arraySize )

{

T* copy = new T[ arraySize ];

int i;

for ( i = 0; i < arraySize; i++ )

    copy[i] = arrayptr[i];

mergesort2( copy, arrayptr, 0, arraySize - 1 );

}

*****************************************************************************************

template

void mergesort2( T* source, T* dest, int l, int r )

{

if ( l != r )

    {

      int mid = ( l + r )/2;

      mergesort2( dest, source, l, mid );

      mergesort2( dest, source, mid + 1, r );

      merge2( source, dest, l, mid, r );

    }

}

*****************************************************************************************

template

void merge2( T* source, T* arrayptr , int l, int mid, int r )

{

int i = l;

int j = mid + 1;

int k = l;

while ( ( i <= mid ) && ( j <= r ) )         // Compare current item from each list

    if ( source[ i ] < source[ j ] )          // Then i item comes first

      arrayptr[ k++ ] = source[ i++ ];

    else                                        // j item comes first

      arrayptr[ k++ ] = source[ j++ ];

                                      // Move what is left of remaining list

if ( i > mid )

    while ( j <= r )

      arrayptr[ k++ ] = source[ j++ ];

else

    while (i <= mid )

      arrayptr[ k++ ] = source[ i++ ];   

}

#endif

The data in tab #2 pertain to the years of experience of project managers and the numbers of successes and failures they have had on major projects. Use the data set given in tab #2 in the attached Excel workbook and logistic regression to find the following:

The probability of success given 10 years of experience is: .

The probability of failure given 18 years of experience is: .  

1. Suppose that Climate Change is caused the emissions of carbon dioxide and methane gases. Suppose further that the United Nations proposes a policy to combat these emissions to reduce the impact of Climate Change. This policy proposes that each country in the world reduces their carbon dioxide and methane emissions by 50% over the next two years (i.e., each country should cut their emissions by half). The United Nations suggests that countries could tax polluters to get them to reduce their emissions.

In class we discussed seven (7) criteria upon which environmental policy are evaluated. Carefully discuss this proposed policy from the perspective of:

a. Efficiency

b. Cost-effectiveness

c. Fairness

d. Enforceability

e. Flexibility

f. Incentives for technological innovation

g. Other moral considerations

For this question, I want 7 answers (one for each of a, b, c, d, e, f, and g, respectively). A couple of sentences under each category should be sufficient.