A) Find the upper limit for the mean at the 90% confidence level.

B) Find the lower limit for the mean at the 90% confidence level.

C) Find the width of the confidence interval at the 90% confidence level.

D) Find the score from the appropriate probability table (standard normal distribution, t distribution, chi-square) to construct a 99% confidence interval.

If you use Excel, please list what Excel functions would allow me to get this answers for future reference

Define the following key terms

1. Octet

2. Prefix length

3. Slash notation

4. Network address

5. Host address

6. Broadcast address

7. Classful addressing

8. Classless addressing

9. Tunneling

10. Dual stack

Question 1
Refer to the operations below:
Add (10 + 5)
Add (4+8)
Add (7*2)
Add (90 – 3)
Print list
Print peek
Remove an item from the list
Print list
1.1 Implement the operations above into a Queue structure called q1.
1.2 Implement the operations above into a Stack structure called s1.

Name your program Question1_1 for the queue structure and Question1_2 for the stack structure

JAVA Language to be used.

Please give step by step explanation on how to save and run the programs

c++

Run the following sorting algorithms:
1. Bubble sort
2. Insertion sort
3. Quicksort
4. Mergesort
Under the following scenarios for input data:
1. Uniform random
2. Almost sorted (90% sorted – 1 in 10 is out of place)
3. Reverse sorted
On data of sizes 5,000, 10,000, … in increments of 5,000 up to …, 50,000

-Attach a screenshot of a program compilation below

-Attach a screenshot of a successful program run below

-Attach a graph (either line graph or bar graph) below.

3.2 90% Sorted Data (10% of data are out of their sorted position)
--Attach a graph below
3.3 Reverse-Sorted (sorted in non-increasing order) Data
--Attach a graph below

template code:

• //a main template file
  
  #include <iostream>
  #include <iomanip>
  #include <ctime>
  #include <string>
  #include "Sort.h"
  
  using namespace std;
  
  void init_and_run(double**, int*, const int, const int, const int, const int);
  void print(double**, int*, const int, const int, const int, const int);
  
  int main()
  {
  
  int size[] = {100, 1000, 5000, 10000, 50000};
  const int NUM_SIZES = 7;
  const int NUM_SORT_ALGO = 7;
  const int NUM_DATA_TYPES = 3;
  const int NUM_REPEAT = 5;
  
  double* totalSortTime[NUM_DATA_TYPES];
  
  
  init_and_run(totalSortTime, size, NUM_SIZES, NUM_DATA_TYPES, NUM_SORT_ALGO, NUM_REPEAT);
  print(totalSortTime, size, NUM_SIZES, NUM_DATA_TYPES, NUM_SORT_ALGO, NUM_REPEAT);
  
  return 0;
  
  }
  
  void init_and_run(double**totalSortTime, int* size, const int NUM_SIZES, const int NUM_DATA_TYPES, const int NUM_SORT_ALGO, const int NUM_REPEAT)
  
  {
  
  clock_t time;
  
  for(int d = 0; d < NUM_DATA_TYPES; d++) {
  totalSortTime[d] = new double [NUM_SIZES * NUM_SORT_ALGO];
  for(int i = 0; i < NUM_SIZES * NUM_SORT_ALGO; i++)
  totalSortTime[d][i] = 0;
  }
  
  
  for(int d = 0; d < NUM_DATA_TYPES; d++) { //data types
  for(int s = 0; s < NUM_SIZES; s++) { //input sizes
  for(int r = 0; r < NUM_REPEAT; r++) { //repetitions
  Sort st(size[s], d);
  for(int t = 0; t < NUM_SORT_ALGO; t++) { //sort algorithms
  st.setSortType(t);
  time = clock();
  st.run();
  //st.print();
  time = clock() - time;
  totalSortTime[d][s * NUM_SORT_ALGO + t] += time;
  }
  }
  }
  }
  
  for(int d = 0; d < NUM_DATA_TYPES; d++) {
  delete [] totalSortTime[d];
  
  }
  }
  void print(double**totalSortTime, int* size, const int NUM_SIZES, const int NUM_DATA_TYPES, const int NUM_SORT_ALGO, const int NUM_REPEAT)
  {
  //cout << string(25, '=') << " AVG SORTING TIME " << string(25, '=') << endl;
  cout << "\nEach value displayed below shows the average sorting time with five instances.\n";
  cout << "The values may vary depending on the system and the implementation.\n";
  cout << "The relative performances, however, should be the same.\n";
  cout << "So are the performances of those algorithms as N or % of sorted numbers grows." << endl;
  
  string dataType[NUM_DATA_TYPES] = {
  " RANDOM_TBL_SIZE ",
  // " TBL_SIZE_PARTIAL_SORT_25 ",
  // " TBL_SIZE_PARTIAL_SORT_50 ",
  // " TBL_SIZE_PARTIAL_SORT_75 ",
  " TBL_SIZE_PARTIAL_SORT_95 ",
  " REVERSE_SORTED "
  };
  
  string sortAlgo[NUM_SORT_ALGO] = {
  "INSERTION",
  "MERGESORT",
  "QUICKSORT_L",
  "QUICKSORT_R",
  "COUNTING"
  "BUBBLE",
  "SELECTION"
  };
  
  
  cout << fixed << setprecision(2) << endl;
  for(int d = 0; d < NUM_DATA_TYPES; d++) {
  cout << string(25, '-') << left << setw(26) << dataType[d] << string(25, '-') << endl;
  cout << right << setw(7) << "N";
  for(int a = 0; a < NUM_SORT_ALGO; a++)
  cout << right << setw(14) << sortAlgo[a];
  cout << endl;
  
  for(int s = 0; s < NUM_SIZES; s++) {
  cout << right << setw(7) << size[s];
  for(int t = 0; t < NUM_SORT_ALGO; t++)
  cout << right << setw(14) << totalSortTime[d][s * NUM_SORT_ALGO + t]/NUM_REPEAT;
  cout << endl;
  }
  cout << endl;
  }
  }

• //DATAGEN_H template file

  
  #ifndef DATAGEN_H
  #define DATAGEN_H
  
  class DataGen {
  private:
  int modType;
  int sortType;
  int dataType;
  
  int** data;
  int inputSize;
  int arraySize;
  int partialSortSize;
  
  void getRandom();
  void copy();
  void partialSort();
  public:
  DataGen();
  DataGen(int*[], int, int, int);
  void generateData();
  //void partialSort();
  
  };
  
  #endif

• //DataGen.h template file

  
  #include "DataGen.h"
  
  class Sort
  {
  friend class DataGen;
  private:
  int* numbers[5];
  int algo_types;
  int size;
  DataGen *dg;
  
  void (Sort::*fp) ();
  void insertionSort();
  void bubbleSort();
  void selectionSort();
  
  void mergeSort();
  void quickSort_L();
  void quickSort_R();
  void countingSort();
  
  void partition_L(int, int, int&, int&);
  void partition_R(int, int, int&, int&);
  
  void merge(int, int, int[]);
  void recursive_mergeSort(int, int, int[]);
  void recursive_quickSort_L(int, int);
  void recursive_quickSort_R(int, int);
  
  void clear();
  public:
  Sort(int, int);
  ~Sort();
  void setSortType(int);
  void run();
  void print();
  };
  #endif

Suppose you conduct 10 significant tests and obtain the following p-values:

Test 1 2 3 4 5 6 7 8 9 10

p-value 0.001 0.030 0.002 0.006 0.040 0.003 0.010 0.100 0.020 0.004

• Which tests’ null hypotheses will you reject if you wish to control the family-wise error rate (FWER) at a significance level of 0.05?

• Which tests’ null hypotheses will you reject if you wish to control the false discovery rate (FDR) at a level of 0.05? Use the Benjamini-Hochberg method to answer this question by hand.

• Verify the results by using the related function in R

1. Given the following data, illustrate Selection Sort.

"

What is the correlation of Stock X and Stock Y?

Round to 4 decimal places please.

Illustrates earnings before interest and taxes for a capital investment project

• Initial cost of the investment: $250,000

• Change in net working capital: $10,000 (50% of this is recoverable at the end of the project)

• Tax rate: 31%

• WACC: 15%

• Depreciation: straight line over five years

• Projected cash flow from salvage: $136,250

What is the Operating Cash Flow for Year 3?

What is the NPV?