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

'define expected-reading 13 min
'define created 10 November 2025
'define edited 11 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

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

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

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

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

|: 6
|: Even and positive

|: -4
|: Not even and positive

|: 15
|: Not even and positive


### Задача 2

Напишете функция, която приема цяло неотрицателно число `[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

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

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

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

: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
|: 5.5

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


### Задача 4

Напишете функция, която приема число с плаваща запетая и *[връща]* две числа:
.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

Напишете функция `[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

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

```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

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

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

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

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

: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
|: 0 1 -1


### Задача 8

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

Тоест, ако масива е `[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

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

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

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

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

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

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

[image ./img/polynomial.png]

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

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

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

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

|: 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.56706
|: Is a root

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

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


### Задача 10

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

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

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

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

: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

|: 4


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

### Задача 11

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

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

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

|: 2 5
|: 3

|: 1 10
|: 4

|: 17 832
|: 139


### Задача 12

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

Получавате две редици от по 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

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

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

: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 912 h 84 m 10 q 7 q 7 i 19
|: Follows pattern


### Задача 14

Напишете функция, която получава масив от 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

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

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

Когато това се случи, изкарайте редицата с 5 числа.
Допуснете, че винаги ще срещнете целевото число.
Използвайте вашите функции.

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

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

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

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