[ЗВУК] [ЗВУК] Продолжаем изучение алгоритмов обработки одномерных массивов. Найдем среднее арифметическое положительных элементов массива R, длина которого составляет n. Начнем, как обычно, с постановки задачи. Исходные данные — это длина массива и сами элементы массива. Элементы массива у нас вещественные. Результатом будет являться среднее арифметическое, или, если наш результат не найден, то тогда мы выведем сообщение о том, что нет среднего. Ограничение на исходные данные: у нас с вами должно быть соблюдено правило, что длина массива — натуральное число, не превышающее максимально возможной длины этого массива. Связь в данном случае использует формулу, которая применяется в математике. Среднее равно, и дальше следует значок сигма — сумма. Снизу указано, с какого номера мы начнем наше суммирование, а сверху этой суммы написано, каким номером мы завершим. Мы считаем сумму элементов этого массива и делим на k. Рассматриваем только положительные элементы, а для того чтобы найти k — количество положительных элементов, мы поступаем следующим образом. Начальное значение k у нас равно нулю, а затем для каждого i от единицы до n, такого, что наш элемент положительный, мы увеличиваем это количество. И теперь рассмотрим алгоритм решения этой задачи. Назовем его «среднее арифметическое положительных элементов массива». Начнем с того, что введем наши исходные данные, и нам нужно будет подсчитать сумму положительных элементов массива и их количество. Начальное значение суммы сделаем нулем, это будет сумма только положительных элементов, а значение количества в начале тоже равно нулю, то есть их нет. Затем рассмотрим последовательно все номера элементов массива от первого до последнего. Если у нас элемент оказывается положительным, то мы делаем два действия. Во-первых, мы увеличиваем количество таких элементов на единицу, а во-вторых, к сумме прибавляем сам элемент. Затем мы закрываем наше условие и завершаем наш цикл ключевым словом «конец цикла». Далее, мы проверяем, есть у нас результат, или нам не удалось его получить. Если наше k равно нулю, это значит, что мы ни разу не сумели его увеличить, то есть ни одного положительного элемента в массиве мы не нашли. Тогда мы должны вывести сообщение о том, что у нас нет среднего. В противном случае мы считаем среднее как сумму элементов, деленную на количество положительных, и затем выводим полученное значение среднего. Завершаем наше условие, и наш алгоритм заканчивается ключевым словом «кон». Если посмотреть внимательно на анализ последнего условия, то мы видим, что это математический принцип «на ноль делить нельзя», только записанный в терминах алгоритма. Если k равно нулю, мы не можем делить на ноль, но выводим сообщение о том, что нет среднего, а если оно есть, то мы можем делить, высчитываем нужный нам результат и дальше выводим его на экран. В этой задаче нам дан массив A, и нам нужно написать постановку задачи, алгоритм и программу для вычисления суммы элементов массива, которые расположены между первым и последним отрицательным элементом этого массива включительно. Начнем с постановки задачи. Мы с вами в качестве исходных данных должны ввести длину массива и сам этот массив. Затем мы должны рассмотреть, какие варианты результата мы можем здесь получить. Варианты результата у нас следующие: мы должны найти сумму, если она существует. Кроме того, у нас есть возможность, что у нас вообще нет отрицательных элементов. Если их нет, тогда мы выведем сообщение о том, что нет отрицательных элементов. И третий вариант — это когда отрицательный элемент в нашем массиве только один. Если бы в условии нашей задачи не было слова «включительно», то тогда мы могли бы считать, что в этом случае результата у нас нет. Но поскольку слово «включительно» у нас присутствует в условии, то тогда в данном случае мы считаем, что сам этот единственный отрицательный элемент и будет суммой. Ограничение на допустимость исходных данных — это то, что длина массива — натуральное число, не превышающее максимально возможной длины массива. И никаких ограничений на сами элементы массива мы накладывать не будем, потому что при любых элементах массива мы получим тот или иной вариант результата. Или сумму, или сообщение о том, что отрицательных элементов нет, или один элемент будет равен сумме. Теперь посмотрим, как выглядит в данном случае связь между исходными данными и результатом. Первым делом я должна записать, как я ищу номер первого отрицательного элемента. Существует такой номер n1, что элемент на этом месте отрицательный. Затем я должна написать, что этот элемент первый. То есть я говорю, что у меня не будет существовать среди номеров, меньших найденного, такого номера, чтобы там элемент был отрицательным. То есть первая часть выражения — это то, что найден отрицательный элемент, а вторая часть — то, что он первый. Теперь аналогичное выражение нужно записать для последнего отрицательного элемента. Обозначу его номер np. У меня будет существовать номер np, такой, что элемент с этим номером будет отрицательным, и при этом это будет из всех возможных элементов последний. То есть у меня не будет существовать номера, который расположен за этим найденным элементом и до самого конца массива, такого, чтобы элемент был отрицательным. Таким образом, я описала, как я ищу номера. Затем я должна написать, как я ищу сумму. В данном случае я снова использую значок сигма — сумма, и я говорю, что я суммирую все элементы с номерами от n1 до np включительно. И вот эта сумма является результатом. Теперь рассмотрим алгоритм. Называю алгоритм «сумма элементов, расположенных между первым и последним отрицательным элементом». Дальше начинаю со слова «нач», ввожу исходные данные. Дальше мне нужно инициализировать эти номера, которые я буду искать. Я даю начальные значения номерам такие, чтобы когда они будут найдены, можно было определить, были ли у меня вообще отрицательные элементы. Я выбираю номер, которого в массиве точно нет. Например, я могу выбрать для n1 начальное значение, равное нулю, и для np точно такое же начальное значение. Дальше я рассматриваю все номера элементов от первого до последнего и проверяю, является ли элемент отрицательным. Если элемент является отрицательным, то тогда я проверяю, является ли он первым отрицательным. Если этот элемент первый отрицательный, то номер n1 еще не успел измениться с нуля на какое-нибудь другое значение. Если элемент отрицательный, и при этом n1 еще равно нулю, то я поменяю n1 на текущий номер элемента и закрою это условие. Понятно, что вот это второе условие может выполниться либо один раз, если я найду первый отрицательный элемент, либо вовсе ни разу, если отрицательных элементов нет. Обращаю ваше внимание, что первое условие еще продолжает действовать. Мы закрыли «вложено, если», а если ai является отрицательным, по-прежнему истинное выражение. Теперь я буду менять номер np на каждом шаге, на котором я нашла отрицательный элемент. Таким образом, при каждом отрицательном элементе будет запоминаться его номер. И в конце концов я найду последний из этих номеров. Теперь я закрываю первое условие и закрываю цикл. Дальше мне нужно проанализировать, а какой результат я получила. То есть какой из трех вариантов результата мне нужно будет вывести на экран. Рассмотрим, как у нас будет выглядеть вывод различных вариантов результата. Если n1 осталось нулем, то есть иными словами говоря, мы не нашли ни одного отрицательного элемента, и это начальное значение ни на какое другое не изменилось, то тогда мы выводим сообщение о том, что нас нет отрицательных элементов. В противном случае мы с вами рассматриваем два оставшихся варианта. Если n1 = np, то это означает, что оба этих номера изменились ровно один раз при первом и единственном отрицательном элементе. Тогда мы выводим сообщение о том, что у нас один отрицательный элемент и результат — наша сумма равна именно этому элементу. Остается случай, когда сумму нужно посчитать. Мы знаем, с какого номера мы начнем считать и каким завершим. Начальное значение суммы у нас равно нулю. И теперь мы начинаем перебирать элементы от номера n1 до номера np включительно. На каждом шаге мы к сумме прибавляем наш текущий элемент массива, затем завершаем цикл и выводим полученное значение суммы. Теперь нам нужно закрыть условные конструкции. Сначала мы закрываем «вложено, если», а затем внешнюю условную конструкцию, после чего завершаем наш алгоритм словом «конец». Теперь напишем программу по нашему алгоритму. Программу я назову between — «между», и первым делом я объявлю константу lmax, которая будет равна 20. И для массива удобно объявить тип. Тип будет называться mass и будет представлять собой массив из 20 вещественных элементов с номерами от 1 до 20. Далее я объявляю переменные. Переменная a у меня будет массив, тип которого описан выше, и затем у меня будут использоваться переменные для длины массива, текущего номера элемента и для двух номеров: номера первого и номера последнего. Кроме того, сумма элементов массива будет принадлежать к вещественному типу, потому что элементы массивы имеют этот тип. Далее я начинаю со слова begin, и первым делом я должна ввести значение длины массива. Для того чтобы оно было правильным, то есть находилось в границах от 1 до lmax включительно, я устраиваю цикл с постусловием, в котором я буду проверять, правильные ли данные были введены пользователем. Я делаю цикл с постусловием repeat... until и повторяю в нем два действия: вывод сообщений о том, что мне нужно ввести n, и, собственно, ввод n. Продолжаться будет этот цикл до тех пор, пока я не добьюсь от пользователя ввода правильных данных. До тех пор, пока n не будет положительным и не превышающим величины lmax. Далее я должна ввести сами элементы массива. Я подсказываю пользователям, сколько именно элементов я должна ввести, то есть «введите (и дальше будет подставлено значение) сколько-то элементов», далее я начинаю цикл по всем номерам от первого до последнего и каждый элемент читаю отдельно. Здесь элементы массива можно располагать в произвольном порядке, при вводе я могу их расположить в одну строку, в один столбец или по нескольку элементов на строчке — здесь важен только порядок расположения элементов. Далее я начинаю кодировать собственно алгоритм, начинаю я с инициализации n1 и np — оба начальных значения равны нулю. Я рассматриваю все номера элементов массива от первого до последнего. Для каждого отрицательного элемента я выполняю два действия: проверяю, первый ли он, и затем я запоминаю номер текущего отрицательного элемента. Поскольку действий много, то после then я располагаю begin, то есть делаю из них составной оператор. Далее я проверяю условие первого отрицательного элемента. Если n1 = 0, тогда я меняю этот номер на текущий, и далее, не закрывая первое условие, я присваиваю np текущий номер. Первое присваивание будет выполнено не более одного раза, а второе у меня будет выполняться при каждом отрицательном элементе. Затем я завершаю составной оператор и начинаю анализировать результат. При n1 = 0 я вывожу сообщение о том, что нет отрицательных, дальше у меня идет else (обращаю ваше внимание еще раз, что точка с запятой перед else в Паскале никогда не ставится), и дальше я проверяю следующее условие: если n1 у меня равно np, то тогда у меня будет один отрицательный элемент, и я вывожу сумму, равную этому элементу. В противном случае я начинаю подсчет суммы. При подсчете суммы у меня много действий: это инициализация, это сам цикл и это вывод результата. Поэтому снова нужен составной оператор — он начинается со слова begin, далее я инициализирую сумму, перебираю все номера от n1 до np включительно, на каждом шаге прибавляю к сумме наш очередной элемент и затем завершаю цикл. Далее я вывожу полученное значение суммы, и мне нужно закрыть теперь последнее «иначе», я пишу там end, соответствующий begin, расположенному после последнего else, ну и затем завершается моя программа end с точкой, который соответствует первому begin. Рассмотрим программу, которая вычисляет сумму элементов, расположенных между первым и последним отрицательным элементом нашего массива. Вначале вводятся исходные данные, то есть количество элементов массива и сами эти элементы. Ввод аналогичен предыдущим примерам, то есть мы проверяем, что у нас правильная длина массива, а элементы массива могут быть любыми. Далее реализуем алгоритм поиска этих номеров. Номер первого отрицательного элемента обозначен n1, а номер последнего обозначен np. Вначале оба эти значения равны нулю, и мы с вами проходим по всем номерам элементов массива и проверяем, если это первый такой элемент, то меняем n1 на текущий номер элемента, то есть на i, а np меняем на i при каждом отрицательном элементе. После того, как цикл закрыт, мы проверяем, есть ли у нас вообще отрицательные элементы. Если n1 = 0, то отрицательных элементов нет, выводим сообщение. Если первый номер и последний номер одинаковые, то у нас один отрицательный элемент, и при этом сумма равна самому этому элементу. В противном случае мы должны ее вычислить. Начальное значение суммы есть ноль, мы перебираем номера элементов массива от n1-го до np-го, на каждом шаге прибавляем к сумме сам этот элемент и выводим значение суммы. Давайте попробуем запустить нашу программу и придумать тесты, в которых у нас будут рассматриваться все возможные случаи. Например, я возьму три элемента массива, и пусть все они будут положительные или нули. Единица, ноль и двойка. В этом случае у нас нет отрицательных элементов, результатом является сообщение. Теперь попробую ввести один отрицательный элемент. Допустим, у меня их пять и значения 0, −3, 4, 1, 6. В этом случае один отрицательный элемент, равный −3, и сумма равна ему же. Теперь попробуем дать больше, чем один отрицательный элемент. Пусть у меня семь элементов массива, и значения их равны −1, 2, 0, −3, 4, 7 и −4. Тогда сумма вычисляется между первым и последним отрицательным элементом, то есть между −1 и −4, причем эти значения включаются в сумму. Если посчитать, то мы видим, что у нас получается сумма, равная 5. [ЗВУК] [ЗВУК]
