C++ 如何计算用户输入列表的最大值、最小值和平均值

伙计们！下周我有期中考试C++，我做了一些练习。对于这一个，我很难理解如何从用户输入的整数列表中获得最小值和平均值。任何帮助都将不胜感激！：）

#包括
使用名称空间std；
int main（）
{
int max=0；
int min=0；
int num=0；
cout num）
{
如果（num>=0）
{
如果（数值>最大值）
{
max=num；
}
如果（数值<最大值）
{
}
}
}
返回0；
}

您可以这样做：

int main()
{
    using namespace std;
    bool cont = true;
    int total = 0;
    int amount = 0;
    int average;
    int min = 0;
    int max = 0;
    int num;

    while(cont)
    {
        cin >> num;
        if(num < 0)
        {
            cont = false;
            break;
        }
        amount++;
        if(amount == 1)
        {
            min = num;
            max = num;
        }
        if(num < min) min = num;
        if(num > max) max = num;
        total += num;
    }

    int average = total/amount;
    printf("Min: %i \nMax: %i \nAverage: %i \n", min, max, average);
}

intmain（）
{
使用名称空间std；
bool cont=真；
int-total=0；
整数金额=0；
整数平均；
int min=0；
int max=0；
int-num；
while（续）
{
cin>>num；
if（num<0）
{
cont=假；
打破
}
金额++；
如果（金额=1）
{
min=num；
max=num；
}
如果（nummax）max=num；
总数+=num；
}
int average=总额/金额；
printf（“最小值：%i\n最大值：%i\n平均值：%i\n”，最小值，最大值，平均值）；
}

我还没有实际测试过这个，但它应该可以正常工作。 此外，您可能希望将平均值设置为浮点值，因为将其设置为int可能并不精确。如果平均值不是一个整数，它将被舍入为一个整数。我只是把它设为整数，因为所有的值都是整数，但实际上它应该是双精度或浮点型

---

希望这能有所帮助。

首先，我想指出的是，你不应该像在其他帖子中所显示的那样，使用带有数字限制的方法。这是一个非常糟糕的方法。要找到一个对象序列的最大值或最小值，您需要的是类型定义为“代码>运算符< P>。这里是C++中的一个解决方案。它基本上是完整的，只是当输入负数时它不会退出（它将在任何非数字输入时退出）

此解决方案的优点是，只需很少的额外工作，它就可以（除非我犯了另一个错误）对任何数值类型工作（平均值的概念不是为非数值类型定义的，所以这没关系），只需在

main（）

中更改模板化函数调用中的类型即可。如果您想要更简单的内容，此答案的编辑历史记录中会有一个早期的“仅限整数”版本

#include <iostream>
#include <limits>
#include <algorithm>

template<typename T>
void listStats() {
    T min   = std::numeric_limits<T>::max();
    T max   = std::numeric_limits<T>::min();
    T sum   = static_cast<T>(0);
    T value;
    int count = 0; 

    while( std::cin >> value ) {
        max = std::max(max, value);
        min = std::min(min, value);
        sum += value;
        count++;
    }

    if( count > 0 ) {
        std::cout << "Minimum: " << min << std::endl;
        std::cout << "Maximum: " << max << std::endl;
        std::cout << "Average: " << sum/double(count) << std::endl;
    } else {
        std::cout << "No input" << std::endl;
    }
}

int main(void)
{
    listStats<int>();
    return 0;
}

#包括
#包括
#包括
模板
void listStats（）{
T最小值=标准：：数值限制：：最大值（）；
T max=std:：numeric_limits:：min（）；
T和=静态_转换（0）；
T值；
整数计数=0；
而（标准：：cin>>值）{
max=std:：max（max，value）；
最小值=标准值：：最小值（最小值，值）；
总和+=数值；
计数++；
}
如果（计数>0）{
std:：cout 1）使用字符串流分解用户输入2）使用循环将这些值添加到数组中3）在数组上循环选取最小值和最大值并计算平均值。这些步骤可以压缩，但这是基本jist。4）不要将最小值和最大值初始化为0。如果所有数字都是负数怎么办？如果所有数字都是负数怎么办是否为正值？对于平均值，您可能需要跟踪到目前为止输入的所有值的总和以及输入的值的数量（以便最终计算平均值）。不要忘记使用双精度而不是整数来计算平均值。@oopsecene根据精度要求，您实际上不需要这样做。最多关闭1。您确定
min=0
是适当的初始化吗？是的，如果有任何有效的输入，它将被更改
std:：numeric\u limits:：min（）呢
和
std:：numeric_limits:：max（）？这些不是C++程序的更好选择吗？是的，但是这不是必需的。@ Emmet，你也可以使用Booo:：累加器平均。你读过我的描述吗，弗拉德？@ EMMET我读过。但是在作业中还有一个要求。为什么不给我们你的答案，弗拉德？我们可能快一点。所有这些都是为了看看你是如何做的，而不是玩猜谜游戏。@Emmet达到这些确切要求的一个可能的方法是在
while
条件中添加
&&value>=0
；尽管在这一点上我希望OP有足够的信息来确定这一点！：）Jason-C：我想我会让OP自己做这项小任务。我认为这是足够的包含在我描述中的附加说明中。如果Vlad有任何进一步的问题，我怀疑他会羞于让我们知道。你真的不需要
cont
，只需要
中断
，而不是
（true）
也会得到同样的结果。：）在不同的域上计算
平均值
似乎没有意义，而不是
min
和
max
；后者使用字典顺序，前者使用长度。使这些匹配的唯一方法是使
min
和
max
也对长度进行操作l——当前对“average string=average string length”（平均字符串=平均字符串长度）的定义似乎是对非数字类型任意定义的延伸。此外，我建议不要使用
元组，它不包含语义信息（可以与
元组混用，这意味着完全不同的东西）此外，使用
enum
对元组中的索引进行黑客攻击时，会将语义放在enum的值上（例如
enum{MIN=3，MAX=4，SUM=5}
不起作用），但enum的目的是在名称中传达语义。定义
结构{T MIN，MAX，mean；}会更清晰、更安全，在语义上更相关
。此解决方案避开了所有在编译时检查语义的良好实践方法；它并不是C++功能的最佳使用。
#include <iostream>
#include <boost/accumulators/accumulators.hpp>
#include <boost/accumulators/statistics/stats.hpp>
#include <boost/accumulators/statistics/mean.hpp>
#include <boost/accumulators/statistics/min.hpp>
#include <boost/accumulators/statistics/max.hpp>
using namespace boost::accumulators;

int main() {
    // Define an accumulator set for calculating the mean, max, and min
    accumulator_set<double, features<tag::min, tag::max, tag::mean> > acc;

    int num = -1;
    bool empty = true;

    while ( std::cin >> num && num >= 0) {
        empty = false;
        acc( num);
    }

    if ( ! empty) {
        // Display the results ...
        std::cout << "Mean: " << mean( acc) << std::endl;
        std::cout << "Min: " << min( acc) << std::endl;
        std::cout << "Max: " << max( acc) << std::endl;  
    }

    return 0;
}

int main()
{
    using namespace std;
    bool cont = true;
    int total = 0;
    int amount = 0;
    int average;
    int min = 0;
    int max = 0;
    int num;

    while(cont)
    {
        cin >> num;
        if(num < 0)
        {
            cont = false;
            break;
        }
        amount++;
        if(amount == 1)
        {
            min = num;
            max = num;
        }
        if(num < min) min = num;
        if(num > max) max = num;
        total += num;
    }

    int average = total/amount;
    printf("Min: %i \nMax: %i \nAverage: %i \n", min, max, average);
}

#include <iostream>

using namespace std;

int main()
{
    int max;
    int min;
    int num;
    int count;
    int sum;
    bool empty;

    cout << "Enter a list of integers terminated by a negative number: " << endl;

    sum = 0; count = 0; empty = true;

    while ( cin >> num && num >= 0 )
    {
        if ( empty )
        {
            max = num;
            min = num;
            empty = false;
        }
        else if ( max < num )
        {
            max = num;
        }
        else if ( num < min )
        {
            min = num;
        }

        ++count;
        sum += num;         
    }

    if ( !empty )
    {
        cout << "minimum value = " << min << endl;      
        cout << "maximum value = " << max << endl;      
        cout << "average value = " << sum / count << endl;      
    }

    return 0;
}

#include <iostream>
#include <string>
#include <tuple>


enum { MAX, MIN, SUM, CNT };

template <typename T>
bool GetInfo( std::tuple<T, T, T, size_t> &t )
{
    bool empty;
    T min;
    T max;
    T sum;
    T num;
    size_t cnt;

    sum = T(); cnt = 0; empty = true;

    while ( std::cin >> num && !( num < T() ) )
    {
        if ( empty )
        {
            max = num;
            min = num;
            empty = false;
        }
        else if ( max < num )
        {
            max = num;
        }
        else if ( num < min )
        {
            min = num;
        }

        sum = sum + num;
        ++cnt;
    }

    if ( !empty )
    {
        std::get<MAX>( t ) = max;
        std::get<MIN>( t ) = min;
        std::get<SUM>( t ) = sum;
        std::get<CNT>( t ) = cnt;
    }

    return !empty;
}


int main()
{
    std::tuple<std::string, std::string, std::string, size_t> t;

    std::cout << "Enter strings (Ctrl+Z - exit): ";

    bool non_empty = GetInfo( t );

    if ( non_empty )
    {
        std::cout << "maximum string is " << std::get<MAX>( t ) << std::endl;
        std::cout << "minimum string is " << std::get<MIN>( t ) << std::endl;
        std::cout << "total string   is " << std::get<SUM>( t ) << std::endl;
        std::cout << "average lemgth is " << std::get<SUM>( t ).size() / std::get<CNT>( t )
                                          << std::endl;
    }
}

Enter strings (Ctrl+Z - exit): abc def ghi
^Z
maximum string is ghi
minimum string is abc
total string   is abcdefghi
average lemgth is 3

template <typename InputIterator, typename UnaryPredicate>
typename std::iterator_traits<InputIterator>::difference_type
GetInfo ( InputIterator first, InputIterator last, 
          std::tuple<typename std::iterator_traits<InputIterator>::value_type, 
                     typename std::iterator_traits<InputIterator>::value_type, 
                     typename std::iterator_traits<InputIterator>::value_type> &t, 
          UnaryPredicate unary_predicate );

#include <iostream>
#include <string>
#include <functional>
#include <tuple>


enum { MAX, MIN, SUM };

template <typename T, typename UnaryPredicate>
size_t GetInfo( std::tuple<T, T, T> &t, UnaryPredicate unary_predicate )
{
    T min;
    T max;
    T sum;
    T num;
    size_t cnt;

    sum = T(); cnt = 0;

    while ( std::cin >> num && !unary_predicate( num ) )
    {
        if ( cnt == 0 )
        {
            max = num;
            min = num;
        }
        else if ( max < num )
        {
            max = num;
        }
        else if ( num < min )
        {
            min = num;
        }

        sum = sum + num;
        ++cnt;
    }

    if ( cnt != 0 )
    {
        std::get<MAX>( t ) = max;
        std::get<MIN>( t ) = min;
        std::get<SUM>( t ) = sum;
    }

    return cnt;
}

int main()
{
    std::tuple<int, int, int> t;

    std::cout << "Enter non-negaruve integers (-1 - exit): ";

    size_t cnt = GetInfo( t, std::bind2nd( std::equal_to<int>(), -1 ) );

    if ( cnt )
    {
        std::cout << "maximum value is " << std::get<MAX>( t ) << std::endl;
        std::cout << "minimum value is " << std::get<MIN>( t ) << std::endl;
        std::cout << "total value   is " << std::get<SUM>( t ) << std::endl;
        std::cout << "average value is " << std::get<SUM>( t ) / cnt
                                          << std::endl;
    }
}

#include <iostream>
#include <limits>
#include <algorithm>

template<typename T>
void listStats() {
    T min   = std::numeric_limits<T>::max();
    T max   = std::numeric_limits<T>::min();
    T sum   = static_cast<T>(0);
    T value;
    int count = 0; 

    while( std::cin >> value ) {
        max = std::max(max, value);
        min = std::min(min, value);
        sum += value;
        count++;
    }

    if( count > 0 ) {
        std::cout << "Minimum: " << min << std::endl;
        std::cout << "Maximum: " << max << std::endl;
        std::cout << "Average: " << sum/double(count) << std::endl;
    } else {
        std::cout << "No input" << std::endl;
    }
}

int main(void)
{
    listStats<int>();
    return 0;
}