[МУЗЫКА] [МУЗЫКА]
Посмотрим ещё одну часто встречающуюся
задачу, а именно подсчёт суммы последовательностей.
Условие точно такое же.
У нас задаётся последовательность чисел, 0 — это признак того,
что у нас кончился ввод.
Всё, что после 0, мы можем даже не читать.
И нам необходимо вывести сумму всех этих чисел последовательности.
Опять же, человек может решить эту задачу, не запоминая полностью последовательность.
Достаточно вначале хранить специальную переменную у себя в голове — 0,
и каждый раз, когда к нам приходит очередное число,
эту переменную изменять на величину собственно этого числа.
Давайте я удалю этот код, чтобы он нам не мешал.
И что мы сделаем?
Заведём переменную для хранения суммы последовательностей.
Она равна 0 в начале.
Первое число также считаем перед циклом один раз отдельно.
Почему?
Потому что это нам нужно для проверки условия, что число не равно 0.
Если бы мы не считали его отдельно и написали вот такое же условие,
как в прошлой задаче, что очередное число не равно 0,
то у нас была бы ошибка, потому что в переменной now ещё ничего не лежит.
Итак, прибавляем к
сумме последовательности очередное считанное
число и считываем новое.
И уже после цикла печатаем сумму последовательности.
Давайте проверим, что этот вариант программы у нас работает.
Вот она, последовательность 1, 2, 3.
Её сумма 6.
Это легко проверить.
Как сделать эту программу более похожей на предыдущую?
Мы можем сделать совсем-совсем похожую,
потому что задача, собственно, похожая, следующим образом.
Сначала считаем первое число.
В предыдущей задаче про поиск максимума мы первое же число запоминали в
качестве максимума.
Здесь в сумме мы можем в качестве суммы запомнить это первое число.
То есть переменную хранящейся суммы отдельно кладем в него.
Условие в while у нас уже такое же, как и было в прошлой задаче,
но там мы считывали сначала переменную,
а затем сравнивали очередную считанную переменную с нашим запомненным значением.
Здесь мы прибавляем, вместо того чтобы сравнивать и заменять.
Вот теперь код совсем похож, даже немножко проще,
потому что вместо if и присваивания у нас только присваивание, прибавление к сумме.
Давайте посмотрим, что после того как мы поменяли этот код,
у нас по-прежнему всё работает.
Например, четыре числа теперь просуммируем.
Да, ничего не сломалось.
Теперь посмотрим, допустим, нас очень раздражает это серое подчеркивание — нам
среда программирования намекает на то,
что мы делаем что-то лишнее и можно сделать это проще.
В принципе, можно последовать рекомендации и почитать внимательнее,
что нам советуют, но я уверен, что оно посоветует сделать такую замену.
Вместо того чтобы писать,
что переменная равна — переменная та же самая — плюс что-то,
оно предложит нам написать вот такую конструкцию: переменная
+= уже какое-то выражение, в нашем случае просто очередное считанное число.
Что означает «+=»?
Это значит, к текущему значению этой переменной прибавить то арифметическое
выражение, которое идёт после него.
Сначала проверяем.
Действительно, всё работает и работает даже правильно.
И уже не подчеркивает, не ругается на нас — значит,
мы сделали достаточно оптимально.
Кроме «+=» существует «−=», «*=»,
«**=» — как возведение в степень, «//=».
И в общем-то, все арифметические операции, какие вы хотите,
можно записать в таком виде, и смыслом её будет: текущее значение переменной,
та операция, которая у вас записана, сделать эту операцию
в качестве правого операнда, используя то арифметическое выражение,
которое записано у вас после: какой-то знак =.
Вот и всё.
Это облегчает нам жизнь, позволяет экономить лишние символы,
ну и вообще говоря, в понимании тоже становится всё гораздо лучше,
потому что у вас могут быть похожие названия переменных.
Это здорово запутывает, когда вы какой-то переменной присваиваете значение,
какая-то похожая переменная плюс что-то.
А так, когда у нас сокращённая запись арифметических операций, такая ошибка уже
не может появиться, мы сразу понимаем, что с текущим значением что-то происходит.
Ну и меньше нажатий на клавиатуре, это, конечно же, лучше.
Кроме операции break для управления циклом,
существует еще одна операция, с которой мы сейчас познакомимся на такой задаче.
Опять же задана та же самая последовательность чисел,
оканчивающаяся 0.
Требуется вывести в том же порядке, как они задавались,
только положительные числа, отрицательные не выводить.
Сейчас мы это и напишем.
Отдельно до цикла опять же считываем первое число.
Я не буду писать заново — у нас это уже есть.
Цикл — пока не дошли до нуля, потому что 0 — это признак конца последовательности.
Сразу у нас первое значение, нужно его обработать,
если оно больше 0,
то печатаем это значение.
А в случае, если оно не больше 0 — ничего не делаем.
И не забываем считать очередное значение.
После цикла тоже ничего делать не нужно.
Сразу считали и вывели.
Давайте посмотрим, что это работает,
а потом уже будем модифицировать нашу программу для освоения новых конструкций.
Итак, ввели 1 — тут же вывелась 1.
Ввели отрицательное число — ничего не вывелось.
Положительное — опять появилось.
На 0 выполнение закончилось.
Всё работает.
Когда у вас будет что-то похожее в задачах, возможно, вы увидите,
что у вас есть входные данные и выходные данные отдельно.
И когда мы смотрим на вывод вот этой нашей программы, у нас входные,
выходные данные как бы перемешиваются друг с другом,
и это не очень похоже на то, что у вас задано в примере.
На самом деле, можете не беспокоиться об этом.
В тестирующей системе мы перенаправляем потоки ввода и вывода в файлы, и на самом
деле всё, что вы вводите, складывается в отдельный файл, который мы уже и сверяем.
То есть, у нас в тестирующей системе ввод с выводом мешаться не будет.
Поэтому как только вы захотели что-то вывести, вы можете сразу это сделать.
Итак, давайте попробуем научиться новой конструкции и
как-то приспособить её к этой задаче.
Эта конструкция называется continue.
Она выполняет цикл с нового шага.
То есть как только мы встретили continue,
мы тут же переходим к выполнению проверки снова условия, которое есть в цикле,
в отличие от break, который вырубает цикл полностью, переходит к следующей операции.
Как бы нам это приспособить сюда?
Во-первых, мы можем сделать вот такой не очень хороший cheat
— положить какое-то начальное отрицательное значение в переменную now.
Почему?
Чтобы у нас зашло хоть раз в этот цикл.
Конечно, когда кто-нибудь будет читать или мы будем читать наш код,
мы можем не сразу понять, зачем там лежит −1, и стоит избегать этих ситуаций.
Ну ладно.
Значит, первое значение — бессмысленное, и перед тем как что-то делать,
нужно считать новое значение.
Давайте я уберу старый код, чтобы он нас не смущал.
Всё — с чистого листа.
Итак, вот у нас считано очередное значение.
Если оно не положительное,
то есть меньше либо равно 0, то сделаем continue — переход проверки условия.
Если оно было равно 0, то условие не выполнится — мы тут же выйдем из цикла.
А если оно было меньше 0, то просто не выполнятся те команды,
которые дальше идут в блоке while, относящиеся к этому циклу.
А какая команда нам нужна?
Напечатать очередное число.
Таким образом, как будет выполняться программа?
Сначала мы первый раз зайдём в цикл благодаря тому,
что там лежало значение −1 — наше специальное.
Затем считаем новое число, и если оно оказалось меньше либо равно 0,
мы тут же перейдём к проверке условия.
И вот эта команда print, которая идет после нашего условного оператора,
естественно, не выполнится.
А вот если оно, это условие, now ≤ 0,
не было выполнено, то в этот if мы не зайдём, и print успешно выполнится.
Давайте проверим, что всё работает.
Итак, для положительных чисел работает, для отрицательных
тоже работает — ожидаемо, и с 0 тоже не превращается в вечный цикл.
Таким образом, мы смогли написать ещё одно решение, использующее continue.
Вообще говоря, использование break и continue запутывает человека, и
пользоваться ими нужно только в ситуациях, когда это действительно обосновано.
И без них код становится сложным и страшным для понимания.
Но злоупотреблять ими не следует,
поэтому старайтесь обходиться в своих решениях без них.
Но чтобы вы могли читать чей-то чужой сложный код, вот именно для этого
мы и научились тому, что такое break, что такое continue.
Ну и конечно, иногда бывает с ними намного удобнее, чем без них,
особенно, когда вы приделываете какую-то новую фичу в свою программу,
и это меняет вообще всю логику, и можно поставить такую заплатку.
Но иногда заплаток становится так много, что уже в общем-то программы не остается,
и тогда имеет смысл выкинуть всё и переписать заново.
Это называется рефакторинг,
но пока что старайтесь писать программы сразу правильно.
Задач в этот раз у вас много, но их нужно постараться решить,
потому что все они очень полезны для дальнейшего изучения.
[МУЗЫКА]
[МУЗЫКА]
