Примеры

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

Давайте рассмотрим пример вычисления n! факториала.

n! факториал прогоняет ряд способов упорядочить n различных объектов.

Он также называется перестановкой n различных объектов.

Например, в автомобильной гонке с участием трех автомобилей, любой из трех автомобилей может финишировать первым.

После того, как у нас есть победитель, только две машины могут конкурировать за второе место.

После того, как второе место определяется, только единственный оставшийся автомобиль станет третьим.

Итак, мы имеем 3 * 2 * 1, что равно 6 различных исходов.

Вот некоторые результаты вычисления факториала. Они перечислены здесь на картинке.

В общем, n! вычисляется путем умножения один на два, на три, и так далее, пока не достигнем n.

Также можно записать итеративную форму (n – 1)! * n.

Отметим также, что 0! имеет значение 1.

Так 5! расписывается как 1 * 2 * 3 * 4 * 5, и результат будет 120.

И n! факториал растет очень быстро.

На самом деле, вы обнаружите, что 13! переполнит 32-битный int, и даже long тип может обрабатывать только до 20 факториала.

Теперь, как n! факториал может на самом деле быть вычислен.

Вот краткий обзор алгоритма для вычисления n! факториала.

Вы можете начать с начального случая 0!, который имеет результат 1.

Обратите внимание, что в примере 5!, мы должны получить пять промежуточных результатов, а именно: 1!, 2!, 3!, 4!, а затем 5!, который будет результатом.

В общем, для n!, будет n шагов.

Давайте установим счетчик для подсчета количества шагов и инициализируем счетчик в 1. И условие для расчета установим меньше, чем или равно n, из числа шагов n.

Затем мы повторим умножение промежуточного результата t на счетчик.

Этот процесс проиллюстрирован на слайде.

Первый шаг состоит в вычислении 1!, который является t, или 0! * 1.

Затем мы должны увеличить счетчик на 1. То есть, счетчик становится 2.

Второй шаг состоит в вычислении 2! умножением t на 2 или значения счетчика.

Третий шаг состоит в вычислении 3! умножением t на 3. И 3 – это обновленное значение счетчика.

Процесс продолжается до тех пор, пока счетчик не больше, меньше или равен пяти, и конечный результат n!, будет сохранен в t.

Вот реализация n! факториала, используя while цикл.

После того, как у нас есть алгоритм, перевод алгоритма в программу Java является простым.

Метод получил название факториал, который принимает один аргумент целого типа.

Имя параметра number представляет n, для которого n! должен быть вычислен.

Метод, возвращает значение десятичного типа как результат.

Как уже упоминалось ранее, вы можете изменить тип возвращаемого значения на long, если метод, как ожидается, будет вычислять факториал числа больше, чем 12.

Отметим также, что я объявляю метод как статический. И я вернусь к статическим методам немного позже.

Первые два выражения внутри метода являются инициализацией, соответствующей первой стадии алгоритма.

В то время как while цикл соответствует второму шагу алгоритма.

Обратите внимание, что условие проверяет счетчик на меньше или равно n, или параметра number.

Внутри тела while цикла, промежуточный результат t, обновляется путем умножения t на счетчик, который фактически является счетчиком факториала.

Счетчик затем увеличивается на единицу. Процесс повторяется до тех пор, пока счетчик не больше, чем number, или параметр.

А значение t затем будет возвращено в качестве результата вычислений.

Давайте посмотрим на второй пример.

В этом примере, мы хотим разработать метод вычисления 2 в n степени.

В информатике, мы должны вычислять 2 в n степени очень часто, потому что все в компьютере представлено в двоичном виде.

Например, байт это 2 в восьмой степени, а 32 бит это 2 в 32-й степени.

В общем, 2 в n степени вычисляется с помощью умножения.

Обратите внимание, что так же, как и другие числа, два в нулевой степени равно 1.

Далее 2 в 1-й степени является 2, 2 во второй степени это 4 и т.д.

Таким образом, чтобы вычислить 2 в n степени, мы должны разработать алгоритм, чтобы определить, как это значение должно быть вычислено.

Процесс на самом деле очень похож на n!.

Первый шаг состоит в том, чтобы посмотреть на первоначальный случай для первой инициализации промежуточного результата t в исходное состояние, в этом случае, 2 в нулевой степени, которая равна 1.

И установить счетчик, чтобы считать количество шагов в вычислении.

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

Вот шаги для вычисления 2 в 4-й степени.

t сначала инициализируется 1.

Следующим шагом является вычисление 2 в 1-й степени, затем 2 во 2-й, 2 в третьей степени, и на последнем этапе вычисляется 2 в 4-й степени.

Вот реализация 2 в n степени, используя while цикл.

Опять же, так как у нас есть хорошо разработанный алгоритм, легко преобразовать алгоритм в программу Java.

Метод получит имя powerTwo, с одним параметром десятичного типа.

Параметр number это n, для которого должен быть вычислен 2 в n степени.

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

Если условие счетчика меньше или равно n, условие возвращает true, тело while цикла будет умножать промежуточный результат t на 2, а затем счетчик увеличивается на единицу.

И процесс повторяется, пока счетчик не станет больше, чем number, и значение t будет затем возвращаться как результат.

Вы можете подумать о том, как сделать метод более гибким для вычисления степени любого числа. Например, 3 в седьмой степени, или 7 в пятой степени, и т.д.