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
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
|
# Задачи - УПП, Седмица 9, 01.12.2023
\n
GitHub classroom: [url https://classroom.github.com/a/lGXxCRZO classroom.github.com/a/lGXxCRZO]
.warn Освен ако не е казано друго, може да зачитате, че максималната дължина на един низ е 1024 знака.
## Задача 1
Получавате от входа два низа.
Трябва да изкарате на екрана низ, при който има знакът "\_" на индексите, където буквите между двата низа се различават, и съответната буква, когато не се различават.
[=Пример:=]
:table_2
|= Вход
|= Изход
|:
```
ABCDE
AKDDCP
|:
```
A__D__
## Задача 2
От входа получавате число N и на следващия ред получавате низ с толкова на брой знака.
Изкарайте на екрана втората половина от низа и след това директно долепена първата половина.
Ако низа е с нечетна дължина, зачитаме средния елемент като част от втората половина.
.important Трябва да използвате динамична памет
[=Примери:=]
:table_2
|= Вход
|= Изход
|:
```
6
A CM N
|:
```
M NA C
|:
```
7
ABCKLMN
|:
```
KLMNABC
## Задача 3
От входа получаввате един низ, трябва да изкарате броя думи в него.
Думите се разделят с една или повече шпации, като знаци (точка, запетая, удивителна, ...) не са думи.
[=Примери:=]
:table_2
|= Вход
|= Изход
|:
```
abc
|: 1
|:
```
abc def
|: 2
|:
```
This , is , a , sentence .!
|: 4
## Задача 4
Една от ранните програми за Apple I компютърът, написана от Steve Wozniak в упътването на компютъра, е така наречената "Woz Monitor", или wozmon за картко.
Тя позволява да погледнеш стойностите в клетки от паметта, да запишеш стойности и да стартираш програми.
Игнорирайки последната му възможност, нека да го имплементираме.
За нашите цели, паметта на компютъра е просто един масив, които ще расте [=когато е нужно=].
Ще адресираме (индексираме) стойностите от масива с числа от 16-тична бройна система.
Когато въведем низ във формата:
:unordered
- "адрес", без нищо друго на реда, изкарваме "X: V", където X е конкретния адрес (пак в 16-тична бройна система) и V е стойността на клетката в този адрес.
- "адрес.адрес", връщаме стойностите между тези адреси (включително) във формата "X: V ...", където X е начален адрес и "V ..." са стойностите на всяка клетка.
.p
Допълнително, ако изкарваме повече от 8 адреса, трябва да продължим на нов ред, като изкараме в същия формат.
Пример: вход: "0.А", изход:
```
0: 0 0 0 0 0 0 0 0
8: 0 0 0
- "адрес: стойност", записваме "стойност" на дадения адрес.
Стойноста също е 16-тично число.
Трябва да върнем старата стойност в адреса (във формата "X: V").
- "адрес: стойност ...", като предходното, обаче може да определим стойностите на сегашната и на следващите клетки (пак изкарваме във формата "X: V ...")
[=Примери:=]
:table_2
|= Вход
|= Изход
|:
```
0
|:
```
0: 0
|:
```
2.8
|:
```
2: 0 0 0 0 0 0 0
|:
```
2: FF
2
|:
```
2: 0
2: FF
|:
```
2: FF 0 A 5
2.5
|:
```
2: 0 0 0 0
2: FF 0 A 5
|:
```
1: FA 0 9 3 5 6 1 2 ABB 8A 99
1.12
|:
```
1: 0 0 0 0 0 0 0 0
9: 0 0 0
1: FA 0 9 3 5 6 1 2
9: ABB 8A 99 0
## Задача 5
Перфокартите са стар формат за съхраняване на текст (код) върху хартиен носител, който е четим от машини.
Разделени са на някакъв брой редове и колони, всяка колона определя една буква, и всеки ред определя битовите стойности на всяка буква, като дупката означава бит 1, а липсата и бит 0.
[image https://upload.wikimedia.org/wikipedia/commons/thumb/4/4c/Blue-punch-card-front-horiz.png/1024px-Blue-punch-card-front-horiz.png
За удобство на програмиста, почти винаги най-отгоре на колоната се изписва с мастило каква е буквата на съответната колона.
Трябва да имплементирате програма, която получава перфо карти в стандартния IBM формат: 12 реда и 80 колони и изкарва съответния ред, който е закодиран.
Тоест, от входа получавате 12 низа, всеки низ е с дължина 80, и са съставени от 0 и 1.\n
Стойностите [=по колони=]:
.bulleted
- от "100000000000" до "000000000001" (със само една 1ца) съответстват на знаците "&", "-", "0", "1", ... "9".
- от "100100000000" до "100000000001" (с две 1ци, едната която е винаги първата) съответстват на знаците от "A" до "I".
- от "010100000000" до "010000000001" (с две 1ци, едната която е винаги втората) съответстват на знаците от "J" до "R".
- от "001100000000" до "001000000001" (с две 1ци, едната която е винаги третата) съответстват на знаците "/", "S", ... "Z".
[=Пример:=]
:table_2
|= Вход
|= Изход
|:
```
100000000000111111111000000000000000000
010000000000000000000111111111000000000
001000000000000000000000000000111111111
000100000000100000000100000000100000000
000010000000010000000010000000010000000
000001000000001000000001000000001000000
000000100000000100000000100000000100000
000000010000000010000000010000000010000
000000001000000001000000001000000001000
000000000100000000100000000100000000100
000000000010000000010000000010000000010
000000000001000000001000000001000000001
|: &-0123456789ABCDEFGHIJKLMNOPQR/STUVWXYZ
## Задача 6
Регулярните изрази са низове, които позволяват да опишем шаблони, с които да филтрираме/приемаме низове.
Вие ще ги изучавате много подробно в "Езици, автомати и изчислимост", но за нашите цели ще се абстрахираме от детайлите.
Правилата за регулярни изрази са следните:
.bulleted
- ако е буквата "\*", значи предходната буква може да се повтаря 0 или повече пъти
- ако е буквата "?", значи предходната буква може да се повтаря 0 или 1 пъти
- ако не е някой от горните знаци, тогава искаме сегашната буква да бъде равна на тази в израза
:unordered
1. Какво описва регулярният израз [`aa*bcd`]?
.p
Първата буква от нашия низ трябва да бъде [`а`].
След това имаме [`a*`], след тази първа буква може да имаме 0 или повече [`a`]-та.
Тоест втората буква може да бъде [`a`] или [`b`], ако е [`a`], третата буква може да бъде [`a`] или [`b`], обаче ако втората буква е [`b`], тогава продължаваме напред и останалите букви трябва да са [`bcd`].
.p
Тоест, този регулярен израз приема низове, които започват с [`a`], след това имат 0 или повече [`a`]-та и завършват на [`bcd`].
Следните низове ще бъдат приети: "abcd", "aabcd", "aaabcd", "aaaabcd" и так. нат.
2. Какво описва регулярният израз [`b*cd?`]?
.p
В началото имаме [`b`] нула или повече пъти, след това имаме [`c`] и накрая имаме нула или едно [`d`].
Следните низове ще бъдат приети: "c", "bc", "bbc", "bbbc", ..., "cd", "bcd", "bbcd", ...
От входа получавате число N и след това ще получите 2N на брой редове.
Един ред ще бъде регулярен израз, следващия ще бъде низ за проверка, след това пак регулярен израз, след това пак низ за проверка и така се редуват.
След всеки регулярен израз и низ за проверка, проверявате дали низа се приема от регулярния израз, и изкарвате "Matched".
В противен случай изкарвате "No match".
Ако регулярния израз е в грешен формат (срещнете "?" или "\*" като първи знак), трябва да изкарате "Bad regex".
[=Пример:=]
[*Смесен вход/изход*]
```
'include ./ex6-io.txt
|
