Как найти отрицательный максимум

Решение задачи 1.9 на Паскале

program maxneg;
 
//****************************************************************
// КОНСТАНТЫ
//****************************************************************
const
  MAX_VAL = 1000;
 
//****************************************************************
// ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
//****************************************************************
var
  A, B, C : Integer;
  Nums    : byte;
 
//****************************************************************
// ФУНКЦИИ И ПРОЦЕДУРЫ
//****************************************************************
 
//****************************************************************
// Возвращает случайное значение
//****************************************************************
function GetRandomNum : Integer;
begin
  Result := Random(MAX_VAL) - ((MAX_VAL div 10) * 7);
end;
 
//****************************************************************
// Сравнивает два числа
// ВХОД: N1, N2 - числа для сравнения
// ВЫХОД: 0 - числа равны
//        1 - число 1 больше числа 2
//        2 - число 2 больше числа 1
//****************************************************************
function GetMax(N1, N2 : integer) : integer;
begin
  Result := 0;
  if (N1 > N2) then Result := 1
  else if (N1 < N2) then Result := 2;
end;
 
//****************************************************************
// Сравнивает три отрицательных числа
// ВХОД: N1, N2, N3 - числа для сравнения
// ВЫХОД: 'A' - наибольшее число N1
//        'B' - наибольшее число N2
//        'C' - наибольшее число N3
//****************************************************************
function GetMaxABC(N1, N2, N3 : integer) : char;
begin
  Result := 'C';
  if GetMax(N1, N2) < 2 then      //Если N1 >= N2
    begin
      if GetMax(N1, N3) < 2 then  //Если N1 >= N3
        Result := 'A';
    end
  else                            //Если N1 < N2
    begin
      if GetMax(N2, N3) < 2 then  //Если N2 >= N3
        Result := 'B';
    end;
end;
 
//****************************************************************
// Определяет знаки чисел и возвращает их в разрядах числа типа BYTE
// ВХОД: na, nb, nc - числа A, B, C
// ВЫХОД: знаки чисел - бит 2 - число na, бит 1 - число nb, бит 0 - число nc
// То есть всего возможны 8 комбинаций:
//   0 - все положительные
//   1 - С < 0
//   2 - B < 0
//   3 - B и С меньше нуля
//   4 - A < 0
//   5 - A и С меньше нуля
//   6 - A и B меньше нуля
//   7 - все отрицательные
//****************************************************************
function GetNumZnak(na, nb, nc : integer) : byte;
var ba, bb, bc  : byte;
begin
  ba := 0;
  bb := 0;
  bc := 0;
  if na < 0 then ba := 4;
  if nb < 0 then bb := 2;
  if nc < 0 then bc := 1;
  Result := ba + bb + bc;
end;
 
//****************************************************************
// Выводит результат на экран
// ВХОД: S - имя числа, N - значение числа
// ВЫХОД: Если N >= 0, то сообщение об отсутствии отрицательных чисел
//        Если N < 0, то имя числа и его значение (число N)
//****************************************************************
procedure NumberToScreen(S : char; N : integer);
begin
  if N < 0 then
    WriteLn('The smallest negative number is ', S, ' = ', N)
  else
    WriteLn('All the numbers are positive');
end;
 
//****************************************************************
// ОСНОВНАЯ ПРОГРАММА
// Алгоритм:
// получить только отрицательные числа
// сравнить эти числа
//****************************************************************
begin
  //Запустить генератор случайных чисел
  Randomize;
 
  //Получить случайные значения для чисел А, В, С
  A := GetRandomNum;
  B := GetRandomNum;
  C := GetRandomNum;
  WriteLn('A = ', A, ', B = ', B, ', C = ', C);
  Nums := GetNumZnak(A, B, C);
 
  case Nums of
  0 :           //Все числа положительные
    NumberToScreen('A', A);
  1 :           //Только С < 0;
    NumberToScreen('C', C);
  2 :           //Только B < 0;
    NumberToScreen('B', B);
  3 :           //B и С меньше нуля
    if GetMax(B, C) < 2 then  //Если B = С или B > C, то
      NumberToScreen('B', B)  //искомое число - это B
    else                      //иначе
      NumberToScreen('C', C); //искомое число - это С
  4 :           //Только A < 0;
    NumberToScreen('A', A);
  5 :           //A и С меньше нуля
    if GetMax(A, C) < 2 then  //Если A = С или A > C, то
      NumberToScreen('A', A)  //искомое число - это A
    else                      //иначе
      NumberToScreen('C', C); //искомое число - это С
  6 :           //A и B меньше нуля
    if GetMax(A, B) < 2 then  //Если A = B или A > B, то
      NumberToScreen('A', A)  //искомое число - это A
    else                      //иначе
      NumberToScreen('B', B); //искомое число - это B
  7 :           //Все числа отрицательные;
    case GetMaxABC(A, B, C) of
    'A' : NumberToScreen('A', A);
    'B' : NumberToScreen('B', B);
    'C' : NumberToScreen('C', C);
    end;
  end;
 
  WriteLn('The end. Press ENTER...');
  ReadLn;
end.

Решение задачи 1.9 на С++

#include 
#include 
 
using namespace std;
 
//****************************************************************
// КОНСТАНТЫ
//****************************************************************
const int MAX_VAL = 1000;  
 
//****************************************************************
// ГЛОБАЛЬНЫЕ ПЕРЕМЕННЫЕ
//****************************************************************
int A, B, C;
char Nums;
 
//****************************************************************
// ФУНКЦИИ И ПРОЦЕДУРЫ
//****************************************************************
 
//****************************************************************
// Возвращает случайное значение
//****************************************************************
int GetRandomNum()
{
  int n = (MAX_VAL / 10) * 7;
  return(rand()%MAX_VAL - (int)n);
}  
 
//****************************************************************
// Сравнивает два числа
// ВХОД: N1, N2 - числа для сравнения
// ВЫХОД: 0 - числа равны
//        1 - число 1 больше числа 2
//        2 - число 2 больше числа 1
//****************************************************************
int GetMax(int N1, int N2)
{
  int Res = 0;
  if (N1 > N2) Res = 1;
  else if (N1 < N2) Res = 2;
  return(Res);
}
 
//****************************************************************
// Сравнивает три отрицательных числа
// ВХОД: N1, N2, N3 - числа для сравнения
// ВЫХОД: 'A' - наибольшее число N1
//        'B' - наибольшее число N2
//        'C' - наибольшее число N3
//****************************************************************
char GetMaxABC(int N1, int N2, int N3)
{
  char Res = 'C';
  if (GetMax(N1, N2) < 2)       //Если N1 >= N2
    {
      if (GetMax(N1, N3) < 2)   //Если N1 >= N3
        Res = 'A';
    }
  else                          //Если N1 < N2
    {
      if (GetMax(N2, N3) < 2)   //Если N2 >= N3
        Res = 'B';
    }
  return(Res);
}
 
//****************************************************************
// Определяет знаки чисел и возвращает их в разрядах числа типа BYTE
// ВХОД: na, nb, nc - числа A, B, C
// ВЫХОД: знаки чисел - бит 2 - число na, бит 1 - число nb, бит 0 - число nc
// То есть всего возможны 8 комбинаций:
//   0 - все положительные
//   1 - С < 0
//   2 - B < 0
//   3 - B и С меньше нуля
//   4 - A < 0
//   5 - A и С меньше нуля
//   6 - A и B меньше нуля
//   7 - все отрицательные
//****************************************************************
char GetNumZnak(int na, int nb, int nc)
{
  int ba = 0;
  int bb = 0;
  int bc = 0;
  if (na < 0) ba = 4;
  if (nb < 0) bb = 2;
  if (nc < 0) bc = 1;
  return(ba + bb + bc);
} 
 
//****************************************************************
// Выводит результат на экран
// ВХОД: S - имя числа, N - значение числа
// ВЫХОД: Если N >= 0, то сообщение об отсутствии отрицательных чисел
//        Если N < 0, то имя числа и его значение (число N)
//****************************************************************
void NumberToScreen(char S, int N)
{
  if (N < 0)
    cout << "The smallest negative number is " << S << " = " << N << endl;
  else
    cout << "All the numbers are positive" << endl;;
}         
 
//****************************************************************
// ОСНОВНАЯ ПРОГРАММА
//****************************************************************
int main(int argc, char *argv[])
{
  //Запустить генератор случайных чисел   
  srand(time(0));         
  
  //Получить случайные значения для чисел А, В, С
  A = GetRandomNum();
  B = GetRandomNum();
  C = GetRandomNum();
  cout << "A = " << A << ", B = " << B << ", C = " << C << endl;
  Nums = GetNumZnak(A, B, C);
 
  switch(Nums)
  {
  case 0 :                     //Все числа положительные
    NumberToScreen('A', A);
    break;
  case 1 :                     //Только С < 0;
    NumberToScreen('C', C);
    break;
  case 2 :                     //Только B < 0;
    NumberToScreen('B', B);
    break;
  case 3 :                     //B и С меньше нуля
    if (GetMax(B, C) < 2)      //Если B = С или B > C, то
      NumberToScreen('B', B);  //искомое число - это B
    else                       //иначе
      NumberToScreen('C', C);  //искомое число - это С
    break;
  case 4 :                     //Только A < 0;
    NumberToScreen('A', A);
    break;
  case 5 :                     //A и С меньше нуля
    if (GetMax(A, C) < 2)      //Если A = С или A > C, то
      NumberToScreen('A', A);  //искомое число - это A
    else                       //иначе
      NumberToScreen('C', C);  //искомое число - это С
    break;
  case 6 :                     //A и B меньше нуля
    if (GetMax(A, B) < 2)      //Если A = B или A > B, то
      NumberToScreen('A', A);  //искомое число - это A
    else                       //иначе
      NumberToScreen('B', B);  //искомое число - это B
    break;
  case 7 :                     //Все числа отрицательные;
    switch(GetMaxABC(A, B, C))
    {
      case 'A' : NumberToScreen('A', A); break;
      case 'B' : NumberToScreen('B', B); break;
      case 'C' : NumberToScreen('C', C); break;
    }
  }    
  
  system("PAUSE");
  return EXIT_SUCCESS;
}

Минимумом называют точку на функции, в которой значение функции меньше, чем в соседних точках.

Максимумом называют точку на функции, в которой значение функции больше, чем в соседних точках.

Минимумы и максимумы вместе именуют экстремумами функции.

В точках экстремумов (т.е. максимумов и минимумов) производная
равна нулю.

— Производная положительна там, где функция возрастает.
— Производная отрицательна там, где функция убывает.

— Функция имеет максимум там, где производная равна нулю и меняет знак с плюса на минус.
— Функция имеет минимум там, где производная равна нулю и меняет знак с минуса на плюс.

select max(cola) from test;

select min(cola) from test;

1