Question

COULD YOU PLEASE HELP ME**************************

write a better mode computation function that uses the ideas in the word file and improves on the mode computation function in the cpp file.

===========source.cpp

#include <ctime>

#include <iomanip>

#include <iostream>

#include <string>

#include <random>

using namespace std;

default_random_engine e(static_cast<unsigned>(time(NULL)));

void fill(int a[], int size, int value)

{

for(int i = 0; i < size; i++)

a[i] = value;

}

void randomFill(int a[], int size, int lb, int up)

{

uniform_int_distribution<int> u(lb, up);

for(int i = 0; i < size; i++)

a[i] = u(e);

}

void show(int a1d[], int size)

{

for(int i = 0; i < size; i++)

cout << setw(2) << a1d[i] << ' ';

cout << endl;

}

int count(int a1d[], int size, int value)

{

int vcount = 0;

for(int i = 0; i < size; i++)

if(a1d[i] == value) vcount++;

return vcount;

}

int findLargest(int a1d[], int size)

{

int largest = a1d[0];

for(int i = 1; i < size; i++)

if(a1d[i] > largest) largest = a1d[i];

return largest;

}

/*

the mode of a set of things is that thing that appears the greater number of times in the set

a set may have several modes

*/

int computemodes(int source[], int size, int modes[], int& msize)

{

/*

1. fill the modes array with zeroes

*/

fill(modes, size, 0);

/*

2. store the number of times each source element appears in the modes array.

if an element appears more than once in the source array then its counts appears

more than once the modes array.

source and modes form a parallel array structure

*/

for(int i = 0; i < size; i++)

modes[i] = count(source, size, source[i]);

/*

3. calculate the largest number in the modes array. this number is the number of

times the mode or modes appears in the source array

*/

int modevalue = findLargest(modes, size);

/*

4. assign -1 to the mode array elements that are less than the mode value

now only mode values in the modes array are not equal to -1.

the corresponding elements in the source array are the modes.

*/

for(int i = 0; i < size; i++)

if(modes[i] != modevalue) modes[i] = -1;

/*

5. we use the modes array to identify the source elements that are modes:

any element in the modes array that is not -1 corresponds to a mode in the

source array. if the mode is 1 then every source element is a mode

and no element in the modes array is -1; if the mode is greater than 1 then

a. many modes array entries are -1

b. the number of times a mode appears in the source equals its corresponding modes value

c. the number of modes array entries that are not -1 are the number of times the modes

appear in the source array

the following nested for loop transforms the modes array into an array in which

the first apppearance of a mode in the source corresponds to a modes array entry

that is not -1 and subsequent appearances of this mode in the source correspond to

modes array entries that are -1.

*/

for(int i = 0; i < size; i++)

if(modes[i] != -1) //first appearance of the mode in the source

for(int j = i + 1; j < size; j++)

if(source[i] == source[j]) modes[j] = -1;//subsequent appearances

/*

at this point the usage of the modes array changes.

heretofore, an entry that is not -1 in the modes array is the number of times

a mode appears in the source array. now an entry in the modes array is a mode.

the loop adds modes from the source array to the modes array.

msize serves 2 purposes:

a. it is number of modes copied so far.

b. it is the next free modes array position.

*/

msize = 0;

for(int i = 0; i < size; i++)

if(modes[i] != -1) //first occurrence of a mode in the source

{

modes[msize] = source[i];

msize++;

}

return modevalue;

}

int main()

{

const int size = 24;

int a[size];

int m[size];

randomFill(a, size, 10, 16);

show(a, size);

int msize = 0;

int modevalue = computemodes(a, size, m, msize);

cout << "The mode value is " << modevalue << endl;

if (msize == 1)

cout << "The mode is ";

else

cout << "The modes are ";

show(m, msize);

system("pause");

return 0;

}

Answer 1

//Code

#include <ctime>

#include <iomanip>

#include <iostream>

#include <string>

#include <random>

#include <utility> //for pair

#include <bits/stdc++.h> //for sort method

using namespace std;

default_random_engine e(static_cast<unsigned>(time(NULL)));

void fill(int a[], int size, int value)

{

for (int i = 0; i < size; i++)

a[i] = value;

}

void randomFill(int a[], int size, int lb, int up)

{

uniform_int_distribution<int> u(lb, up);

for (int i = 0; i < size; i++)

a[i] = u(e);

}

void show(int a1d[], int size)

{

for (int i = 0; i < size; i++)

cout << setw(2) << a1d[i] << ' ';

cout << endl;

}

//helper method to find the index of a key in a vector of key-value pairs

int findPosition(int key, vector< pair<int,int > > &modePairs){

//looping through vector

for(int i=0;i<modePairs.size();i++){

if(modePairs[i].first==key){

//found, returning index

return i;

}

}

//not found, returning -1

return -1;

}

//method needed to sort the pair vector by the count (second value)

bool sortByCount(const pair<int,int> &a,

const pair<int,int> &b)

{

return (a.second > b.second);

}

/*

the mode of a set of things is that thing that appears the greater number of times in the set

a set may have several modes.

this method will return the mode count and a sorted vector of pair of integers which

contains the mode value - count pairs in descending order of the count

*/

int computemodes(int source[], int size, vector< pair<int,int > > &modePairs)

{

int index;

//looping through the source array for only ONCE

for(int i=0;i<size;i++){

//checking if the vector already contains the key

index=findPosition(source[i],modePairs);

if(index==-1){

//does not exist, creating a new pair

pair <int, int> p;

p.first=source[i];

p.second=1; //setting count as 1

//adding to vector

modePairs.push_back(p);

}else{

//found, incrementing the count of the found pair by 1

modePairs[index].second++;

}

}

//sorting by descending order of the count (check the sortByCount method)

sort(modePairs.begin(), modePairs.end(), sortByCount);

//the first element will always contain the mode count, assuming that the

//array contains atleast one element

return modePairs[0].second;

}

int main()

{

const int size = 24;

int a[size];

int m[size];

randomFill(a, size, 10, 16);

show(a, size);

int msize = 0;

//creating an empty vector of integer pairs

vector< pair<int,int > > modePairs;

//computing the mode(s)

int modevalue = computemodes(a, size, modePairs);

//displaying mode value (count)

cout << "The mode value is " << modevalue << endl;

//displaying the modes

cout<<"The mode(s): ";

//displaying all pairs with count modevalue

for(int i=0;i<modePairs.size();i++){

if(modePairs[i].second==modevalue){

cout<<setw(2)<<modePairs[i].first<<" ";

}else{

//since the modePairs is sorted, we dont have to iterate anymore as

//all the remaining elements will have less mode counts

break;

}

}

cout<<endl;

system("pause");

return 0;

}

/*OUTPUT*/

13 12 14 13 11 11 12 15 15 15 16 16 16 12 16 16 14 12 16 16 15 13 14 10

The mode value is 7

The mode(s): 16

Press any key to continue . . .

/*another OUTPUT*/

13 10 16 16 15 13 16 14 14 13 11 12 14 14 10 12 14 10 11 12 12 10 15 12

The mode value is 5

The mode(s): 14 12

Press any key to continue . . .