Блог

Теоретически я знаю, что для максимума я бы заменил текущее значение новым целым числом, которое вводит пользователь, если оно выше последнего, и наоборот для минимального, но я не могу, как это сделать с моим кодом. По сути, я спрашиваю, есть ли у меня способ сравнить два целых числа без сохранения их данных.

Это часть кода, который у меня есть на данный момент. Я нашел среднее значение, сумму и сумму введенных целых чисел, а также количество четных и нечетных целых чисел. Теперь мне просто нужно показать минимальные и максимальные целочисленные значения.

 int main()
{
    int intVal;
    int sum = 0;
    int maxValue = -1;
    int minValue = -1;
    double average = 0;
    int count = 0;
    int evenCount = 0;
    int oddCount = 0;

    cout << endl << "Enter an integer (negative value to Quit):  ";
    cin  >> intVal;
    cout << endl;


    while(intVal >= 0)
    {
        count   ;
        sum  = intVal;
    
        if(intVal > 0)
            average = sum / count;
    
        if(intVal % 2 == 0)
            evenCount   ;
        else
            oddCount   ;
       
        cout << "Enter an integer (negative value to Quit):  ";
        cin  >> intVal;
        cout << endl;
     }
}
 

Просто сравните и обновите, если оно должно быть обновлено:

 if (maxValue < 0 || intVal > maxValue) maxValue = intVal;
if (minValue < 0 || intVal < minValue) minValue = intVal;
 

деталь:

 if (                 // if
  maxValue < 0       // there are no value yet (this is the first value)
  ||                 // or
  intVal > maxValue) // new value is larger than current maximum,
  maxValue = intVal; // update the maximum
 

Вот некоторый код, который может помочь вам разобраться в этом

 #include <iostream>

using namespace std;

int getmin(int a, int b)
{
  if (a < b)
  {
    return a;
  }
  else
  {
    return b;
  }
}

int getmax(int a, int b)
{
  if (a > b)
  {
    return a;
  }
  else
  {
    return b;
  }
}

int prompt()
{
  int val;
  cout << "Enter an integer (negative to quit): ";
  cin >> val;
  return val;
}

int status(int current, int evens, int odds, int minimum, int maximum, int sum)
{
  cout << "=== Stats (last: " << current << ") ==="
    << "Odds: " << odds << endl
    << "Evens: " << evens << endl
    << "Min: " << minimum << endl
    << "Max: " << maximum << endl
    << "Sum: " << sum << endl
    << "Avg: " << sum * 1.0 / (evens   odds) << endl
    << "Total: " << odds   evens << endl
    << "======" << endl;
}

int main()
{
  int current = 0;
  int evens = 0;
  int odds = 0;
  int sum = 0;
  int minimum = INT32_MAX;
  int maximum = INT32_MIN;

  while (true)
  {
    current = prompt();
    minimum = getmin(minimum, current);
    maximum = getmax(maximum, current);

    if (current < 0)
    {
      break;
    }

    sum  = current;

    if (current % 2 == 0)
    {
      evens  = 1;
    }
    else
    {
      odds  = 1;
    }

    status(current, evens, odds, minimum, maximum, sum);
  }

  cout << "Exiting" << endl;
  return 0;
}
 

Обратите внимание, что getmin и getmax могут быть заменены для реализаций алгоритма C

• http://www.cplusplus.com/reference/algorithm/min/
• http://www.cplusplus.com/reference/algorithm/max/

Независимо от того, как вы находите минимальное и максимальное значения, важно всегда инициализировать значения самыми высокими и самыми низкими значениями, которые может содержать тип, соответственно. В противном случае, в зависимости от диапазона введенных значений, ваши max и min могут не захватить максимальные или минимальные значения.

Теперь, решив разрешить только положительные числа и ноль, вы несколько уменьшаете эту возможность, но возьмем ваш minValue = -1; пример. Если вы принимаете только положительные числа, как вы это делаете, вы minValue никогда не изменитесь, потому что пользователь не может ввести что-либо меньшее, чем 0 в соответствии с вашим кодом.

Для инициализации переменных для захвата максимальных и минимальных значений C предоставляет std::numeric_limits и, в частности, функции-члены std ::numeric_limits::min и std ::numeric_limits::max .

Чтобы инициализировать переменные для получения максимальных и минимальных целочисленных значений, вы должны инициализировать следующим образом, например:

     int min = std::numeric_limits<int>::max(),
        max = std::numeric_limits<int>::min();
 

С min набором максимально возможных значений и max набором минимально возможного значения. Таким образом, независимо от того, какое значение введено, нет возможности, чтобы введенное значение выходило за рамки вашей инициализации.

Что касается зацикливания и поиска max и min без сохранения в массиве и т. Д., Вы можете сделать это с помощью простого троичного в качестве сокращения if ... else ... , или вполне нормально использовать полное if ... else ... для каждого min и max . Используя троичный, вы могли бы сделать:

 #include <iostream>
#include <limits>

int main (void) {
    
    int min = std::numeric_limits<int>::max(),
        max = std::numeric_limits<int>::min(),
        n;
    
    while (std::cin >> n amp;amp; n >= 0) {
        max = n > max ? n : max;
        min = n < min ? n : min;
    }
    
    std::cout << "nmin: " << min << "nmax: " << max << 'n';
}
 

(приведенный выше код прервет цикл чтения при вводе любого значения, меньшего нуля)

Пример использования / вывода

 $ ./bin/minmaxlimits
1
9
7
13
2
449
8
-1

min: 1
max: 449
 

Ключевым моментом здесь является то, что не корректируйте свои max значения и min значения инициализации только потому, что вы ограничиваете ввод положительными значениями. Если вы всегда инициализируете, используя max() min() числовые ограничения и, вы никогда не ошибетесь.