Работа цикла с постусловием
Помимо выбора того или иного действия, часто в программах приходится выполнять какие-то повторяющиеся действия, причем они должны выполняться до тех пор, пока не будет достигнуто какое-то условие, достигнув которого программа прекращается повторять эти действия. Это как раз пресловутый цикл.
Это тема, равно как и тема об операторах выбора очень легкая. Вам важно просто понять, что и как применять. Давайте рассмотрим цикл с точки зрения человека.
Итак, вы наверняка следите за своей физической формой и делаете по утрам хотя бы отжимания от пола. Ваш алгоритм действий примерно такой: вы принимаете упор лежа, отжались раз, распрямили руки и вновь отжались. И так пока вы либо не устанете, либо не выполните поставленное условие (мне надо отжаться сегодня 100 раз!). Как видите, сам процесс отжимания это не более чем обычный повтор одних и тех же действий, т.е. тот же по сути цикл. Надеюсь, вы поняли суть. Если нет, то ниже мы уже разберем цикл на примерах. Для тех, кто лучше усваивает визуальную информацию, можете посмотреть мой урок по с++ 6. В нем я также приводил блок-схемы циклов.
В C# циклы делятся на четыре группы: цикл с предусловием, цикл с постусловием, параметризованный цикл и так называемый цикл Для каждого (foreach). Давайте рассмотрим их на нашем примере с отжиманием.
Традиционно легким для изучения считаются циклы с пре и пост условиями. Их синтаксис такой:
а) Цикл с предусловием:
while (условие)
действие;
б)Цикл с постусловием
do
{
Действие;
}
while (условие выхода из цикла);
Обратите внимание на то, что в пункте а я указал всего одно действие. Их может быть много, тогда после скобок с условием ставятся операторные скобки {} (правило то же, что и в if). Тоже самое относится и к остальным циклам (исключение цикл с постусловием, так как там уже есть операторные скобки)
while (условие)
{Действие1;
Действие2;
}
А теперь давайте рассмотрим, как работают эти циклы.
Итак, опишем наш алгоритм с помощью цикла с предусловием. Допустим, что вы собрались отжаться 30 раз. Тогда наш алгоритм будет выглядеть так:
int КоличествоОтжиманий=0; //пока мы не отжимались while (КоличествоОтжиманий<30){ КоличествоОтжиманий++; }
Как видите, все предельно просто. Я ввел счетчик КоличествоОтжиманий, который потом уже использовал в качестве проверки условия. В теле цикла я уже приращивал этот счетчик на единицу. Как только у меня КоличествоОтжиманий сравнялось 30, цикл прекращает свою работу.
Хорошо, а как же тогда работает цикл с постусловием. Представьте себе «спортсмена», для которого эти самые отжимания в тягость. Он делает отжимание и с надеждой вслушивается в голос тренера, который ему сообщает сколько он сделал. И тогда этот спортсмен обреченно делает эти отжимания до тех пор, пока не будет выполнена поставленная норма. Конечно, я несколько утрирую, но просто в памяти вскочил армейский эпизод :).
int КоличествоОтжиманий=0; //пока мы не отжимались do { КоличествоОтжиманий++; } while (КоличествоОтжиманий<30)
Обратили внимание на тот факт, что этот цикл выполнится хотя бы один раз? В этом и есть самое главное различие. Представьте себе, когда тренер говорит своему подопечному, чтобы тот отжался 30 раз. Если спортсмен делал это уже, то он его просто пошлет куда подальше:
int КоличествоОтжиманий=30; //Этот цикл уже никогда не выполнится while (КоличествоОтжиманий<=30) { КоличествоОтжиманий++; }
А в случае цикла с постусловием спортсмену придется еще раз отжаться, чтобы сообразить, что он уже делал эти пресловутые 30 отжиманий.
Не забывайте, что выходом из цикла является условие. Если оно истина, то выходим, ложь – продолжаем дальше. Поэтому мы можем написать такой код для спортсмена, который любит отжиматься до упаду.
bool Устал=false; string Ответ; int КоличествоОтжиманий=0; while (!Устал) { КоличествоОтжиманий++; Console.WriteLine (“Вы устали? (да/нет)”); Ответ=Console.ReadLine (); Ответ=Ответ.ToLower().Trim (); //уберем пробелы и сделаем текст строчным if (Ответ.Equals(“да”)) Устал=true; } Console.WriteLine (“Вы сделали всего {0} отжиманий”, КоличествоОтжиманий);
Пробежитесь мысленно по коду. Думаю, что здесь для вас все ясно. Единственное, на что стоит обратить внимание – в последней строчке кода в методе WriteLine я написал непонятную для вас {0}. Дело в том, что этот метод умеет форматировать вывод, а нам нужно, чтобы наш счетчик плавно вписался в текст. Поставив {0}, я указал, что в этом месте будет наш счетчик. 0 обозначает порядок вывода переменных. Если бы я указал после запятой несколько переменных, то другие бы в тексте были бы помечены как {1}, {2} и т.д. Более подробно мы рассмотрим это с вами, когда будем изучать классы и методы, а это уже совсем скоро.
В циклах часто бывают ситуации, когда мы точно не знаем, где будет точка выхода. Например, предыдущий код можно отнести к подобному. В случае такого цикла нужно использовать оператор прерывания цикла break. Встретив этот оператор, C# сразу же покинет тело цикла. В случае нашего верхнего кода можно было бы не присваивать переменной Устал значение true, а написать так:
if (Ответ.Equals(“да”)) break;
Все, цикл прервался. Это очень часто используемый в циклах оператор, так что имейте это в виду. У него есть брат continue, о котором мы поговорим в следующем уроке.
А пока на этом все. Отдыхайте и готовьтесь к следующему уроку.
<<Предыдущий урок Следующий урок>>
Источник
Рассмотрим третью алгоритмическую структуру – цикл.
Циклом называется блок кода, который для решения задачи требуется повторить несколько раз.
Каждый цикл состоит из
- блока проверки условия повторения цикла
- тела цикла
Цикл выполняется до тех пор, пока блок проверки условия возвращает истинное значение.
Тело цикла содержит последовательность операций, которая выполняется в случае истинного условия повторения цикла. После выполнения последней операции тела цикла снова выполняется операция проверки условия повторения цикла. Если это условие не выполняется, то будет выполнена операция, стоящая непосредственно после цикла в коде программы.
В языке Си следующие виды циклов:
- while – цикл с предусловием;
- do…while – цикл с постусловием;
- for – параметрический цикл (цикл с заданным числом повторений).
Цикл с предусловием while
Общая форма записи
while (Условие)
{
БлокОпераций;
}
Если Условие выполняется (выражение, проверяющее Условие, не равно нулю), то выполняется БлокОпераций, заключенный в фигурные скобки, затем Условие проверяется снова.
Последовательность действий, состоящая из проверки Условия и выполнения БлокаОпераций, повторяется до тех пор, пока выражение, проверяющее Условие, не станет ложным (равным нулю). При этом происходит выход из цикла, и производится выполнение операции, стоящей после оператора цикла.
Пример на Си: Посчитать сумму чисел от 1 до введенного k
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include <stdio.h>
int main() {
int k; // объявляем целую переменную key
int i = 1;
int sum = 0; // начальное значение суммы равно 0
f(“k = “);
scanf(“%d”, &k); // вводим значение переменной k
while (i <= k) // пока i меньше или равно k
{
sum = sum + i; // добавляем значение i к сумме
i++; // увеличиваем i на 1
}
f(“sum = %dn”, sum); // вывод значения суммы
getchar(); getchar();
return 0;
}
Результат выполнения
При построении цикла while, в него необходимо включить конструкции, изменяющие величину проверяемого выражения так, чтобы в конце концов оно стало ложным (равным нулю). Иначе выполнение цикла будет осуществляться бесконечно (бесконечный цикл).
Пример бесконечного цикла
1
2
3
4
while (1)
{
БлокОпераций;
}
while – цикл с предусловием, поэтому вполне возможно, что тело цикла не будет выполнено ни разу если в момент первой проверки проверяемое условие окажется ложным.
Например, если в приведенном выше коде программы ввести k=-1, то получим результат
Цикл с постусловием do…while
Общая форма записи
do {
БлокОпераций;
} while (Условие);
Цикл do…while – это цикл с постусловием, где истинность выражения, проверяющего Условие проверяется после выполнения Блока Операций, заключенного в фигурные скобки. Тело цикла выполняется до тех пор, пока выражение, проверяющее Условие, не станет ложным, то есть тело цикла с постусловием выполнится хотя бы один раз.
Использовать цикл do…while лучше в тех случаях, когда должна быть выполнена хотя бы одна итерация, либо когда инициализация объектов, участвующих в проверке условия, происходит внутри тела цикла.
Пример на Си. Проверка, что пользователь ввел число от 0 до 10
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include <stdio.h>
#include <stdlib.h> // для использования функции system()
int main() {
int num; // объявляем целую переменную для числа
system(“chcp 1251”); // переходим на русский язык в консоли
system(“cls”); // очищаем экран
do {
f(“Введите число от 0 до 10: “); // приглашение пользователю
scanf(“%d”, &num); // ввод числа
} while ((num < 0) || (num > 10)); // повторяем цикл пока num<0 или num>10
f(“Вы ввели число %d”, num); // выводим введенное значение num – от 0 до 10
getchar(); getchar();
return 0;
}
Результат выполнения:
Параметрический цикл for
Общая форма записи
for (Инициализация; Условие; Модификация)
{
БлокОпераций;
}
for – параметрический цикл (цикл с фиксированным числом повторений). Для организации такого цикла необходимо осуществить три операции:
- Инициализация – присваивание параметру цикла начального значения;
- Условие – проверка условия повторения цикла, чаще всего – сравнение величины параметра с некоторым граничным значением;
- Модификация – изменение значения параметра для следующего прохождения тела цикла.
Эти три операции записываются в скобках и разделяются точкой с запятой ;;. Как правило, параметром цикла является целочисленная переменная.
Инициализация параметра осуществляется только один раз – когда цикл for начинает выполняться.
Проверка Условия повторения цикла осуществляется перед каждым возможным выполнением тела цикла. Когда выражение, проверяющее Условие становится ложным (равным нулю), цикл завершается. Модификация параметра осуществляется в конце каждого выполнения тела цикла. Параметр может как увеличиваться, так и уменьшаться.
Пример на Си: Посчитать сумму чисел от 1 до введенного k
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include <stdio.h>
int main() {
int k; // объявляем целую переменную key
int sum = 0; // начальное значение суммы равно 0
f(“k = “);
scanf(“%d”, &k); // вводим значение переменной k
for(int i=1; i<=k; i++) // цикл для переменной i от 1 до k с шагом 1
{
sum = sum + i; // добавляем значение i к сумме
}
f(“sum = %dn”, sum); // вывод значения суммы
getchar(); getchar();
return 0;
}
Результат выполнения
В записи цикла for можно опустить одно или несколько выражений, но нельзя опускать точку с запятой, разделяющие три составляющие цикла.
Код предыдущего примера можно представить в виде
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include <stdio.h>
int main() {
int k; // объявляем целую переменную key
int sum = 0; // начальное значение суммы равно 0
f(“k = “);
scanf(“%d”, &k); // вводим значение переменной k
int i=1;
for(; i<=k; i++) // цикл для переменной i от 1 до k с шагом 1
{
sum = sum + i; // добавляем значение i к сумме
}
f(“sum = %dn”, sum); // вывод значения суммы
getchar(); getchar();
return 0;
}
Параметры, находящиеся в выражениях в заголовке цикла можно изменить при выполнении операции в теле цикла, например
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include <stdio.h>
int main() {
int k; // объявляем целую переменную key
int sum = 0; // начальное значение суммы равно 0
f(“k = “);
scanf(“%d”, &k); // вводим значение переменной k
for(int i=1; i<=k; ) // цикл для переменной i от 1 до k с шагом 1
{
sum = sum + i; // добавляем значение i к сумме
i++; // добавляем 1 к значению i
}
f(“sum = %dn”, sum); // вывод значения суммы
getchar(); getchar();
return 0;
}
В цикле for может использоваться операция запятая – , – для разделения нескольких выражений. Это позволяет включить в спецификацию цикла несколько инициализирующих или корректирующих выражений. Выражения, к которым применяется операция запятая, будут вычисляться слева направо.
Пример на Си:
1
2
3
4
5
6
7
8
9
10
11
12
13
#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include <stdio.h>
int main() {
int k; // объявляем целую переменную key
f(“k = “);
scanf(“%d”, &k); // вводим значение переменной k
for(int i=1, j=2; i<=k; i++, j+=2) // цикл для переменных
{ // (i от 1 до k с шагом 1) и (j от 2 с шагом 2)
f(“i = %d j = %dn”, i, j); // выводим значения i и j
}
getchar(); getchar();
return 0;
}
Результат выполнения
Вложенные циклы
В Си допускаются вложенные циклы, то есть когда один цикл находится внутри другого:
for (i = 0; i<n; i++) // внешний цикл – Цикл1
{
for (j = 0; j<n; j++) // вложенный цикл – Цикл2
{
; // блок операций Цикла2
}
// блок операций Цикла1;
}
Пример: Вывести числа от 0 до 99, по 10 в каждой строке
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include <stdio.h>
int main() {
for(int i=0; i<10; i++) // цикл для десятков
{
for (int j = 0; j < 10; j++) // цикл для единиц
{
f(“%2d “, i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел
}
f(“n”); // во внешнем цикле переводим строку
}
getchar(); // scanf() не использовался,
return 0; // поэтому консоль можно удержать одним вызовом getchar()
}
Результат выполнения
Рекомендации по выбору цикла
При выборе цикла необходимо оценить необходимость проверки условия при входе в цикл или по завершении прохождения цикла.
Цикл с постусловием удобно применять в случаях, когда для проверки условия требуется вычислить значение выражения, которое затем будет размещено в теле цикла (см. выше пример ввода числа от 0 до 10).
Цикл c предусловием используется в случае если все переменные, участвующие в выражении, проверяющем условие, проинициализированы заранее, но точное число повторений цикла неизвестно или предполагается сложная модификация переменных, участвующих в формировании условия повторения цикла.
Если цикл ориентирован на работу с параметром, для которого заранее известно число повторений и шаг изменения, то более предпочтительным является параметрический цикл. Очень удобно использовать параметрический цикл при работе с массивами для перебора элементов.
Операторы прерывания и продолжения цикла break и continue
В теле любого цикла можно использовать операторы прерывания цикла – break и продолжения цикла – continue.
Оператор break позволяет выйти из цикла, не завершая его.
Оператор continue позволяет пропустить часть операторов тела цикла и начать новую итерацию.
Пример на Си: Вывести числа от 0 до 99 ниже главной диагонали
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include <stdio.h>
int main() {
for(int i=0; i<10; i++) // цикл для десятков
{
for (int j = 0; j < 10; j++) // цикл для единиц
{
if (j > i) // если число единиц больше числа десятков в числе
break; // выходим из вложенного цикла и переходим к новой строке
f(“%2d “, i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел
}
f(“n”); // во внешнем цикле переводим строку
}
getchar(); // scanf() не использовался,
return 0; // поэтому консоль можно удержать одним вызовом getchar()
}
Результат выполнения
Пример на Си: Вывести числа от 0 до 99 исключая числа, оканчивающиеся на 5 или 8
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include <stdio.h>
int main() {
for(int i=0; i<10; i++) // цикл для десятков
{
for (int j = 0; j < 10; j++) // цикл для единиц
{
if ((j == 5) || (j == 8)) // если число единиц в числе равно 5 или 8,
continue; // переходим к следующей итерации цикла
f(“%2d “, i * 10 + j); // выводим вычисленное число (2 знакоместа) и пробел
}
f(“n”); // во внешнем цикле переводим строку
}
getchar(); // scanf() не использовался,
return 0; // поэтому консоль можно удержать одним вызовом getchar()
}
Результат выполнения
При вложенных циклах действия операторов break и continue распространяется только на самую внутреннюю структуру, в которой они содержатся.
Оператор безусловного перехода goto
Общая форма записи
goto Метка;
. . .
Метка : Операция;
Выполнение оператора goto вызывает передачу управления в программе операции, помеченной Меткой. По сути Метка является идентификатором адреса операции, которой должно быть передано управление. Для отделения Метки от Операции используется двоеточие – :.
Метка может располагаться в программе как до оператора goto, так и после него. Имена Меток образуются по тем же правилам, что и имена переменных.
Пример на Си: Вывести все целые числа от 5 до 0.
1
2
3
4
5
6
7
8
9
10
11
12
#define _CRT_SECURE_NO_WARNINGS // для возможности использования scanf
#include <stdio.h>
int main() {
int k = 5;
M1: if (k < 0) // если k<0,
goto M2; // переходим на метку M2 (выходим из программы)
f(“%d “, k); // выводим значение k
k–; // уменьшаем k на 1
goto M1; // переходим на метку M1 (повторяем операции выше)
M2: getchar();
return 0;
}
Результат выполнения
Использование оператора goto в программах на Си без крайней необходимости не рекомендуется, поскольку это может повлечь за собой ряд ошибок, связанных с плохой читаемостью кода программы. Использование операторов цикла позволяет практически полностью исключить необходимость использования оператора goto.
Назад: Язык Си
Источник
На занятии рассматривается цикл с постусловием в Паскаль Repeat и происходит знакомство со строковым типом данных
Основной задачей портала labs-org.ru является предоставление возможности получения навыков решения практических задач с использованием языка программирования Pascal. На основе решенных примеров и заданий по Паскалю, изложенных по мере увеличения их сложности, даже новичкам будет достаточно просто усвоить предоставленный материал.
Цикл с постусловием в Паскаль (repeat)
Пример: Ввести целое положительное число (n) и определить четное ли оно.
Проблема 1: Как избежать ввода отрицательного числа или нуля?
Решение 1: Если вводится неверное число, то нужно вернуться назад к вводу данных (цикл).
Проблема 2: Неизвестно, сколько шагов надо сделать.
Решение 2: Надо остановиться, когда n > 0, т.е. надо делать «до тех пор пока n не станет больше0».
- Один раз тело цикла надо сделать в любом случае => проверку условия цикла надо делать в конце цикла (цикл с постусловием)!.
- Цикл Repeat в Паскале используется для организации повторений (итераций) с заранее неизвестным их числом.
- Цикл повторяется до тех пор, пока не станет истинным некоторое условие.
repeat оператор1; оператор2; . . .; операторN until условие {до тех пор, пока условие не станет истинным}
Блок-схема решения примера:
Блок-схема решения примера
Решение на Паскале:
- Операторы образуют тело цикла и будут выполняться до тех пор, пока значение “условие” не станет равно true, т.е. не станет истинным.
- Условием может быть переменная или логическое выражение.
- Проверка условия осуществляется уже после первого прохождения операторов тела структуры, т.е. после первой итерации, т.о. цикл с постусловием в Паскаль обязательно выполнится хотя бы один раз, независимо от истинности условия.
Еще одно использование цикла Repeat рассмотрим на примере с решением.
Пример: Печатать «ноль» указанное количество раз
Показать решение:
| 1 2 3 4 5 6 7 8 9 10 | var i,n:integer; begin write (‘kolichestvo raz’); readln(n); i:=1; repeat write(0); i:=i+1 until i>n end. |
В решенной задаче оператор 8-й строки – это счетчик (i:=i+1), который просчитывает количество раз и одновременно является условием для выхода из цикла.
Задача 1. Написать программу решения задачи о печати чисел 3 5 7 9 11 13. Для решения задачи использовать цикл Repeat
Узнать о работе оператора с постусловием в Паскале можно также из видеоурока:
Строковый тип данных в Паскаль
Для решения следующей задачи нам пригодится работа со строковым типом данных.
Рассмотрим как объявляются строки в Паскале:
Объявление строковой переменной:
Присваивание значения строковой переменной:
str:=’вот такая вот строка’;
Пример использования строковых переменных в Паскале
| 1 2 3 4 5 6 7 | var str1,str2: string; begin str1:=’Привет, ‘; writeln(‘Ваше имя?’); readln(str2); writeln(str1,str2) end. |
Теперь снова возвращаемся к нашему циклу repeat.
Задача 2. Компьютер предлагает человеку ввести слово, после чего распечатывает это слово, снабдив его восклицательным знаком. Затем снова предлагает ввести слово и так до тех пор, пока человек не введет слово «Хватит». Распечатав его с восклицательным знаком, компьютер отвечает: «Хватит так хватит» и заканчивает работу. Для решения задачи использовать цикл с постусловием в Паскаль.
Дополнительно: Перед выводом каждого слова необходимо выводить его порядковый номер.
Источник