В настоящата глава ще се запознаем с цикъла for, който ще използваме за извеждане на различни фигурки в конзолата. Ще използваме единични и вложени цикли (в тялото на един цикъл се изпълнява друг), като крайната ни цел е да се научим да "изчертаваме" прости и не чак толкова прости фигурки в конзолата.
Да се начертае в конзолата правоъгълник от 10 x 10 звездички.
| Вход | Изход |
|---|---|
| (няма) | **************************************************************************************************** |
За изпълнението на задачата ще прибегнем до малка хитрост, ще използваме метод. В глава 10 ще се запознаем подробно с това, какво са методите и как се използват. Методът ще ни позволи да изпълнем един и същ код повече от един път и на повече от едно място в една програма. На този етап няма да разкриваме повече от концепцията на методите.
Как работи примерът? Инициализира се управляваща променлива на цикъла i = 0 и тя се увеличава на всяка итерация, докато е по-малка от 10 (проверката се извършва след всяко изпълнение на тялото на цикъла и след итерацията). Така кодът в тялото на цикълa се изпълнява точно 10 пъти. Кодът в тялото на цикъла ще се извика за всеки ред на правоъгълника. В метода ще се използва класът StringBuffer, който, при всяко завъртане на цикъла for (този в метода), ще "залепи" по една звездичка, като по този начин ще създаде ред от десет звездички. След като приключи изпълнението на цикъла, низът ще бъде върнат на основния цикъл и ще се изведе полученият ред. Това ще се повтори за всички 10 (десет) итерации, като по този начин на всяко завъртане на цикъла ще получаваме по цял един ред.
Тествайте решението си тук: https://judge.softuni.bg/Contests/Practice/Index/657#0
Да се напише програма, чийто вход е цяло положително число n и извежда в конзолата правоъгълник от N x N звездички.
| Вход | Изход | Вход | Изход | Вход | Изход |
|---|---|---|---|---|---|
| 2 | **** |
3 | ********* |
4 | **************** |
За решаване на тази задача, ще използваме класа Scanner, който ще ни позволи да прихванем подадения размер на фигурата.
Тествайте решението си тук: https://judge.softuni.bg/Contests/Practice/Index/657#1
Вложените цикли представляват конструкция, при която в тялото на един цикъл (външен) се изпълнява друг цикъл (вътрешен). За всяко завъртане на външния цикъл, вътрешният се извърта целият. Това се случва по следния начин: при стартиране на програмата се изпълнява инициализацията на управляващата променлива във външния цикъл и се прави проверка дали стойността на управляващата променлива удовлетворява условието за край. След това се изпълнява вътрешният цикъл. Извършва се инициализация на началната стойност на управляващата променлива във вложения (вътрешния) цикъл, прави се проверка дали управляващата променлива за край на цикъла удовлетворява условието за край и се изпълнява кодът в тялото му. При достигане на зададената стойност за край на цикъла, програмата се връща една стъпка нагоре и изпълнява предходния (външния) цикъл. Прави се една стъпка в управляващата променлива, проверява се дали условието за край е удовлетворено и отново се започва изпълнението на вложения (вътрешния) цикъл. Това се повтаря докато променливата на външния цикъл достигне стойност, която удовлетворява условието за край и надхвърля зададената граничната стойност.
Нека разгледаме примера по-горе. След инициализацията на външния (outer) цикъл, започва да се изпълнява неговото тяло, което съдържа втория (вложен или още вътрешен (inner)) цикъл. Той извежда на един ред numberOfstars на брой звездички. След като вътрешният цикъл приключи изпълнението си, управлението на програмата се връща при първата итерация на външния и след това външният ще продължи. В тялото на външния цикъл е добавен ред (System.out.println()), който ще се грижи при приключването на изпълнението на вътрешния цикъл да се преминава на следващия ред. Без този код всички звездички ще бъдат изведени на един ред. Ако във вътрешния цикъл вместо print използваме println, всички звездички ще се изведат на отделен ред. Можете да опитате и да се уверите сами. Следва инкрементиране на променливата (увеличаване, в нашия случай с 1) от външния цикъл и отново ще бъде изпълнен целия вътрешен цикъл. Вътрешният цикъл ще се изпълни толкова пъти, колкото се изпълнява тялото на външния цикъл, в случaя numberOfstars пъти.
Да се начертае на конзолата квадрат от N x N звездички:
| Вход | Изход | Вход | Изход | Вход | Изход |
|---|---|---|---|---|---|
| 2 | * ** * |
3 | * * ** * ** * * |
4 | * * * ** * * ** * * ** * * * |
Задачата е аналогична на предходната. Тук обаче е необходимо да се обмисли как да бъде изведен интервал след звездичките така, че да няма излишни интервали в началото или края.
Тествайте решението си тук: https://judge.softuni.bg/Contests/Practice/Index/657#2
Да се напише програма, която въвежда число n и печата триъгълник от долари.
| Вход | Изход | Вход | Изход | Вход | Изход |
|---|---|---|---|---|---|
| 3 | $$ $$ $ $ |
4 | $$ $$ $ $$ $ $ $ |
5 | $$ $$ $ $$ $ $ $$ $ $ $ $ |
Задачата е сходна с тези за рисуване на правоъгълник и квадрат. Отново ще използваме вложени цикли, но тук има уловка. Разликата е в това, че броят на колонките, които трябва да отпечатаме, зависи от реда, на който се намираме, а не от входното число n. От примерните входни и изходни данни забелязваме, че броят на доларите зависи от това на кой ред се намираме към момента на печатането, т.е. 1 знак долар означава първи ред, 2 знака долар означават втори ред и т.н. Нека разгледаме долния пример по-подробно. Виждаме, че променливата на вложения цикъл е обвързана с променливата на външния. По този начин нашата програма печата желания триъгълник.
Тествайте решението си тук: https://judge.softuni.bg/Contests/Practice/Index/657#3
Да се напише програма, която въвежда цяло положително число n и чертае на конзолата квадратна рамка с размер n * n.
| Вход | Изход | Вход | Изход |
|---|---|---|---|
| 3 | + - +| - |+ - + |
4 | + - - +| - - || - - |+ - - + |
| Вход | Изход | Вход | Изход |
|---|---|---|---|
| 5 | + - - - +| - - - || - - - || - - - |+ - - - + |
6 | + - - - - +| - - - - || - - - - || - - - - || - - - - |+ - - - - + |
Можем да решим задачата по следния начин:
- Четем от конзолата числото
n. - Отпечатваме горната част: първо знак
+, после n-2 пъти-и накрая+. - Отпечатваме средната част: печатаме n-2 реда като първо печатаме знак
|, после n-2 пъти-и накрая|. - Отпечатваме долната част: първо
+, после n-2 пъти-и накрая+. Ще използваме отново вложени цикли.
Тествайте решението си тук: https://judge.softuni.bg/Contests/Practice/Index/657#4
Да се напише програма, която въвежда цяло положително число n и извежда в конзолата ромб от звездички с размер n.
| Вход | Изход | Вход | Изход |
|---|---|---|---|
| 1 | * |
2 | * * * * |
| Вход | Изход | Вход | Изход |
|---|---|---|---|
| 3 | * * * * * * * * * |
4 | * * * * * * * * * * * * * * * * |
За да решим поставената задача е необходимо мислено да разделим ромба на две части: горна (включва и средния ред) и долна. За извеждането в конзолата на всяка една част ще използваме два цикъла, като читателя сам трябва да открие зависимостта между n и променливите в циклите.
За първия цикъл може да използваме следните насоки:
- Отпечатвaме
n-rowинтервала. - Отпечатваме
*. - Отпечатваме
row-1пъти*.
Втората (долна) част ще изведем по аналогичен начин, което отново оставяме читателя да се опита да направи сам.
Тествайте решението си тук: https://judge.softuni.bg/Contests/Practice/Index/657#5
Да се напише програма, която въвежда число n (1 ≤ n ≤ 100) и извежда "коледна елха" с височина n+1.
| Вход | Изход | Вход | Изход |
|---|---|---|---|
| 1 | | * | * |
2 | | * | * ** | ** |
| Вход | Изход | Вход | Изход |
|---|---|---|---|
| 3 | | * | * ** | ** *** | *** |
4 | | * | * ** | ** *** | *** **** | **** |
От примерите виждаме, че елхата може да бъде разделена на три логически части. Първата част са звездичките и празните места преди и след тях, средната част е |, а последната част са отново звездички, като този път празни места има само преди тях. Отпечатването може да бъде постигнато само с един цикъл и отново ще прибегнем до метода, който изпозлвахме в началото.
Тествайте решението си тук: https://judge.softuni.bg/Contests/Practice/Index/657#6
Да се напише програма, която въвежда цяло число n (3 ≤ n ≤ 100) и печата слънчеви очила с размери 5*n x n като в примерите:
| Вход | Изход | Вход | Изход |
|---|---|---|---|
| 3 | ****** *******////*|||*////******* ****** |
4 | ******** *********//////*||||*//////**//////* *//////********* ******** |
| Вход | Изход |
|---|---|
| 5 | ********** ***********////////* *////////**////////*|||||*////////**////////* *////////*********** ********** |
От примерите виждаме, че очилата могат да се разделят на три части - горна, средна и долна. По-долу е част от кода, с помощта на който задачата може да се реши.
При рисуването на горния и долния ред трябва да се изпечатат 2 * n звездички, n интервала и 2 * n звездички.
При печатането на средната част трябва да проверим дали редът е (n-1) / 2 - 1, тъй като от примерите е видно, че на този ред трябва да печатаме вертикални чертички вместо интервали.
Тествайте решението си тук: https://judge.softuni.bg/Contests/Practice/Index/657#7
Да се напише програма, която въвежда число n (2 ≤ n ≤ 100) и печата къщичка с размери n x n.
| Вход | Изход | Вход | Изход | Вход | Изход |
|---|---|---|---|---|---|
| 2 | **|| |
3 | -*-***|*| |
4 | -**-****|**||**| |
| Вход | Изход | Вход | Изход |
|---|---|---|---|
| 5 | --*---***-*****|***||***| |
8 | ---**-----****---******-********|******||******||******||******| |
Разбираме от условието на задачата, че къщичката е с размери n x n. Това, което виждаме от примерните вход и изход, е че:
- Къщичката е разделена на 2 части: покрив и основа.
- Когато
nе четно число, върхът на къщичката е "тъп". - Когато
nе нечетно число, покривът е с един ред по-голям от основата.
- Съставен е от звезди и тирета.
- В най-високата си част има една или две звезди, спрямо това дали n e нечетно или четно, както и тирета.
- В най-ниската си част има много звезди и малко или никакви тирета.
- С всеки един ред по-надолу, звездите се увеличават с 2, а тиретата намаляват с 2.
- Широка е
nна брой реда. - Съставена е от звезди и вертикални черти.
- Редовете представляват 2 вертикални черти - по една в началото и в края на реда, както и звезди между вертикалните черти с дължина на низа
n - 2.
Прочитаме n от конзолата и записваме стойността в променлива от тип int.
 |
Много е важно да проверяваме дали са валидни входните данни! В тези задачи не е проблем директно да обръщаме прочетеното от конзолата в тип Integer, защото изрично е казано, че ще получаваме валидни целочислени числа. Ако обаче правим по-сериозни приложения, е добра практика да проверяваме входните данни. Какво ще стане, ако вместо число потребителят въведе буквата "А"? |
За да начертаем покрива, записваме колко ще е началният брой звезди в променлива stars:
- Ако
nе четно число, ще са 2 броя. - Ако е нечетно, ще е 1 брой.
Изчисляваме дължината на покрива. Тя е равна на половината от n. Резултата записваме в променливата roofLength.
Важно е да се отбележи че, когато n е нечетно число, дължината на покрива е по-голяма с един ред от тази на основата. В езика Java, когато два числа от целочислен тип се делят и има остатък, то резултатът ще е число без остатъка.
Пример:
int result = 3 / 2; //резултат 1
Ако искаме да закръглим резултата нагоре, трябва да използваме метода Math.ceil(...):
int result = (int)Math.ceil(3 / 2f);
В този пример делението не е от 2 целочислени числа. "f" след число показва, че даденото число е от тип float (число с плаваща запетая). Резултатът от 3 / 2f е 1.5f. Math.ceil(...) закръгля делението нагоре. В нашият случай 1.5f ще стане 2. (int) се използва, за да може да трансформираме типа обратно в int.
След като сме изчислили дължината на покрива, завъртаме цикъл от 0 до roofLength. На всяка итерация ще:
- Изчисляваме броя тирета, които трябва да изрисуваме. Броят ще е равен на
(n - stars) / 2. Записваме го в променливаpadding.
- Отпечатваме на конзолата: "тирета" (
paddingна брой пъти) + "звезди" (starsпъти) + "тирета" (paddingпъти).
- Преди да свърши итерацията на цикъла добавяме 2 към
stars(броя на звездите).
|
Не е добра идея да правим събирания на много на брой символни низове по показания по-горе начин. За повече информация посетете: https://bg.wikipedia.org/wiki/%D0%9D%D0%B8%D0%B7#String_Builder |
След като сме приключили с покрива, е време за основата. Тя е по-лесна за печатане:
- Започваме с цикъл от 0 до n (изключено).
- Отпечатваме на конзолата:
|+*(n - 2на брой пъти) +|.
Ако всичко сме написали както трябва, задачата ни е решена.
Тествайте решението си тук: https://judge.softuni.bg/Contests/Practice/Index/657#8
Да се напише програма, която въвежда цяло число n (1 ≤ n ≤ 100) и печата диамант с размери n x n.
| Вход | Изход | Вход | Изход | Вход | Изход |
|---|---|---|---|---|---|
| 1 | * |
2 | ** |
3 | -*-*-*-*- |
| Вход | Изход | Вход | Изход | Вход | Изход |
|---|---|---|---|---|---|
| 4 | -**-*--*-**- |
5 | --*---*-*-*---*-*-*---*-- |
6 | --**---*--*-*----*-*--*---**-- |
| Вход | Изход | Вход | Изход | Вход | Изход |
|---|---|---|---|---|---|
| 7 | ---*-----*-*---*---*-*-----*-*---*---*-*-----*--- |
8 | ---**-----*--*---*----*-*------*-*----*---*--*-----**--- |
9 | ----*-------*-*-----*---*---*-----*-*-------*-*-----*---*---*-----*-*-------*---- |
Това, което знаем от условието на задачата, е че диамантът е с размер n x n.
От примерните вход и изход можем да си направим изводите, че всички редове съдържат точно по n символа и всички редове, с изключение на горните върхове, имат по 2 звезди. Можем мислено да разделим диаманта на 2 части:
- Горна част. Тя започва от горният връх до средата.
- Долна част. Тя започва от реда след средата до най-долният връх (включително).
- Ако n е четно, то тя започва с 1 звезда.
- Ако n е нечетно, то тя започва с 2 звезди.
- С всеки ред надолу, звездите се отдалечават една от друга.
- Пространството преди, между, и след звездите е запълнено с тирета.
- С всеки ред надолу, звездите се събират една към друга. Това означава, че пространството (тиретата) между тях намалява, а пространството (тиретата) отляво и отдясно се увеличава.
- В най-долната си част е с 1 или 2 звезди, спрямо това дали n е нечетно или четно.
- На всеки ред звездите са заобиколени от външни тирета, с изключение на средния ред.
- На всеки ред има пространство между двете звезди, с изключение на първия и последния ред (понякога звездата е 1).
Прочитаме стойността на n от конзолата и я записваме в променлива от тип Integer.
Започваме да чертаем горната част на диаманта. Първото нещо, което трябва да направим, е да изчислим началната стойност на външната бройка тирета leftRight (тиретата от външната част на звездите). Тя е равна на (n - 1) / 2, закръглено надолу.
След като сме изчислили leftRight, започваме да чертаем горната част на диаманта. Може да започнем, като завъртим цикъл от 0 до n / 2 + 1 (закръглено надолу).
При всяка итерация на цикъла трябва да се изпълнят следните стъпки:
- Рисуваме по конзолата левите тирета (с дължина
leftRight) и веднага след тях първата звезда.
- Ще изчислим разстоянието между двете звезди. Може да го направим като извадим от n дължината на външните тирета, както и числото 2 (бройката на звездите, т.е. очертанията на диаманта). Резултата от тази разлика записваме в променлива
mid.
- Ако
midе по-малко от 0, то тогава знаем, че на реда трябва да има 1 звезда. Ако е по-голямо или равно на 0, то тогава трябва да начертаем тирета с дължинаmidи една звезда след тях. - Рисуваме на конзолата десните външни тирета с дължина
leftRight.
- В края на цикъла намаляваме
leftRightс 1 (звездите се отдалечават).
Готови сме с горната част.
Рисуването на долната част е доста подобна на рисуването на горната част. Разликите са, че вместо да намаляваме leftRight с 1 към края на цикъла, ще увеличаваме leftRight с 1 в началото на цикъла. Също така, цикълът ще е от 0 до (n - 1) / 2.
|
Повторението на едно и също парче код се смята за лоша практика, тъй като кодът става труден за поддръжка. Да си представим, че имаме код (напр. логиката за чертането на ред от диаманта) на още няколко места в програмата и се налга да направим някаква промяна. За целта би било необходимо да коригираме кода на всяко едно място, където сме сложили този код. А сега нека се замислим върху следния казус: Какво би станало, ако същият този код трябва да се използва не 1, 2 или 3 пъти, а десетки пъти. Един от подходите за справяне с този проблем е използването на методи. Допълнителна информация за тях можете да откриете в глава 10 на тази книга, както и в Интернет. |
Тествайте решението си тук: https://judge.softuni.bg/Contests/Practice/Index/657#9
Научихме се да чертаем фигурки с вложени for цикли:
for (int r = 1; r <= 5; r++)
{
System.out.println("*");
for (int c = 1; c < 5; c++)
System.out.println(" *");
System.out.println();
}Научихме се, също така, да използваме методи за да избягваме повторението на едно и също парче код няколко пъти.