Язык Си для начинающих / #5 - Циклы и операторы в них

Привет!

В ходе этого урока мы с вами познакомимся с циклами в языке C, а также узнаем, какие операторы существуют внутри этих циклов.

Но сперва я хочу порекомендовать сайт itproger.com.

На этом сайте вы найдете данный урок, а также домашние задания, готовый код и много другой полезной информации.

Ссылка на этот урок будет в описании к этому видео.

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

В языке C существует три типа циклов.

Это for, while, а также do while.

Мы все их сейчас изучим.

Начнем мы с такого цикла как for.

Чтобы его записать, мы прописываем ключевое слово for, дальше открываем круглые скобки, а также открываем фигурные скобки.

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

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

Хотя, если вы пропишите переменную, например, где-нибудь здесь, а здесь ее уже просто будете использовать, то это не вызовет никакой ошибки и также это все будет работать корректно.

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

Что здесь нам необходимо сделать?

Мы создаем некую переменную и изначально указываем для нее первоначальное значение.

Например, я создал переменную i и говорю, что изначально она равна числу 0.

Дальше я указываю условие, то есть я говорю...

До каких пор у нас будет работать цикл?

У нас цикл будет работать до тех пор, пока переменная i будет меньшим, чем число 10.

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

Например, переменная i будет каждый раз увеличиваться на 1.

Таким образом, когда мы это все запустим, у нас изначально переменная i будет равна 0.

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

И так у нас это как бы сработает 10 раз, потом когда переменная уже i будет больше или равна 10, то соответственно у нас условие уже не будет верным и поэтому мы не сможем, и поэтому вернее этот цикл он уже не будет работать.

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

Ну и также давайте запустим нашу программку и посмотрим, что же у нас получилось.

Получается, что у нас вводятся все цифры от 0 и до 9 включительно.

Если мы хотим, чтобы у нас цифры, например, вывелись от 1 до 10, то в таком случае мы, во-первых, переменную изначально указываем, что у нее значение будет 1, а здесь мы меняем условие.

Либо мы устанавливаем то, что i будет меньше либо равно 10, либо мы устанавливаем, что i будет меньше, чем число 11.

В таком случае 10 еще будет подходить под проверку, а вот 11 уже не будет подходить под проверку.

И если такое запустить, то в таком случае, видите, у нас идет от 1 до 10.

Наш цикл обработался корректно.

Также внутри этого цикла вы можете устанавливать любые условия, какие только захотите.

То есть, например, я могу сказать, что изначально наша переменная i будет равна числу 100.

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

И каждый раз за итерацию мы, например, переменную i будем делить на 2.

Единственное, что здесь было бы лучше...

прописать float, потому что мы все-таки уже производим деление, ну и здесь, соответственно, тоже буквочку f мы прописываем, и даже давайте вот так вот пропишем, что у нас лишь два числа будут после точки.

Запускаем нашу программку, и мы можем заметить, что видите, изначально у нас вывелось 100, потом вот эта переменная i поделилась на 2, и у нас вывелось 50,

Потом 25, потом 12,5, а вот следующее число уже не подошло под эту проверку, потому что следующее число было меньше, чем 10.

А у нас проверка говорит о том, что цикл будет работать только до тех пор, пока сама эта переменная больше, чем 10.

Так вот, проверка уже не сработала, и, соответственно, следующее число у нас было не выведено.

То бишь, вот здесь вы можете установить любые условия, какие только захотите, и все у вас будет работать корректно.

Также здесь присутствует такой же принцип, как в условных операторах.

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

Вот таким вот образом.

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

Следующий формат цикла, он называется while.

Записывается он следующим образом.

Чем вообще все эти циклы отличаются друг от друга?

По сути, в плане выполнения цикла,

ну, в плане выполнения кода, они ничем не отличаются.

То есть, что цикл for, что цикл while, что цикл do while, они обработают код несколько раз подряд.

Единственное, в чем их отличие, так это в формате написания самого цикла.

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

Вот, например, где-нибудь здесь я создам переменную,

Пускай эта переменная будет называться isHasCar, вот таким вот образом.

Укажем, что у нее будет значение как true.

Также дополнительно, конечно же, необходимо подключить соответствующую библиотеку std.bool, чтобы у нас это все работало.

И здесь я, например, могу просто прописать условие.

Например, этот цикл, он будет работать до тех пор, пока у нас isHasCar будет равно значению true.

Но опять-таки, не вижу смысла прописывать полную конструкцию, если можно это все сократить и просто прописать isHasCar.

То есть,

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

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

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

Здесь, например, мы будем получать данные от пользователя.

Это пускай будет некое число.

Также давайте создадим саму переменную.

Ой, кстати, я тут прописал int, а это, конечно же, должен быть bool.

Это моя ошибка.

Так вот, давайте еще создадим одну переменную.

Пускай эта переменная будет называться как x. И, соответственно, мы будем устанавливать...

получать от пользователя значение, и это значение будем устанавливать вот в эту переменную.

И здесь мы также допишем еще дополнительную проверку.

Мы пропишем, что если x будет равно, например, 1, давайте так, если x будет равен 1, то в таком случае мы переменную из hasCar будем устанавливать из значения false, ну и, соответственно, из цикла мы будем выходить.

То есть, что я сейчас прописал?

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

Если пользователь введет число единица, то в таком случае мы значение для переменной устанавливаем как false.

И дальше, когда мы опять-таки вернемся к этому кусочку кода, то есть опять будет идти проверка,

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

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

Также давайте я предлагаю еще...

выводить какой-то просто текст, например, будем писать, что введите цифру.

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

Итак, запускаем программу, вот, введите цифру, я, например, ввожу 4, программа дальше работает, потому что я не ввел единицу, соответственно, переменная не стала со значением false, соответственно, условия до сих пор верные, поэтому опять-таки цикл продолжит свою работу.

Я могу вводить и другие числа, но это никак не поменяет работу самой программки.

То есть пока я не введу число 1, у нас цикл будет постоянно работать.

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

То есть я действительно вышел из этого цикла, ну и соответственно, поскольку дальше кода никакого нет, то программа у нас просто завершилась.

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

Но в то же время просто в цикле while здесь другой формат написания условия, написания вот этого самого цикла.

То есть здесь мы указываем все параметры внутри круглых скобок.

А здесь все, что нам необходимо сделать, так это просто прописать условие, и этого хватит для создания цикла.

Также давайте я покажу вам, как можно создать на основе цикла while по сути тот же самый цикл for.

То есть как можно, играя с этой переменной i, как можно создать цикл while.

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

Ну, конечно же, значение можете указать любое.

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

Дальше открываем фигурные скобки.

Здесь я предлагаю выводить вот эту переменную i. Соответственно, давайте мы пропишем ее вывод вот таким образом.

Ну и, конечно же, чтобы цикл у нас был полноценным, нам необходимо саму эту переменную как-либо изменять.

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

Таким образом, что мы получаем?

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

Если все это запустить, то мы замечаем, что опять тот же самый у нас получается вывод.

Условия можете менять как угодно.

Например, можно прописать, что i у нас изначально, пускай, будет равна даже 1000.

Дальше здесь пока i будет больше, чем 10, например, у нас будет такое условие.

И здесь мы будем делить это все, например, даже на 20.

Давайте вот так вот пропишем.

Ну и, конечно же, у нас должен быть здесь float, здесь тоже.

И вот таким вот образом.

Запустим, посмотрим, что получилось.

И получается у нас, видите, то, что у нас было изначально 1000, потом поделили на 20, у нас получилось 50.

И дальше у нас даже ничего не выводилось, потому что 50 при делении на 20 у нас получается число меньше, чем 10.

Ну и, соответственно, уже условие не выполняется и все останавливается.

Вот такой вот еще у нас есть здесь цикл.

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

Ну, когда нам не нужно создавать еще переменную i какую-то, да, потому что когда нам нужно создать переменную i, то более удобно прописать цикл for.

Его больше используют, когда просто необходимо проверить лишь одно условие.

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

Ну, по типу мы не изменяем ее, мы не добавляем к ней какие-то там числа и что-то в этом духе, а просто проверяем условия.

Ну и дополнительно существует такой цикл как «do while».

«Do while» это точно тот же самый цикл «while».

Единственная разница заключается в том, что цикл «while» работает в следующем ключе.

Он сначала проверяет условия.

Если условия верные, то, соответственно, цикл выполняется.

Do while он сначала один раз 100% выполняет код, дальше он проверяет условия, если условия корректные, то он дальше выполняет код, если условия некорректные, то соответственно он выходит из цикла.

Давайте мы его пропишем.

Итак, поскольку этот цикл он срабатывает 100% один раз.

то в самом верху здесь не прописывается никакого условия.

Здесь прописывается просто do, то есть как бы мы говорим, что сделать.

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

И внизу как раз прописывается вот этот вот while, то есть прописывается само условие.

Ну и, соответственно, давайте мы пропишем вот что.

Is has карпуская у нас будет такая переменная.

Она будет равна значению false.

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

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

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

То есть по логике цикл вообще не должен работать.

Но он будет работать хотя бы один раз 100%, просто по той причине, что мы сначала выполняем код, а лишь потом выполняем саму эту проверку.

Ну и, соответственно, здесь давайте мы просто с вами пропишем, например, yes, также перевод на новую строку, и запустим это все.

Как мы можем заметить, у нас все-таки сейчас вводится слово yes, по той причине, что изначально выполнился код, потом прошла сама эта проверка, проверка оказалась неверной,

Ну и поскольку проверка не успешная, то больше в цикл мы не заходили, ну и соответственно один раз у нас только «Yes» и вывелось.

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

Но в любом случае, если бы я, например, такое бы запустил, то это бы сделало вот что.

У нас сначала бы опять-таки вывелось бы слово «Yes», потом проверка была бы успешной,

И, соответственно, цикл бы в бесконечном ритме, он бы выводил вот это вот слово yes.

Не советую такое запускать, потому что огромная будет нагрузка на процессор.

Ну что ж, вот такие вот три типа циклов существуют в языке C. То есть это цикл for, это цикл while, а также do while.

Все они очень схожи, выполняют по сути одно и то же самое.

И разница лишь в том, что если нужно прописать манипуляцию над какой-то переменой, то используется for.

Если нужно прописать просто условие, то используется либо while, либо do while.

И здесь уже в зависимости от того, как вам нужно выполнить саму задачу.

То есть если изначально нужно, чтобы просто код один раз 100% выполнился, то используется do while.

А если нужно, чтобы просто проверилось условие, и не важно, чтобы первый раз 100% обработался, то используется просто while.

Теперь давайте мы с вами рассмотрим

Некоторые операторы, которые существуют внутри этих циклов.

Смотрите, мы сейчас эти операторы будем рассматривать на примере цикла FOR, но по факту все эти операторы, они существуют также в цикле WHILE и DO WHILE и работают они точно так же, как и в цикле FOR.

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

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

Итак, у нас x будет от 0 до 5, как бы идти, и каждый раз на единичку мы будем увеличивать нашу переменную x. Что мы здесь с вами сделаем?

Давайте мы с вами пропишем супер простое условие.

Если x будет, ну, либо большим, либо мы можем написать просто, если x будет равен, например, числу 3,

Я хочу, чтобы мы просто брали и выходили из цикла.

Чтобы такое сделать, мне необходимо прописать оператор break.

Ну и соответственно давайте это все запустим.

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

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

Еще раз это все запускаем.

И посмотрим, что в этот раз у нас получилось.

Итак, видите, у нас выводится 0, 1, 2.

А дальше у нас ничего не выводится.

Хотя в самом здесь цикле прописано, что цикл должен работать до тех пор, пока у нас x будет меньше, чем 5.

Вот, например, даже я могу здесь поставить меньше, чем 50.

У нас все равно выведется только 0, 1 и 2.

Почему так происходит?

Потому что...

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

А поскольку мы вышли из цикла, то все остальные итерации, все остальные циклы уже не срабатывают.

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

Дальше у нас кода нет, поэтому программа и завершается.

То есть, этот оператор break, он берет и выходит просто из цикла.

Помимо оператора break, существует также оператор continue.

Конечно же, их можно использовать и в связке, а можно использовать по отдельности.

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

Здесь никакой ошибки не будет.

Давайте мы с вами пропишем следующее.

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

Вот этот вот break.

И здесь я пропишу следующее.

Я хочу, чтобы у нас в цикле выводились только четные числа, например.

Поэтому, как мне необходимо прописать?

Ну или давайте нет, давайте наоборот.

У нас в цикле будут выводиться только нечетные числа.

Как мне нужно это все прописать?

Я указываю, что если x...

Если остаток х при делении на 2 будет равен 0, то в таком случае я могу сказать, что это у нас четное число.

И, соответственно, я буду использовать оператор continue.

Вот таким вот образом.

Также цикл давайте сделаем чуть поменьше, чтобы у нас не особо много чисел выводилось.

Теперь давайте запустим всю эту программку и посмотрим, что у нас получилось.

Как видите, у нас вводятся только нечетные числа, то есть это 1, 3, 5, 7 и 9.

Почему так происходит?

Дело в том, что вот здесь мы с вами проверяем, что если x у нас при делении на 2 у него остаток будет 0, то мы 100% знаем, что это четное число.

И, соответственно, если это будет четное число, то мы используем оператор continue.

который, в отличие от break, не выходит из цикла, а просто пропускает одну итерацию.

То есть, по сути, он пропускает один цикл.

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

обратно к вот этому кусочку кода, здесь опять-таки x у нас увеличивается на единичку, ну и опять идет обработка того же самого кода, то есть по сути continue просто пропускает один цикл, одну итерацию.

Таким образом у нас как раз и вывелись только нечетные числа, вот так это в принципе здесь и работает.

И вот эти вот break и continue вы можете использовать в любом цикле, также их конечно же можно комбинировать, например если в таком

в духе я это все запущу, то у нас вывелось только число 1.

Число 1 у нас было выведено по той причине, что все четные числа у нас пропускаются, поэтому 0, а также 2, они были у нас пропущены.

Ну и когда у нас x равно 3, то мы просто вообще выходим из цикла, поэтому 3 тоже у нас не было выведено.

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

Теперь давайте рассмотрим еще работу с циклами на практике.

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

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

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

На самом-то деле можно использовать любой цикл, какой только захотите.

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

Это вполне возможно и можете это попробовать сделать.

Итак, я буду использовать цикл for.

Здесь в самом цикле

Я создаю новую переменную.

Она у нас будет идти от 0, она у нас будет идти вплоть до количества элементов в этом массиве.

То есть здесь у меня 5 элементов, соответственно до 5 как раз она у нас и будет идти.

И каждый раз мы будем i увеличивать на единичку.

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

Чтобы это сделать, мы, во-первых, здесь указываем, ну, просто метку указываем и перевод на новую строку.

А здесь же мы обращаемся к массиву r, указываем в квадратные, ну, указываем сами эти квадратные скобки.

И в качестве индекса мы будем устанавливать переменную i. Вот так это у нас как раз здесь и будет работать.

То есть, что мы с вами получим?

Мы с вами получим то, что...

В первую итерацию у нас i будет равна 0, поэтому здесь у нас будет подставлено r0, то есть выведется первый элемент.

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

Опять-таки напоминаю, что отчет индекса ведется с нуля.

Ну и так вот вплоть до последней итерации у нас i будет равно 4, соответственно это будет наш последний элемент.

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

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

Такого элемента не существует, потому что это нулевой, это первый, это второй, третий и четвертый элемент по индексу, пятого не существует, поэтому это была бы ошибка.

Поэтому именно вот такой формат я здесь как бы условия прописал.

Давайте мы это все с вами запустим.

Да, кстати, можно было бы удалить вот эти вот фигурные скобки.

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

Мы замечаем, что все элементы действительно были выведены на экран.

Все эти элементы, которые были в массиве, они были выведены на экран и все обработалось крепко.

Точно то же самое можно сделать при помощи цикла while или же do while.

Опять-таки попробуйте это сделать самостоятельно.

Это достаточно просто.

Теперь давайте создадим еще один цикл.

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

И в этом втором цикле мы давайте с вами найдем минимальный элемент внутри этого массива.

Как такое можно сделать?

Во-первых, вот это вот условие мы с вами давайте его повторно скопируем, вот эту всю конструкцию.

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

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

внутри, в пределах вот этого вот цикла видна эта переменная i. За ее пределами, за пределами вот этих вот фигурных скобок и за пределами этого цикла эта переменная не видна.

Точно то же самое и здесь.

Поэтому, если я здесь повторно создаю эту переменную,

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

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

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

Итак, что мы здесь с вами будем делать?

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

То есть, изначально мы предположим, что допустим, первый элемент массива это минимальный элемент всего массива.

Конечно же, в нашем случае это не так, но мы просто...

Как бы от этой точки будем отталкиваться.

Скажем, что вот первый элемент, это пускай будет минимальный элемент.

Возможно это так.

Дальше мы это с вами будем проверять.

Здесь в цикле мы действительно это начинаем все проверять.

То есть я проверяю, что если определенный элемент в массиве, он будет меньшим, нежели мин.

то в таком случае мы указываем, что наш новый минимальный элемент это как раз вот этот вот элемент, с которым мы сейчас работаем.

То бишь, еще раз, что я здесь прописал.

Здесь мы в цикле перебираем весь массив.

И если какой-либо элемент он сейчас меньше, чем тот минимум, который вот здесь мы с вами создали, то в таком случае мы можем 100% сказать, что наш новый минимум это будет тот элемент, который вот сейчас у нас здесь есть.

Если все это запустить...

Что мы с вами замечаем?

Да, да, да, да, да, я кое-что здесь не дописал.

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

Еще раз запустим программку.

А, нет, стоп, я что-то слишком тороплюсь.

Мне, конечно же, еще сам этот минимум необходимо вывести вот здесь.

Давайте мы напишем минимум и, соответственно, выведем сам этот минимум.

В нашем случае это переменная min.

Ну и опять-таки это все запустим, посмотрим, что получилось.

Итак, мы замечаем, что вот вверх весь наш цикл вывел, весь наш массив вывелся.

И дальше вводится действительно наиболее минимальный элемент внутри этого массива.

Это число минус 2.

Если я здесь, например, сделаю, что это будет у нас минус 67.

Здесь также еще перевод на новую строку допишем.

то в таком случае новый минимум это будет как раз минус 67.

То есть наша программка работает абсолютно корректно.

Если нам необходимо найти наоборот максимум, то в таком случае мы делаем по сути то же самое.

Мы говорим, что допустим, что минимум, что максимум, это предположительно у нас будет первый элемент.

Мы вот так вот сейчас предположим.

И здесь мы с вами дописываем просто новое условие.

Давайте даже вот это все скопируем.

Вот потому что это все очень будет схоже.

Здесь я говорю, что если какой-то определенный элемент, который мы сейчас перебираем, он больше, чем максимум, то, соответственно, мы говорим, что новый максимум это тот элемент, который мы сейчас с вами перебираем.

Ну и также это все необходимо еще вывести на экран.

Здесь пишем максимум.

И здесь, соответственно, переменную max устанавливаем и запускаем это все.

Таким образом, минимум у нас минус 67, а максимум у нас 6.

Что вполне верно.

Видите, в этом массиве 6 это действительно наибольший элемент.

То есть все здесь очень-очень просто.

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

Ну что ж, у меня на этом все.

Так что увидимся в следующем уроке.

До скорых встреч.

Пока.