Buderus-trade.ru

Теплотехника Будерус
0 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

10. 1 Цикл For в Паскаль. Цикл с известным числом повторений (цикл с параметром). Тело цикла

#10.1 Цикл For в Паскаль. Цикл с известным числом повторений (цикл с параметром). Тело цикла.

vedro-compota's picture

В Паскале можно использовать три конструкции для организации циклов, они известны по именами:

  1. For
  2. While
  3. Repeat

В этом уроке — мы познакомимся с первый из них — циклом For.

Цикл For — схема работы

Цикл For также называют циклом с известным числом повторений.
Он обладает следующей структурой (изобразим её на блок-схеме):
Пасклаь структрура и работа цикла FOR блок схема

Как видим на схеме, в цикле for имеются:

    Заголовок цикла (шестиугольный блок на схеме выше) — а котором описывается как именно будет изменяться счётчик цикла (на схеме выше это переменная $i$).

Счетчик цикла — это специальная переменная (типа integer), для которой на основании правой и левой границы цикл for определяет ряд значений, которые она «проходит» при выполнении цикла.
В примере на схеме в качестве левой и правой границы указаны числа $1$ и $10$, то есть переменная $i$ должна будет «пробежать» по ряду значений:

— для каждого из этих значений тело цикла будет повторяться (в данном случае 10 раз). Правая и левая границы всегда должны обладать типом integer.

Сразу же приведём пример кода программы, цикл в которой соответствует блок схеме на рисунке выше:

— здесь в теле программы тоже три операции (но уже конкретные) и тот же диапазон значений счетчика, что и на блок-схеме. Запустите программу и посмотрите на результат.

Далее рассмотрим примеры решения задач, чтобы лучше понять как работает цикл for.

Если правая граница счётчика меньше левой — downto

Если правая граница для счётчика цикла меньше чем левая то необходимо использовать вместо конструкции:

Разбор практических примеров

Пример №1 — использование значений счетчика

Вывести на экран все числа от 1 до 125.

— так как нам нужно было повторять только действие вывода, то в теле цикла мы разместили одну операцию, а потому операторные скобки для тела цикла не нужны.

Пример №2 — условный оператор внутри цикла

Вывести на экран все нечетные числа от 37 до 1025.

Здесь для решения в сравнении с решением предыдущей задачи просто изменим диапазон значений счетчика и добавим в тело цикла условный оператор с проверкой остатка от деления на $2$:

— обратите внимание, что здесь тоже не используются операторные скобки для окружения тела цикла. Дело в том, что вложенным в непосредственно в блок цикл for является только один условный оператор if, а вызов стандартной процедуры write() вложен уже в if, а не непосредственно в for, а потому в данном случае считается, что в теле цикла for находится только одна операция (for) и, следовательно, операторные скобки не обязательны.

Пример №3 — downto

Задача:
Выведите на экран все число от 133 до 57.

Решение (тут всё просто):

Пример №4 — downto и цикл в одной из веток условного оператора

Пользователь вводит целое число, если оно больше $8$ выведите на экран все числа от этого числа до $5$ (в обратном порядке), иначе сообщите об ошибке.

Пример №5 — условный оператор с составным условием внутри цикла

Выведите на экран, все четные числа, делящиеся на 7 нацело, лежащие в диапазоне от 28 до 117.

Решение:
В этой задаче нам необходимо перебрать все числа от 28 до 117 (будем делать это циклом), проверяя каждое число, на соответствие сразу двум условиям:

  1. является четным — т.е. по сути делится на 2 нацело; на 7;
Читайте так же:
Как сбросить счетчик у опель зафира

Так оба условия для выводимого числа нужно проверять одновременно (они должны выполняться одновременно— только тогда его можно выводить), то будем использовать логическое И.
Третье же условие принадлежности диапазону будет гарантировать сам цикл for — так как мы будем перебирать только числа из этого диапазона, а потом в услвоном операторе проверять его не нужно, в качестве очередного числа используем счетчик цикла:

Пример №6 — логические выражения, условия внутри цикла + анализ условия

Выведите на экран, все четные числа от 35 до 117 и все числа, делящиеся на $5$ нацело, лежащие в диапазоне от 45 до 178.
Указание: сначала можно решить задачу двумя циклами, но потом перепишите с использованием одного цикла, в теле которого составьте логическое выражение, описывающее подходящие числа (используйте логические операции).

Решение двумя циклами:

Решить двумя циклами проще — достаточно пройтись по двум числовым «отрезкам» (диапазонам) сначала циклом по диапазону [35..117], а потом по диапазону [45..178]. Внутри тел циклов надо проверять условия, которые написаны в задаче с помощью условного оператора.

— заметьте, что в этом решении числа выводится не по порядку, что не очень хорошо. В следующем решении мы это исправим.

Решение одним циклом:

Чтобы решить задачу одним циклом (используя единственную конструкцию for), нам стоит заметить, что отрезки [35..117], а потом по диапазону [45..178] пересекаются — так как:
$35 lt 45 lt 117 lt 178$
— это значит, что мы можем просто перебрать все числа от 35 до 178, и:

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

— вывести только то, что нам нужно.

Приведём код, решающий задачу одним циклом:

— здесь внутри тела цикла стоит два независимых условных оператора, числа при выводе упорядочены, но есть дублирование, так как например 50 и четное и делится на 5 и находится на пересечении диапазонов.
Чтобы избежать дублирование надо сделать так, чтобы для каждого очередного числа из значений $i$ положительно выполнялось максимум одно условие — тогда очередное значение $i$ либо будет выведено один раз либо не будет выведено вообще.

Поэтому сделаем проверку второго условия, альтернативой на случай неуспеха первого — для чего введём ветку ложности в первый условный оператор и вложим в неё второй (это потребует совсем незначительных правок):

— заметьте, что во вложенном в else условии проверяется только левая граница диапазона [45..178] — это связано с тем, что значения $i$ в заголовке цикла итак ограничены сверху числом 178.

Видео-пояснения

Для этого урока есть следующие видео:

Самостоятельная работа

Вопросы

  1. Зачем нужен цикл for?
  2. Что такое заголовок цикла?
  3. Что такое счетчик цикла?
  4. Что такое тело цикла?
  5. Переменной $i$ в цикле for левую границу установили в $5$, а правую в $12$ — сколько раз выполнится цикл?

Задачи

  1. Выведите на экран, все четные числа от 35 до 64.
  2. Пользователь вводит целое число, если оно больше единицы, то выведите на экран все целые числа от этого числа до единицы (в обратном порядке), которые делятся на 5 без остатка. Иначе (если введённое пользователем число не больше единицы) сообщите об ошибке.
  3. Пользователь вводит целое число, если оно больше 100, то выведите на экран все числа от этого числа до $1$, иначе же все числа от $1$ до этого числа.
Читайте так же:
Счетчик калорий по камере

Подсказка: в каждой ветке условного оператора тут должно быть по одному циклу.

Операторы цикла

В цикле со счетчиком тело цикла повторяется заранее определенное число раз. Циклы со счетчиком используются довольно часто, и поэтому в языке Паскаль для этих целей имеется специальная конструкция.

Можно, конечно, циклы со счетчиком моделировать при помощи операторов while и Repeat, но структура цикла со счетчиком проще.

Общая форма записи цикла со счетчиком

for i := A to B do
begin
. . .
end;

for i := A downto B do
begin
. . .
end;

Здесь переменная i — управляющая переменная или переменная цикла,

А — начальное значение переменной цикла,

В — конечное значение переменной цикла.

При переходе к обработке оператора цикла for управляющей переменной присваивается заданное начальное значение. Затем в цикле выполняется исполнительный оператор (или составной оператор). Каждый раз при выполнении исполнительного оператора управляющая переменная увеличивается на 1 (для for. to) или уменьшается на 1 (для for. downto). Цикл завершается при достижении управляющей переменной своего конечного значения.

1) for i := 1 to ListSize do
begin
readln (Number):
S := S +Number;
end;

2) for Dlina := 15 downto 1 do
writeln (Sqr(Dlina));

3) for x := 1 to 10 do
for y := 1 to 10 do
writeln (x,’*’,y,’=’,x*y);

4) for Range := Number+1 to Multi*3 do
writeln (Sqrt(Range));

При использовании цикла for компьютер выполняет за программиста черновую работу по инициализации управляющей переменной и по ее увеличению (уменьшению) при каждом повторении цикла. Единственное ограничение заключается в том, что тип управляющей переменной не должен быть real. Переменная цикла не должна изменяться какими-либо операторами внутри цикла. К ней можно обращаться и использовать в вычислениях, но нельзя присваивать новое значение. Присваивания могут выполняться только механизмом самого цикла. Таким образом, следующий цикл является некорректным:

for i := 1 to 10 do
begin
. . .
i := i-1;
. . .
end;

Управляющая переменная должна описываться, как и любая другая переменная. Обычно переменная цикла имеет тип integer, но позднее Вы рассмотрите другие типы данных, которые могут указываться в качестве типа управляющей переменной.

Внимание! Следует помнить, что управляющая переменная не может быть типа real.

Исполнительная часть цикла может быть либо простым, либо составным оператором. Если начальное значение цикла for . to больше конечного значения, то никакие операции не выполнятся. Таким образом, следующий оператор не приведет ни к каким действиям

for j := 1 to 0 do
writeln (j);

Однако цикл, представленный в такой форме, распечатает целые числа от единицы до десяти:

for j := 1 to 10 do
writeln (j);

Как можно догадаться, следующий цикл выполняет счет в обратном порядке:

for j := 10 downto 1 do
writeln (j);

Часто тело цикла For содержит еще один оператор цикла For. Структуры такого рода называются вложенными циклами. При завершении внутреннего цикла управляющая переменная внешнего цикла увеличивается. Повторение этих действий будет продолжаться до завершения внешнего цикла. Приведенный ниже вложенный цикл печатает пары чисел, начиная от (1,1), (1,2). и кончая (10,10):

for х:= 1 to 10 do
for у:= 1 to 10 do
writeln (‘(‘,х,’,’,y,’), ‘);

Задание. Выполните две задачи, уже решенные Вами задачи с помощью других видов цикла, с помощью со счетчиком.

Операторы циклов в языке Паскаль. Примеры использования.

Цикл является одной из важнейших алгоритмических структур и представляет собой последовательность операторов, которая выполняется неоднократно. В программах , связанных с обработкой данных или вычислениями, часто приходится выполнять циклически повторяющиеся действия. Циклы позволяют записать такие действия в компактной форме. Циклы принадлежат к числу управляющих операторов. В языке программирования Паскаль имеется три разновидности цикла:

Читайте так же:
Ук центрстрой поверка счетчиков

цикл со счетчиком (цикл «для» — for… to / downto);

цикл с предусловием (цикл «пока» — while);

цикл с постусловием (цикл «до тех пор, пока» — repeat…until).

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

Цикл со счетчиком.

В тех случаях, когда число повторений заранее определено, удобно использовать оператор For..To..Do. Данный оператор имеет встроенный счетчик и может использовать шаг либо «+1» либо «-1». В случаях если мы вычисляем от меньшего к большему, то используется вид For..To..Do. Если от большего к меньшему изменяется счетчик, то используется вариант For…Downto..Do. Общий вид оператора: For (переменная):=нач. значение…to (downto) конечное значение do.

Var i:integer; sum:Real;

Цикл с предусловием

Общий вид оператора:

while условие do (Эта часть называется заголовком цикла)

оператор; (Эта часть называется телом цикла)

Телом цикла может быть и группа операторов, заключенная в операторные скобки begin… end (то есть составной оператор).

Цикл с предусловием выполняется до тех пор, пока истинно условие в заголовке цикла, причем оно проверяется вначале, потом исполняется оператор. Переменным, входящим в условие, должны быть присвоены определенные значения до входа в цикл.

В теле цикла должны быть операторы, которые в какой-то момент изменят значение условия, сделав его ложным. Если этого не случается, цикл будет бесконечным. Цикл работает пока условие выполняется. Это цикл с предусловием, в котором есть возможность не выполнять тело ни разу.

Н-р. Задача о вычислении суммы.

Var i:integer; sum:Real;

Цикл с постусловием.

Общий вид оператора : repeat группа операторов until условие;

Здесь вначале выполняются группа операторов, а потом производится проверка, следует ли вновь повторить эту группу. Если условие ложно, выполнение цикла повторяется, иначе – заканчивается.

Решение предыдущей задачи о суммировании .

Var i:integer; sum:Real;

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

Тут вы можете оставить комментарий к выбранному абзацу или сообщить об ошибке.

Цикл счетчик паскаль примеры

страницы: 1 2 3

Содержание

  • Содержание
  • Операторы циклов
    • for-to и for-downto
      • Инкрементный цикл с параметром
      • Декрементный цикл с параметром
      • Оператор безусловного перехода goto

      Операторы циклов

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

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

      Замечание: Алгоритмы, построенные только с использованием циклов, называются итеративными 1 — от слова итерация , которое обозначает повторяемую последовательность действий.

      for-to и for-downto

      В случае, когда количество однотипных действий заранее известно (например, необходимо обработать все компоненты массива), стоит отдать предпочтение циклу с параметром ( for ).

      Инкрементный цикл с параметром

      Общий вид оператора for-to :

      Счётчик i (переменная), нижняя граница first (переменная, константа или выражение) и верхняя граница last (переменная, константа или выражение) должны относиться к эквивалентным порядковым типам данных. Если тип нижней или верхней границы не эквивалентен типу счётчика, а лишь совместим с ним, то осуществляется неявное приведение: значение границы преобразуется к типу счётчика, в результате чего возможны ошибки.

      Цикл for-to работает следующим образом:

      1. вычисляется значение верхней границы last;
      2. переменной i присваивается значение нижней границы first;
      3. производится проверка того, что i <= last;
      4. если это так, то выполняется <оператор> ;
      5. значение переменной i увеличивается на единицу;
      6. пункты 3–5, составляющие одну итерацию цикла, выполняются до тех пор, пока i не станет строго больше, чем last; как только это произошло, выполнение цикла прекращается, а управление передаётся следующему за ним оператору.

      Из этой последовательности действий можно понять, какое количество раз отработает цикл for-to в каждом из трёх случаев:

      • first < last : цикл будет работать last — first + 1 раз;
      • first = last : цикл отработает ровно один раз;
      • first > last : цикл вообще не будет работать.

      После окончания работы цикла переменная–счётчик может потерять своё значение 2 . Таким образом, нельзя с уверенностью утверждать, что после того, как цикл завершил работу, обязательно окажется, что i = last + 1 . Поэтому попытки использовать переменную-счётчик сразу после завершения цикла (без присваивания ей какого–либо нового значения) могут привести к непредсказуемому поведению программы при отладке.

      Декрементный цикл с параметром

      Существует аналогичный вариант цикла for , который позволяет производить обработку не от меньшего к большему, а в противоположном направлении:

      Счётчик i (переменная), верхняя граница first (переменная, константа или выражение) и нижняя граница last (переменная, константа или выражение) должны иметь эквивалентные порядковые типы . Если тип нижней или верхней границы не эквивалентен типу счетчика, а лишь совместим с ним, то осуществляется неявное приведение типов.

      Цикл for-downto работает следующим образом:

      1. переменной i присваивается значение first ;
      2. производится проверка того, что i >= last ;
      3. если это так, то выполняется <оператор> ;
      4. значение переменной i уменьшается на единицу;
      5. пункты 2-4 выполняются до тех пор, пока i не станет меньше, чем last ; как только это произошло, выполнение цикла прекращается, а управление передаётся следующему за ним оператору.
      • first < last , то цикл вообще не будет работать;
      • first = last , то цикл отработает один раз;
      • first > last , то цикл будет работать first — last + 1 раз.

      Замечание о неопределённости значения счётчика после окончания работы цикла справедливо и в этом случае.

      while и repeat-until

      Если заранее неизвестно, сколько раз необходимо выполнить тело цикла, то удобнее всего пользоваться циклом с предусловием ( while ) или циклом с постусловием ( repeat-until ).

      Общий вид этих операторов таков:

      Условие окончания цикла может быть выражено переменной, константой или выражением, имеющим логический тип .

      Замечание: Обратите внимание, что на каждой итерации циклы for и while выполняют только по одному оператору (либо группу операторов, заключённую в операторные скобки begin-end и потому воспринимаемую как единый составной оператор). В отличие от них, цикл repeat-until позволяет выполнить сразу несколько операторов: ключевые слова repeat и until сами служат операторными скобками.

      Так же, как циклы for-to и for-downto , циклы while и repeat-until можно назвать в некотором смысле противоположными друг другу.

      Последовательности действий при выполнении этих циклов таковы:

      Для while :Для repeat-until :
      1. Проверяется, истинно ли <условие_1>.1. Выполняются <операторы>.
      2. Если это так, то выполняется <оператор>.2. Проверяется, ложно ли <условие_2>
      3. Пункты 1 и 2 выполняются до тех пор, пока <условие_1> не станет ложным.3. Пункты 1 и 2 выполняются до тех пор, пока <условие_2> не станет истинным.

      Таким образом, если <условие_1> изначально ложно, то цикл while не выполнится ни разу. Если же <условие_2> изначально истинно, то цикл repeat-until выполнится один раз.

      Break и Continue

      Существует возможность 3 прервать выполнение цикла (или одной его итерации), не дождавшись конца его (или её) работы.

      Break прерывает работу всего цикла и передаёт управление на следующий за ним оператор.

      Continue прерывает работу текущей итерации цикла и передаёт управление следующей итерации (цикл repeat-until ) или на предшествующую ей проверку (циклы for-to , for-downto , while ).

      Замечание: При прерывании работы циклов for-to и for-downto с помощью функции Break переменная цикла (счётчик) сохраняет своё текущее значение, не «портится».

      Оператор безусловного перехода goto

      Возвращаясь к сказанному об операторе goto 4 , необходимо отметить, что при всей его нежелательности всё–таки существует ситуация, когда предпочтительно использовать именно этот оператор — как с точки зрения структурированности текста программы, так и с точки зрения логики её построения, и уж тем более с точки зрения уменьшения трудозатрат программиста. Эта ситуация — необходимость передачи управления изнутри нескольких вложенных циклов на самый верхний уровень.

      Дело в том, что процедуры Break и Continue прерывают только один цикл — тот, в теле которого они содержатся. Поэтому в упомянутой выше ситуации пришлось бы заметно усложнить текст программы, вводя много дополнительных прерываний. А один оператор goto способен заменить их все.

      Сравните, например, два программно–эквивалентных отрывка:

      Write ( ‘Матрица ‘ ) ;
      for i := 1 to n do
      begin
      flag := False ;
      for j := 1 to m do
      if a[i , j] > a[i , i] then
      begin
      flag := True ;
      Write ( ‘не ‘ ) ;
      Break ;
      end ;
      if flag then Break ;
      end ;
      WriteLn ( ‘обладает свойством’ +
      ‘ диагонального преобладания.’ ) ;

      Write ( ‘Матрица ‘ ) ;
      for i := 1 to n do
      for j := 1 to m do
      if a[i , j] > a[i , i] then
      begin
      Write ( ‘не ‘ ) ;
      goto 1 ;
      end ;
      1 : WriteLn ( ‘обладает свойством’ +
      ‘ диагонального преобладания.’ ) ;

      Пример использования циклов

      Задача. Вычислить интеграл в заданных границах a и b для некоторой гладкой функции f от одной переменной (с заданной точностью).

      Алгоритм. Метод последовательных приближений, которым мы воспользуемся для решения этой задачи, состоит в многократном вычислении интеграла со всё возрастающей точностью, — до тех пор, пока два последовательных результата не станут различаться менее, чем на заданное число (скажем, eps = 0,001). Количество приближений нам заранее неизвестно (оно зависит от задаваемой точности), поэтому здесь годится только цикл с условием (любой из них).

      Вычислять одно текущее значение для интеграла мы будем с помощью метода прямоугольников: разобьём отрезок [a, b] на несколько мелких частей, каждую из них дополним (или урежем — в зависимости от наклона графика функции на данном участке) до прямоугольника, а затем просуммируем получившиеся площади. Количество шагов нам известно, поэтому здесь удобнее всего воспользоваться циклом с параметром.

      На нашем рисунке изображена функция f(x) = x 2 (на отрезке [1, 2]). Каждая из криволинейных трапеций будет урезана (сверху) до прямоугольника: высотой каждого из них послужит значение функции на левом конце участка. График станет «ступенчатым».

      Реализация

      03-01.png

      Вывод массива, удобный для пользователя

      Задача. Распечатать двумерный массив размерности MxN удобным для пользователя способом. (Известно, что массив содержит только целые числа из промежутка [0 .. 100].)

      Алгоритм. Понятно, что если весь массив мы вытянем в одну строчку (или, того хуже, в один столбик), то хороших слов в свой адрес мы от пользователя не дождёмся. Именно поэтому нам нужно вывести массив построчно, отражая его структуру.

      голоса
      Рейтинг статьи
Ссылка на основную публикацию
Adblock
detector