Целочисленное деление с остатком в JavaScript?
JavaScript вычисляет прямо пол отрицательных чисел и остаток нецелых чисел, следуя математическим определениям для них.
FLOOR определяется как «наибольшее целое число, меньшее, чем параметр», таким образом:
- положительные числа: FLOOR (X) = целая часть X;
- отрицательные числа: FLOOR (X) = целая часть X минус 1 (потому что она должна быть МЕНЬШЕ, чем параметр, т. е. более отрицательной!)
REMAINDER определяется как «остаток» от деления (евклидова арифметика). Когда дивиденд не является целым числом, частное, как правило, также не является целым числом, то есть нет остатка, но если частное вынуждено быть целым числом (и это то, что происходит, когда кто-то пытается получить остаток или модуль число с плавающей запятой), очевидно, будет нецелое «оставшееся».
JavaScript действительно рассчитывает все, как и ожидалось, поэтому программист должен быть осторожным, чтобы задавать правильные вопросы (и люди должны быть осторожны, чтобы ответить на то, что спрашивают!) Первый вопрос Ярина был НЕ «что такое целочисленное деление X на Y», но, вместо этого, «ВЕСЬ количество раз, когда данное целое число ПРОХОДИТ В другое». Для положительных чисел ответ одинаков для обоих, но не для отрицательных, потому что целочисленное деление (делитель на делитель) будет на -1 меньше, чем число, которое (делитель) «переходит» в другое (делимое). Другими словами, FLOOR вернет правильный ответ для целочисленного деления отрицательного числа, но Ярин этого не спрашивал!
gammax правильно ответил, что код работает так, как спросил Ярин. С другой стороны, Самуил не прав, он, наверное, не делал математику, иначе он бы увидел, что это работает (также он не сказал, что было делителем его примера, но я надеюсь, что это было 3):
Остаток = X% Y = -100% 3 = -1
GoesInto = (X — остаток) / Y = (-100 — -1) / 3 = -99 / 3 = -33
Кстати, я протестировал код на Firefox 27.0.1, он работал как положено, с положительными и отрицательными числами, а также с нецелыми значениями, как для делимого, так и для делителя. Пример:
-100,34 / 3,57: GoesInto = -28, остаток = -0,3800000000000079
Да, я заметил, что здесь есть проблема точности, но у меня не было времени проверить ее (я не знаю, проблема ли это с Firefox, Windows 7 или с FPU моего процессора). Для вопроса Ярина, который включает только целые числа, код gammax работает отлично.
javascript — Целочисленное деление с остатком в JavaScript?
JavaScript вычисляет прямо число отрицательных чисел и остаток нецелых чисел, следуя математическим определениям для них.
FLOOR определяется как «наибольшее целое число, меньшее, чем параметр», таким образом:
- положительные числа: FLOOR (X) = целая часть X;
- отрицательные числа: FLOOR (X) = целая часть X минус 1 (потому что она должна быть МЕНЬШЕ, чем параметр, т. е. более отрицательной!)
REMAINDER определяется как «остаток» от деления (евклидова арифметика). Когда дивиденд не является целым числом, частное, как правило, также не является целым числом, то есть нет остатка, но если частное вынуждено быть целым числом (и это то, что происходит, когда кто-то пытается получить остаток или модуль число с плавающей запятой), очевидно, будет нецелое «оставшееся».
JavaScript действительно рассчитывает все, как и ожидалось, поэтому программист должен быть осторожным, чтобы задавать правильные вопросы (а люди должны быть осторожны, чтобы ответить на то, что задают!). Первый вопрос Ярина был НЕ «что такое целочисленное деление X на Y», но, вместо этого, «ВЕСЬ количество раз, когда данное целое число ПРОХОДИТ В другое». Для положительных чисел ответ одинаков для обоих, но не для отрицательных чисел, потому что целочисленное деление (делитель на делитель) будет на -1 меньше, чем число, которое (делитель) «переходит в» другое (делимое). Другими словами, FLOOR вернет правильный ответ для целочисленного деления отрицательного числа, но Ярин этого не спрашивал!
gammax правильно ответил, что код работает так, как спросил Ярин. С другой стороны, Самуил не прав, он, наверное, не делал математику, иначе он бы увидел, что это работает (также он не сказал, что было делителем его примера, но я надеюсь, что это было 3):
Остаток = X% Y = -100% 3 = -1
GoesInto = (X — остаток)/Y = (-100 — -1)/3 = -99/3 = -33
Кстати, я протестировал код на Firefox 27.0.1, он работал как положено, с положительными и отрицательными числами, а также с нецелыми значениями, как для делимого, так и для делителя. Пример:
-100,34/3,57: GoesInto = -28, остаток = -0,3800000000000079
Да, я заметил, что здесь есть проблема с точностью, но у меня не было времени проверить ее (я не знаю, проблема ли это с Firefox, Windows 7 или с FPU моего процессора). Что касается вопроса Ярина, который включает только целые числа, код gammax работает отлично.
Целочисленное деление с остатком в JavaScript?
В JavaScript вычисляет нужное слово из отрицательных чисел и остальные нецелые числа, следующие математические определения для них.
Пол определяется как «наибольшее целое число меньше, чем параметр» и, таким образом:
- положительные значения: пол(X)=целая часть числа X;
- отрицательные числа: пол(X)=целая часть от Икс минус 1 (т. к. она должна быть меньше, чем параметр, т. е., больше негативных!)
Остаток определяется как в «осталось» из отдела (Евклидовой арифметики). Когда дивиденд не является целым числом, то коэффициент обычно также не является целым числом, т. е. нет конца, а если частное вынужден быть целым числом (и что’что происходит, когда кто-то пытается получить остаток или модуль с плавающей запятой), там будет нецелым, что «осталось» и, очевидно.
JavaScript его рассчитают все как положено, так что программист должен быть осторожным, чтобы задать правильные вопросы (и люди должны быть осторожны, чтобы ответить на то, что просят!) Ярин’Первый вопрос был не «Что такое целочисленное деление X на y», но, вместо этого, «в целом количество раз заданное целое число переходит в еще один». Для положительных чисел, ответ один и тот же для обоих, но не для отрицательных чисел, потому что целочисленное деление (делимое делитель) будет -1 меньше раза в число (делитель) на «переходит в» другой (дивидендов). Другими словами, пол будет возвращать правильный ответ для целочисленного деления отрицательного числа, но Ярин не’т спросить!
gammax правильно ответили, что код работает как спросил Ярин. С другой стороны, Самуил неправильно, он не’т делать математику, я думаю, иначе он бы увидел, что он работает (кроме того, он не’т сказать, что делитель своим примером, но я надеюсь, что это был 3):
Остаток = Х % У = -100 % 3 = -1
GoesInto = (Х — Остаток) / Г = (-100 — -1) / 3 = -99 / 3 = -33
Кстати, я тестировал код на Firefox 27.0.1, он работал, как ожидалось, с положительными и отрицательными числами, а также с нецелые значения, как для делимого и делителя. Пример:
-100.34 / 3.57: GoesInto = -28, Остаток = -0.3800000000000079
Да, я заметил, есть в точности проблема есть, но я не’т было времени, чтобы проверить его (я не’т знаю, если это’ов проблемы с Firefox, Windows 7 или с моим процессором’ы ФПУ). Для Ярины’s не вопрос, хотя, который только включает целые, gammax’s код работает отлично.
Арифметические операции Javascript — jQuery, Prototype, Extjs. Javascript
Арифметические операции применяются к числовым операндам и возвращают числовое значение, означающее результат операции. Если типы операндов различны, то делается попытка преобразовать их к числовому типу. При этом:- Операция «сложение» выполняется только тогда, когда оба операнда являются числами или логическими значениями. Если хотя бы один операнд является строкой, то производится конкатенация строк.
- Остальные операции преобразуют операнды в числа, а затем выполняют операцию.
- Операции «инкремент» и «декремент» применяются только к переменным.
Операция | Название | Описание |
---|---|---|
a + b | Сложение | Возвращает сумму двух операндов. |
a — b | Вычитание | Возвращает разность от вычитания правого операнда из левого. |
a * b | Умножение | Возвращает произведение двух операндов. |
a / b | Деление | Возвращает частное от деления левого операнда на правый. |
a % b | Остаток по модулю | Возвращает целый остаток от деления левого операнда на правый. Плавающие числа перед операцией округляются до целых. |
++ | Инкремент | Унарная операция. Увеличивает значение переменной на 1. Если используется как префикс (++a), возвращает значение операнда после увеличения его на 1. Если используется как постфикс (a++), возвращает значение операнда перед увеличением его на 1. |
— | Декремент | Унарная операция. Уменьшает значение переменной на 1. Если используется как префикс (—a), возвращает значение операнда после уменьшения его на 1. Если используется как постфикс (a—), возвращает значение операнда перед уменьшением его на 1. |
-a | Смена знака | Унарная операция. Возвращает арифметическое отрицание операнда. |
var i, j, k; i = 19 % 6.8; // i равно 5 k = 2; j = k++; // j равно 2, k равно 3 j = ++k; // j и k равны 4
Два программиста и календарь — Журнал «Код»: программирование без снобизма
👉 На самом деле проще и логичнее сделать массив с количеством дней в каждом месяце. Но мы хотим попрактиковаться, потренировать ум и попробовать обойтись без списка. Такой нестандартный подход к решениям может вам здорово пригодиться в будущем на более сложных задачках и в рабочих проектах.
Что делать с февралём
В високосный год в феврале 29 дней, а не 28, как обычно. Но так как мы не знаем, про какой год идёт речь, и февраль не влияет на количество дней в других месяцах, то для простоты будем считать, что в феврале у нас всегда 28 дней.
Кто-то для подсчёта дней в месяце использует костяшки на руках, другие пользуются специальными стишками и фразами, которые помогают вспомнить количество дней, но это всё не то. Нужно именно универсальное решение, например функция. На вход эта функция будет получать номер месяца, а на выходе давать нужное количество дней.
Для начала запишем в виде таблицы наши месяцы и дни:
Получается, что если на вход мы подадим 8 (август), то на выходе функция нам должна вернуть число 31 (количество дней в августе). Такую функцию мы и будем делать.
Магия математики: целочисленное деление и остаток
Целочисленное деление — это целая часть от деления одного числа на другое, в математике обозначается обратной косой чертой: \. Грубо говоря, это сколько раз одно число полностью помещается в другом.
Например, 7 \ 2 = 3
. Это значит, что если 7 разделить на 2, то получится 3,5, но так как нам нужна целая часть от деления, то остаётся только 3.
Ещё примеры:
8 \ 3 = 2
5 \ 1 = 5
12 \ 4 = 3
Остаток от деления (его ещё называют остаток по модулю) — это как раз то, что остаётся от предыдущего деления, то, что не поместилось в целую часть. Иногда обозначается символом — %.
Для примера возьмём те же самые пары чисел, что были выше: 7 % 2 = 1
. Это значит, при делении 7 на 2 у нас останется в остатке единица:
7 = (2 × 3) + 1
Эта единица, которая не влезла в деление, и называется остатком от деления.
Ещё примеры с теми же числами:
8 % 3 = 2, потому что [8 = (3 × 2) + 2]
5 % 1 = 0, потому что [5 = (1 × 5) + 0]
12 % 4 = 0, потому что [12 = (4 × 3) + 0]
Используя только простую математику и эти две операции, попробуем найти нужную формулу.
Первый подход: проверяем чётные и нечётные месяцы
Попробуем сразу подобрать такое решение, которое подходило бы к большинству месяцев. Обычное количество дней — 30 или 31. Давайте проверим, вдруг дни зависят от того, чётный номер у месяца или нечётный.
Чтобы это выяснить, используем операцию взятия остатка от деления на 2. Если месяц чётный, то число разделится нацело и в остатке будет 0. Если месяц нечётный, то в остатке будет 1.
Проверим нашу теорию, и те дни, которые совпадут с нашей формулой, покрасим в зелёный цвет, а которые не совпадут — в красный. Номер месяца в этой и во всех других формулах обозначим как икс:
f = 30 + x % 2
У нас совпала почти половина месяцев, неплохо для начала. Как мы видим, март, месяц номер 3, как раз имеет 31 день, а июнь, месяц номер 6, — 30 дней.
С февралём будем разбираться потом, а сейчас нужно что-то придумать, чтобы начиная с августа наша формула работала наоборот. Для этого надо заменить в нашей формуле чётные месяцы на нечётные, чтобы при делении они давали в остатке 1, а не 0, как раньше. Для этого достаточно прибавить единицу к иксу: (x + 1) % 2
f = 30 + (x + 1) % 2
Теперь у нас идеально вписывается вторая половина календаря, но первая предсказуемо сломалась. Надо найти способ как-то объединить эти два способа.
Второй подход: объединяем обе половины формулы
Нам нужно, чтобы сначала применялась первая формула, а как только дойдём до августа — вторая.
Август — месяц номер 8, поэтому будем проверять, дошли мы уже до восьмого месяца или нет. Мы знаем, что всего месяцев 12, и если взять целую часть от деления на 8, то до августа она будет равна нулю, а начиная с августа — единице:
1 \ 8 = 0
8 \ 8 = 1
12 \ 8 = 1
Чтобы в этом убедиться, давайте нарисуем таблицу, куда запишем все значения:
Как раз то, что нам нужно: начиная с августа наша формула помечает все нужные месяцы единицей. Теперь надо этот фильтр аккуратно встроить в формулу.
Когда мы использовали в самом начале в формуле выражение х % 2
— работала первая половина месяцев, а когда добавили единицу — (х + 1) % 2
, — то работала вторая половина. Нам нужно, чтобы единица в этой формуле появлялась начиная с августа, а для этого как раз мы использовали целочисленное деление на 8. Поэтому если мы икс целочисленно разделим на 8, то начиная с августа он будет давать единицу, а до этого — ноль.
Целая часть от деления на 8 выглядит так: х \ 8
. Используем это в нашей формуле:
f = 30 + (x + x \ 8) % 2
Всё работает, кроме февраля. Давайте это исправим.
Добавляем февраль в формулу
В последней формуле у февраля получилось 30 дней, а надо 28. Значит, нужно убрать из него два дня. Так как формула у нас общая для всех, получается, что дни уберутся для всех месяцев либо до, либо после февраля. После февраля месяцев много, а до него — только январь. Поэтому уберём два дня у первых двух месяцев, а январь подправим потом.
Чтобы убрать 2 дня, сделаем в формуле не 30 дней, а 28:
f = 28 + …
Но тогда это повлияет на все месяцы! Добавим по 2 дня к каждому месяцу начиная с марта. Для этого используем выражение 2 % х
, оно берёт остаток от деления на икс.
Для января и февраля этот остаток будет равен нулю:
2 % 1 = 0 [2 = (1 × 2) + 0]
2 % 2 = 0 [2 = (2 × 1) + 0]
А для всех остальных остаток будет равен двум, например, для июля:
2 % 7 = 2 [2 = (7 × 0) + 2]
Запишем все значения 2 % х
в таблицу:
Да, действительно, к первым двум месяцам ничего не прибавляется, а остальные получают нужные два дня. Запишем это в формулу и проверим:
f = 28 + (x + x / 8) % 2 + (2 % x)
Финал: добавляем январь
Осталось решить последнюю проблему: прибавить два дня только к январю. Скажем это на языке формул: нам нужно прибавить два дня к месяцу, номер которого равен единице. Если использовать то, что мы уже знаем, то единицу получить очень просто: 1 \ х
.
Если икс равен единице, то наша целая часть от деления тоже равна единице:
1 \ 1 = 1
А для всех остальных иксов целая часть будет равна нулю:
1 \ 2 = 0
1 \ 9 = 0
Чтобы прибавить не один, а два месяца, умножим это на 2: (1 \ х) × 2
. Теперь подставим в формулу:
f = 28 + (x + x \ 8) % 2 + 2 % x + (1 \ x) × 2
Сработало!
Целое число от деления javascript
В этой статье подробно рассмотрим числа, математические операторы, способы преобразования числа в строку и наоборот, а также много других важных моментов.
Функция isFinite
Функция isFinite позволяет проверить, является ли аргумент конечным числом.
В качестве ответа данная функция возвращает false , если аргумент является Infinity , -Infinity , NaN или будет быть приведён к одному из этих специальных числовых значений. В противном случае данная функция вернёт значение true .
Кроме глобальной функции isFinite в JavaScript имеется ещё метод Number.isFinite . Он в отличие от isFinite не осуществляет принудительное приведения аргумента к числу.
Функция isNaN
Функция isNaN предназначена для определения того, является ли аргумент числом или может ли быть преобразован к нему. Если это так, то функция isNaN возвращает false. В противном случае она возвращает true.
Если это действие нужно выполнить без приведения типа, то используйте метод Number.isNaN . Данный метод был введён в язык, начиная с ECMAScript 6.
Как явно преобразовать строку в число?
Явно привести строку в число можно посредством следующих способов:
1. Использовать унарный оператор + , который необходимо поместить перед значением.
Этот способ пренебрегает пробелами в начале и конце строки, а также
(переводом строки).
Используя данный способ необходимо обратить внимание на то, что пустая строка или строка, состоящая из пробелов и
, переводится в число 0. Кроме этого она также преобразует тип данных null и логические значения к числу.
2. Функция parseInt . Данная функция предназначена для преобразования аргумента в целое число . В отличие от использования унарного оператора + , данный метод позволяет преобразовать строку в число, в которой не все символы являются цифровыми . Начинает она преобразовывать строку, начиная с первого символа. И как только она встречает символ, не являющийся цифровым, данная функция останавливает свою работу и возвращает полученное число.
Данная функция может работать с разными системами счисления (двоичной, восьмеричной, десятичной, шестнадцатеричной). Указание основание системы счисления осуществляется посредством 2 аргумента.
Кроме этого рекомендуется, всегда указывать основание системы счисления и не полагаться на значение по умолчанию установленное этой функции, например в том или ином браузере.
Кроме функции parseInt в JavaScript имеется метод Number.parseInt . Данный метод ничем не отличается от функции parseInt и был введён в JavaScript со спецификацией ECMASCRIPT 2015 (6).
3. Функция parseFloat . Функция parseFloat аналогична parseInt , за исключением того что позволяет выполнить преобразование аргумента в дробное число.
Кроме этого функция parseFloat в отличие от parseInt не имеет 2 аргумента, и следовательно она всегда пытается рассмотреть строку как число в десятичной системе счисления.
Кроме функции parseFloat в JavaScript имеется метод Number.parseFloat . Данный метод ничем не отличается от функции parseFloat и был введён в JavaScript со спецификацией ECMASCRIPT 2015 (6).
Преобразование числа в строку
Превратить число в строку можно с помощью метода toString .
Метод toString позволяет также указать основание системы счисления с учётом которой необходимо явно привести число к строке:
Как проверить является ли переменная числом
Определить является ли значение переменной числом можно используя один из следующих способов:
1. С использованием функций isNaN и isFinite:
Этот способ позволяет определить является ли указанное значение числом или может быть приведено к нему. Данный вариант не считает числом пустую строку, строку из пробелов, значение null , Infinity , -Infinity , true и false .
2. С использованием оператора typeof и функций isFinite, isNaN:
Эта функция определяет имеет ли указанное значение тип Number, а также не принадлежит ли оно к одному из специальных значений Infinity, -Infinity и NaN. Эсли это так, то данная функция возвращает значение true.
3. С помощью метода ECMAScript 6 Number.isInteger(value) . Данный метод позволяет определить, является ли указанное значение целым числом.
Чётные и нечётные числа
Проверить является ли число чётным или нечётным можно посредством следующих функций:
Но перед тем как проводить такую проверку желательно убедиться что указанное значение является числом:
Простые числа в Javascript
Рассмотрим пример в котором выведем с помощью Javascript простые числа от 2 до 100.
Округление числа в Javascript
Округлить дробное число до целого значения в JavaScript можно различными способами.
1. Используя специально предназначенные для этого методы Math.floor , Math.ceil и Math.round . Метод Math.floor округляет дробное число до ближайшего целого вниз, т.е. попросту отбрасывает дробную часть. Math.ceil скругляет дробное число до ближайшего целого вверх. Math.round округляет число вверх или вниз в зависимости от значения дробной части. Если дробная часть больше или равно 0.5, то вверх, иначе скруление осуществляется вниз.
2. С помощью метода toFixed(точность) . Данный метод округляет дробную часть числа до заданной точности. Результат округления возвращает в виде строки.
Если знаков после запятой для формирования указанной точности числа не хватает, то оно дополняется нулями.
3. Посредством метода toPrecision(точность) . Данный метод представляет число с указанной точностью. При этом он может округлить не только дробную, но и целую часть числа. Полученное число данный метод может представить в зависимости от результата с фиксированной запятой или в экспоненциальной форме.
4. Используя логические операторы НЕ или ИЛИ.
Целая и дробная часть числа
Получить целую часть числа можно используя метод Math.floor() и parseInt() :
Получить дробную часть числа можно воспользовавшимся оператором процент ( % ). Данный оператор возвращает остаток, который будет получен от деления первого числа на второе. В данном случае в качестве 2 числа необходимо использовать 1.
Кроме этого дробную часть можно получить также с помощью вычислений:
Делится ли число нацело
Определить делится ли число нацело можно используя оператор процента:
Форматирование чисел
В JavaScript отформатировать вывод числа в соответствии с региональными стандартами (языковыми настройками операционной системы) позволяет метод toLocaleString() .
Например, выполним форматирование числа в соответствии с региональными стандартами, которые установлены в системе по умолчанию:
Например, выполним форматирование числа в соответствии с региональными стандартами России (ru):
Данный метод можно также использовать для форматирования числа в виде валюты:
Представление числа в виде процентов:
Разбить число на разряды (свойство useGrouping ):
Вывести с число с определённым количеством цифр (2) после запятой:
Сравнение чисел
Для сравнения чисел в JavaScript используются следующие операторы: == (равно), != (не равно), > (больше), (меньше), >= (больше или равно), (меньше или равно).
Например, сравним два числа:
При сравнении чисел с дробной частью необходимо учитывать погрешности, которые могут возникать во время этих вычислений.
Например, в JavaScript сумма чисел (0.2 + 0.4) не равна 0.6:
Погрешности происходят потому что все вычисления компьютер или другое электронное устройство производит в 2 системе счисления. Т.е. перед тем как выполнить какие-то действия компьютер сначала должен преобразовать представленные в выражении числа в 2 систему счисления. Но, не любое дробное десятичное число можно представить в 2 системе счисления точно.
Например, число 0.2510 в двоичную систему преобразуется точно.
Например, число 0.210 можно преобразовать в 2 систему только с определённой точностью:
В результате эти погрешности скажутся при вычисления суммы двух чисел и результатах сравнения. Т.е. получится что на самом деле JavaScript будет видет эту запись следующим образом:
При вычислениях или отображении чисел с дробной частью необходимо всегда указывать точность, с которой это необходимо делать.
Например, сравнить числа до 2 знаков после запятой используя методы toFixed() и toPrecision() :
Основные математические операции
В JavaScript существуют следующие математические операторы: + (сложение), – (вычитание), * (умножение), / (деление), % (остаток от деления), ++ (увелить значение на 1), — (уменьшить значение на 1).
Кроме этого в JavaScript есть комбинированные операторы: x+=y ( x=x+y ), x-=y ( x=x-y ), x*=y ( x=x*y ), x/=y ( x=x/y ), x%=y ( x=x%y ).
6 ответов 6
Поделить на число без остатка в JS можно несколькоми способами.
Способ 1. Округление:
Этот способ расчитан на результат вычисления больше нуля. Если результат будет отрицательный, то такая конструкция сработает не правильно.
Как вариант, для решения этой задачи округлением можно использовать опертор if:
Способ 2 : Вероятно не такой быстрый как предыдущий, но более универсальный. Приведение к int:
Способ 3. Производительный и универсальный:
Ну и немного хадкора:
В javascript отсутствует деление на целые числа и числа с плавающей запятой.
Возможно, как следствие, отсутствуют и специальные арифметические операторы для целых чисел.
Исходя из этого есть несколько вариантов решения:
Выполнение обычного деления и взятие от результата целой части. Для этой процедуры есть функции Math.floor и Math.ceil, разница заключается в том, большее целое или меньшее будет выбрано.
Как видно из примера, для положительных чисел подходит floor , для отрицательных ceil
Использование битовых операций. На уровне спецификации, указано, что битовые операции работают только с 32х-битными целыми числами, поэтому при работе с ними стоит быть осторожным: при применении их к большим числа, старшие биты числа будут обрезаны. При этом это позволяет быстро брать целую часть, за счет приведения аргумента к целому числу перед выполнением битовой операции.
Широко распространенным приемом является применение побитового или с 0 , что оставляет все биты исходного числа неизменными. А также побитовый сдвиг, так же на 0 разрядов
в JavaScript, как мне получить:
- целое число раз данное целое число переходит в другое?
- остаток?
15 ответов:
для некоторого числа y и какой делитель x вычислить коэффициент ( quotient ) и остаток ( remainder ) как:
Я не эксперт в побитовых операторах, но вот еще один способ получить целое число:
Это будет работать для отрицательных чисел, а Math.floor() будет вращаться в неправильном направлении.
это тоже кажется правильным:
Я сделал некоторые тесты скорости на Firefox.
вышеуказанное основано на 10 миллионах проб для каждого.
вывод: использовать (a/b>>0) (или (
(a/b)) или (a/b|0) ) для того чтобы достигнуть увеличения около 20% в эффективности. Также имейте в виду, что все они несовместимы с Math.floor , когда a/b .
ES6 вводит новый Math.trunc метод. Это позволяет исправить @MarkElliot это чтобы заставить его работать и для отрицательных чисел:
отметим, что Math методы имеют преимущество перед побитовыми операторами, что они работают с числами более 2 31 .
вы можете использовать функцию parseInt чтобы получить усеченный результат.
чтобы получить остаток, используйте оператор mod:
parseInt есть некоторые подводные камни со строками, чтобы избежать использования параметра radix с базой 10
в некоторых случаях строковое представление числа может быть научной нотацией, в этом случае parseInt приведет к неправильному результату.
этот вызов приведет к 1 в результате.
JavaScript вычисляет справа пол отрицательных чисел и остаток нецелых чисел, следуя математическим определениям для них.
FLOOR определяется как «наибольшее целое число, меньшее параметра», таким образом:
- положительные числа: FLOOR (X)=целая часть X;
- отрицательные числа: FLOOR (X)=целая часть X минус 1 (потому что она должна быть меньше параметра, т. е. больше отрицательно!)
остаток определяется как» оставшийся » от деления (евклидова арифметика). Когда дивиденд не является целым числом, фактор обычно также не является целым числом, т. е. нет остатка, но если фактор вынужден быть целым числом (и это то, что происходит, когда кто-то пытается получить остаток или модуль числа с плавающей запятой), очевидно, будет нецелым «осталось».
JavaScript вычисляет все, как ожидалось, поэтому программист должен быть осторожен, чтобы задавать правильные вопросы (и люди должны быть осторожны, чтобы ответить на то, что спрашивается!) Первый вопрос Ярина был не «что такое целочисленное деление X на Y», а, вместо этого,»целое число раз данное целое число переходит в другое». Для положительных чисел ответ одинаков для обоих, но не для отрицательных чисел, потому что целочисленное деление (дивиденд по делителю) будет -1 меньше, чем раз число (делитель) «переходит» в другое (дивиденд). В других слова, ПОЛ вернет правильный ответ для целочисленного деления отрицательного числа, но Ярин этого не спрашивал!
gammax ответил правильно, что код работает, как просил Ярин. С другой стороны, Сэмюэль ошибается, он не делал математику, я думаю, или он увидел бы, что это работает (кроме того, он не сказал, что было делителем его примера, но я надеюсь, что это было 3):
Остаток = X % Y = -100% 3 = -1
GoesInto = (X-Остаток) / Y = (-100–1) / 3 = -99 / 3 = -33
кстати, я тестировал код на Firefox 27.0.1, он работал как ожидалось, с положительными и отрицательными числами, а также с нецелыми значениями, как для дивидендов, так и для делителей. Пример:
-100.34 / 3.57: GoesInto = -28, Остаток = -0.3800000000000079
Да, я заметил, что там есть проблема с точностью, но у меня не было времени, чтобы проверить это (я не знаю, если это проблема с Firefox, Windows 7 или с FPU моего процессора). Для Ярины это вопрос, однако, который включает только целые числа, код gammax работает отлично.
Арифметические операции. HTML, XHTML и CSS на 100%
Читайте также
Арифметические операции
Арифметические операции Для работы с числами используют арифметические операции.• Сложение – знак плюс (+). Например, 5 + 7 = 12.• Вычитание – знак минус (-). Например, 67 – 43 = 24.• Умножение – звездочка (*). Например, 2 * 2 = 4.• Деление – косая черта (/). Например, 45 / 5 = 9.• Остаток от
Арифметические операторы
Арифметические операторы Арифметические операторы языка VBScript представлены в табл. П2.10.Таблица П2.10. Арифметические операторы Оператор Описание — (унарный оператор) Изменение знака аргумента на противоположный — (бинарный оператор) Вычитание двух чисел + Сложение двух
Арифметические операторы
Арифметические операторы Арифметические операторы служат для выполнения арифметических действий над числами. Все арифметические операторы, поддерживаемые JavaScript, перечислены в табл. 14.2.Таблица 14.2. Арифметические операторы Арифметические операторы делятся на две
Арифметические операции
Арифметические операции + – сложение— – вычитание* – умножение/ – делениеDIV – деление нацелоMOD – остаток от деления
Арифметические операции
Арифметические операции Унарные операции – применяются к одной переменной.++ – увеличение на единицу (x++ выдаёт старое значение, ++x – новое значение).– – – уменьшение на единицу, аналогично операции ++.Бинарные операции – стоят между двумя переменными или
Арифметические операторы
Арифметические операторы Арифметические операторы возвращают значения, соответствующие типам числовых операндов:• + — сложение;• – — вычитание;• * — умножение;• / — деление чисел с плавающей запятой;• div — целочисленное деление с отбрасыванием остатка;• mod —
I. Арифметические операции
I. Арифметические операции + Прибавляет величину, находящуюся справа, к величине, стоящей слева — Вычитает величину, стоящую справа, из величины, указанной слева — Будучи унарной операцией, изменяет знак величины, стоящей справа * Умножает величину справа на величину,
Арифметические операции (Arithmetic operations)
Арифметические операции (Arithmetic operations) Библиотека обеспечивает базовые классы функциональных объектов для всех арифметических операторов языка.template ‹class T›struct plus: binary_function‹T, T, T› { Т operator()(const T& x, const T& y) const {return x + y;}};template ‹class T›struct minus: binary_function‹T, T, T› { Т operator()(const T&
4.2. Арифметические операции
4.2. Арифметические операции Таблица 4.1. Арифметические операции Символ операции Значение Использование * Умножение expr*expr / Деление expr / expr % Остаток от деления expr % expr + Сложение expr + expr — Вычитание expr – expr Деление целых чисел дает в результате целое
Арифметические операции
Арифметические операции Арифметические выражения вычисляются слева направо за исключением случаев, когда возникает двусмысленность. В этих случаях арифметические операции вычисляются в соответствии с приоритетами, описанными в табл. 21.3. Например, умножение
Пример 8-2. Арифметические операции
Пример 8-2. Арифметические операции #!/bin/bash# От 1 до 6 пятью различными способами.n=1; echo -n «$n «let «n = $n + 1» # let «n = n + 1» тоже допустимоecho -n «$n «: $((n = $n + 1))# оператор «:» обязателен, поскольку в противном случае, Bash будет#+ интерпретировать выражение «$((n = $n + 1))» как команду.echo -n «$n «n=$(($n + 1))echo
6.6 Арифметические Преобразования
6.6 Арифметические Преобразования Большое количество операций вызывают преобразования и дают тип результата одинаковым образом. Этот стереотип будет называться «обычным арифметическим преобразованием».Во-первых, любые операнды типа char, unsigned char или short преобразуются к
2.2. Арифметические операции над числами, представленными в различных системах счисления
2.2. Арифметические операции над числами, представленными в различных системах счисления Арифметические операции во всех позиционных системах счисления выполняются по одним и тем же правилам. Для проведения арифметических операций над числами, представленными в
54. Арифметические команды
54. Арифметические команды Такие команды работают с двумя типами:1) целыми двоичными числами, то есть с числами, закодированными в двоичной системе счисления.Десятичные числа – специальный вид представления числовой информации, в основу которого положен принцип
math — Как выполнить целочисленное деление и отдельно получить остаток в JavaScript?
JavaScript вычисляет нижний предел отрицательных чисел и остаток нецелых чисел, следуя математическим определениям для них.
ЭТАЖ определяется как «наибольшее целое число, меньшее, чем параметр», таким образом:
- положительных чисел: FLOOR (X) = целая часть X;
- отрицательных чисел: FLOOR (X) = целая часть X минус 1 (потому что она должна быть МЕНЬШЕ, чем параметр, т.е.е., побольше негатива!)
REMAINDER определяется как «остаток» от деления (евклидова арифметика). Когда делимое не является целым числом, частное обычно также не является целым числом, т. Е. Нет остатка, но если частное принудительно должно быть целым числом (и это то, что происходит, когда кто-то пытается получить остаток или модуль число с плавающей запятой), очевидно, останется нецелое число.
JavaScript действительно рассчитывает все, как ожидалось, поэтому программист должен быть осторожен, задавая правильные вопросы (и люди должны быть осторожны, чтобы отвечать на то, что задают!) Первый вопрос Ярина НЕ был «каково целочисленное деление X на Y», а вместо этого «ВСЕ раз, когда данное целое число ВХОДИТ В другое».Для положительных чисел ответ одинаков для обоих, но не для отрицательных чисел, потому что целочисленное деление (делимое на делитель) будет на -1 меньше, чем количество раз, когда число (делитель) «переходит» в другое (делимое). Другими словами, FLOOR вернет правильный ответ при целочисленном делении отрицательного числа, но Ярин этого не спрашивал!
gammax ответил правильно, этот код работает так, как просил Ярин. С другой стороны, Сэмюэл ошибается, я думаю, он не занимался математикой, иначе он бы увидел, что это действительно работает (также он не сказал, что было делителем в его примере, но я надеюсь, что это было 3):
Остаток = X% Y = -100% 3 = -1
GoesInto = (X — остаток) / Y = (-100 — -1) / 3 = -99 / 3 = -33
Кстати, тестировал код на Firefox 27.0.1, он работал, как ожидалось, с положительными и отрицательными числами, а также с нецелыми значениями, как для делимого, так и для делителя. Пример:
-100,34 / 3,57: GoesInto = -28, остаток = -0,3800000000000079
Да, я заметил, там есть проблема с точностью, но у меня не было времени проверить это (я не знаю, проблема ли это в Firefox, Windows 7 или в FPU моего процессора). Однако на вопрос Ярина, который включает только целые числа, код gammax работает отлично.
JavaScript: Оператор остатка (%)
, Никлас Энвалл Оператор остатка (%) возвращает остаток от деления .Чтобы освежить нашу память, деление выглядит так: Dividend / Divisor = Quotient
. Остаток — это сумма, которая не полностью входит в делитель.
Таким образом, остаток всегда будет 0
, если частное является целым числом . В приведенном ниже примере нет остатка:
4
--- = 2
2
У него нет остатка, потому что 2
дважды входит в 4
, ничего не оставляя.Вы можете просмотреть это как:
4 2 2
--- = --- + --- = 1 + 1 = 2
2 2 2
Теперь, в следующем примере ниже есть остаток 2
. Потому что 4
может войти в 6
один раз, оставив нам остаток 2
. Обратите внимание, что мы все еще используем остаток для вычисления окончательного ответа 1,5
:
6 4 2
--- = --- + --- = 1 + 0,5 = 1,5
4 4 4
Следовательно, именно этот остаток возвращает оператор остатка.Оператор работает как делитель дивидендов
. Проиллюстрируем это двумя приведенными выше примерами:
4% 2; // 0
6% 4; // 2
Мы можем создать нашу собственную функцию остатка (хотя рекомендуется %
):
const остаток = (делимое, делитель) => {
const quoitent = Math.trunc (делимое / делитель);
возвращаемый дивиденд - частное * делитель;
};
Часть Math.trunc (делимое / делитель)
удалит все десятичные дроби, которые могли иметь место.Затем мы снова умножаем это на делитель, чтобы получить все , кроме остатка . Наконец, вычитая это из исходного дивиденда, мы получаем остаток. Мы бы создали оператор по модулю, если бы поменяли местами trunc
на floor
. Остаток и модуль почти идентичны друг другу, но их разделяет то, как они обрабатывают отрицательные числа.
Пример 1: Четные и нечетные числа
Оператор остатка обычно используется для определения четности или нечетности числа.Причина этого в том, что частное от деления любого четного числа на 2
всегда будет целым числом. Кроме того, все нечетные числа не делятся на 2
:
const isEven = num => num% 2 === 0;
isEven (2); // истинный
isEven (3); // ложный
const isOdd = число => число% 2 === 1;
isOdd (2); // ложный
isOdd (3); // true
Пример 2: Секунды в HH: MM: SS
Давайте определим проблему, которую можно решить с помощью оператора остатка:
Напишите программу, которая может преобразовать N секунд в формат hh: mm: ss.Например, функция input 3667s должна выводить 1: 1: 7.
Несколько сложная часть проблемы состоит в том, что мы должны правильно распределять секунды. Во-первых, отметим, что:
- 1 минута составляет 60 секунд.
- 1 час — 60 минут.
Теперь давайте посмотрим на созданный мной код и исследуем его:
const convertFromSecondsToHHMMSS = (s) => {
const ЧАСЫ = Math.floor ((s / 60) / 60); // 1
const МИНУТЫ = Math.floor ((s / 60)% 60); // 2
const СЕКУНДЫ = s% 60; // 3
return `$ {HOURS}: $ {MINUTES}: $ {SECONDS}`;
}
- Разделите секунды на
60
, чтобы преобразовать секунды в минуты.Затем разделите минуты на60
, чтобы получить часы. Используйтеэтаж
, чтобы отбросить десятичные дроби. - Теперь оставшиеся секунды выражены в десятичных дробях, начиная с 1. Итак, разделите секунды на
60
, чтобы преобразовать секунды в минуты. Затем на этот раз используйте оператор остатка с делителем60
, чтобы получить оставшиеся минуты. Наконец, еще раз отбросьте все возможные десятичные дроби сэтаж
. - Используйте оператор остатка, чтобы получить оставшиеся секунды, используя
60
в качестве делителя.Обратите внимание, что секунды, разделенные на60
, дают нам все возможные минуты. Таким образом, остаток будет оставшимися секундами.
Возможно, более читаемый пример будет использовать тот факт, что 3600
секунд равно 1
часам. Попробуем еще раз:
const convertFromSecondsToHHMMSS = (s) => {
const ЧАСЫ = Math.floor (s / 3600); // 1
const МИНУТЫ = Math.floor ((s% 3600) / 60); // 2
const СЕКУНДЫ = (s% 3600)% 60; // 3
return `$ {HOURS}: $ {MINUTES}: $ {SECONDS}`;
}
- Преобразуйте секунды в часы, а затем отбросьте возможные десятичные дроби с
этажом
. - Получите отброшенные секунды с первого шага с помощью оператора остатка. Затем разделите это на 60, чтобы преобразовать эти секунды в минуты. Наконец, отбросьте все возможные десятичные дроби.
- Получите оставшиеся секунды после «преобразования в часы», затем используйте их, чтобы получить все оставшиеся секунды, указав 60 в качестве делителя (просто выполнение
секунд% 60
также работает).
Пример 3: FizzBuzz
Вы, наверное, слышали о Fizzbuzz и, возможно, даже реализовали его. Но вот проблема:
Напишите программу, которая печатает числа от 1 до 100.Но печатайте «Fizz», только если числа кратны 3. Кроме того, печатайте «Buzz», только если числа кратны 5. Наконец, печатайте «FizzBuzz», только если числа кратны 3 и 5.
Давайте перерыв решить проблему, прежде чем мы начнем кодировать. Описание в значительной степени дает нам операции, необходимые для решения проблемы. Я определил следующее ограничение: печатает только одну вещь на приращение и следующие операции:
- Если число кратно
3
, напечатайте"Fizz"
. - Если число кратно
5
, выведите«Жужжание»
. - Если число кратно
3
и5
, выведите"FizzBuzz"
. - Распечатайте число.
Так что же такое кратное? Ну, кратное — это результат умножения данного числа на другое число. Так как же определить, кратно ли число, например, 3
? Ответ заключается в том, что может использовать оператор остатка для .Теперь посмотрим на следующий пример:
// кратное 3 (3, 6, 9):
1 * 3; // 3
2 * 3; // 6
3 * 3; // 9
// оператор остатка
3% 3; // 0
4% 3; // 1
5% 3; // 2
6% 3; // 0
7% 3; // 1
8% 3; // 2
9% 3; // 0
Вы видите закономерность? Если дивиденд кратен 3
, он вернет 0
. Это означает, что в данном случае единственным не кратным 3
является 4
. Наконец, мы можем приступить к реализации операций:
for (let i = 1; i <= 100; i ++) {
if (i% 3 === 0 && i% 5 === 0) {
приставка.журнал ('FizzBuzz');
} else if (i% 3 === 0) {
console.log («Физз»);
} else if (i% 5 === 0) {
console.log ("Жужжание");
} еще {
console.log (я);
}
}
Конечно, для FizzBuzz есть сотни различных решений, и это всего лишь пример, иллюстрирующий оператор остатка в JavaScript.
код гольф - Дивизион и остаток
(х (х *)), (х *?) (? = \ 1 * $) (х? (Х *)) (? = \ 4 * $) ((? = \ 2 + $) \ 2 \ 5 * $ | $ \ 4)
Попробуйте онлайн! - ECMAScript
Попробуйте онлайн! - Python
Принимает унарные аргументы в виде двух строк размером x
символов, длина которых представляет числа.Сначала идет делитель, за ним следует разделитель ,
, за которым следует дивиденд. Частное и остаток возвращаются в группах захвата \ 4
и \ 3
соответственно.
Я разработал базовую форму этого кода 3 апреля 2014 г., работая над регулярным выражением с множеством чисел. Это было месяцем ранее, когда Teukon и я независимо разработали алгоритм умножения, описанный здесь, но до этого момента мы не писали и не использовали какое-либо регулярное выражение, чтобы найти неизвестное частное известного дивиденда и делителя.И только после деления на \ $ \ sqrt 2 \ $ я адаптировал его для правильной обработки нулевого дивиденда.
Он используется в различных формах (показанных выше или ниже) этими другими регулярными выражениями:
Прокомментировано и с отступом:
(x (x *)), # \ 1 = делитель; \ 2 = \ 1-1; хвост = дивиденд
(x *?) (? = \ 1 * $) # \ 3 = остаток от деления; хвост - = \ 3
(x? (x *)) # \ 4 = предполагаемое частное - найти наибольшее, совпадающее с
# следующие утверждения; \ 5 = \ 4-1, или 0, если \ 4 == 0; хвост - = \ 4
(? = \ 4 * $) # assert tail делится на частное
(
(? = \ 2 + $) # assert tail положительный и делится на divisor-1
\ 2 \ 5 * $ # assert tail- (divisor-1) делится на частное-1
|
$ \ 4 # если делимое == 0, утверждать, что частное == дивиденд
)
Чтобы показать, что происходит, вот функция Python, которая выполняет деление с использованием алгоритма регулярного выражения:
def modulo_is_zero (n, модуль):
вернуть n == 0, если модуль == 0, иначе n> = 0 и n% модуль == 0
def div (делимое, делитель):
если делитель == 0:
возвращение
остаток = делитель% дивиденда
дивиденд - = остаток
частное = дивиденд
если дивиденд! = 0:
а 1:
если modulo_is_zero (делимое - частное, частное) и \
modulo_is_zero (делимое - частное, делитель-1) и \
modulo_is_zero (делимое - частное - (делитель-1), частное-1):
сломать
частное - = 1
если частное == 0:
возвращение
return [частное, остаток]
Попробуйте онлайн!
Обратите внимание, что в регулярном выражении \ $ 0 \ Equiv 0 \ pmod 0 \ $.Это очень удобно, так как позволяет возвращать частное от \ $ 1 \ $ без особых случаев. Единственный особый случай, который нам действительно нужно обработать, - это когда дивиденд равен нулю.
Во-первых, чтобы продемонстрировать, что правильный ответ удовлетворяет используемым утверждениям - предположим, что остаток уже вычтен, и мы делим \ $ B = C / A \ $:
\ $ \ begin {выровнено} C & = AB \\ С-В & = (А-1) В \\ C-B- (A-1) & = (A-1) (B-1) \ end {align} \
долл. СШАТаким образом,
\ $ \ begin {выровнено} С & \ эквив 0 \ pmod A \\ С & \ эквив 0 \ pmod B \\ C-B & \ Equiv 0 \ pmod {A-1} \\ C-B- (A-1) & \ эквив 0 \ pmod {B-1} \ end {align} \
долл. СШАПоследние два можно упростить до:
\ $ \ begin {выровнено} С & \ Equiv B \ pmod {A-1} \\ C & \ Equiv A \ pmod {B-1} \ end {align} \
долл. СШАЗдесь становится ясно, почему ни одного из этих двух недостаточно.Если \ $ A
В отличие от алгоритма умножения, правильность этого алгоритма деления невозможно просто доказать с помощью китайской теоремы об остатках, потому что \ $ C \ $ теперь является постоянным, а \ $ B \ $, определяющим один из модулей, является неизвестным.Но благодаря H.PWiz у нас наконец есть строгое доказательство того, почему обобщенная форма деления всегда работает, и строго определенные пороговые значения, когда деление работает в двух сокращенных формах.
Теперь давайте посмотрим, как можно сократить регулярное выражение. Во-первых, если мы предположим \ $ C \ ge A \ $, это станет 50 байтов :
(х (х *)), (х *?) (? = \ 1 * $) (х (х *)) (? = \ 4 * $) (? = \ 2 + $) \ 2 \ 5 * $
Попробуйте онлайн! - ECMAScript
Попробуйте онлайн! - Python
Попробуйте онлайн! - эквивалент Python
Если мы знаем, что все делители будут в требуемом диапазоне, регулярное выражение деления можно дополнительно сократить.
Используя \ $ C \ Equiv A \ pmod {B-1} \ $ и \ $ C \ Equiv 0 \ pmod B \ $, нам нужно найти наибольшее частное совпадения .
Используя \ $ C \ Equiv B \ pmod {A-1} \ $, нам нужно найти наименьшее соответствие частному.
Находится на 42 байта , вот случай использования только \ $ C \ Equiv A \ pmod {B-1} \ $ и \ $ C \ Equiv 0 \ pmod B \ $:
(x (x *)), (x *?) (? = \ 1 * $) (x (x *)) (? = \ 4 * $) \ 2 \ 5 * $
Попробуйте онлайн! - ECMAScript
Это может быть сокращено еще больше, благодаря уловке, найденной Гримми (и используемой в этом посте).Я использовал его для сокращения регулярных выражений факториала, Proth, \ $ np_n \ $ и последовательных простых чисел и постоянных экспонент. Как автономное регулярное выражение деления, оно занимает 39 байт :
(x +), (x *?) (? = \ 1 * $) ((x *) (? = \ 1 \ 4 * $) x) \ 3 * $
Попробуйте онлайн! - ECMAScript
Попробуйте онлайн! - Python
Попробуйте онлайн! - Эквивалент
(x +), # \ 1 = делитель
(x *?) (? = \ 1 * $) # \ 2 = остаток от деления; хвост - = \ 2
(# \ 3 = предполагаемое частное - найдите наибольшее, которое соответствует
(х *) # \ 4 = \ 3-1; хвост - = \ 4
(? = \ 1 \ 4 * $) # assert tail- (quotient-1) -divisor делится на частное-1
x # хвост - = 1
)
\ 3 * $ # утверждает, что хвост и дивиденд делятся на частное
Вышеупомянутый алгоритм гарантированно вернет правильное частное, если выполняется хотя бы одно из следующих ограничений (вместе с \ $ C \ Equiv 0 \ pmod A \ $):
- \ $ A ^ 2 + 2A <4C \ $ или эквивалентно \ $ A + 2 <4B \ $
- \ $ A = C \ $ или эквивалентно \ $ B = 1 \ $
- Это работает, потому что регулярное выражение вычитает \ $ C- (B-1) -A \ $, чтобы утверждать, что это \ $ \ Equiv 0 \ pmod {B-1} \ $, и это вычитание всегда приводит к несоответствие (так как не может иметь отрицательного результата), если \ $ A = C \ $, если только \ $ B = 1 \ $.
- \ $ A \ $ - степень простого числа
- Один из случаев, когда это должно быть верно, - это когда \ $ C \ $ полупросто и ни одно из двух других условий не выполняется. Это также должно быть истинным, если \ $ C \ $ - степень простого числа.
Доказательство первого ограничения следует:
\ $ \ begin {выровнено} С & \ эквив 0 \ pmod B \\ C & \ Equiv A \ pmod {B-1} \ end {align} \
долл. СШАПредположим, алгоритм находит \ $ B '\ $, удовлетворяющий этим модулям, с \ $ C = A'B' \ $.Поскольку поиск \ $ B \ $ выполняется от наибольшего к наименьшему, единственный способ сначала найти \ $ B '\ ne B \ $ - это \ $ B
\ $ \ begin {выровнено} C & \ Equiv 0 \ pmod {B '} \\ C & \ Equiv A \ pmod {B'-1} \\ A'B '& \ Equiv A \ pmod {B'-1} \\ B '& \ Equiv 1 \ pmod {B'-1} \ end {align} \
долл. СШАИтак, с модульным умножением \ $ A'B '\ $,
\ $ \ begin {выровнено} A '& \ Equiv A \ pmod {B'-1} \\ А &> А '\\ А & \ ge А '+ В'-1 \ end {align} \
долл. 2> C \ ge A \ $ или эквивалентно \ $ A> B \ ge 1 \ $Доказательство первого ограничения следует:
\ $ C \ Equiv B \ pmod {A-1} \ $
Предположим, алгоритм находит \ $ B '\ $, удовлетворяющий этому модулю.Поскольку поиск \ $ B \ $ выполняется от наименьшего к наибольшему, единственный способ сначала найти \ $ B '\ ne B \ $ - это \ $ B> B'> 0 \ $. Тогда:
\ $ \ begin {выровнено} C & \ Equiv B '\ pmod {A-1} \\ AB & \ Equiv B '\ pmod {A-1} \\ А & \ эквив 1 \ pmod {А-1} \ end {align} \
долл. СШАИтак, путем модульного деления \ $ AB / A \ $,
\ $ \ begin {выровнено} B & \ Equiv B '\ pmod {A-1} \\ В &> В '\\ B & \ ge B '+ A-1 \\ B- (A-1) & \ ge B '> 0 \\ В- (А-1) &> 0 \\ Б &> А-1 \\ B & \ ge A \ end {align} \
долл. США