Тема 1.4: заборы блоков кода исправлены на три обратные кавычки

JustCaptain · 1 неделю назад e44b3dcaea03c3c3b4fbebcb5af2325d40ae8b10

Родитель: 6fd6c9a · сравнить с родителем

4 файла

C++/Тема 1.4. Циклы и перебор вариантов/Задачи/Необязательные задачи.md +4 −4

Показать разницуСкрыть разницу

131	131
132	132	Ввод:
133	133
134		−'''text
	134	+```text
135	135	3
136		−'''
	136	+```
137	137
138	138	Вывод:
139	139
140		−'''text
	140	+```text
141	141	1 2 3
142	142	2 4 6
143	143	3 6 9
144		−'''
	144	+```
145	145
146	146	> [!NOTE]
147	147	> Здесь нужны вложенные циклы: внешний отвечает за строки, внутренний — за столбцы. После внутреннего цикла не забудьте `cout << endl;`.

C++/Тема 1.4. Циклы и перебор вариантов/Задачи/Обязательные задачи (LMS).md +20 −20

Показать разницуСкрыть разницу

24	24
25	25	Ввод:
26	26
27		−'''text
	27	+```text
28	28	10
29	29	3
30		−'''
	30	+```
31	31
32	32	Вывод:
33	33
34		−'''text
	34	+```text
35	35	3
36		−'''
	36	+```
37	37
38	38	Ввод:
39	39
40		−'''text
	40	+```text
41	41	5
42	42	5
43		−'''
	43	+```
44	44
45	45	Вывод:
46	46
47		−'''text
	47	+```text
48	48	1
49		−'''
	49	+```
50	50
51	51	> [!NOTE]
52	52	> В первом примере Юра решает 3, потом 4, потом 5 задач: 3 + 4 + 5 = 12 ≥ 10, значит, хватит трёх дней. Во втором примере уже в первый день решено 5 задач из 5 — нужен один день.
73	73
74	74	Ввод:
75	75
76		−'''text
	76	+```text
77	77	123
78		−'''
	78	+```
79	79
80	80	Вывод:
81	81
82		−'''text
	82	+```text
83	83	131
84		−'''
	84	+```
85	85
86	86	Ввод:
87	87
88		−'''text
	88	+```text
89	89	9
90		−'''
	90	+```
91	91
92	92	Вывод:
93	93
94		−'''text
	94	+```text
95	95	11
96		−'''
	96	+```
97	97
98	98	Ввод:
99	99
100		−'''text
	100	+```text
101	101	99
102		−'''
	102	+```
103	103
104	104	Вывод:
105	105
106		−'''text
	106	+```text
107	107	101
108		−'''
	108	+```
109	109
110	110	> [!NOTE]
111	111	> Числа 124, 125, ..., 130 палиндромами не являются, а 131 читается одинаково в обе стороны. После однозначного числа 9 идёт двузначное 11, после 99 — трёхзначное 101.

C++/Тема 1.4. Циклы и перебор вариантов/Задачи/Практика.md +44 −44

Показать разницуСкрыть разницу

22	22
23	23	Ввод:
24	24
25		−'''text
	25	+```text
26	26	6
27	27	4 -3 8 0 -2 5
28		−'''
	28	+```
29	29
30	30	Вывод:
31	31
32		−'''text
	32	+```text
33	33	17
34		−'''
	34	+```
35	35
36	36	> [!NOTE]
37	37	> Положительные числа: 4, 8 и 5. Их сумма: 4 + 8 + 5 = 17. Ноль не добавляется, потому что условие `x > 0` для него ложно.
56	56
57	57	Ввод:
58	58
59		−'''text
	59	+```text
60	60	6 30
61	61	12 18 27 35 31 28
62		−'''
	62	+```
63	63
64	64	Вывод:
65	65
66		−'''text
	66	+```text
67	67	4
68		−'''
	68	+```
69	69
70	70	Ввод:
71	71
72		−'''text
	72	+```text
73	73	3 100
74	74	10 20 30
75		−'''
	75	+```
76	76
77	77	Вывод:
78	78
79		−'''text
	79	+```text
80	80	0
81		−'''
	81	+```
82	82
83	83	> [!NOTE]
84	84	> Номера башен считаются с единицы, а счётчик цикла начинается с нуля — поэтому при выводе нужно `i + 1`.
103	103
104	104	Ввод:
105	105
106		−'''text
	106	+```text
107	107	5
108	108	2 7 8 5 4
109		−'''
	109	+```
110	110
111	111	Вывод:
112	112
113		−'''text
	113	+```text
114	114	YES
115		−'''
	115	+```
116	116
117	117	Ввод:
118	118
119		−'''text
	119	+```text
120	120	4
121	121	2 4 5 7
122		−'''
	122	+```
123	123
124	124	Вывод:
125	125
126		−'''text
	126	+```text
127	127	NO
128		−'''
	128	+```
129	129
130	130	> [!NOTE]
131	131	> В первом примере чётность меняется на каждом шаге: чёт, нечёт, чёт, нечёт, чёт. Во втором примере числа 2 и 4 стоят подряд — чередование нарушено.
150	150
151	151	Ввод:
152	152
153		−'''text
	153	+```text
154	154	6
155	155	98 87 98 91 75 98
156		−'''
	156	+```
157	157
158	158	Вывод:
159	159
160		−'''text
	160	+```text
161	161	3
162		−'''
	162	+```
163	163
164	164	> [!NOTE]
165	165	> Лучший результат — 98 баллов, его показали три участника.
184	184
185	185	Ввод:
186	186
187		−'''text
	187	+```text
188	188	6
189	189	5 9 2 4 8 1
190		−'''
	190	+```
191	191
192	192	Вывод:
193	193
194		−'''text
	194	+```text
195	195	15
196		−'''
	196	+```
197	197
198	198	> [!NOTE]
199	199	> Первый максимум — 9. После него стоят 2, 4, 8 и 1: их сумма равна 15. Здесь нужны два прохода по данным, поэтому числа придётся сохранить в массив.
224	224
225	225	Ввод:
226	226
227		−'''text
	227	+```text
228	228	10
229		−'''
	229	+```
230	230
231	231	Вывод:
232	232
233		−'''text
	233	+```text
234	234	18
235		−'''
	235	+```
236	236
237	237	> [!NOTE]
238	238	> Подходящие числа: 3, 6, 9. Их сумма равна 18. Обратите внимание на границу цикла: `i <= n`, потому что `N` входит в диапазон.
257	257
258	258	Ввод:
259	259
260		−'''text
	260	+```text
261	261	8
262	262	5 4 5 3 5 2 4 5
263		−'''
	263	+```
264	264
265	265	Вывод:
266	266
267		−'''text
	267	+```text
268	268	4
269		−'''
	269	+```
270	270
271	271	---
272	272
288	288
289	289	Ввод:
290	290
291		−'''text
	291	+```text
292	292	17 25 11 42 39 0
293		−'''
	293	+```
294	294
295	295	Вывод:
296	296
297		−'''text
	297	+```text
298	298	42
299		−'''
	299	+```
300	300
301	301	> [!NOTE]
302	302	> Количество чисел заранее неизвестно, поэтому здесь удобен `while` с условием `cin >> x && x != 0`.
321	321
322	322	Ввод:
323	323
324		−'''text
	324	+```text
325	325	5 8 3 6 8 2 0
326		−'''
	326	+```
327	327
328	328	Вывод:
329	329
330		−'''text
	330	+```text
331	331	2
332		−'''
	332	+```
333	333
334	334	> [!NOTE]
335	335	> Максимум равен 8 и встречается дважды. Когда находится новый максимум, счётчик сбрасывается в 1, а при повторении максимума — увеличивается.

C++/Тема 1.4. Циклы и перебор вариантов/Необходимый материал.md +50 −50

Показать разницуСкрыть разницу

32	32
33	33	Используется, когда количество повторений известно.
34	34
35		−'''cpp
	35	+```cpp
36	36	for (инициализация; условие; шаг) {
37	37	// тело цикла
38	38	}
39		−'''
	39	+```
40	40
41	41	Порядок работы:
42	42
45	45	3. Тело цикла — то, что повторяется.
46	46	4. Шаг — выполняется после каждой итерации. Обычно `i++`.
47	47
48		−'''cpp
	48	+```cpp
49	49	// числа от 1 до 5
50	50	for (int i = 1; i <= 5; i++) {
51	51	cout << i << " ";
52	52	}
53	53	cout << endl; // 1 2 3 4 5
54		−'''
	54	+```
55	55
56	56	### Три частых варианта границ
57	57
58		−'''cpp
	58	+```cpp
59	59	// обход n элементов: i = 0, 1, ..., n - 1 — ровно n итераций
60	60	for (int i = 0; i < n; i++) { ... }
61	61
64	64
65	65	// обратный обход: n, n - 1, ..., 1
66	66	for (int i = n; i >= 1; i--) { ... }
67		−'''
	67	+```
68	68
69	69	> [!WARNING]
70	70	> `i < n` и `i <= n` — это разное число итераций. Для `for (int i = 0; i < n; i++)` итераций ровно `n`, а для `for (int i = 0; i <= n; i++)` — уже `n + 1`. Это самая частая ошибка на олимпиадах.
75	75
76	76	Используется, когда количество повторений заранее неизвестно, но есть условие продолжения.
77	77
78		−'''cpp
	78	+```cpp
79	79	while (условие) {
80	80	// тело цикла
81	81	}
82		−'''
	82	+```
83	83
84	84	Порядок работы: проверяется условие → если истинно, выполняется тело → условие проверяется снова → если ложно, цикл завершается.
85	85
86		−'''cpp
	86	+```cpp
87	87	// сумма чисел от 1 до n
88	88	int s = 0;
89	89	int i = 1;
91	91	s += i;
92	92	i++;
93	93	}
94		−'''
	94	+```
95	95
96	96	> [!CAUTION]
97	97	> В `while` счётчик меняется вручную внутри тела цикла. Если забыть `i++`, условие никогда не станет ложным и программа зависнет — получится бесконечный цикл.
102	102
103	103	Похож на `while`, но условие проверяется после тела, поэтому тело выполняется хотя бы один раз.
104	104
105		−'''cpp
	105	+```cpp
106	106	do {
107	107	// тело цикла
108	108	} while (условие);
109		−'''
	109	+```
110	110
111		−'''cpp
	111	+```cpp
112	112	// сумма и количество чисел до первого нуля
113	113	double sum = 0;
114	114	int count = 0;
121	121	count++;
122	122	}
123	123	} while (number != 0);
124		−'''
	124	+```
125	125
126	126	> [!NOTE]
127	127	> `do-while` нужен там, где действие должно произойти хотя бы раз: например, «запросить пароль, потом проверить». В олимпиадных задачах он встречается редко, чаще хватает `while`.
148	148
149	149	Вложенный цикл — цикл внутри цикла. Внешний цикл делает одну итерацию, а внутренний за это время полностью проходит все свои.
150	150
151		−'''cpp
	151	+```cpp
152	152	// таблица умножения 3 × 3
153	153	for (int i = 1; i <= 3; i++) {
154	154	for (int j = 1; j <= 3; j++) {
156	156	}
157	157	cout << endl;
158	158	}
159		−'''
	159	+```
160	160
161		−'''text
	161	+```text
162	162	1 2 3
163	163	2 4 6
164	164	3 6 9
165		−'''
	165	+```
166	166
167	167	Полный перебор — стратегия, при которой мы проверяем все возможные варианты и выбираем подходящий. Обычно реализуется вложенными циклами.
168	168
169		−'''cpp
	169	+```cpp
170	170	// все пары (i, j), такие что i + j = 5
171	171	for (int i = 0; i <= 5; i++) {
172	172	for (int j = 0; j <= 5; j++) {
175	175	}
176	176	}
177	177	}
178		−'''
	178	+```
179	179
180	180	> [!WARNING]
181	181	> Два вложенных цикла по `n` итераций дают `n²` операций — сложность O(n²). Для `n = 1000` это миллион операций (быстро), а для `n = 100000` — уже 10¹⁰ (слишком долго). Если перебор не укладывается в лимит времени, ищите формулу или другой алгоритм.
186	186
187	187	### Сумма
188	188
189		−'''cpp
	189	+```cpp
190	190	int sum = 0;
191	191	for (int i = 0; i < n; i++) {
192	192	int x;
193	193	cin >> x;
194	194	sum += x;
195	195	}
196		−'''
	196	+```
197	197
198	198	### Сумма с условием
199	199
200		−'''cpp
	200	+```cpp
201	201	int sum = 0;
202	202	for (int i = 0; i < n; i++) {
203	203	int x;
206	206	sum += x;
207	207	}
208	208	}
209		−'''
	209	+```
210	210
211	211	### Подсчёт количества
212	212
213		−'''cpp
	213	+```cpp
214	214	int cnt = 0;
215	215	for (int i = 0; i < n; i++) {
216	216	int x;
219	219	cnt++;
220	220	}
221	221	}
222		−'''
	222	+```
223	223
224	224	### Максимум и минимум
225	225
226		−'''cpp
	226	+```cpp
227	227	int mx = -1000000000; // «минус бесконечность»
228	228	int mn = 1000000000; // «плюс бесконечность»
229	229
233	233	if (x > mx) mx = x;
234	234	if (x < mn) mn = x;
235	235	}
236		−'''
	236	+```
237	237
238	238	### Поиск первого подходящего
239	239
240		−'''cpp
	240	+```cpp
241	241	for (int i = 0; i < n; i++) {
242	242	int x;
243	243	cin >> x;
247	247	}
248	248	}
249	249	cout << 0 << endl; // не нашли
250		−'''
	250	+```
251	251
252	252	### Количество максимальных элементов
253	253
254		−'''cpp
	254	+```cpp
255	255	int mx = -1000000000;
256	256	int cnt = 0;
257	257
265	265	cnt++;
266	266	}
267	267	}
268		−'''
	268	+```
269	269
270	270	### Второй максимум
271	271
272		−'''cpp
	272	+```cpp
273	273	int mx1 = -1000000000; // максимум
274	274	int mx2 = -1000000000; // наибольшее число, меньшее максимума
275	275
283	283	mx2 = x;
284	284	}
285	285	}
286		−'''
	286	+```
287	287
288	288	### Длина самой длинной серии
289	289
290		−'''cpp
	290	+```cpp
291	291	int current = 0, best = 0;
292	292	for (int i = 0; i < n; i++) {
293	293	int x;
299	299	current = 0;
300	300	}
301	301	}
302		−'''
	302	+```
303	303
304	304	> [!IMPORTANT]
305	305	> Переменные `sum`, `cnt`, `mx`, `mn` обязательно инициализируются до цикла. Иначе там будет «мусор» и ответ окажется неверным.
310	310
311	311	Если количество чисел заранее неизвестно, а последовательность завершается нулём (ноль в неё не входит), удобно писать так:
312	312
313		−'''cpp
	313	+```cpp
314	314	int x;
315	315	while (cin >> x && x != 0) {
316	316	// обработка x
317	317	}
318		−'''
	318	+```
319	319
320	320	Условие `cin >> x && x != 0` читается так: «считать число, и если оно не ноль — продолжить». Как только встречается `0`, цикл завершается.
321	321
322		−'''cpp
	322	+```cpp
323	323	// максимум последовательности до нуля
324	324	int mx = -1000000000;
325	325	int x;
327	327	if (x > mx) mx = x;
328	328	}
329	329	cout << mx << endl;
330		−'''
	330	+```
331	331
332	332	---
333	333
335	335
336	336	Сумму арифметической прогрессии можно посчитать без цикла:
337	337
338		−'''text
	338	+```text
339	339	1 + 2 + 3 + ... + n = n * (n + 1) / 2
340		−'''
	340	+```
341	341
342		−'''cpp
	342	+```cpp
343	343	// циклом — n итераций
344	344	int s = 0;
345	345	for (int i = 1; i <= n; i++) {
346	346	s += i;
347	347	}
348		−'''
	348	+```
349	349
350		−'''cpp
	350	+```cpp
351	351	// формулой — одна операция
352	352	long long s = (long long)n * (n + 1) / 2;
353		−'''
	353	+```
354	354
355	355	Пример: задача «Ёлочки». Ёлка красоты `n` состоит из `2n` ветвей длины `1, 2, ..., n` и ствола длины `2n + 1`. Площадь равна `2 * (1 + 2 + ... + n) + 2n + 1`, то есть `n * (n + 1) + 2n + 1`.
356	356
357		−'''cpp
	357	+```cpp
358	358	long long n;
359	359	cin >> n;
360	360	cout << n * (n + 1) + 2 * n + 1 << endl;
361		−'''
	361	+```
362	362
363	363	> [!TIP]
364	364	> Если задачу можно решить формулой — решайте формулой. Цикл на 2·10⁹ итераций работает десятки секунд и не проходит по времени, а формула — мгновенно.
384	384
385	385	## 11. Шаблон программы
386	386
387		−'''cpp
	387	+```cpp
388	388	#include <iostream>
389	389	using namespace std;
390	390
397	397
398	398	return 0;
399	399	}
400		−'''
	400	+```

← К файлам