Циклы C#: создание и управление циклами, циклы с пред и постусловиями
уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.
Циклы — это конструкции языка программирования, которые позволяют выполнять определенный блок кода до тех пор, пока выполняется определенное условие. В C# существуют четыре вида циклов — for , foreach , while и do while . Например, трудно себе представить програму, которая ищет все простые числа от 0 до 9999 и, при этом не использует в своей работе циклы. Рассмотрим какие бывают и как работают эти циклы в C#.
Цикл for
Конструкция цикла for следующая:
for (инициализация ; условие; порядок выполнения)
- инициализация — начальное значение счётчика;
- условие — пока условие выдает true цикл будет выполняться;
- порядок выполнения — команда, которая должна наращивать счётчик.
Раз уж речь в начале зашла про простые числа, то и рассмотрим пример их поиска с использованием циклов. С использованием цикла for поиск простого числа можно организовать, например вот так:
using System; namespace Prime < class Program < static bool IsPrime(int number) < for (int i = 2; i < number; i++) < if (number % i == 0) return false; >return true; > static void Main(string[] args) < Console.WriteLine("Введите любое целое положительное число: "); Console.WriteLine(IsPrime(int.Parse(Console.ReadLine())) ? "Простое число" : "Не простое число"); >> > Рассмотрим основные моменты нашей программы. Начнем с метода IsPrime() — именно в нем происходит проверка числа с использованием цикла for . Этот метод в качестве аргумента принимает целое число, а результатом является логический тип bool : true , если число является простым и false — в противоположном случае. Внутри цикла мы проверяем остаток от деления числа на значение счётчика. Чтобы было понятно, как будет работать наша программа с циклом, распишем все действия метода по шагам, на примере числа 5:
- Шаг 1: инициализируем переменную счётчика, присвоив i значение 2.
- Шаг 2: проверяем истинность условия выхода ( i
- Шаг 3: проверяем остаток от деления 5 на текущее значение счётчика. Остаток больше нуля, поэтому условие if не выполняется и программа попробует перейти к следующему шагу цикла. Если условие if выполняется, то срабатывает оператор return, который возвращает нас из метода IsPrime() в основную программу с результатом метода равным true .
- Шаг 4: наращиваем счётчик на 1 (выражение i++ в цикле).
- Возвращаемся на шаг 2. Если i больше заданного числа, то выходим из цикла и функция вернет true так как все возможные значения делителей были просмотрены и при всех значениях остаток от деления был больше нуля. Если же условие выхода из цикла не выполняется, то переходим на шаг 3.
Таким образом, для числа 5 наш цикл будет состоять из трех итераций ( i = 1, 2, 3 ), а так как 5 — это простое число, то мы дойдем до оператора return в последней строке метода. Вот так работает цикл и сам метод IsPrime() .
Теперь посмотрим вот эту строку в методе Main() :
Console.WriteLine(IsPrime(int.Parse(Console.ReadLine())) ? "Простое число" : "Не простое число");
Здесь мы воспользовались нашим методом, а также тернарной операцией для вывода итогов проверки числа. Таким образом, всего в одной простенькой программке мы смогли применить практически все, что узнали о C# до этого момента: посмотрели как работает цикл for , в цикле использовали арифметический оператор — остаток от деления в логической операции if и, в заключении, использовали тернарную операцию для вывода результата в консоль.
Возвращаясь к теме цикла for так же стоит отметить следующую его особенность инициализация ; условие; порядок выполнения могут отсутствовать и добавляются по желанию.
Например, в C# можно создать бесконечный цикл for :
Есть и другие особенности этого цикла, например, использование запятых в инициализации и порядке выполнения , но это всё уже тонкости программирования, которые нам пока не потребуются для дальнейшего изучения языка C#.
Цикл while
Цикл while выполняется до тех пор пока условие возвращает истину ( true ).
Вернемся к нашим простым числам. Например, нам необходимо найти все простые числа в заданном диапазоне. Конечно, мы бы могли без проблем воспользоваться тем же самым циклом for , но для разнообразия рассмотрим пример с использованием while :
int max = 4000; int i = 0; while (i i++; >
Наш цикл while будет выполняться до тех пор, пока значение i не станет больше переменной max . То есть, в примере — это значение 4000 .
Цикл do…while
Конструкция цикла do..while :
Думаю, не стоит повторять, что значит условие или действие в описании конструкции цикла. Стоит лишь только добавить, что этот цикл выполниться хотя бы один раз минимум, тогда как предыдущий цикл while может не выполниться не разу, если будет задано заведомо ложное условие.
Цикл foreach
Конструкция цикла foreach :
foreach (тип переменная in набор данных)
Здесь стоит кое-что пояснить. В описании конструкции цикла грамматической ошибки нет, то есть в цикле используется тип данных переменной, и переменная через которую мы будем получать доступ к очередному значению в наборе данных. При этом, в качестве набора данных могут выступать массивы, списки и так далее. Забегая немного вперед, покажу как воспользоваться циклом foreach для поиска простых чисел в массиве:
int[] array = < 1, 3, 7, 9, 12, 134, 145, 1345, 3456, 76, 56, 89, 123, 11 >; foreach (int value in array) < Console.WriteLine(IsPrime(value) ? $"простое" : $" непростое"); >
Как видите, в цикле мы указали тип данных (целое число int ), переменную ( value ) и набор данных — массив с именем array . Цикл foreach последовательно перебирает все элементы массива и выводит результат проверки в консоль.
Управление циклами в C#
Управлять циклами в C# возможно с использованием двух операторов перехода:
- continue — прерывает текущую итерацию цикла и переходит к следующей;
- break — полностью прерывает выполнение цикла.
Пример с continue
Чтобы далеко не ходить, за основу для примера возьмем предыдущий цикл foreach . Пусть теперь наша программа пропускает все числа в массиве, которые больше 100 . С помощью оператора continue сделать это довольно просто:
foreach (int value in array) < if (value >100) //число больше 100? < continue; //прерываем текущую итерацию и переходим к следующему числу из массива >Console.WriteLine(IsPrime(value) ? $" простое" : $" непростое"); >
Теперь, если запустить приложение, то в консоли появится результат проверки только для чисел до 100 включительно, то есть:
1, 3, 7, 9, 12, 76, 56, 89, 11 .
Пример с break
Как было сказано выше, оператор break полностью прерывает выполнение цикла. Так, если в предыдущем примере мы отсеивали все числа больше 100 , то в этом примере цикл прервется как только встретит число более 100 :
foreach (int value in array) < if (value >100) //число больше 100? < break; //прерываем выполнение цикла >Console.WriteLine(IsPrime(value) ? $" простое" : $" непростое"); >
Не трудно догадаться, что последним числом, которое будет проверено в цикле будет число 12 , так как следующее число в массиве 134 (больше 100 ).
Итого
Итак, сегодня мы разобрались с циклами в C#, посмотрели как они работают на примере поиска простых чисел, а также научились управлять циклами в нашем приложении с помощью операторов continue и break. При этом, я постарался сделать так, чтобы в примерах было задействовано максимальное количество конструкций и операторов, которые мы изучили ранее.
уважаемые посетители блога, если Вам понравилась, то, пожалуйста, помогите автору с лечением. Подробности тут.
Метанит си шарп циклы
За каждый месяц банк начисляет к сумме вклада 7% от суммы. Напишите консольную программу, в которую пользователь вводит сумму вклада и количество месяцев. А банк вычисляет конечную сумму вклада с учетом начисления процентов за каждый месяц.
Для вычисления суммы с учетом процентов используйте цикл for . Для ввода суммы вклада используйте выражение Convert.ToDecimal(Console.ReadLine()) (сумма вклада будет представлять тип decimal).
using System; namespace HelloApp < class Program < static void Main(string[] args) < Console.WriteLine("Введите сумму вклада: "); decimal sum = Convert.ToDecimal(Console.ReadLine()); Console.WriteLine("Введите срок вклада в месяцах: "); int period = Convert.ToInt32(Console.ReadLine()); for(int i = 1; i Console.WriteLine($"После месяцев сумма вклада составит "); Console.ReadKey(); > > > Перепишите предыдущую программу, только вместо цикла for используйте цикл while .
using System; namespace HelloApp < class Program < static void Main(string[] args) < Console.WriteLine("Введите сумму вклада: "); decimal sum = Convert.ToDecimal(Console.ReadLine()); Console.WriteLine("Введите срок вклада в месяцах: "); int period = Convert.ToInt32(Console.ReadLine()); int i = period; while (i >0) < sum += sum * 0.07M; i--; >Console.WriteLine($"После месяцев сумма вклада составит "); Console.ReadKey(); > > > Напишите программу, которая выводит на консоль таблицу умножения
using System; namespace HelloApp < class Program < static void Main(string[] args) < for (int i = 1; i < 10; i++) < for(int j = 1; j < 10; j++) < Console.Write($"\t"); > Console.WriteLine(); > Console.ReadKey(); > > >
Напишите программу, в которую пользователь вводит два числа и выводит результат их умножения. При этом программа должны запрашивать у пользователя ввод чисел, пока оба вводимых числа не окажутся в диапазоне от 0 до 10. Если введенные числа окажутся больше 10 или меньше 0, то программа должна вывести пользователю о том, что введенные числа недопустимы, и повторно запросить у пользователя ввод двух чисел. Если введенные числа принадлежат диапазону от 0 до 10, то программа выводит результат умножения.
Для организации ввода чисел используйте бесконечный цикл while и оператор break.
using System; namespace HelloApp < class Program < static void Main(string[] args) < while (true) < Console.WriteLine("Введите первое число:"); int num1 = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("Введите второе число:"); int num2 = Convert.ToInt32(Console.ReadLine()); if(num1 < 0 || num1 >10 || num2 < 0 || num2 >10) < Console.WriteLine("Оба числа должны быть в диапазоне от 0 до 10"); >else < Console.WriteLine($"* = "); break; > > Console.ReadKey(); > > > Метанит си шарп циклы
Циклы позволяет выполнить одно действие множество раз в зависимости от определенного условия. В языке Си есть следующие типы циклов:
Цикл for
Цикл for имеет следующее формальное определение:
for (инициализация; условие; приращение;) < // тело цикла >
заголовок цикла состоит из трех частей. Первая часть — инициализация выполняется один раз при начале выполнения цикла и представляет установку начальных условий, как правило, это инициализация счетчиков — специальных переменных, которые используются для контроля за циклом.
Вторая часть — условие , при соблюдении которого выполняется цикл. Зачастую в качестве условия используется операция сравнения, и если она возвращает ненулевое значение (то есть условие истинно), то выполняется тело цикла, а затем вычисляется выражение_3 .
Третья часть — приращение задает изменение параметров цикла. Обычно здесь происходит увеличение счетчиков цикла.
Рассмотрим стандартный цикл for и для этого выведем числа с 0 до 5 на консоль:
#include int main(void) < for (int i = 0; i < 6; i++) < printf("%d", i); >return 0; > Первая часть объявления цикла — int i = 0 — создает и инициализирует счетчик i. Счетчик необязательно должен представлять тип int. Это может быть и другой числовой тип, например, float. И перед выполнением цикла его значение будет равно 0. В данном случае это то же самое, что и объявление переменной.
Вторая часть — условие, при котором будет выполняться цикл. В данном случае цикл будет выполняться, пока i не достигнет 6.
И третья часть — приращение счетчика на единицу. Опять же нам необязательно увеличивать на единицу. Можно уменьшать: i—. Можно изменять на другое значение: i+=2.
В итоге блок цикла сработает 6 раз, пока значение i не станет равным 6. И каждый раз это значение будет увеличиваться на 1.
Каждый отдельный проход цикла называется итерацией. То есть в примере выше было 6 итераций.
Усложним цикл и выведем квадраты чисел от 0 до 8:
#include int main(void) < for (int i = 0; i < 9; i++) < printf("%d * %d = %d \n", i, i, i * i); >return 0; > Здесь блок цикла сработает 9 раз, пока значение i не станет равным 9. И каждый раз это значение будет увеличиваться на 1.
0 * 0 = 0 1 * 1 = 1 2 * 2 = 4 3 * 3 = 9 4 * 4 = 16 5 * 5 = 25 6 * 6 = 36 7 * 7 = 49 8 * 8 = 64
Необязательно указывать все три выражения в определении цикла, мы можем одно или даже все их них опустить:
Формально определение цикла осталось тем же, только теперь первое и третье выражения в определении цикла отсутствуют: for (; i < 9;) . Переменная-счетчик определена и инициализирована вне цикла, а ее приращение происходит в самом цикле.
Можно определять вложенные циклы. Например, выведем таблицу умножения:
#include int main(void) < for (int i=1; i < 10; i++) < for(int j = 1; j < 10; j++) < printf("%d \t", i * j); >printf("\n"); > return 0; > Цикл do..while
В цикле do..while сначала выполняется код цикла, а потом происходит проверка условия в инструкции while . И пока это условие истинно, то есть не равно 0, то цикл повторяется.
#include int main(void) < int i = 6; do < printf("%d", i); i--; >while (i > 0); return 0; > Здесь код цикла сработает 6 раз, пока i не станет равным нулю. Но важно отметить, что цикл do гарантирует хотя бы единократное выполнение действий, даже если перед первым выполнением условие в инструкции while не будет истинно. То есть мы можем написать:
Хотя у нас переменная i меньше 0, цикл все равно один раз выполнится.
Цикл while
В отличие от цикла do цикл while сразу проверяет истинность некоторого условия, и если условие истинно, то есть не равно 0, то код цикла выполняется:
Например, выведем на консоль все числа от 6 до 1:
#include int main(void) < int i = 6; while (i >0) < printf("%d \n", i); i--; >return 0; > Здесь, пока истинно условие i > 0 , будут выполняться действия цикла — printf(«%d \n», i) и i—
Операторы continue и break
Иногда возникает необходимость выйти из цикла до его завершения. В этом случае можно воспользоваться оператором break . Например:
Здесь когда значение переменной i достигнет 5, осуществляется выход из цикла с помощью оператора break .
В отличие от оператора break , оператор continue производит переход к следующей итерации. Например, нам надо посчитать сумму только нечетных чисел из некоторого диапазона:
#include int main(void) < int result = 0; for (int i=0; iprintf("result = %d", result); // 25 return 0; > Чтобы узнать, четное ли число, мы получаем остаток от целочисленного деления на 2, и если он равен 0, то с помощью оператора continue переходим к следующей итерации цикла. А если число нечетное, то складываем его с остальными нечетными числами.