1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
|
'def title Задачи - УПП, Седмица 6, 10.11.2023
'def desc Условия на задачите за упражнение
# {title}
\n
GitHub classroom: {url classroom.github.com/a/BBLlWMOy;https://classroom.github.com/a/BBLlWMOy}
## Задача 1
Първо получавате две цели положителни числа: N и M.
След това ще получите редица числа, първите ще отговарят на матрица NxM (N реда, M стълба), вторите на матрица MxN.
Трябва да умножите първата матрица по втората, както следва обикновенното правило за умножение ред по стълб и да изкарате резултата на екрана.
N и M са между 1 и 60.
{b Пример:}
:table
:2
|= Вход
|= Изход
|:
```
4 3
8 1 9
0 3 0
4 7 5
6 9 0
9 5 7 3
6 7 2 0
1 3 3 7
|:
```
87 74 85 87
18 21 6 0
83 84 57 47
108 93 60 18
## Задача 2
Разглеждаме числатата от 0 до N.
За всяко число знаем колко интервала го включват (покриват).
Тоест в {` 0 1 1 0} означава, че 0 интервала "покриват" числото 0, един интервал покрива числото 1, един интервал покрива числото 2 и 0 покриват числото 3.
Търси се колко различни интервала имаме.
Не различаваме между два долепени интервала и един дълъг интервал.
От входа получаввате N (от 1 до 30), и след това N на брой числа: броя покриващи интервали за всички числа от 0 до N-1.
{b Примери:}
:table
:2
|= Вход
|= Изход
|:
```
5
1 1 0 1 1
|: 2
|:
```
5
1 2 1 2 1
|: 3
|:
```
5
9 5 2 9 0
|: 16
|:
```
11
1 1 2 3 2 2 4 2 1 1 1
|: 5
## Задача 3
Трябва да имплементирате дигитална версия на морски шах.
Всяка клетка е номерирана от 1 до 9, както на мобилен телефон или калкулатор.
В началото изкарвате (празното) игрално поле, първо играе Х, след това О, и се редуват докато не завърши играта.
След като един играч избере своя ход, трябва да покажете игралното поле.
Ако след това излезе, че някой играч е спечелил, трябва да изкарате "PLAYER wins!" (където PLAYER е X или O) и да спрете програмата.
В случай, че игралното поле се запълни и никой не е спечелил, след последното му изкарване трябва да върнете "Draw!" и да спрете програмата.
{b Пример:}
{i Смесен вход/изход, вход е означен с "$ " преди него}
```
'snippet 1 $ ./ex3-io.txt
{b Бонус:} направете го да работи с NxN брой клетки, като N е число между 1 и 50.
## Задача 4
Имплементирайте играта {url chomp;https://en.wikipedia.org/wiki/Chomp}: представете си, че имаме един шоколад, разделен на NxM квадратчета.
Всеки играч избира квадратче (координати), след това изяжда всички парчета, които са в дясно или надолу от квадратчето.
Играчът, който изяде квадратчето в горния ляв ъгъл губи играта.
От входа получавате две числа, N и M, това е броя редове и колони в шоколада.
След това изкарвате шоколада, като с # маркирате неизядено квадратче, а с шпация - изядено.
Редуват се първия и втория играч, като всеки въвежда две числа - координати в шоколада (между 1 и N за реда и 1 и M за колоната).
Когато някой изяде парчето в горния ляв ъгъл, програмата изкарва "PLAYER wins!" (PLAYER е 1 или 2) и спира изпълнение.
{b Пример}
{i Смесен вход/изход, вход е означен с "$ " преди него}
```
'snippet 1 $ ex4-io.txt
## Задача 5
{b Тази задача е много трудна, proceed with caution!}
Ще имплементираме програма, която "симулира" един елементарен компютър.
Компютъра ни, като всеки друг, работи само и единствено с цели неотрицателни числа.
Неговата (използваема) памет е разделена на две части: два "регистъра", наречени А и B, и "RAM" памет (един масив) с 128 стойности.
В началото въвеждаме програма (разбира се това са числа), която трябва да бъде поставена в RAM паметта.
Първото число е инструкция, следващите няколко числа са нейни аргументи, и след това имаме друга инструкция.
Започваме изпълнение от началото на паметта, след като изпълним една инструкция, изпълняваме тази директно до нея, и така докато не стигнем инструкцията "EXT".
В такъв случай, изкарваме стойността в регистър B и спираме програмата.
Това са командите, описани във формата "D - {` A B C}", като D е число, съответстващо на инструкцията с име {` A} (името го използваме за нас, в кода то не присъства) и аргументи след името {` B} и {` C}.
{` MEMORY} е число, съответстващо на индекс (адрес) в паметта на компютъра (между 0 и 127), а {` VALUE} е произволна числова стойност.
:unordered
- 0 - {` EXT} - край на изпълнението на програмата в симулирания компютър
- 1 - {` INC MEMORY} - инкрементира стойността на индекс {` MEMORY}\n
Пример: {` 0 2} - инкрементира стойността на индекс 2
- 2 - {` RIN VALUE MEMORY} - инкрементира стойността на индекс {` VALUE + MEMORY}\n
Пример: {` 1 3 6} - инкрементира стойността на адрес {` 3 + 6 = 9}
- 3 - {` DEC MEMORY} - декрементира стойността на индекс {` MEMORY}
- 4 - {` RDE VALUE MEMORY} - декрементира стойността на индекс {` VALUE + MEMORY}
- 5 - {` STA MEMORY} - запазва стойността на индекс {` MEMORY} в регистъра А\n
Пример: {` 4 19} - запазва стойността на индекс 19 в регистъра А
- 6 - {` RST VALUE MEMORY} - запазва стойността на адрес {` VALUE + MEMORY} в регистър А\n
Пример: {` 5 2 14} - запазва стойността на индекс {` 2 + 14 = 16} в регистър А
- 7 - {` STB MEMORY} - запазва стойността на индекс {` MEMORY} в регистъра B
- 8 - {` BEQ MEMORY} - продължава изпълнение от индекс {` MEMORY}, ако стойността в регистъра А е нула\n
Пример: {` 7 8} - продължава изпълнение от индекс 8, ако стойността в регистър А е нула
- 9 - {` BNE MEMORY} - продължава изпълнение от индекс {` MEMORY}, ако стойността в регистъра А не е нула
В началото получавате N, това са броя числа, които съставят цялата програма.
След това се въвеждат N числа, които са цялата програма.
Ако по време на изпълнение стигнете до инструкция, която не е дефинирана, изкарвате "Error: undefined instruction!" и спирате програмата.
Ако някой аргумент е индекс в паметта, обаче стойността му е извън обхвата на паметта, изкарвате "Error: invalid memory address!" и спирате програмата.
Ако няма грешка и програмата успешно стигне до {` EXT} инструкция, както беше казано, изкарваме на екрана стойността в регистъра B.
{b Примери:}
:table
:2
|= Вход
|= Изход
|: 3 10 8 0
|: Error: undefined instruction!
|: 3 5 8000 0
|: Error: invalid memory address!
|: 6 1 3 7 3 0 958
|: 959
|: 17 5 9 8 6 1 8 3 9 5 9 9 2 7 8 0 91461 772000
|: 863461
.question Какво прави последната програма?
{b Бонус:} направете програми за симулаторния компютър, които
.ordered
1. умножават числата 87401 и 37
2. намира сумата на числата 87, 305, 2, 612, 222
|
