The document describes a function called findMode that takes an integer array and size as parameters and returns a vector containing the mode(s) of the array in ascending order. The author has written the findMode function but is having trouble writing a main method to test it. The response provides a main method that tests findMode on sample arrays with different characteristics to ensure it works as intended.

1. Below is the assignment description and the file I have written. I would love to test this file to
make sure that everything is satisfied (vector with all modes in ascending order). I'm having a
really hard time constructing a main method to test it. Help!!
-------------------------------------------------------
The mode is the value that appears most often in a set of data. Write a function named findMode
that takes as parameters an array of int and the size of the array, and returns a vector containing
the mode(s). If there is just a single most frequent value, the vector will only contain that one
value, but if multiple values tie for maximum frequency, the vector will need to contain all such
values. This includes the case where every number in the array appears only once. Each mode
should appear only once in the vector. The values in the vector that is returned must be in
ascending order. If you need to sort a vector, it's similar to sorting an array, but specifying the
beginning and end of the vector look a little bit different. If your vector is named result, then it
would look like this: "std::sort(result.begin(), result.end());".
-------------------------------------------------------
#include // needed for the sort() function
#include // needed to use the vector type
#include // needed for the main function

2. using std::vector;
using std::sort;
vector findMode(int array[], int size)
{
int maxFreq = 1; // initalizing the largest frequency to be 1
vector result; // results is an empty vector
//Initializing the loop through the integer array
for (int i = 0; i < size; i++)
{

3. int count = 1; //started the counter at 1
//started the the loop after the 1st entry, looking for matches with the value at index i.
for (int j = i + 1; j < size; j++)
{
//if an entry matches another, then add one to the counter
if (array[i] == array[j])
{
count++;
}
}
//when the counter is equal to the max frequency, the integer is added to the result vector.

4. if (count == maxFreq)
{
result.push_back(array[i]);
}
//when the counter for i is greater than the max frequency, updates the maxFreq, clear the values
stored in the result vector, and push the value to the empty vector.
if (count > maxFreq)
{
maxFreq = count;
result.clear();
result.push_back(array[i]);

5. }
}
//sort the modes in ascending order
sort(result.begin(), result.end());
return result;
Below is the assignment description and the file I have written. I would love to test this file to
make sure that everything is satisfied (vector with all modes in ascending order). I'm having a
really hard time constructing a main method to test it. Help!!
-------------------------------------------------------
The mode is the value that appears most often in a set of data. Write a function named findMode
that takes as parameters an array of int and the size of the array, and returns a vector containing
the mode(s). If there is just a single most frequent value, the vector will only contain that one
value, but if multiple values tie for maximum frequency, the vector will need to contain all such
values. This includes the case where every number in the array appears only once. Each mode
should appear only once in the vector. The values in the vector that is returned must be in
ascending order. If you need to sort a vector, it's similar to sorting an array, but specifying the
beginning and end of the vector look a little bit different. If your vector is named result, then it
would look like this: "std::sort(result.begin(), result.end());".

6. -------------------------------------------------------
#include // needed for the sort() function
#include // needed to use the vector type
#include // needed for the main function
using std::vector;
using std::sort;
vector findMode(int array[], int size)
{
int maxFreq = 1; // initalizing the largest frequency to be 1

7. vector result; // results is an empty vector
//Initializing the loop through the integer array
for (int i = 0; i < size; i++)
{
int count = 1; //started the counter at 1
//started the the loop after the 1st entry, looking for matches with the value at index i.
for (int j = i + 1; j < size; j++)
{
//if an entry matches another, then add one to the counter

8. if (array[i] == array[j])
{
count++;
}
}
//when the counter is equal to the max frequency, the integer is added to the result vector.
if (count == maxFreq)
{
result.push_back(array[i]);
}
//when the counter for i is greater than the max frequency, updates the maxFreq, clear the values
stored in the result vector, and push the value to the empty vector.

9. if (count > maxFreq)
{
maxFreq = count;
result.clear();
result.push_back(array[i]);
}
}
//sort the modes in ascending order
sort(result.begin(), result.end());
return result;
Below is the assignment description and the file I have written. I would love to test this file to
make sure that everything is satisfied (vector with all modes in ascending order). I'm having a

10. really hard time constructing a main method to test it. Help!!
-------------------------------------------------------
The mode is the value that appears most often in a set of data. Write a function named findMode
that takes as parameters an array of int and the size of the array, and returns a vector containing
the mode(s). If there is just a single most frequent value, the vector will only contain that one
value, but if multiple values tie for maximum frequency, the vector will need to contain all such
values. This includes the case where every number in the array appears only once. Each mode
should appear only once in the vector. The values in the vector that is returned must be in
ascending order. If you need to sort a vector, it's similar to sorting an array, but specifying the
beginning and end of the vector look a little bit different. If your vector is named result, then it
would look like this: "std::sort(result.begin(), result.end());".
The mode is the value that appears most often in a set of data. Write a function named findMode
that takes as parameters an array of int and the size of the array, and returns a vector containing
the mode(s). If there is just a single most frequent value, the vector will only contain that one
value, but if multiple values tie for maximum frequency, the vector will need to contain all such
values. This includes the case where every number in the array appears only once. Each mode
should appear only once in the vector. The values in the vector that is returned must be in
ascending order. If you need to sort a vector, it's similar to sorting an array, but specifying the
beginning and end of the vector look a little bit different. If your vector is named result, then it
would look like this: "std::sort(result.begin(), result.end());".
-------------------------------------------------------
#include // needed for the sort() function
#include // needed to use the vector type

11. #include // needed for the main function
using std::vector;
using std::sort;
vector findMode(int array[], int size)
{
int maxFreq = 1; // initalizing the largest frequency to be 1
vector result; // results is an empty vector
//Initializing the loop through the integer array

12. for (int i = 0; i < size; i++)
{
int count = 1; //started the counter at 1
//started the the loop after the 1st entry, looking for matches with the value at index i.
for (int j = i + 1; j < size; j++)
{
//if an entry matches another, then add one to the counter
if (array[i] == array[j])
{
count++;
}

13. }
//when the counter is equal to the max frequency, the integer is added to the result vector.
if (count == maxFreq)
{
result.push_back(array[i]);
}
//when the counter for i is greater than the max frequency, updates the maxFreq, clear the values
stored in the result vector, and push the value to the empty vector.
if (count > maxFreq)
{
maxFreq = count;

14. result.clear();
result.push_back(array[i]);
}
}
//sort the modes in ascending order
sort(result.begin(), result.end());
return result;
Solution
Here is your main method, Copy Paste This code and Replace your main method using the below
Code.
int main()
{
//Case 1
// int arr[10]= {1,1,1,1,1,1,1,2,3,4};
//vector result = findMode(arr,10);
//Case 2

15. // int arr[10]= {1,2,3,4};
//vector result = findMode(arr,4);
//Case 3
// int arr[1]= {1};
//vector result = findMode(arr,1);
//Case 4
// int arr[10]= {1,1,2,2,3,3};
//vector result = findMode(arr,6);
int arr[10]= {1,1,2,2,3,3};
vector result = findMode(arr,6);
for (std::vector::iterator it = result.begin() ; it != result.end(); ++it)
std::cout << ' ' << *it;
}
I have written few more Tests for you, you can uncomment them and test your code using those
inputs. I hope it helps.