/*
 **************************************************************************
 * Program name : 035_Mean_Median_and_Mode (Version 1.00)                 *
 * Author       : Duck Wong                                               *
 * Language     : C / C++                                                 *
 * Compiler     : Boodshed Dec-C++ compiler Ver 3.95                      *
 * Computer     : PII350                                                  *
 * O/S          : Windows 98                                              *
 **************************************************************************
 * Version 1.00 : 2000/06/14 - first version                              *
 **************************************************************************
 * Description  : (a) Set the initial values to Zero                      *
 *                (b) Input the course code, no. of student & test result *
 *                (c) List of result in unsorted order                    *
 *                (d) List of result in sorted order                      *
 *                (e) Find Mean, Mode and Median                          *
 *                (f) Try again ?                                         *
 **************************************************************************
*/
#include <iostream.h>
#include <stdlib.h>
#include <iomanip.h>

void bubblesort(int []);
void mean(const int []);
void mode(const int [], int []);

int   Student;                       // Actual no. of student

int main()
{
 // part 1 : declaration
 int   Index;                        // loop counter
 const int Arraysize=40;             // Maximum no. of student is 40
 int   Result[Arraysize];            // No. of elements in array Result is 40
 const int Grade=11;                 // Maximum no. of grade
 int   Frequency[11];                // No. of elements in array Frequency is 11
 char  Coursecode[12];               // A string (array of character)
 char  Again;                        // Try again ?

 do {
     // part 2 : Set the initial values to Zero
     for (Index=1; Index<=Arraysize; Index++)
       Result[Index-1]=0;
     for (Index=1; Index<=11; Index++)
       Frequency[Index]=0;

     // part 3 : Input the course code, no. of student & test result
     cout << "\nPlease input the course code : ";
     cin  >> Coursecode;
     do
       {
        cout << "\n\nHow many student take this courde (1-40) : ";
        cin  >> Student;
       } while (Student<1 || Student>Arraysize);
     cout << "\n";
     for (Index=1; Index<=Student; Index++)
       do
         {
          cout << "\tEnter the result (1-10) for no." << Index << "  : ";
          cin  >> Result[Index-1];
         } while (Result[Index-1]<1 || Result[Index-1]>10);

     // part 4 : List of result in unsorted order
     cout << "\n\nThe unsorted list of examination is : \n";
     for (Index=1; Index<=Student; Index++)
       cout << Result[Index-1] << "\t";

     // part 5 : List of result in sorted order
     cout << "\n\nThe sorted list of examination is : \n";
     bubblesort(Result);                                             // Note (1)
     for (Index=1; Index<=Student; Index++)
       cout << Result[Index-1] << "\t";
     cout << "\n\n";
     system("PAUSE");

     // part 6 : Find Mean, Mode and Median
     cout << "\n     Course Code    : " << Coursecode
          << "\n     No. of Student : " << Student << "\n";
     mode(Result, Frequency);                                        // Note (3)
     mean(Result);                                                   // Note (2)
     cout << "\nThe Median is : " << Result[(Student-1)/2];          // Note (4)

     // part 7 : try another number ?
     cout << "\n\n\t\aTry another number (Y/N) : ";
     cin  >> Again;
     cout << "\n";
    }while (Again=='Y' || Again=='y');
 cout << "\n" << endl;

 system("PAUSE");
 return 0;
}

void bubblesort(int Result[])                                        // Note (1)
{
 int Index_1, Index_2, tempint;

 for (Index_1=0; Index_1<Student-1; Index_1++)
   for (Index_2=Index_1+1; Index_2<Student; Index_2++)
     if (Result[Index_1]>Result[Index_2])
       {
        tempint = Result[Index_1];
        Result[Index_1] = Result[Index_2];
        Result[Index_2] = tempint;
       }
}

void mode(const int Result[],int Frequency[])                        // Note (3)
{
 int Index_1,Index_2, Modegrade;

 for (Index_1=0; Index_1<Student; Index_1++)                         // Note (5)
   Frequency[Result[Index_1]] += 1;
 cout << "\n------------------------------------------------"
      << "\n        Grade      Frequency"
      << "\n------------------------------------------------";
 for (Index_1=1; Index_1<=10; Index_1++)
   {
    cout << "\n" << setw(9) << Index_1 << "          ";
    for (Index_2=1; Index_2<=Frequency[Index_1]; Index_2++)
      cout << "* ";
   }
 cout << "\n------------------------------------------------\n";

 Modegrade = 1;                                                      // Note (6)
 for (Index_1=2; Index_1<=10; Index_1++)
   if (Frequency[Index_1]>Frequency[Modegrade])
     Modegrade = Index_1;
 cout << "\nThe Mode is   : ";
 for (Index_1=1; Index_1<=10; Index_1++)                             // Note (7)
   if (Frequency[Index_1]==Frequency[Modegrade])
     cout << Index_1 << " , ";
}

void mean(const int Result[])                                        // Note (2)
{
 int Index;
 float Sum;

 Sum = 0;
 for (Index=0; Index<Student; Index++)
   Sum += Result[Index];
 cout << "\nThe Mean is   : " << Sum/Student;
}

/* Notes
   (1) The technique I use is similar to "Bubble sort". Every pass, the
       smallest number in the unsorted list to moved to the end of the
       sorted list.

       Example :

       Pass             |  Unsorted Numbers     | Sorted elements
       -----------------|-----------------------|------------------------
       Before sorting   |  25, 12, 34, 64, 20   |
       1st pass         |      25, 34, 64, 20   | 12,
       2nd pass         |          34, 64, 25   | 12, 20
       3rd pass         |              64, 34   | 12, 20, 25
       4th pass         |                  64   | 12, 20, 25, 34
       End of sorting   |                       | 12, 20, 25, 34, 64
       -----------------|-----------------------|------------------------
       No. of pass is equal to no. of item less one.

   (2) The Mean is the average value of the data items. So it is equal to
       the sum of all data items divided by the number of data items.

   (3) The Mode is the most frequent value in the list (the array Frequency[]).

   (4) The Median is element in the middle of the list.

   (5) (a) The statement "Frequency[Result[Index_1]] += 1;" update the value
           of in the array Frequency.
           Example   : Let's say the value in Result[4] is 9 and
                       the current value in Frequency[9] is 2.
           Therefore : Frequency[9] = Frequency[9] + 1 = 2 + 1 = 3.

        (b) Then a bar chat is displayed on the screen, which show the number
            of frequency.

            Example :
            ------------------------------------------------
                    Grade      Frequency
            ------------------------------------------------
                    1          *
                    2          * *
                    3          * * * *
                    4
                    5          * *
                    6          * * * * *
                    7
                    8          * *
                    9          * * * *
                   10
            ------------------------------------------------

   (6) The variable Modegrade is used to store the number of the element which
       contains the latgest number in the array Frequency.

   (7) Since the values in the array Frequency may be the same, so we have to
       scan all the elements in the array to display the number of the element
       or elements which contains the latgest number in the array Frequency.
*/