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

'def title Задачи - УПП, Седмица 10, 04.12.2025
'def  desc Условията на задачите за упражнение.

# {title}

{pagenav 12 min;01 December 2025;03 December 2025}

.important
Едно от най-важните неща: {b всяка динамично-заделена памет трябва да се освободи преди края на програмата!}

GitHub Classroom: {url https://classroom.github.com/a/kDfmWmy7}

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

### Задача 1

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise01.cpp}

Потребителя ще въведе цяло неотрицателно число n.
След това ще въведе n на брой реални числа.
Трябва да изкарате числата в обратен ред.

Няма ограничения върху размера n.

:table
:2
|= Вход
|= Изход

|: 5 1 2 3 4 5
|: 5 4 3 2 1

|: 49 40.8 -97 45 -98 -22 63 -28 78 44 59 -39 10 -46 -39 87 -59 -59 57 70.01 91 5 -90 -72 94 -19 40 55 24 -91 86 -56 70 54 -12 -53 37 -31.1 -82 -70 -15 -100 -91 6 89 -43 93 -45 -69 -24
|: -24 -69 -45 93 -43 89 6 -91 -100 -15 -70 -82 -31.1 37 -53 -12 54 70 -56 86 -91 24 55 40 -19 94 -72 -90 5 91 70.01 57 -59 -59 87 -39 -46 10 -39 59 44 78 -28 63 -22 -98 45 -97 40.8



### Задача 2

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise02.cpp}

Реализирайте функцията {` average}, която приема масив, съставен от цели числа, с произволен размер, и връща средното аритметично на всички тези числа.

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

:table
:2
|= Вход
|= Изход

|: 4 -2 38 0 2 16 -231 8 8
|: -20.125



### Задача 3

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise03.cpp}

От входа получавате размерите на матрица, съставена от неотрицателни целочислени стойности, и след това всички стойности в самата матрица.
{b В паметта} обърнете реда на редовете и изкарайте резултата.

.question
Може ли да се направи по по-прост начин, отколкото ако матрицата беше статично-заделена?

:table
:2
|= Вход
|= Изход

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

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



### Задача 4

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise04.cpp}

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

Ако умножението не е възможно, изкарайте съобщение за грешка.

:table
:2
|= Вход
|= Изход

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

|:
```
8 10 8
20 25 20
32 40 32

|:
```
4 2
28.1 10
7 0
-93.9 -40
5 68
3 2
10 11
3 -1
0 0

|:
```
Cannot multiply!



### Задача 5

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise05.cpp}

.note
{i (07.12.2025)} Оправено условие и пример

Реализирайте функция {` largest}, която приема матрица, съставена от цели числа, с произволни размери, и връща най-големия елемент в нея.

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

:table
:2
|= Вход
|= Изход

|:
```
5 7
-25 52 87 -79 -25
-6 96 42 90 26
60 -100 97 -12 -89
32 -7 31 89 -83
-70 84 -61 38 31
-8 22 -36 -99 -41
27 -70 -65 44 87

|: 97



### Задача 6

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise06.cpp}

От входа получавате цели числа, докато не получите числото 0.
Трябва да върнете редицата, където всяко число е равно на сумата на себе си и следващото число.
Последното число не го променяйте.

:table
:2
|= Вход
|= Изход

|: 1 2 3 4 5 0
|: 15 14 12 9 5

|: 8 18 -34 9 11 500 3 777 0
|: 1292 1284 1266 1300 1291 1280 780 777 0



### Задача 7

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise07.cpp}

Змия пълзи върху произволно голяма дъска, разделена на квадратна решетка.
Тя започва в клетка (0,0), която ще зачитаме за горния ляв ъгъл на дъската.

Във всеки момент тя (главата ѝ) отива на някоя съседна клетка: горна, долна, лява или дясна.
Ако тази клетка е невалидна или змията вече е била на тази клетка, тя спира да се движи.

От входа получавате движенията на змията чрез буквите u, d, l, r, докато тя не спре да се движи.
След това получавате координат в дъската, трябва да върнете дали змията някога е посетила тази клетка.

.note
{i (07.12.2025)} Разменени ред и колона в примерите

:table
:2
|= Вход
|= Изход

|: r r d l u 1 0
|: Not visited

|: r r d l u 0 1
|: Visited

|: r r d l u 85 13
|: Not visited

|: r l 0 1
|: Visited

|: l 0 0
|: Visited

|: r r d d r r u u l l 1 3
|: Not visited



### Задача 8

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise08.cpp}

От входа получавате преплетени елементите в два масива, съдържащи цели числа.
Тоест, първия елемент е първи на първия масив, втори елемент е първи на втория масив, третия елемент е втори на първия масив и так. нат.

Трябва да върнете елементите, пак преплетени, но по друга схема: елементите от втората редица са в обратен ред и първия елемент (от ляво на дясно) е елемент на втората редица.

Числото 0 обозначава край на преплетената редица.

:table
:2
|= Вход
|= Изход

|: 1 10 2 20 3 30 4 40 5 50 0
|: 50 1 40 2 30 3 20 4 10 5

|: 1 10 2 0
|: 10 1 2



### Задача 9

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise09.cpp}

От входа получавате стойностите на "jagged" матрица: такава, където редовете имат различни размери в паметта.
Тоест, получавате размер на текущия ред и след това всичките му стойности.
Ако размера е нула, приемете че матрицата е завършена.

Трябва да изкарате, на отделни редове, стойностите във всяка "колона" отгоре надолу, започвайки от последната "колона" към първата.
Игнорирайте "дупки" от елементи.

:table
:2
|= Вход
|= Изход

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

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



### Задача 10

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise10.cpp}

.important
Заемайте възможно най-малко памет!

Матрица от тип "пясъчен часовник" ще наричаме всяка матрица, където броя елементи от първия и последния ред са еднакви, от втория и пред-последния, от третия и пред-пред последния и так. нат., и размера на всеки вътрешен е с единица по-малък от предходния, докато в средата не остане само един елемент (при нечетен размер) или два елемента (при четен размер).

Върнете елементите от краищата на пясъчния часовник: първо са елементите от първия ред, след това тези от вторичния диагонал, след това тези от дъното и накрая тези от главния диагонал, като елементите се обикалят в съответната посока.
Тоест, елементите на главния диагонал се обикалят в обратен ред.


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

.note
{i (07.12.2025)} Поправен примера с четния размер

:table
:2
|= Вход
|= Изход

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

|: 1 2 3 4 5 6 7 4

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

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

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

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



## За упражнение

### Задача 11

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise11.cpp}

От входа получавате цяло неотрицатлно число n, което обозначава степеннта на полином.
След това получавате реалните коефициенти пред всяка степен (започвайки от най-голямата, n).

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

.note
{i (07.12.2025)} Поправени примерите с първа степен полином

:table
:2
|= Вход
|= Изход

|: 2 1 -5 6 2
|: Is a root

|: 2 1 -5 6 3
|: Is a root

|: 2 1 -5 6 5
|: Not a root

|: 0 5 0
|: Not a root

|: 0 5 5
|: Not a root

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

|: 1 1 5 0
|: Not a root

|: 7 0 0 1 -5 14 0.5 -2.2 7 -0.78691
|: Is a root



### Задача 12

.solution-link {url Решение;https://github.com/Syndamia/upp-2025-solutions/tree/main/Week10/Exercise12.cpp}

.important
Заемайте възможно най-малко памет!

От входа получавате двойки елементи: първо индекс и след това число с плаваща запетая.
В масив с непознат размер (от стойности с плаваща запетая), на тези позиции са единствените ненулеви числа.
Входа свършва, когато подадения индекс е отрицателно число.


След това получавате индекс и трябва да върнете стойността на съответния елемент.

:table
:2
|= Вход
|= Изход

|: 0 81 383 9.2 100293 -4 -1 383
|: 9.2

|: 0 81 383 9.2 100293 -4 -1 100292
|: 0



### Задача 13

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

След това влизате в "потребителски интерфейс", където от входа получавате буква, обозначаваща команда върху дневника.
Командите са:
.bulleted
- {` e} обозначава край на програмата
- {` m}, получавате индекс на ден и трябва да върнете максималната продажба в този ден
- {` M}, трябва да върнете индекса на най-печелившия ден

{b Пример:} {i (вход и изход са смесени, изходът е удебелен)}
```
3
4 0.5 100 19.99 7
0
2 500 8
m 0
{b 100}
m 1
{b 0}
m 2
{b 500}
M
{b 2}
e

### Задача 14

От входа получавате матрица по следния начин: първия елемент е на позиция (1,1) (горня ляв елемент на матрицата), втория елемент е (1,m) (горния десен елемент на матрицата), третия елемент е (2,1), четвъртия е (2, m).
Така, докато не се запълнят първата и последната колона.
Схемата продължава по същия начин, но и за вторатата и пред-последната колона.

Стойностите в матрицата са целочислени.
Когато получите елемента -1001, тогава тогава елементите за двете колони са свършили и продължавате със следващата двойка колони.
Когато получите -2222, тогава елементите на матрицата са свършили.

За дадена колона може да получите по-малко елементи отколкото трябва! В такъв случай попълнете останалите позиции с нули.

След това, от входа получавате ред и колона.
Трябва да изкарате матрицата, без съответния ред и стълб.

:table
:2
|= Вход
|= Изход

|: 1 2 3 -1001 4 5 6 7 8 9 -1001 -2222 2 1
.comment
1 4 5 2
3 6 7
  8 9

|:
```
1 5 2
3 7