Как найти наибольшее целое число меньшее числа

The following C code works in a certain sense—it gives you the next most negative integer that’s representable as a floating-point number:

double flooor(double x) {
  return floor(nextafter(x, -1.0/0.0));
}

The following Python code is a direct transliteration, but it relies on NumPy:

def flooor(x):
  return math.floor(numpy.nextafter(x, -numpy.inf))

The nextafter function moves from its first argument one double closer to its second argument. It has a special case; if z < 0 and you ask for nextafter(0.0, z), it will return the smallest negative subnormal number.

From your specification, it is unclear what should be done with positive infinity and the most negative finite number. This code sends positive infinity to the most positive finite number, negative infinity to itself, and the most negative finite number to negative infinity.

Martijn Pieters gave the incantation int(math.ceil(x)) - 1 in his answer, since deleted. This correctly finds the largest int less than the float x. This rounds x up, converts it to integer, and subtracts 1, giving the largest Python int that is numerically less than x.

Найти наименьшее и наибольшее целое число при условии

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

While7. Дано целое число N (> 0). Найти наименьшее целое положительное число K, квадрат которого превосходит N: K² > N. Функцию извлечения квадратного корня не использовать.

Начальное значение искомого числа принимаем за 1 (это минимальное целое положительное). Потом увеличиваем его до тех пор, пока его квадрат не превосходит заданное число N. Первое число, нарушающее это условие, и будет искомым числом K.

var
  N, K: integer;

begin
  { ******* Ввод данных ******* }
  writeln('Введите целое положительное число:');
  write(' N = ');
  readln(N); { <-- Вводим число }
  { ******* Основная программа ******* }
  K := 1; { <== Начальное значение искомого числа }
  { Увеличиваем K до тех пор, пока его
  квадрат не превосходит N: }
  while K * K <= N do 
    inc(K); { <-- Увеличиваем число на 1 }
  writeln;
  writeln('Ответ: ', K);
  readln
end.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647
**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1
While8. Дано целое число N (> 0). Найти наибольшее целое число K, квадрат которого не превосходит N: K² ≤ N. Функцию извлечения квадратного корня не использовать.

Задача While8 от предыдущей отличается одним существенным моментом: нужно находить не наименьшее целое, нарушающее условие, а наибольшее целое положительное, при котором условие ещё выполняется. Естественно, что разница между этими двумя числами всего в 1. Поэтому, если K² ≤ N, то будем увеличивать K на 1 (как и в предыдущей задаче), а на выходе из цикла отнимем 1, так как при этом K условие K² ≤ N нарушается.

var
  N, k: integer;

begin
  write('N = ');
  readln(N);
  K := 1; { <-- Начальное значение числа }
  { Выполняем цикл до тех пор, пока 
  квадрат числа K не превосходит N: }
  while K * K <= N do 
    inc(K); { <-- Увеличиваем число на 1 }
  writeln;  
  writeln('Ответ: ', K - 1);
  readln
end.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647
**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1
While9. Дано целое число N (> 1). Найти наименьшее целое число K, при котором выполняется неравенство 3K > N.

var
  N, k: integer;

begin
  write('N = ');
  readln(N); { <-- Вводим число N>1 }
  K := 1; { <-- Начальное значение искомого числа }
  { Выполняем цикл до тех пор, пока 
  число 3 * K не превосходит N: }
  while 3 * K <= N do
    inc(K); { <-- Увеличиваем число на 1 }
  writeln;
  write('Ответ: ', K);
  readln
end.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647
**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1
While10. Дано целое число N (> 1). Найти наибольшее целое число K, при котором выполняется неравенство 3K < N.

Увеличиваем целое K при условии, если 3(K+1) < N. Тогда наибольшее число, при котором 3K < N, будет K.

var
  N, K: integer;

begin
  write('N = ');
  readln(N); { <-- Вводим число N > 1 }
  K := 1; { <-- Начальное значение }
  { Увеличиваем K до тех пор, пока 
  число 3(K+1) меньше N: }
  while 3 * (K + 1) < N do
    inc(K); { <-- Увеличиваем число на 1 }
  writeln;  
  writeln('Ответ: ', K);
  readln
end.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647
**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1
Вариант с использованием цикла Repeat:

var
  N, k: integer;

begin
  write('N = ');
  readln(N);
  K := 1;
  { Выполняем цикл до наступления условия 3K ≥ N: } 
  repeat
    inc(K)
  until 3 * K >= N;
  writeln;  
  writeln('Ответ: ', K);
  readln
end.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647
**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1
While11. Дано целое число N (> 1). Вывести наименьшее из целых чисел K, для которых сумма 1 + 2 + … + K будет больше или равна N, и саму эту сумму.

var
  N, K, Sum: word;

begin
  writeln('Введите целое положительное число N (> 1):');
  readln(N); { <-- Вводим число }
  K := 1; { <-- Начальное значение искомого числа }
  Sum := 1; { <-- Начальное значение суммы }
  { Выполняем цикл до тех пор, пока Sum меньше N: }
  while Sum < N do
  begin
    inc(K); { <-- Увеличиваем слагаемое на 1 }
    Sum := Sum + K { <-- Увеличиваем сумму на K }
  end;
  writeln(' K = ', K);
  writeln(' сумма: ', Sum);
  readln
end.

**type** word;: Представляет 16-битовое целое число без знака.Диапазон значений: 0 .. 65 535
**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1
While12. Дано целое число N (> 1). Вывести наибольшее из целых чисел K, для которых сумма 1 + 2 + … + K будет меньше или равна N, и саму эту сумму.

var
  N, k, Sum: integer;

begin
  writeln('Введите целое число N(> 1):');
  readln(N);
  K := 1; { <-- Начальное значение числа }
  Sum := 1; { <-- Начальное значение суммы }
  { Выполняем цикл до тех пор, пока Sum+K+1 не
  больше N (K+1 - следующее за K слагаемое): }
  while Sum + K + 1 <= N do
  begin
    inc(K); { <-- Увеличиваем число на 1 }
    Sum := Sum + K { <-- Увеличиваем сумму на K }
  end;
  writeln(' K = ', K);
  writeln(' Сумма: ', Sum);
  readln
end.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647
**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1
While13. Дано число A (> 1). Вывести наименьшее из целых чисел K, для которых сумма 1 + 1/2 + … + 1/K будет больше A, и саму эту сумму.

Здесь нужно пояснить один момент: как нетрудно догадаться, сумма 1+1/2+1/3+1/4+…1/K с увеличением K растет очень медленно. Для примера посмотрите суммы для некоторых значений K:

Как видим, даже при K=10⁹ (1 миллиард) сумма ряда чуть больше 21, а вычисления у меня на ноутбуке длились 12-13 секунд. Поэтому при вводе K нужно быть осторожным и не вводить большие числа типа 100, 200 и т.д., так как окончания вычислений можете не дождаться ⌛.

var
  K: integer;
  A, Sum: real;

begin
  writeln('Введите число A (> 1):');
  write(' A = ');
  readln(A); { <-- Вводим число }
  K := 1; { <== Начальное значение искомого числа }
  Sum := 1; { <== Начальное значение суммы }
  { Выполняем цикл до тех пор, пока Sum не больше A: }
  while Sum <= A do
  begin
    inc(K); { <== Увеличиваем число на 1 }
    Sum := Sum + 1 / K { <== Увеличиваем сумму на 1/K }
  end;  
  writeln;
  writeln(' число: ', K);
  writeln(' сумма: ', Sum);
  readln
end.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647
**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 — 16 Диапазон значений: -1.8∙10³⁰⁸ .. 1.8∙10³⁰⁸
**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1
While14. Дано число A (> 1). Вывести наибольшее из целых чисел K, для которых сумма 1 + 1/2 + … + 1/K будет меньше A, и саму эту сумму.

var
  K: integer;
  A, Sum: real;

begin
  write('A = ');
  readln(A); { <-- Вводим число }
  K := 1; { <== Начальное значение числа }
  Sum := 1; { <== Начальное значение суммы }
  { Выполняем цикл до тех пор, пока следующая за Sum 
  сумма - то есть число Sum+1/(K+1) - будет меньше A: }
  while Sum + 1/(K+1) < A do
  begin
    inc(K); { <== Увеличиваем число на 1 }
    Sum := Sum + 1 / K { <== Увеличиваем сумму }
  end;
  writeln;
  writeln(' K = ', K);
  writeln(' сумма: ', Sum);
  readln
end.

**type** integer;: Представляет 32-битовое целое число со знаком.Диапазон значений: -2 147 483 648 .. 2 147 483 647
**type** real;: Представляет число двойной точности с плавающей запятой.Размер: 8 байт Количество значащих цифр: 15 — 16 Диапазон значений: -1.8∙10³⁰⁸ .. 1.8∙10³⁰⁸
**procedure** Inc(**var** i: integer);: Увеличивает значение переменной i на 1

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

double flooor(double x) {
  return floor(nextafter(x, -1.0/0.0));
}

Следующий код Python является прямой транслитерацией, но он полагается на NumPy:

def flooor(x):
  return math.floor(numpy.nextafter(x, -numpy.inf))

Функция nextafter перемещается от своего первого аргумента один double ближе ко второму аргументу. У него есть особый случай; если z < 0, и вы запрашиваете nextafter(0.0, z), он вернет наименьшее отрицательное отрицательное число.

Из вашей спецификации неясно, что делать с положительной бесконечностью и самым отрицательным конечным числом. Этот код посылает положительную бесконечность к самому положительному конечному числу, отрицательной бесконечности к себе и к самому отрицательному конечному числу к отрицательной бесконечности.

Martijn Pieters дал заклинание int(math.ceil(x)) - 1 в своем ответе, так как был удален. Это правильно находит наибольший int меньше, чем float x. Этот раунд x вверх, преобразует его в целое и вычитает 1, давая самый большой Python int, который численно меньше x.