Как составить циклическую программу паскаль

Здравствуйте, дорогие читатели! Вот мы с вами и подошли к изучению циклов. Циклы в Паскаль. Что это такое? Как этим пользоваться? Для чего они нужны? Именно на эти вопросы я сегодня и отвечу.
Если вы читали этот урок, то знаете, что существует три вида алгоритмов: линейный, разветвляющийся и циклический. Мы с вами уже знаем, как реализовывать линейные и разветвляющиеся алгоритмы на Паскале. Приступим к изучению последнего типа алгоритмов.
В языке Pascal, как и в большинстве языков программирования, существует три типа циклических конструкций.

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

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

Задача 1. Вывести все числа от 1 до числа, введенного с клавиатуры.

Как вы, наверное, уже поняли из названия, while — это цикл, в котором условие стоит перед телом. Причем тело цикла выполняется тогда и только тогда, когда условие true; как только условие становится false, выполнение цикла прекращается.

While имеет формат:

while < условие> do <оператор 1>;  {Пока … делай ….}

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

Решение задачи.

program example_while; 

var
  i, N: integer; { объявляем переменные }

begin
  i := 1; { Присваиваем i значение 1 }
  readln(N); { Считываем последнее число }
  while i <= N do {Как только i станет больше N, цикл прекратится (можно было бы написать просто <, но пришлось бы добавлять 1 к N) }
  begin {Открываем операторные скобки}
    write(i, ' '); {Выводим i}
    Inc(i);  {увеличиваем i на один.}
  end; { закрываем скобки }
end.

Repeat, или цикл с постусловием

Repeat  — полная противоположность while. Repeat — это цикл, в котором условие стоит после тела. Причем оно выполняется тогда и только тогда, когда результат условия false; как только логическое выражение становится true, выполнение цикла прекращается.

Repeat имеет формат:

repeat { повторяй … }
<оператор 1>;
< оператор 2>;
…
until {до…} <условие>

Begin и end не требуются.

Решение задачи.

program example_repeat;

var
  i, N: integer;{ объявляем переменные }

begin
  i := 1; { Присваиваем i значение 1 }
  readln(N); { Считываем последнее число }
  repeat {после repeat не требуется begin и end }
    write(i, ' '); {Выводим i}
    Inc(i);  {увеличиваем i на один.}
  until i = N + 1; {Например, i = 11, а N = 10. Цикл прекратится, так условие стало true.}
end.

For, или цикл с параметром

For — это  цикл, в котором тело выполняется заданное количество раз.

Существует две формы записи этого цикла:

Первая форма

for <счетчик1> := <значение1> to <конечное_значение> do <оператор1>;

После каждой итерации значение <счетчик1> будет увеличиваться на 1.

<значение1> — это начальное значение счетчика. Это может быть переменная или число.
<конечное_значение> : как только значение <счетчик1> станет больше <конечное_значение>, выполнение цикла прекратится.

Если требуется написать несколько операторов в теле цикла, используем begin и end.

И <счетчик1>, и <конечное_значение>, и <значение1> —  переменные целого типа.

Чаще всего в качестве счетчика используется переменная i.

Вторая форма

for <счетчик2> := <значение2> downto <конечное_значение> do <оператор1>;

После каждой итерации значение <счетчик2> будет уменьшатся на 1.

<значение2> — это начальное значение счетчика.
<конечное_значение> : как только значение <счетчик2> станет меньше <конечное_значение>, выполнение цикла прекратится.

Два важных примечания:

1. Цикл повторяется, пока значение значение счетчика лежит в отрезке [значение ; конечное_значение].
2. Изменять значение счетчика внутри тела нельзя!  Вот что выводит компилятор:

Решение задачи:

 
program example_for;

var
  i, N: integer;

begin
  read(N); {предположим, что мы ввели 10}
  for i := 1 to N do write(i, ' '); {количество итераций - 10 - 1 + 1 = 10}
end.

Согласитесь,  данный код проще и лаконичнее, чем все предыдущие. И цикл for — не совсем обычный цикл, в нем нет логического условия. Поэтому цикл с параметром в программировании называют синтаксическим сахаром. Синтаксический сахар — это дополнения синтаксиса языка программирования, которые не добавляют новых возможностей, а делают использование языка более удобным для человека.

Давайте решим пару задач.

For1. Даны целые числа K и N  (N > 0). Вывести N раз число K.

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

program for1;

var
  K, N, i: integer;

begin
  read(K, N);
  for i := 1 to N do write(K, ' '); {Пишем К через пробел }
end.

For2. Даны два целых числа A и B (A < B). Вывести в порядке возрастания все целые числа, расположенные между A и B (включая сами числа A и B), а также количество N этих чисел.

Так как A < B, то цикл должен будет выводить все числа от А до B. Чтобы сосчитать количество чисел, используем формулу: <конечное_значение> — <начальное_значение> + 1.

program for2;

var
  A, B, i, count: integer;

begin
  read(A, B);
  for i := A to B do write(i, ' '); {выписываем числа от меньшего к большему}
  count := B - A + 1; {считаем количество чисел}
  writeln;
  write( 'Количество чисел - ', count);
end.

For9. Даны два целых числа A и B (A < B). Найти сумму квадратов всех целых чисел от A до B включительно.

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

program for9;

var
  A, B, i, S: integer;

begin
  read(A, B);
  S := 0; {PascalABC делает это автоматически, но если у вас другой компилятор советуем обнулять переменные вручную}
  for i := A to B do S := S + Sqr(i);  {складываем все квадраты}
  writeln;
  write( 'Сумма квадратов - ', S);
end.

For13°. Дано целое число N (> 0). Найти значение выражения 1.1 – 1.2 + 1.3 – … (N слагаемых, знаки чередуются). Условный оператор не использовать.

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

program for13;

var
  N, A, i: integer;
  S: real;

begin
  Write('N = ');
  readln(N); 
  S := 1.1; 
  A := 1; {Сначала положительное}
  for i := 2 to N do {первую итерацию цикла мы уже произвели, поэтому начинаем отсчет с 2}
  begin 
   A := -A; {Теперь отрицательное}
   S := S + A * (1 + i / 10);  {Складываем}
  end;
  Writeln(S:5:1); {Отдадим под дробную часть одно знакоместо}
end.

While1°. Даны положительные числа A и B (A > B). На отрезке длины A размещено максимально возможное количество отрезков длины B (без наложений). Не используя операции умножения и деления, найти длину незанятой части отрезка A.

Каждый раз вычитаем B из А, пока А — В  >= 0.

program while1;

var
  A, B: integer;

begin
  readln(A, B);
  while (A - B) >=  0 do A := A - B; {Пока разница положительная, вычитаем. Необходимо предусмотреть вариант с кратностью А и B, поэтому >=}
  write(A);
end.

While4°. Дано целое число N (> 0). Если оно является степенью числа 3, то вывести True, если не является — вывести False.

Действуем следующим образом: пока N делится нацело на три, делим N нацело. Затем, если N = 1 — число является степенью тройки; если N <> 1, тогда число — не степень тройки. Для того чтобы решить эту задачу, требуется знать, что такое div и   mod,  и как работают логические выражения.

program while4;

var
  N: integer;

begin
  readln(N);
  while N mod 3 = 0 do N := N div 3; {Пока остаток от деления на три равен нулю, делим N нацело } 
  writeln(N = 1); {логическое выражение}
end.

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

Когда в алгоритме некоторое действие нужно выполнить несколько раз, используются циклы. В программирование цикл — это многократное повторение определенных инструкций. Циклы состоят из заголовка и тела. Заголовок содержит в себе условия, которые определяют работу цикла, а тело – повторяющиеся действия. В этом уроке рассмотрим:

• цикл со счетчиком (с параметром);
• цикл с предусловием;
• цикл с постусловием.
• вложенные циклы/a>.

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

1 For — цикл с параметром

Цикл с параметром, известный также как цикл со счетчиком, используется при известном количестве повторений. Он имеет две формы записи. В любом случае он выполняет следующий после него оператор (как правило, это составной оператор заключенный в «операторные скобки» Begin..End), каждый раз изменяя переменную цикла с шагом 1

For <счетчик>:=< начальное значение> To <конечное значение> Do <тело цикла>;

For <счетчик>:=<начальное значение> Downto <конечное значение> Do <тело цикла>;

Счетчик – это переменная порядкового типа. Начальное и конечное значение должны быть того же типа, что и счетчик. Тело выполняется до тех пор пока условие истинно.

Условия выполнения цикла проверяются перед выполнением блока операторов. Если переменная цикла больше максимального значения (при to) или меньше минимального (downto), то цикл FOR не выполняется.

Формы записи, представленные выше, отличаются словами To и Downto. Если Вы используете цикл с To, то значение счетчика с каждым шагом будет увеличиваться на единицу, а если с Downto, то уменьшаться. Из этого следует, что в первом варианте начальное значение не должно превышать конечное, во втором — верно противоположное. В программе ниже, указанное пользователем количество раз, будут выводиться символы.

program for_primer;
uses crt;
var i, x: integer;
begin
  write('X=');
  readln(x);
  for i:=1 to x do
    write('a');
readkey;
end.

Здесь тело цикла не заключено в Begin-End, так как оператор всего один. Но если их будет больше, то операторные скобки обязательны. Стоит также отметить, что счетчик по выходу из цикла не будет иметь определенного значения, но если цикл закончиться раньше положенного, то счетчик сохранит последнее, записанное в него значение.

Другой пример — вычисление суммы чисел от A до B:

Program Summa;
Var a, b, S: Integer;
Begin
  ClrScr;
  Write('a = ');
  Readln(a);
  Write('b = ');
  Readln(b);
  S:=0;
  For I:=a To b Do
    S:=S + I;
  Writeln ('Cумма = ', S);
  ReadLn
End. 

2 While – цикл с предусловием

Оператор While – начинает описание цикла с предусловием. Такой вид цикла нужен, в тех алгоритмах, где число повторений неизвестно заранее. В общем виде он выглядит так:

While <выражение> Do <тело цикла>;

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

Пример программы написанный с использованием цикла While:

program while_primer;
uses crt;
var i, x, limit: integer;
begin
  write('Предел=');
  readln(limit);
  write(' Числа Фибоначчи: ');
  i:=1; x:=1;
  while i<=limit do
  begin
    write(i,' ');
    i:=i+x;
    x:=i-x;
  end;
  readkey;
end.

В данном коде использовался составной оператор Begin-End, так как операторов в теле цикла несколько.

3 Repeat – цикл с постусловием

Главной особенностью цикла с постусловием (часто встречается название: цикл-ДО) является выполнение его тела минимум один раз. Это связано с тем, что условие записывается в конце и соответственно вначале выполнится тело, а затем провериться условие. Формально он выглядит так:

Repeat
  <тело цикла>
Until <условие>

В противоположность двум рассмотренным прежде циклам, этот прекращает свое выполнение тогда, когда условие становиться истинным, т. е. чтобы итерации продолжались условие должно быть ложно. Рассмотрим работу цикла с постусловием на примере:

program repeat_primer;
uses crt;
var i, otvet: integer;
begin
  i:=1;
  repeat
    i:=i+1;
    write(i,'+',i,'*2=');
    read(otvet);
  until otvet<>i+i*2;
  readkey;
end.

Программа продолжает работать до тех пор, пока пользователь не допустит ошибку в ответе. Думаю, Вы заметили, что в примере (непосредственно в цикле) составной оператор Begin-End, несмотря на количество операторов не поставлен. Просто его роль выполняют слова repeat и until.

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

• Goto – переходит в отмеченную область;
• Break – производит безусловный выход из цикла;
• Continue – осуществляет переход к новой итерации.

4 Вложенные циклы

Циклы в паскаль могут вкладываться друг в друга. Житейский пример: например, у нас есть список студентов, у каждого из которых есть оценки — если мы захотим перебрать все оценки для каждого студента то один цикл (внешний) будет перебираться студентов, а второй (вложенный) — оценки конкретного студента. Обрабатывать списки (массивы) мы научимся дальше.

Рассмотрим вложенные циклы на примере цикла с параметром:

For <счетчик 1>:=<начальное знач.> To <конечное знач.> Do <тело цикла 1>;
For <счетчик 2>:=<начальное знач.> To <конечное знач.> Do <тело цикла 2>;
…
For <счетчик n>:=<начальное знач.> To <конечное знач.> Do <тело цикла n>;

Вернувшись к терминологии, отметим, что в таких структурах одни циклы называются внешними, а другие внутренними. Так цикл 2 относительно цикла 1 является внутренним, а для цикла n он внешний.

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

Предположим у нас есть вложенные циклы for:

for i:=1 to m1 do
for j:=1 to m2 do
…
for k:=1 to mn do

Количество проходов по первому циклу = m1, второму = m2*m1, n-ому = mn*mn-1*mn-2*..*m2*m1. В качестве доказательства предлагаю разобраться в следующей программе.

program counter_performance;
uses crt;
var i, j, k, g, h: integer;
s_i, s_j, s_k, s_g, s_h: integer;
begin
  s_i:=0; s_j:=0; s_k:=0; s_g:=0; s_h:=0;
  for i:=1 to 5 do
  begin
    s_i:=s_i+1;
    for j:=1 to 3 do
    begin
      s_j:=s_j+1;
      for k:=1 to 19 do
      begin
        s_k:=s_k+1;
        for g:=1 to 10 do
        begin
          s_g:=s_g+1;
          for h:=1 to 6 do
            s_h:=s_h+1;
        end;
      end;
    end;
  end;
  write('i=',s_i,' j=',s_j,' k=',s_k,' g=',s_g,' h=',s_h);
  readkey;
end.

Имеются 5 циклов со счётчиками от i до h. В каждом из них при помощи переменных подсчитывается, сколько раз выполняется каждый цикл. Запустив программу на своем компьютере, Вы должны увидеть такой результат:

Результат работы вложенных циклов

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

program nested_loops;
uses crt;
var i, j: integer;
begin
  i:=1; j:=1;
  while i<20 do begin
    while j<i+1 do begin
      write('');
      j:=j+1;
    end;
    j:=1;
    i:=i+1;
    writeln;
  end;
  readkey;
end.

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

План урока:

Понятие циклического алгоритма

Программирование циклического алгоритма

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

Решение задач с использованием операторов while, repeat, for

Понятие циклического алгоритма

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

Циклические алгоритмы – это алгоритмы, в которых некоторая часть операций повторяется многократно.

Цикл – конструкция с оператором, который повторяется определённое или неопределённое заранее количество раз. Действия, выполняющиеся последовательно внутри цикла, называют телом цикла.

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

Циклы разделяют на три типа в зависимости от метода организации повторений:

• Цикл, в котором задано условие окончания работы;
• Когда известно условие продолжения работы цикла;
• Когда известно число повторений цикла.

Программирование циклического алгоритма

Выбрав среду программирования Паскаль необходимо познакомиться с операторами, с помощью которых можно разработать программу с циклом. Ими являются while, repeat, for. Оператор while был разобран ещё на прошлом уроке, однако забывать о нём нельзя.

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

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

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

Цикл с постусловием – это алгоритм циклической структуры, в котором проверка условия продолжения осуществляется после выполнения тела цикла.

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

Такие циклы удобны, когда в условии используется результат выполнения тела цикла. Например, если мы хотим найти в тексте слово «стоп», мы должны сначала прочитать очередное слово, и только потом проверить, является ли оно искомым или следует продолжить поиск.

 

Цикл с заданным числом повторений

Этот вид цикла вместо логического условия выполнения использует параметр (счетчик) – специальную переменную, которая на каждом шаге цикла получает очередное значение из определенного диапазона. Цикл повторяется до тех пор, пока не будут перебраны все элементы диапазона. Таким образом, определяя диапазон, мы определяем заранее заданное число повторений.

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

Для программирования циклических алгоритмов и корректного выполнения программ с их использованием, необходимо знать операторы цикла. Чаще всего, в языке Паскаль используют операторы цикла: for, repeat и while. Разберем их подробнее.

Оператор while

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

Если переводить его дословно, то можно сказать, что он работает по принципу «пока <условие> выполнять действие <оператор 1>», а заканчивается при переходе программы на слово end. Перед выполнением операторов внутри цикла условие обязательно проверяется и уже дальше, в зависимости от его истинности, программа либо выполняет тело цикла, либо переходит к последующим операторам.

Решение задач с использованием оператора while

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

Задача 1. На вход подаются целые числа. До тех пор, пока не будет введено число, которое больше 17, программа должна вывести сумму полученного числа и числа 8. Когда вводимое число будет больше 17, то после выполнения программы цикл завершается.

Решение.

Шаг 1. Для начала необходимо дать программе название.

Шаг 2. Учитывая, что на вход подаётся целое число, указать тип данных, в данном случае – integer.

Шаг 3. Запись командного блока. Нужно написать слово, обозначающее начало, begin.

Шаг 4. Нужно дать переменной a значение 1, чтобы цикл начался автоматически.

Шаг 5. Запись цикла. Поскольку известно условие окончания работы, для этой задачи необходимо написать «пока a меньше или равно 17» и сделать переход к последующим операторам путём написания составного цикла.

Шаг 6. Первоначальный вывод программы. Необходимо написать то, что программа будет выдавать в первую очередь. В данном случае, она будет запрашивать целое число, запрос так и пишется: «Введите целое число: » .

Шаг 7. Запись необходимых операторов. Используя оператор readln программа считывает данные и переводит курсор на новую строку. Далее она производит операции над поступившими данными.

Шаг 8. Запись суммы. Исходя из условия задачи необходимо сделать так, чтобы программа выводила сумму входящего числа и числа 8. Осуществить это можно используя оператор writeln.

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

Шаг 10. Проверка правильности записи алгоритма. В конце программного блока, после слова end нельзя забывать точку, её обязательно нужно поставить.

Оператор repeat

Оператор цикла repeat until используется для создания циклического алгоритма с постусловием. Его схема выглядит так:

Дословно оператор Паскаля repeat можно перевести как «повторяй <оператор 1>, до <условие>». В зависимости от истинности условия, либо происходит переход на повторение «оператора 1», либо осуществляется выход из цикла к последующим операторам.

Оператор repeat имеет два важных отличия от оператора while:

• в операторе repeat сначала выполняется тело, а затем проверяется условие;
• в операторе repeat прописывается условие завершения цикла, тогда как в операторе while – условие его продолжения.

Решение задач с использованием оператора repeat

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

Решение.

Шаг 1. Название программы. В данном случае – «задача 1».

Шаг 2. Учитывая, что на вход подаются целые числа, требуется указать тип данных – integer.

Шаг 3. Командный блок. Запись начального слова begin.

Шаг 4. Вывод запроса программы. Поскольку программе необходимо целое число, нужно попросить пользователя ввести его. Осуществляется это с помощью процедуры writeln и текста «Введите целое число, которое больше 1: ».

Шаг 5. Необходимо присвоить переменной i значение 1 для того, чтобы последовательность начиналась с натурального числа.

Шаг 6. Запись цикла. Учитывая, что используется цикл с постусловием, необходимо сначала записать оператор, который будет повторяться, затем увеличить i на 1, чтобы образовывалась последовательность, и уже после этого прописать условие повторения. В данной задаче цикл перестаёт повторяться тогда, когда переменная i принимает значение больше введённого числа, которое является последним членом последовательности.

Шаг 7. Проверка программы на правильность в выводе. В результате своей работы программа должна вывести последовательность натуральных чисел от 1 до n, через пробел.

Оператор for

Используя оператор for можно задать нужное количество повторений одних и тех же действий. По-другому его называют оператором циклов с известным числом повторений. Он имеет два соединительных слова – это to и downto. Различие между ними в том, что при использовании первого к предыдущему значению переменной цикла прибавляется единица, а при написании второго – вычитается единица. Схемы оператора имеют следующий вид:

Дословно его можно перевести как «для переменной в значении от начального к конечному выполнять <оператор 1> ».

Решение задач с использованием оператора for

Рассмотреть пример с оператором for можно при написании короткого алгоритма для следующей задачи.

Задача 1. Напишите на одном из языков программирование алгоритм, который выводит квадраты чисел от 1 до 10.

Решение.

Шаг 1. Необходимо дать программе название.

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

Шаг 3. Запись блока с командами алгоритма.

Шаг 4. Перебор последовательности чисел осуществляется в цикле for, в котором счетчик i пробегает значения от 1 до 10, а расчет и вывод квадратов осуществляется в процедуре write.

Решение задач с использованием операторов while, repeat, for

Задача 1 Разработать алгоритм программы, которая выведет таблицу умножения чисел от 1 до 10 на 9.

Решение

Для решения можно написать два вида кода. Однако, этапы разработки программы, задачи, которые ей необходимо выполнить, очень похожи на прошлые примеры, и она ничем не отличается от решения обычной задачи. Поскольку различие в этих двух кодах лишь в использованном операторе while и for, то рассматривать их по-отдельности нет смысла. Последовательность написания первого кода выглядит так:

Шаг 1. Нужно назвать программу.

Шаг 2. Так как пользователь не вводит никаких данных, то их можно ввести в сам код программы. Тип используемых данных в данном случае – это integer.

Шаг 3. Написание команд. Изначально нужно сделать так, чтобы программа вывела название того, для чего она предназначена. В данной задаче это «Таблица умножения на 9».

Шаг 4. Запись цикла for. С помощью него программа будет последовательно умножать числа от 1 до 10 на 9 и составлять таблицу умножения путём вывода каждого значения по схеме «9x, i, =, p», где i – умножаемое на 9 число, p – результат произведения 9 и i.

Шаг 6. Программа завершает свою работу. Необходимо проверить правильность выведенных данных и, если это необходимо, поправить код для более корректной работы.

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

• оператор цикла с предварительным условием;
• оператор цикла с последующим условием;
• оператор цикла с параметром.

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

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

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

Оператор цикла с предварительным условием While имеет следующий формат:

  While <выражение> do <оператор>; 

 где

 While (пока), do (делать) – зарезервированные слова;
выражение– выражение логического типа;
оператор– произвольный оператор.

Оператор цикла действует следующим образом. Предварительно, до начала цикла, (отсюда и название «Оператор цикла с предварительным условием») проверяется логическое выражение. Если выражение имеет значение True(истина), то выполняются операторы циклической части (тело цикла), после чего снова проверяется логическое выражение. Пока выражение имеет значение True(истина) выполняются операторы циклической части. Как только оно становиться ложным – False, происходит выход из цикла. Если с самого начала значение логического выражения ложно (False), то операторы циклической части не выполняются ни разу.

Блок-схема оператора цикла с предварительным условием:

ЗАДАЧА 1. Вычислить сумму целых чисел от 0 до 99.

Program a10;
var
i:integer; {количество чисел}
s:integer; {сумма чисел}
begin
i:=1; s:=0;
while i<99> do
begin
s:=s+i;
i:=i+1;
end; {после выхода из цикла i = 99}
i:=i-1; {поэтому уменьшаем на 1}
writeln('Cумма',i:4, ' чисел равна:', s:6);
end.

Результаты работы программы:

 Cумма 98 чисел равна: 4851 

ЗАДАЧА 2. Вычислить сумму нечетных целых чисел от 0 до 99.

Program a11;
var
i:integer; {нечётное число}
s:integer; {сумма чисел}
begin
i:=1; s:=0;
while i<99> do
begin
s:=s+i;
i:=i+2;
end;
i:=i-2;
writeln('Сумма нечетных чисел равна:', s:6);
end.

Результаты работы программы:

 Cумма нечетных чисел равна: 2401 

Пример.

program example1;
var
ch:char;
begin
Write('Продолжить вычисления (Y/N)?');
ch:=' ';
while(UpCase(ch)<>'Y') and (UpCase(ch)<>'N')do
ch:=Readkey;
end.

Примечание:

• Функция UpCase () преобразует символ в верхний регистр.
• Функция Readkey () считывает символ с клавиатуры.

Оператор цикла с последующим условием Repeat

Формат оператора:

 Repeat
операторы циклической 
 части программы 
 Until логическое выражение 

Здесь Repeat (повторять), Until (до тех пор) – зарезервированные слова языка.

Блок-схема оператора цикла с последующим условием:

Оператор цикла с последующим условием Repeat работает следующим образом.

Операторы циклической части повторяются, по крайней мере, один раз до тех пор, пока значение логического выражения ложно (False). Условием прекращения циклических вычислений является истинное (True) значение логического выражения.

Итак, сначала выполняется циклическая часть, а затем проверяется условие. При этом нижняя граница операторов циклической части обозначена словом Until, поэтому нет необходимости заключать операторы циклической части в операторные скобки Begin…End.

ЗАДАЧА 3. Вычислить сумму нечетных целых чисел от 0 до 99 (см. Задачу 2).

Program a12;
Var
i:integer; {нечётное число}
s:integer; {сумма чисел}
Begin
i:=1; s:=0;
Repeat
s:=s+i;
i:=i+2;
Until i=99;
i:=i-2;
writeln('сумма нечетных чисел',' равна:', s:6);
End.

Результаты работы программы:

 Сумма нечетных чисел равна: 2401 

ЗАДАЧА 4. Написать программу, которая выводит таблицу квадратов первых пяти целых положительных нечетных чисел

Program a13;
var
x:integer; {число}
y:integer; {квадрат числа}
begin
writeln('Таблица квадратов');
writeln('==================');
writeln('Число квадрат');
writeln('-------------------');
x:=1;
repeat
y:=x*x;
writeln(x:4,y:6);
x:=x+2;
until x=11;
writeln('-------------------');
End.

Результаты работы программы:

 Таблица квадратов 
 ================== 
 Число   квадрат 
 —————— 
     1       1      
     3       9      
     5       25     
     7       49     
     9       81     
 —————— 

 Оператор цикла с параметром For

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

Формат оператора

 For i:=m1 to m2 Do
begin 
 операторы циклической 
 части программы 
 end; 

здесь For (для), to (до), Do (делать) – зарезервированные слова языка;

 i – параметр цикла;

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

В операторе цикла For начальное m1 и конечное значение m2 параметра цикла i должны быть заданы. Параметр цикла i увеличивается/уменьшается автоматически.

Если i=1 и m1>m2, то циклическая часть не выполняется ни разу.

После естественного завершения работы оператора цикла (выход из цикла) значение параметра цикла i не определено.

Если параметр цикла увеличивается, то его шаг равен +1.

Если параметр цикла должен уменьшаться, то в этом случае m1 должно быть больше m2, а вместо служебного слова TO необходимо поставить DOWNTO. Шаг уменьшения равен –1.

ЗАДАЧА 5. Напечатать все буквы латинского алфавита.

Programa14;
var
ch:char;
begin
writeln('Латинский алфавит:');
for ch:='A' to 'Z' do
write(' ',ch);
end.

Результаты работы программы:

 Латинский алфавит: 

 ABCDEFGHIJKLMNOPQRSTUVWXYZ 

ЗАДАЧА 6. Написать программу, которая выводит таблицу квадратов первых десяти целых положительных чисел.

program a15.
var
x:integer; {число}
y:integer; {квадрат числа}
i:integer; {параметр цикла}
begin
writeln('Таблица квадратов');
writeln('=================');
writeln('Число квадрат');
writeln('-----------------');
x:=1;
for i:= 1 to 10 do
begin
y:=x*x;
writeln(x:4,y:6);
x:=x+1;
{лучше так!}
{y:=i*i;}
{writeln(i:4,y:6);}
end;
writeln('-----------------');
end.

Результат работы программы:

 Таблица квадратов 
 ================== 
 Число   квадрат 
 —————— 
     1       1      
     2       4      
     3       9      
     4       16     
     5       25     
     6       36     
     7       49     
     8       64     
     9       81     
    10       100    
 ——————