Question

REQUIREMENTS: Problem Description: Create a Dynamic 2D Array Class. This class should overload the Call Operator () for the following behaviors:

Return (modifiable) Lvalue element for a non-const object

Return (read-only) Rvalue element for a const object

Return a copy of the data values for row

Return a copy of all the data as a 1D vector

Create a TestScores Class which uses a Dynamic 2D Array object as an internal data structure. This class should have the following behaviors:

Get the scores for a given student

Get the average score for a given student

Get the class average

Get the Standard Deviation for the class

Create a BandPassFilter which allow only scores within One-Sigma to pass through.

Answer the questions:

How many scores passed through?

What percentage is this?

How does this compare to a Normal Distribution?

Demonstrate your classes with a TestScores Object which has 15 students with five(5) test scores each. Generate scores between 45 and 100 using a Random Generator. Document your code, tell me what you are doing, and make it readable.

C++ ONLY PLEASE

Answer 1

IF YOU HAVE ANY DOUBTS COMMENT BELOW I WILL BE THERE TO HELP YOU

ANSWER:

CODE:

/*************************************************

* The objective of the program code is to create *

* a TestScores which uses a 2D dynamic array     *

* class as internal data structure. Demonstrate *

* classes with a TestScores Object.              *

*************************************************/

//use this header file

//only for visual studio

#include "stdafx.h"

//define the header section

#include<iostream>

#include<fstream>

#include<string>

#include<iomanip>

//Run with student data file as input

using namespace std;

const int maxvalue = 100;

//define the function called dataInput

//to read the data in array format

//and to store the data in array format.

void dataInput(ifstream &inputfile, string nm[], int marks[][5], int &k)

{

     //define the necessary variables

     k = 0;

     int m = 0;

     int n = 0;

     //check for the input file

     while (!inputfile.eof())

     {

          inputfile >> nm[m];

          for (int j = 0; j<5; j++)

              inputfile >> marks[m][j];

          m++;

     }

     k = m;

}

//define the function checkGrade

//to check for the grades

char checkGrade(double average)

{

     //check for the grades

     if (average >= 90 && average <= 100)

          return 'A';

     else if (average >= 80 && average <= 89)

          return 'B';

     if (average >= 70 && average <= 79)

          return 'C';

     if (average >= 60 && average <= 69)

          return 'D';

     if (average >= 50 && average <= 59)

          return 'F';

}

//define the function called CalculateAverage

//that calculates the marks of the students

//and the student's grade

void CalculateAverage(int i[][5], char grad[], double average[], int studentsCount)

{

     //use for() loop to calculate

     //the grade for the students

     for (int m = 0; m<studentsCount; m++)

     {

          double total = 0;

          for (int n = 0; n<5; n++)

              total += i[m][n];

          average[m] = total / static_cast<double> (5);

          grad[m] = checkGrade(average[m]);

     }

}

//define the function called AverageresultPrint

//to display the results in the particular format.

void AverageresultPrint(string nm[], double average[], int marks[][5], char grad[], int k)

{

     for (int m = 0; m<k; m++)

     {

          cout << left << setw(10) << nm[m];

          for (int k = 0; k<5; k++)

              cout << right << setw(8) << marks[m][k];

          cout << endl;

     }

     //define the average for the student

     cout << setw(8) << "Average: ";

     for (int n = 0; n<k; n++)

          cout << setw(5) << average[n];

     cout << endl;

}

//define the main() function

int main()

{

     //define the one-dimensional array

     //to store the names of the students

     string nm[maxvalue];

     //define the parallel two-dimensional array

     //to store the scores of the test

     int marks[maxvalue][5];

     //define the parallel one-dimensional array

     //to store the grade results

     char grad[maxvalue];

     int studentsCount;

     double average[maxvalue];

     //Read the input file

     ifstream infile("StudentData.txt");

     //check if the file exists or not

     if (!infile)

     {

          cout << "Return error, exit from the program: unable to open file" << endl;

          return 0;

     }

    

     //call the functions

     dataInput(infile, nm, marks, studentsCount);

     infile.close();

     CalculateAverage(marks, grad, average, studentsCount);

     AverageresultPrint(nm, average, marks, grad, studentsCount);

    

     //pause the system for a while

     system("pause");

     //return nothing

     return 0;

}

Programmatic insertion:

To create a dynamic 2D array class, first need to declare a 2D array:

a = [][]

for i in range(3) :

     for j in range(3) :

          a[i][j] = i + j

print a

To append values into the lists,

a = []

for i in xrange(2) :

     a.append([])

     for j in xrange(2) :

          a[i].append(i + j)

a[[0, 1, 2], [1, 2, 3]]

it will be done as given above.

Points to remember:

• create a dynamic array of pointers
• create a row for every pointer (Note: rows may not be contiguous)
• initialize all entries as false to indicate that there are no edges initially

Utility method to print adjacency matrix is written below:

void Graph::print()

{

     For(int u = 0; u<V; u++)

     {

          for (int v = 0; v<V; v++)

              cout << adj[u][v] << " ";

          cout << endl;

     }

}

Output:

0 1 1 0

0 0 1 0

1 0 0 1

0 0 0 1

Note: memset() is actually used separately for individual rows. As the rows are allocated at different addresses, it can’t replace these calls with one call and making a memset() call like below would be disastrous.

memset (adj, false , V*V*sizeof (bool));

RATE THUMBSUP PLEASE