c++ - 如何在 C++ 中显示项目计数对列表？

Question

我已经创建了一个简单模式计算器，并且正在显示随机列表 - 如下所示:

12 14 11 10 15 13 16 13 14 14 11 13 16 15 15 15 10 14 13 14 12 13 14 12
众数为6
模式为14

.但我的问题是我无法让配对列表显示而不是显示列表方式 - 我想将其显示为项目计数配对列表:

{2,3}、{4,3}、{5,2}、{3,2}、{1,2}
模式显然是 2 和 4。

谁能帮我解决这个问题？谢谢您的帮助。

这是一张图片以了解更多详情:https://imgur.com/a/FYNcxkv

here is my code:

#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 appearance 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

您可以使用以下方式创建 map 计数:

template <typename T>
std::map<T, std::size_t> map_count(const std::vector<T>& v)
{
    std::map<T, std::size_t> res;

    for (const auto& e: v) { res[e]++; }
    return res;
}

从那开始:

template <typename T>
std::pair<const T, std::size_t> find_mode(const std::map<T, std::size_t>& m)
{
    if (m.empty()) {throw std::runtime_error("empty map");}

    return *std::max_element(m.begin(),
                             m.end(),
                             [](const auto& lhs, const auto& rhs){ return lhs.second < rhs.second; }
                             );
}

Demo