Задача 2.1.
Здесь нужно посмотреть на решение примера в уроке 16 (с выводом на экран чисел от 1 до 10) и подумать, как его изменить, чтобы решить текущую задачу.
Здесь наоборот нужно вывести числа на экран в порядке убывания.
Для решения этой задачи воспользуемся циклом for.
Раз первое значение, которое мы должны вывести на экран, равно 10, объявим переменную-счётчик и присвоим ей начальное значение 10.
int i = 10;
Раз последнее значение, которое должно быть выведено на экран равно 1, укажем проверочное условие i >= 1;
Обратим внимание, что условие именно i >= 1, а не i > 1, иначе мы не досчитаемся одного значения.
Ну и поскольку наша задача - вывести числа с интервалом 1, воспользуемся оператором декремента i --.
В итоге получаем цикл
for (int i = 10; i >= 1 ; i--)
{
System.out.println(i);
}
Всё, осталось сохранить файл
Скомпилировать и запустить.
Задача решена.
Задача 2.2.
Алгоритм решения этой задачи близок к предыдущему. Нужно правильно написать код для цикла.
Поскольку первое значение - это 0, то объявленной переменной нужно присвоить значение 0. Так мы и сделаем.
int i = 0;
Т.к. последнее значение для вывода на экран 30, причём обратим внимание на слово "включительно" в условии задачи, проверочное условие в цикле будет таким
i <= 30;
Ну и, наконец, нужно определиться с оператором счётчика. Поскольку в условии задачи сказано, что интервал равен 5. Причём на каждой итерации значение переменной-счётчика должно увеличиваться на 5, мы получаем
i = i + 5;
или в другой форме записи i += 5;
Полностью полученный нами цикл выглядит так
for (int i = 0; i <= 30 ; i += 5)
{
System.out.println(i);
}
Код полностью
Скомпилированный и запущенный
Задача 2.3.
Здесь, как и в предыдущих задачах нужно правильно подобрать параметры цикла.
Делаем по аналогии с предыдущей задачей.
Первое значение, которое нужно вывести на экран - это 5, соответственно, начальное значение переменной-счётчика будет 5. Объявим её и присвоим ей начальное значение.
int i = 5;
Последнее значение 95 ("включительно"), соответственно, проверочное условие i <= 95
Необходимый интервал 10. Счётчик увеличивает значение переменной. Значит, оператор счётчика
i += 10
Получаем в результате цикл
for (int i = 5; i <= 95 ; i += 10)
{
System.out.println(i);
}
Код в окончательном варианте
Результат его компиляции и исполнения
Задача 2.4.
Смотрим условие задачи. У нас есть целочисленная переменная со значением. Объявим её и присвоим ей значение.
int chislo = 10;
Теперь думаем, как найти факториал этого числа с помощью цикла.
Для начала вспомним, что такое факториал.
Факториал числа n - это произведение всех целых положительных чисел от 1 до n. Обозначается (в коде программы обозначение использоваться не будет, пишу просто для справки) восклицательным знаком после числа.
Итак, например, факториал числа 5 обозначается вот так 5! и равен
5! = 1 * 2 * 3 * 4 * 5 и итого равен 120.
Факториал числа 3 равен
3! = 1 * 2 * 3 = 6.
Что такое факториал вспомнили. Теперь подумаем, как нам найти факториал числа, хранящегося в переменной chislo, с помощью цикла for.
Во-первых, предлагаю создать переменную для хранения факториала числа chislo.
Объявим её до цикла и присвоим ей начальное значение
int fact = 1;
Во-вторых, очевидно, что оператор счётчика должен либо увеличивать значение переменной-счётчика на 1, либо уменьшать. Соответственно, начальное значение должно быть равно 1 (либо 0), либо самому числу chislo.
Рассматриваем Вариант №1.
Придумаем тело цикла.
Что может цикл? На каждой итерации присваивать переменной-счётчику (пусть это снова будет i) новые значения. Начальное и конечное значение мы задаём сами. Интервал мы задаём сами.
Очевидно, что тело цикла будет
fact = fact * i;
Интервал, как мы поняли, будет 1. Соответственно, оператор счётчика будет i++.
Какое значение переменной i должно быть первым? На единицу смысла нет умножать, поэтому начнём сразу с двойки. Объявим переменную-счётчик i и присвоим начальное значение int i = 2;
Теперь значение i на каждой итерации будет увеличиваться на 1.
До каких пор нам нужно, чтобы значение i увеличивалось? До тех пор, пока оно не станет равно числу chislo. То есть последнее значение i должно быть равно chislo.
С помощью какого проверочного условия этого можно добиться? i <= chislo.
Всё, цикл готов.
for (int i = 2; i <= chislo; i++)
{
fact = fact * i;
}
Вариант №2
Идём на уменьшение.
Тело цикла в принципе можно не менять. Оно нас устраивает. Меняем всё остальное.
Первое значение переменной-счётчика будет равно chislo.
int i = chislo.
Очевидно, что на каждой итерации значение счётчика должно уменьшаться на 1. Значит, оператор счётчика i--
Каким должно быть последнее значение i ? В единице смысла нет. Смысла в лишней итерации нет. Пусть будет двойка.
Соответственно, проверочное условие i >= 2 либо i > 1. Мне лично нравится i >= 2. Так нагляднее.
В итоге цикл
for (int i = chislo; i >= 2; i--)
{
fact = fact * i;
}
По итогам первого или второго варианта мы получили факториал числа chislo и он у нас хранится в переменной fact. Теперь его значение нужно вывести на экран.
System.out.println ("Факториал числа " + chislo + " равен " + fact);
Код готов (я выберу вариант №1 цикла)
Скомпилированный и запущенный
Попробуйте самостоятельно включить в код цикл по варианту №2.
Задача 2.5.
Опять начинаем с объявления целочисленной переменной и присваивания ей значения
int chislo = 8;
Цикл в данной задаче нам нужен, чтобы переменной-счётчику присваивать значения от 1 до 10.
Как писать код для такого цикла мы знаем.
Каким должно быть тело цикла тоже в принципе несложно сообразить.
Готовый цикл
for (int i = 1; i <= 10; i++)
{
System.out.println(chislo + " * " + i + " = " + (i * chislo));
}
Получаем код
Выполнится он следующим образом
Задача 2.6.
Как и ранее объявляем переменные согласно условию задачи и присваиваем им начальные значения
int chislo1 = 3;
int chislo2 = 15;
Теперь на мой взгляд нужно определить, какое из этих чисел большее, а какое меньшее.
И наверное нам нужны переменные, в которых будут храниться минимальное и максимальное значение. Объявим их.
int min;
int max;
Теперь нужно присвоить им минимальное и максимальное значение соответственно.
Всё это сделать удобно через оператор if else следующим образом
if (chislo1 > chislo2)
{
min = chislo2;
max = chislo1;
}
else
{
min = chislo1;
max = chislo2;
}
Итак, минимальное и максимальное число нашли. Минимальное значение хранится в переменной min, максимально - в переменной max.
Ещё надо не забыть про вариант, когда chislo1 = chislo2. То есть когда не как такового интервала. Тут, думаю, справедливым будет следующий порядок действий: если число чётное, то оно должно быть выведено на экран, если нечётное, то не должно быть выведено на экран.
Обращаю внимание на то, что мы использовали именно else, а не второй оператор if (с условием chislo1 < chislo2), т.к. в случае их равенства, не сработал бы ни первый, ни второй оператор if. И переменные min и max остались бы без значения. А при варианте с else в случае равенства chislo1 и chislo2 переменным min и max будут присвоены значения. Одинаковые.
И вспоминаем, как нам определить, чётное число или нет. Условие простое - если остаток от деления на 2 равен нулю, то число чётное.
С таким раскладом нам остаётся сделать такую конструкцию с циклом и оператором if
for (int i = min; i <= max; i++)
{
if (i % 2 == 0) System.out.println(i);
}
Итоговый код
Результат выполнения
Задача 2.7.
Виноват. Ранее не рассказывал про то, как работает оператор вывода текста System.out.print().
Так вот. System.out.println() делает так, что следующий вывод текста после его выполнения будет осуществляться с новой строки.
System.out.print() так не делает. Если указать команды таким образом
System.out.print(1);
System.out.print(2);
System.out.print(3);
то на экран будет выведено
123
Итак, давайте сначала придумаем код для вывода цифр от 1 до 9 в строчку. То есть напечатаем первую строку. На мой взгляд цикл должен быть таким
for (int i = 1; i<=9; i++)
{
System.out.print(i);
}
Но если оставить так, то вывод на экран будет таким
123456789
Это не очень красиво. Стоит добавить пробелы
for (int i = 1; i<=9; i++)
{
System.out.print(i + " ");
}
Так гораздо лучше
1 2 3 4 5 6 7 8 9
Всё, первую строку вывели на экран. Теперь нужно подумать, как вывести оставшиеся 8 строк.
Если представить, что наша первая строка - это таблица, то мы имеем таблицу с одной строкой и 9-ю столбцами. По сути переменная i - это номер столбца в таблице.
Но наша задача вывести таблицу с 9-ю столбцами и 9-ю строками. И значение в каждой ячейке будет равно произведению номера столбца на номер строки.
В принципе в первой строке это условие выполняется.
1*1 = 1, 1*2 = 2 ... 1*9 = 9. Всё правильно.
Очевидно, что нам нужна вторая переменная, в которой бы хранился номер строки. Причём, она тоже должна менять свои значения от 1 до 9.
И значение каждой ячейки в таблице в нашем случае будет равно произведению номера столбца на номер строки.
И очевидно, что в данном случае целесообразно воспользоваться конструкцией с вложенным циклом.
И сделаем мы это следующим образом
for (int i = 1; i <= 9; i++)
{
for (int j = 1; j <= 9; j++)
{
System.out.print(i*j + " ");
}
}
В такой конструкции правда i стало номером строки, а j стало номером столбца.
Как сработает такой цикл? Он выведет в одну строку результат перемножения номеров всех строк и номеров столбцов. Мы получим 81 значение с разделителем пробелом.
Но нам нужно, чтобы это всё было выведено ни в одну строку, а в 9.
Для того, чтобы это сделать, добавим между первыми и вторыми закрывающимися скобками System.out.println("").
Что нам это даст? Как я говорил, оператор System.out.println() делает так, что последующий вывод текста будет осуществляться с новой строки. Поэтому такой командой мы ничего не выводим на экран, но делаем так, что после выполнения каждой итерации внешнего цикла, по сути после того, как в текущей строке все ячейки таблицы будут заполнены, мы последующий вывод текста начинаем с новой строки.
Пробуем сохранить
и выполнить
Всё, задача решена.
Осталось выполнить дополнительное задание.
Вся таблица выведена на экран, но числа не чётко друг под другом. Давайте сделаем так, чтобы всё было красиво.
А сделать это можно следующим образом. Мы можем наблюдать, что во всей таблице есть числа, состоящие из одного числа или из двух чисел.
И решить нашу проблему мы можем, добавив пробел к числам, состоящим из одной цифры. Добавить пробел можно как слева, так и справа. На мой вкус если добавить пробел слева, то так правильнее. Допишем перед оператором вывода текста такое условие
if (i*j<10) System.out.print(" ");
И будет нам счастье!
Исправленный код
Результат выполнения
Ну вот! Теперь всё красиво.
Дополнительное задание к задаче решено.
Ссылка на предыдущий урок
Ссылка на следующий урок
Ссылка на содержание курса