Твърдението "Всеки цикъл се изпълнява най-малко един път" не е вярно. Има някои цикли, които може да не се изпълнят дори един път, ако изразът във входната точка на цикъла е невярно. Това е типично за циклите `while` и `for` в програмирането. Ето един пример: ```python i = 10 while i < 1: print(i) i -= 1 ``` В този пример, условието на цикъла `while` е че `i` трябва да е по-малко от `1`. Но първоначалната стойност на `i` е `10`, което е по-голямо от `1`. Затова тялото на цикъла никога не се изпълнява. Ако изобразим този код като ASCII арт, това би изглеждало така: ``` start | v [i=10]--No-->(end) | v [i<1]--Yes-->[print(i), i-=1] ^ | |______________| ``` Тук виждаме, че програмата започва с `i=10`, проверява дали `i` е по-малко от `1`, и ако е така, изпълнява тялото на цикъла. Ако `i` не е по-малко от `1`, програмата просто прекъсва цикъла и продължава към края.

Алгоритъмът на мехурчето (Bubble sort) е прост метод за сортиране, който основно работи чрез многократно обхождане на списъка, сравнява съседните елементи и ги разменя, ако са в грешна последователност. Този алгоритъм получава името си, защото при многократно обхождане по-големите елементи 'изплувват' навърх и това прилича на мехурчета във вода. Нека разгледаме примерен код на Python за алгоритъма: ```python def bubble_sort(masiv): n = len(masiv) for i in range(n): for j in range(0, n-i-1): if masiv[j] > masiv[j+1] : masiv[j], masiv[j+1] = masiv[j+1], masiv[j] return masiv ``` Тук е визуализация на работата на алгоритъма (сортиране на числата от 5 до 1 във възходящ ред): ``` Стъпка 1: [5, 4, 3, 2, 1] -> Сравняваме 5 и 4, разменяме ги Стъпка 2: [4, 5, 3, 2, 1] -> Сравняваме 5 и 3, разменяме ги Стъпка 3: [4, 3, 5, 2, 1] -> Сравняваме 5 и 2, разменяме ги Стъпка 4: [4, 3, 2, 5, 1] -> Сравняваме 5 и 1, разменяме ги Стъпка 5: [4, 3, 2, 1, 5] -> Първата итерация приключи, най-голямото число е на последната позиция Следващите стъпки продължават по същия начин, докато всички числа не са подредени във възходящ ред. ``` Използването на алгоритъма на мехурчето не е ефикасно за големи списъци, тъй като сложността му е O(n^2).

За да решим тази задача, трябва да използваме няколко физически формули. Първо, нека изчислим ускорението на самолета. Ускорението (а) е равно на изменението на скоростта (v) делено на времето (t). В нашия случай това е: a = Δv / t = 80m/s / 50s = 1.6m/s². След това, изчисляваме силата, която двигателят трябва да приложи за да постигне това ускорение. Според втория закон на Нютон, силата (F) е равна на масата (m) умножена по ускорението (a). Тоест: F = m * a = 20000kg * 1.6m/s² = 32000N. Сега можем да изчислим мощността (P), която е равна на силата (F) умножена по скоростта (v). В този случай: P = F * v = 32000N * 80m/s = 2560000W или 2560kW. Така че мощността на двигателя на самолета е 2560 киловата.

Първо, нека изчислим работата, която силата на гравитацията извършва по време на падането на тялото по наклонената равнина. Тази работа е равна на промяната в кинетичната енергия на тялото. След това ще използваме принципа на запазване на енергията за да намерим скоростта v на тялото на дъното на равнината. 1. Работата W, извършена от гравитационната сила е равна на разликата между кинетичната енергия на тялото в края и в началото на движението: W = ΔK = Kf - Ki Защото тялото започва от покой, началната му кинетична енергия Ki е равна на нула. Затова работата W е равна на крайната кинетична енергия Kf. 2. Кинетичната енергия е дадена от формулата K = 1/2 * m * v^2, където m е масата на тялото и v е скоростта му. От формулата за работата W получаваме, че Kf = W = m * g * h, където g е ускорението на тялото вследствие на силата на гравитацията и h е височината на наклонената равнина. 3. След като намерим скоростта v на тялото на дъното на равнината, можем да я използваме, за да намерим работата W', извършена от силата на триене f в хоризонталния участък. Тази работа е равна на промяната в кинетичната енергия на тялото, тоест W' = ΔK' = Ki' - Kf' = Kf - 0 = W. 4. Тъй като работата W' е равна на произведението на силата на триене f и преминатия път s, то от формулата W' = f * s получаваме, че f = W' / s. Ако заместим m с 2 kg, h с 1.2 m, g с 9.8 m/s^2 (ускорението на свободното падане на Земята) и s с 4 m, получаваме следните стойности: W = 2 kg * 9.8 m/s^2 * 1.2 m = 23.52 J (джаули) f = 23.52 J / 4 m = 5.88 N (нютони) Затова силата на триене е приблизително 5.88 нютони.

Елементите на масива могат да бъдат от различен тип в някои програмни езици, като Python и JavaScript, но в други, като C++ и Java, те трябва да бъдат от един и същи тип. В Python, например, можем да имаме масив (списък), който съдържа различни типове данни: ```python my_list = [1, "два", 3.0, True] ``` В този списък имаме следните типове данни: цяло число (1), низ (два), десетично число (3.0) и булева стойност (True). В C++, обаче, трябва да декларираме типа на данните, които ще съхраняваме в масива, и всички елементи трябва да бъдат от този тип: ```c++ int my_array[4] = {1, 2, 3, 4}; ``` Тук всички елементи са от тип цяло число. Визуализация на масив в ASCII арт би изглеждала така: ``` +---+---+---+---+ | 1 | 2 | 3 | 4 | +---+---+---+---+ ``` Това е масив с 4 елемента, всеки от които се съхранява в отделна клетка.

За да намерим мощността на мотора, първо трябва да разберем каква работа се извършва. Работата е равна на силата умножена по разстоянието, което в този случай е скоростта на асансьора. Общата маса на асансьора и товара е M + m = 400kg + 300kg = 700kg. Силата, която трябва да бъде преодоляна, е тежестта на общата маса плюс силата на триене. Това е F = mg + f = 700kg * 9.8m/s² + 0N = 6860N (където g е ускорението поради гравитацията, приемаме го за 9.8m/s² за Земята). Работата, която трябва да бъде извършена всеки секунда, е равна на силата умножена по скоростта, т.е. W = Fv = 6860N * 2m/s = 13720 Joules. Мощността е работата делено на времето, което в този случай е 1 секунда, така че мощността на мотора трябва да бъде P = W/t = 13720W или 13.72kW.

Отговорът е а) - след изпълнение на тялото на цикъла. Операторът do-while в програмирането е такъв вид цикъл, при който тялото на цикъла се изпълнява първо, а след това се проверява условието. Ако условието е верно (т.е., резултатът от проверката е истина), тялото на цикъла се изпълнява отново. Ако условието не е верно (т.е., резултатът от проверката е лъжа), изпълнението на програмата продължава след оператора do-while. Ето пример за код на езика C++: ```c++ #include <iostream> using namespace std; int main() { int i = 0; do { cout << i << "\n"; i++; } while (i < 5); return 0; } ``` Този код ще отпечата числата от 0 до 4 на конзолата. Ако се опитаме да визуализираме горепосочения код, би изглеждало нещо така: ``` ________ | i = 0 | |________| | v _____do_____ | | | cout << i | | i++ | |____________| | v ________ | i < 5 | |________| | v ____yes____ | | v | return to do | |____no_____| | v ________ | return 0| |_________| ``` Във визуализацията, "do" се изпълнява първо, след което се проверява условието "i < 5". Ако условието е верно, цикълът се повтаря отново, ако не - програмата продължава след цикъла с "return 0".

Програмата, която сте предоставили, извършва следните действия: 1. Въвежда се стойност на променливата n, която определя броя на елементите в масива. 2. Създава се масив m с размер 100 и в него се въвеждат n числа от стандартния вход. 3. Променливата a се инициализира с първия елемент на масива m. 4. Итерацията през останалите елементи на масива проверява дали текущият елемент е по-малък от стойността на a. Ако е по-малък, то a приема стойността на този елемент. Въз основа на това, след изпълнението на програмата, променливата a ще има стойността на най-малкия елемент във въведения масив. Отговорът е подточка в) - най-малкият елемент в масива. Примерен код на тази програма на C++ би изглеждал така: ```c++ #include<iostream> using namespace std; int main(){ int n, a, i, m[100]; cin >> n; for(i=0; i<n; i++) cin >> m[i]; a=m[0]; for(i=1; i<n; i++) if(a > m[i]) a = m[i]; cout << "Най-малкият елемент е: " << a << endl; return 0; } ``` Тази програма ще върне най-малкия елемент от въведения масив, като използва алгоритъм за линейно търсене. Визуализацията на алгоритъма в ASCII арт би изглеждала така: ``` Въведи брой елементи: 5 Въведи елементите: 7 3 9 1 5 m: 7 3 9 1 5 a: 7 Проверка 1: a(7) > m[1](3)? Да, затова a сега е 3 Проверка 2: a(3) > m[2](9)? Не Проверка 3: a(3) > m[3](1)? Да, затова a сега е 1 Проверка 4: a(1) > m[4](5)? Не Резултат: Най-малкият елемент е 1 ```

Даденият фрагмент от програмата пресмята сумата от неположителните елементи на масива а (вариант в). За да разберем какво точно прави този код, нека да го разгледаме по-подробно: 1. `int a(20),s=0` - тук се декларира масив `а` с 20 елемента и променлива `s`, която ще съхранява сумата от елементите. 2. `for(int i=0;i<20;i++)` - това е цикъл, който ще мине през всички елементи на масива `а`. 3. `if(a(i)<=0) s=s+a(i);` - това е условие, което проверява дали текущият елемент от масива `а` е неположителен (т.е. 0 или отрицателно число). Ако е така, то той се добавя към сумата `s`. ASCII арт илюстрация: ``` ----[ Масив а ]---- [ a[0] ][ a[1] ][ a[2] ]...[ a[17] ][ a[18] ][ a[19] ] Цикълът минава през всеки елемент: [ a[0] ] -> ако е неположителен, добавя се към s [ a[1] ] -> ако е неположителен, добавя се към s ... [ a[19] ] -> ако е неположителен, добавя се към s ```

Операторът continue се използва за подточка а) - прекъсване на текущото изпълнение на тялото на цикъла, като след това изпълнението на цикъла продължава. Операторът continue прекъсва текущата итерация и продължава към следващата. Ето пример: ```python for i in range(10): if i == 5: continue print(i) ``` Този код ще отпечата всички числа от 0 до 9, без 5, тъй като когато i е равно на 5, операторът continue прекъсва текущата итерация и продължава със следващата. Визуализация на кода: ``` 0 1 2 3 4 # continue се активира, 5 се пропуска 6 7 8 9 ``` Обратно, операторът break, който отговаря на подточка b), прекъсва цялостното изпълнение на цикъла и изпълнението продължава с изпълнение на следващия оператор след цикъла. Ето пример: ```python for i in range(10): if i == 5: break print(i) ``` Този код ще отпечата числата от 0 до 4. Когато i стане равно на 5, операторът break прекъсва изпълнението на цикъла и програмата продължава с кода след цикъла. Визуализация на кода: ``` 0 1 2 3 4 # break се активира, цикълът се прекъсва ```