path: root / src / teaching / upp-2025 / week07 / index.du

# Задачи - УПП, Седмица 7, 13.11.2025

'define expected-reading 13 min
'define created 10 November 2025
'define edited 14 November 2025
[$pagenav]

GitHub Classroom: [url https://classroom.github.com/a/clYBilXQ]

:important

.p Както при [`if`]-ове, следното е лоша практика и ще се вземат точки:

```c++
bool f() {
    if (condition)
        return true;
    else
        return false;
}


:important

.p Следното е [=грешно=] и ще се вземат точки:

```c++
int* f() {
    int numbers[5] = { 0 };
    return numbers;
}


## За решаване

### Задача 1

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise01.cpp Решение]

Напишете функция, която приема цяло число и връща дали е четно и положително.
Нека вашата функция да следва декларацията:

```c++
bool evenAndPositive(int x);

От входа получавате цяло число.
Използвайки [`evenAndPositive`], върнете дали е четно и положително.

:table_2
|= Вход
|= Изход

|: 6
|: Even and positive

|: -4
|: Not even and positive

|: 15
|: Not even and positive


### Задача 2

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise02.cpp Решение]

Напишете функция, която приема цяло неотрицателно число [`n`] и връща n-тото число на фибоначи.
Припомняме, че нулевото число на фибоначи е 0, първото число е 1 и всяко следващо е сумата на предходните две.

Нека вашата функция да следва декларацията:

```c++
unsigned int fib(unsigned int n);

От входа получавате цяло неотрицателно число.
Използвайки [`fib`], трябва да изкарате n-тото число на фибоначи.

:table_2
|= Вход
|= Изход

|: 0
|: 0

|: 1
|: 1

|: 2
|: 1

|: 3
|: 2

|: 12
|: 144

|: 33
|: 3524578


### Задача 3

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise03.cpp Решение]

Напишете функция, която приема масив от 15 цели числа и намира средното аритметично на всички тях.
Нека вашата функция да следва декларацията:

```c++
double average(int numbers[15]);

От входа получавате 15 цели числа.
Използвайки [`average`], трябва да изкарате средното аритметично на всички тях.

.note
[*(14.11.2025)*] Оправен изхода на втори пример.

:table_2
|= Вход
|= Изход

|: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
|: 8

|: 1 2 3 4 5 6 7 8 9 10 0 0 0 0 0
|: 3.66667

|: -77 21 -78 -55 53 -19 51 81 77 -73 -26 51 79 -73 -86
|: -4.93333


### Задача 4

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise04.cpp Решение]

Напишете функция, която приема число с плаваща запетая и [*връща*] две числа:
.numbered
1. числото, разделено на половина и
2. числото, закръглено надолу към най-близкото цяло число.

Нека вашата функция да следва декларацията:

```c++
void calc(float number, double &half, int* integer);

От входа получавате число с плаваща запетая.
Използвайки [`calc`], трябва да изкарате двете [*върнати*] стойности.

:table_2
|= Вход
|= Изход

|: 3.14
|: 1.57 3

|: -9.99
|: -4.995 -9


### Задача 5

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise05.cpp Решение]

Напишете функция [`maxElem`], която приема масив от числа с плаваща запетая и негов размер [=поотделно=]!
Това означава, че на функцията може да ѝ бъде подаден масив с 10, 15, 2 или ... елемента.

Нека вашата функция да върне най-големия елемент в масива.

От входа получавате една редица от 5 реални числа и втора редица от 7 реални числа.
Използвайки [`maxElem`], върнете най-големия елемент в първата и във втората редица.

:table_2
|= Вход
|= Изход

|:
```
1 2 3 4 5
1 2 3 4 5 6 7

|: 5 7

|:
```
12.01 28 50.5 -16.4 -72.22
37.4 0.9 -100.34 19 -1 37.9 -52

|: 50.5 37.9


### Задача 6

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise06.cpp Решение]

Напишете функция, която приема масив с произволна дължина (масива и размера се подават поотделно), съствен от цели числа, и [*върнете*] най-големия и най-малкия му елемент.
Нека вашата функция да следва декларацията:

```c++
void minmaxElems(int* arr, unsigned size, int* min, int* max);

От входа получавате две редици от по 10 и 8 цели числа съответно.
Използвайки [`minmaxElems`], върнете най-големия и най-малкия елемент на всяка редица.

:table_2
|= Вход
|= Изход

|:
```
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8

|:
```
10 1
8 1

|:
```
98 42 -86 81 -27 98 46 -48 8 -48
14 22 -65 10 -3 -97 -76 86

|:
```
98 -86
86 -97


### Задача 7

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise07.cpp Решение]

Напишете функция, която приема масив с произволна дължина, съставен от цели числа, и връща сумата на всички елементи.
Нека вашата функция да следва декларацията:

```
unsigned sumElems(int* arr, unsigned size);

От входа получавате 11 цели числа.
Трябва да върнете първата последователност от 3 елемента, чиято сума е 0, използвайки [`sumElems`].

Ако няма такава, не изкарвайте нищо.

.note
[*(14.11.2025)*] Оправен изхода на трети пример.

:table_2
|= Вход
|= Изход

|: 5 12 -3 1 2 6 -10 4 7 11 -2
|: -3 1 2

|: 1 2 3 4 5 6 7 8 9 10 11
|:

|: -2 -1 0 1 -1 3 4 -4 -4 5 8
|: -1 0 1


### Задача 8

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise08.cpp Решение]

Напишете функция, която приема масив с произволен размер, съставен от цели неотрицателни числа, и неотрицателно число: ротация.
Трябва да завъртите елементите в масива с ротация на брой позиции на дясно.

Тоест, ако масива е [`1 2 3 4`], тогава след ротация с една позиция, масива ще е [`4 1 2 3`].
Ако имахме две ротации, тогава щяхме да получим [`3 4 1 2`].

Не модифицирайте оригиналния масив!
Трябва да [*върнете*] друг масив със завъртяните елементи.

От входа получавате две редици от по 6 и 7 цели числа.
След всяка редица получавате ротация.
Трябва да изкарате двете редици, обаче завъртяни, използвайки вашата функция.

:table_2
|= Вход
|= Изход

|:
```
1 2 3 4 5 6 1
1 2 3 4 5 6 7 0

|:
```
6 1 2 3 4 5
1 2 3 4 5 6 7

|:
```
1 2 3 4 5 6 8
1 2 3 4 5 6 7 17

|:
```
5 6 1 2 3 4
5 6 7 1 2 3 4


### Задача 9

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise09.cpp Решение]

.note
[*(14.11.2025)*] Оправена декларацията на функцията, примери и добавено упътване.

.warn
НЕ може да използвате "вградената" функция [`pow`]!

Напишете функция, която приема число с плаваща запетая и цяло неотрицателно число, и връща първото число на степен второто.
Нека вашата функция да следва декларацията:

```c++
double topower(double x, unsigned int a);

От входа получавате 11 реални числа.
Първите 10 са коефициентите в полином от 10та степен.
11тото е потенциален корен.

Трябва да върнете дали 11тото действително е корен на уравнението, използвайки [`topower`].

Припомняме, че едно число [`x`] е корен на полином от 10та степен, когато:

[image ./img/polynomial.png]

[=Упътване:=]
За някои примери, прецизността на въведения корен не е достатъчна.
Може да приемете, че ако (абсолютната стойност на) сумата е по-малка от 0.0001, то сумата на практика е 0.

:table_2
|= Вход
|= Изход

|: 0 0 0 0 0 0 0 0 0 0 0 0
|: Is a root

|: 0 0 0 0 0 0 0 0 0 0 5 5
|: Not a root

|: 0 0 0 0 0 0 0 0 0 -5 5 1
|: Is a root

|: 0 0 0 0 0 0 0 2 3 -11 -6 -0.5
|: Is a root

|: 0 0 0 0 0 0 0 2 3 -11 -6 -2
|: Not a root

|: 1 7 -38 -192 209 -1009 5768 -19002 -2580 -99792 -120960 5.56705510103
|: Is a root

|: 1 7 -38 -192 209 -1009 5768 -19002 -2580 -99792 -120960 -0.9867787287
|: Is a root

|: 1 7 -38 -192 209 -1009 5768 -19002 -2580 -99792 -120960 2.14882
|: Not a root


### Задача 10

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise10.cpp Решение]

Напишете функция, която приема два масива с произволни размери, съставени от цели числа, и връща колко от елементите на двата масива съвпадат по стойност на еднакви индекси.
Тоест, на колко еднакви позиции срещаме еднакви елементи.

Нека вашата функция да следва декларацията:

```c++
unsigned int countSameElementsOnSameIndecies(int* arr1, unsigned int size1, int* arr2, unsigned int size2);

От входа получавате две редици от по 10 и 15 цели числа.
Трябва да върнете бройката на съвпадащи стойности на съвпадащи индекси, използвайки [`countSameElementsOnSameIndecies`].

.note
[*14.11.2025*] Оправен вход на последния пример.

:table_2
|= Вход
|= Изход

|:
```
1 2 3 4 5 6 7 8 9 10
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

|: 10

|:
```
1 2 3 4 5 6 7 8 9 10
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

|: 0

|:
```
33 12 -97 -28 -48 -11 68 -42 88 -97
51 12 -97 -36 -47 -11 69 -42  6  88 -100 -79 -74 91 0

|: 4


## За самоподготовка

### Задача 11

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise11.cpp Решение]

Напишете функция, която приема неотрицателно цяло число и връща дали е просто.

От входа получавате две естествени числа.
Трябва да върнете бройката на всички прости числа между тези две числа (включително), използвайки вашата функция.

:table_2
|= Вход
|= Изход

|: 2 5
|: 3

|: 1 10
|: 4

|: 17 832
|: 139


### Задача 12

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise12.cpp Решение]

Напишете функция, която получава масив с произволен размер, съствен от цели числа, и инкрементира всеки елемент.

Получавате две редици от по 10 и 9 елемента.
Трябва да върнете двете редици, обаче всеки елемент е инкрементиран, използвайки вашата фунцкия.

:table_2
|= Вход
|= Изход

|:
```
1 2 3 4 5 6 7 8 9 10
10 20 30 40 50 60 70 80 90

|:
```
2 3 4 5 6 7 8 9 10 11
11 21 31 41 51 61 71 81 91

|:
```
-70 93 -39 99 21 -86 48 70 -53 0
25 100 28 -32 32 -70 -95 -98 -86

|:
```
-69 94 -38 100 22 -85 49 71 -52 1
26 101 29 -31 33 -69 -94 -97 -85


### Задача 13

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise13.cpp Решение]

Напишете функция, която получава масив от 4 букви и връща дали трите буква образуват последователност "буква, цифра, буква, цифра".

От входа получавате 12 букви и трябва да върнете дали целия масив образува последователността "буква, цифра, буква, цифра, буква, цифрва, ...", използвайки вашата функция.

.note
[*(14.11.2025)*] Оправен трети пример.

:table_2
|= Вход
|= Изход

|: a 0 a 0 a 0 a 0 a 0 a 0
|: Follows pattern

|: a b c d e f g h i j k l
|: Does not follow pattern

|: k 9 H 8 m 0 Q 7 Q 7 i 1
|: Follows pattern


### Задача 14

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise14.cpp Решение]

Напишете функция, която получава масив от 10 реални числа и [*връща*] масив от 5 реални числа.
Резултатния масив се формира по следния начин:
.numbered
1. Първия елемент на [*върнатия*] масив е разликата на втория от първия елемент на входния (получения) масив.
2. Втория елемент на [*върнатия*] масив е разликата на четвъртия от третия елемент на входния масив.
3. И така нататък.

От входа получавате масив с 10 елемента.
Трябва да [*върнете*] резултатния 5-елементен масив от вашата функция.

:table_2
|= Вход
|= Изход

|: 1 2 3 4 5 6 7 8 9 10
|: 1 1 1 1 1

|: 1 2 3 5 6 9 10 14 15 20
|: 1 2 3 4 5

|: 1 1 1 1 1 1 1 1 1 1
|: 0 0 0 0 0

|: 38 70 -34 84 -84 -15 10 92 27 -22
|: 32 118 69 82 -49


### Задача 15

.solution-link [url https://github.com/Syndamia/upp-2025-solutions/tree/main/Week07/Exercise15.cpp Решение]

Напишете две функции, всяка от които приема масив с 5 естествени числа.
Нека първата да повдига всяко число на втора степен и втората да умножава всяко число по 3.
Тези операции трябва да се извършват върху входните за функциите елементи (inplace).

От входа получавате 5 неотрицателни цели числа и 6то целево число.
Започвайки с 5те числа, първо ги повдигате на втора степен, след това умножавате по 3, след това повдигате пак, след това умножавате пак, и така докато целевото число не се срещне в редицата.

Когато това се случи, изкарайте редицата с 5 числа.
Допуснете, че винаги ще срещнете целевото число.
Използвайте вашите функции.
.note
[*(14.11.2025)*] Оправени входове на първите два примера.

:table_2
|= Вход
|= Изход

|: 1 2 3 4 5 48
|: 3 12 27 48 75

|: 1 2 3 4 5 47775744
|: 729 186624 4782969 47775744 284765625

|: 6 5 3 6 7 3586355551445647360
|: 3586355551445647360 2189469451904296875 617673396283947 3586355551445647360 15687628237922985707