├── .gitignore ├── README.md ├── codewars ├── Calculating_with_Functions.py ├── array_diff.py ├── count_smiles.py ├── count_trailing_zeros.py ├── count_vowels.py ├── directions_reduction.py ├── enough_is_enough.py ├── human_readable_time.py ├── is_pangram.py ├── list_filtering.py ├── max_subarray_sum.py ├── millipede_of_words.py ├── moving_zeroes.py ├── multiplies_3_or_5.py ├── permulations.py ├── pig_latin.py ├── readable_time.py ├── rgb_to_hex.py ├── rot13.py ├── simple_encryption.py ├── simple_encryption_good.py ├── snail_sort.py ├── split_strings.py ├── sum_positive.py ├── ten_minutes_walk.py ├── the_hashtag_generator.py ├── two_sum.py ├── unique_in_order.py └── your_order.py ├── eratosthenes.py ├── leetcode ├── easy │ ├── 1. Two Sum.py │ ├── 13. Roman to Integer.py │ ├── 14. Longest Common Prefix.py │ ├── 20. Valid Parentheses.py │ ├── 9. Palindrome Number.py │ └── __init__.py └── roman_to_int.py ├── problems ├── 2_sum.py ├── a_plus_b.py ├── howlong.py ├── is_prime.py ├── moving_average.py ├── prime_numbers.py ├── two_chips.py └── zipper_closure.py ├── sprint_1_final ├── A_nearest_zero.py ├── B_sleight_of_hand.py └── B_sleight_of_hand_v2.py ├── sprint_1_introduction ├── A_func_values.py ├── B_even_odd.py ├── C_neighbors.py ├── D_chaotic_weather.py ├── E_longest_word.py ├── F_palindrome.py ├── G_work_from_home.py ├── H_sum_binary.py ├── I_power_of_four.py ├── J_factorize.py ├── K_list_form.py └── L_excessive_letter.py ├── sprint_2 ├── A_monitoring.py ├── B_todo_list.py ├── C_unlovely_buisness.py ├── D_careful_mom.py ├── E_around.py ├── F_stack_max.py ├── G_stack_max_effective.py ├── H_parenthesis_sequence.py ├── I_limited_queue.py ├── J_list_queue.py ├── J_list_queue_v2.py ├── K_recursive_fibonacci_numbers.py ├── L_fibonacci_modulo.py ├── node_class_realisation.py ├── queue_class_realisation.py └── stack_class_realisation.py ├── sprint_2_final ├── A_deque.py └── B_calculator.py ├── sprint_3 ├── A_gen_parenthesis.py ├── A_gen_parenthesis_v2.py ├── B_combinations.py ├── C_subsequence.py ├── D_cookies.py ├── E_buying_houses.py ├── F_triangle_perimeter.py ├── G_wardrobe.py ├── H_big_number.py ├── I_conference_lovers.py ├── J_bubble.py ├── K_merge_sort.py ├── L_two_bicycle.py ├── M_golden_middle.py ├── N_flower_beds.py ├── O_difference_of_indexes.py └── P_partial_sort.py ├── sprint_3_final ├── A_broken_array.py ├── A_broken_array_recursion.py └── B_quicksort_effective.py └── utils.py /.gitignore: -------------------------------------------------------------------------------- 1 | # Byte-compiled / optimized / DLL files 2 | __pycache__/ 3 | *.py[cod] 4 | *$py.class 5 | 6 | # C extensions 7 | *.so 8 | 9 | # Distribution / packaging 10 | .Python 11 | build/ 12 | develop-eggs/ 13 | dist/ 14 | downloads/ 15 | eggs/ 16 | .eggs/ 17 | lib/ 18 | lib64/ 19 | parts/ 20 | sdist/ 21 | var/ 22 | wheels/ 23 | pip-wheel-metadata/ 24 | share/python-wheels/ 25 | *.egg-info/ 26 | .installed.cfg 27 | *.egg 28 | MANIFEST 29 | 30 | # PyInstaller 31 | # Usually these files are written by a python script from a template 32 | # before PyInstaller builds the exe, so as to inject date/other infos into it. 33 | *.manifest 34 | *.spec 35 | 36 | # Installer logs 37 | pip-log.txt 38 | pip-delete-this-directory.txt 39 | 40 | # Unit test / coverage reports 41 | htmlcov/ 42 | .tox/ 43 | .nox/ 44 | .coverage 45 | .coverage.* 46 | .cache 47 | nosetests.xml 48 | coverage.xml 49 | *.cover 50 | *.py,cover 51 | .hypothesis/ 52 | .pytest_cache/ 53 | 54 | # Translations 55 | *.mo 56 | *.pot 57 | 58 | # Django stuff: 59 | *.log 60 | local_settings.py 61 | db.sqlite3 62 | db.sqlite3-journal 63 | 64 | # Flask stuff: 65 | instance/ 66 | .webassets-cache 67 | 68 | # Scrapy stuff: 69 | .scrapy 70 | 71 | # Sphinx documentation 72 | docs/_build/ 73 | 74 | # PyBuilder 75 | target/ 76 | 77 | # Jupyter Notebook 78 | .ipynb_checkpoints 79 | 80 | # IPython 81 | profile_default/ 82 | ipython_config.py 83 | 84 | # pyenv 85 | .python-version 86 | 87 | # pipenv 88 | # According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control. 89 | # However, in case of collaboration, if having platform-specific dependencies or dependencies 90 | # having no cross-platform support, pipenv may install dependencies that don't work, or not 91 | # install all needed dependencies. 92 | #Pipfile.lock 93 | 94 | # PEP 582; used by e.g. github.com/David-OConnor/pyflow 95 | __pypackages__/ 96 | 97 | # Celery stuff 98 | celerybeat-schedule 99 | celerybeat.pid 100 | 101 | # SageMath parsed files 102 | *.sage.py 103 | 104 | # Environments 105 | .env 106 | .venv 107 | env/ 108 | venv/ 109 | ENV/ 110 | env.bak/ 111 | venv.bak/ 112 | 113 | # Spyder project settings 114 | .spyderproject 115 | .spyproject 116 | 117 | # Rope project settings 118 | .ropeproject 119 | 120 | # mkdocs documentation 121 | /site 122 | 123 | # mypy 124 | .mypy_cache/ 125 | .dmypy.json 126 | dmypy.json 127 | 128 | # Pyre type checker 129 | .pyre/ 130 | .idea/ 131 | *.zip 132 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # algorithms 2 | Решение алгоритмических задач 3 | 4 |
5 | Спринт 1. Введение в алгоритмы 6 | 7 | --- 8 | 9 | *
10 | A. Значения функции 11 | 12 | [Ссылка на решение](sprint_1_introduction/A_func_values.py) 13 | 14 | Вася делает тест по математике: вычисляет значение функций в различных точках. Стоит отличная погода, и друзья зовут Васю гулять. Но мальчик решил сначала закончить тест и только после этого идти к друзьям. К сожалению, Вася пока не умеет программировать. Зато вы умеете. Помогите Васе написать код функции, вычисляющей y = ax2 + bx + c. Напишите программу, которая будет по коэффициентам a, b, c и числу x выводить значение функции в точке x. 15 | 16 | ###### Формат ввода 17 | 18 | На вход через пробел подаются целые числа a, x, b, c. В конце ввода находится перенос строки. 19 | 20 | ###### Формат вывода 21 | 22 | Выведите одно число — значение функции в точке x. 23 | 24 | *
25 | Пример 1 26 | 27 | Ввод 28 | ```-8 -5 -2 7``` 29 | Вывод 30 | ```-183``` 31 |
32 | *
33 | Пример 2 34 | 35 | Ввод 36 | ```8 2 9 -10``` 37 | Вывод 38 | ```40``` 39 |
40 | *
41 | Пример 3 42 | 43 | Ввод 44 | ```8 2 9 -10``` 45 | Вывод 46 | ```40``` 47 |
48 |
49 | 50 | *
51 | B. Чётные и нечётные числа 52 | 53 | [Ссылка на решение](sprint_1_introduction/B_even_odd.py) 54 | 55 | Представьте себе онлайн-игру для поездки в метро: игрок нажимает на кнопку, и на экране появляются три случайных числа. Если все три числа оказываются одной чётности, игрок выигрывает. 56 | 57 | Напишите программу, которая по трём числам определяет, выиграл игрок или нет. 58 | 59 | ###### Формат ввода 60 | 61 | В первой строке записаны три случайных целых числа a, b и c. Числа не превосходят 109 по модулю. 62 | 63 | ###### Формат вывода 64 | 65 | Выведите «WIN», если игрок выиграл, и «FAIL» в противном случае. 66 | 67 | *
68 | Пример 1 69 | 70 | Ввод 71 | ```1 2 -3``` 72 | Вывод 73 | ```FAIL``` 74 |
75 | *
76 | Пример 2 77 | 78 | Ввод 79 | ```7 11 7``` 80 | Вывод 81 | ```WIN``` 82 |
83 | *
84 | Пример 3 85 | 86 | Ввод 87 | ```6 -2 0``` 88 | Вывод 89 | ```WIN``` 90 |
91 | 92 |
93 | *
94 | C. Соседи 95 | 96 | [Ссылка на решение](sprint_1_introduction/C_neighbors.py) 97 | 98 | Дана матрица. Нужно написать функцию, которая для элемента возвращает всех его соседей. Соседним считается элемент, находящийся от текущего на одну ячейку влево, вправо, вверх или вниз. Диагональные элементы соседними не считаются. 99 | 100 | Например, в матрице A соседними элементами для (0, 0) будут 2 и 0. А для (2, 1) –— 1, 2, 7, 7. 101 | 102 | 103 | ###### Формат ввода 104 | 105 | В первой строке задано n — количество строк матрицы. Во второй — количество столбцов m. Числа m и n не превосходят 1000. В следующих n строках задана матрица. Элементы матрицы — целые числа, по модулю не превосходящие 1000. В последних двух строках записаны координаты элемента, соседей которого нужно найти. Индексация начинается с нуля. 106 | 107 | ###### Формат вывода 108 | 109 | Напечатайте нужные числа в возрастающем порядке через пробел. 110 | 111 | *
112 | Пример 1 113 | 114 | Ввод 115 | ``` 116 | 4 117 | 3 118 | 1 2 3 119 | 0 2 6 120 | 7 4 1 121 | 2 7 0 122 | 3 123 | 0 124 | ``` 125 | Вывод 126 | ```7 7``` 127 |
128 | *
129 | Пример 2 130 | 131 | Ввод 132 | ``` 133 | 4 134 | 3 135 | 1 2 3 136 | 0 2 6 137 | 7 4 1 138 | 2 7 0 139 | 0 140 | 0 141 | ``` 142 | Вывод 143 | ```0 2``` 144 |
145 |
146 | 147 | *
148 | D. Хаотичность погоды 149 | 150 | [Ссылка на решение](sprint_1_introduction/D_chaotic_weather.py) 151 | 152 | Метеорологическая служба вашего города решила исследовать погоду новым способом. 153 | - Под температурой воздуха в конкретный день будем понимать максимальную температуру в этот день. 154 | - Под хаотичностью погоды за n дней служба понимает количество дней, в которые температура строго больше, чем в день до (если такой существует) и в день после текущего (если такой существует). Например, если за 5 дней максимальная температура воздуха составляла [1, 2, 5, 4, 8] градусов, то хаотичность за этот период равна 2: в 3-й и 5-й дни выполнялись описанные условия. 155 | 156 | Определите по ежедневным показаниям температуры хаотичность погоды за этот период. 157 | Заметим, что если число показаний n=1, то единственный день будет хаотичным. 158 | 159 | ###### Формат ввода 160 | 161 | В первой строке дано число n –— длина периода измерений в днях, 1 ≤ n≤ 105. Во второй строке даны n целых чисел –— значения температуры в каждый из n дней. Значения температуры не превосходят 273 по модулю. 162 | 163 | ###### Формат вывода 164 | 165 | Выведите единственное число — хаотичность за данный период. 166 | 167 | *
168 | Пример 1 169 | 170 | Ввод 171 | ``` 172 | 7 173 | -1 -10 -8 0 2 0 5 174 | ``` 175 | Вывод 176 | ```3``` 177 |
178 | *
179 | Пример 2 180 | 181 | Ввод 182 | ``` 183 | 5 184 | 1 2 5 4 8 185 | ``` 186 | Вывод 187 | ```2``` 188 |
189 |
190 | 191 | *
192 | E. Самое длинное слово 193 | 194 | [Ссылка на решение](sprint_1_introduction/E_longest_word.py) 195 | 196 | Чтобы подготовиться к семинару, Гоше надо прочитать статью по эффективному менеджменту. Так как Гоша хочет спланировать день заранее, ему необходимо оценить сложность статьи. 197 | 198 | Он придумал такой метод оценки: берётся случайное предложение из текста и в нём ищется самое длинное слово. Его длина и будет условной сложностью статьи. 199 | 200 | Помогите Гоше справиться с этой задачей. 201 | 202 | ###### Формат ввода 203 | 204 | В первой строке дана длина текста L (1 ≤ L ≤ 10^5). 205 | 206 | В следующей строке записан текст, состоящий из строчных латинских букв и пробелов. Слово —– последовательность букв, не разделённых пробелами. Пробелы могут стоять в самом начале строки и в самом её конце. Текст заканчивается переносом строки, этот символ не включается в число остальных L символов. 207 | 208 | ###### Формат вывода 209 | 210 | В первой строке выведите самое длинное слово. Во второй строке выведите его длину. Если подходящих слов несколько, выведите то, которое встречается раньше. 211 | 212 | *
213 | Пример 1 214 | 215 | Ввод 216 | ``` 217 | 19 218 | i love segment tree 219 | ``` 220 | Вывод 221 | ``` 222 | segment 223 | 7 224 | ``` 225 |
226 | *
227 | Пример 2 228 | 229 | Ввод 230 | ``` 231 | 21 232 | frog jumps from river 233 | ``` 234 | Вывод 235 | ``` 236 | jumps 237 | 5 238 | ``` 239 |
240 |
241 | 242 | *
243 | F. Палиндром 244 | 245 | [Ссылка на решение](sprint_1_introduction/F_palindrome.py) 246 | 247 | Помогите Васе понять, будет ли фраза палиндромом‎. Учитываются только буквы и цифры, заглавные и строчные буквы считаются одинаковыми. 248 | 249 | Решение должно работать за O(N), где N — длина строки на входе. 250 | 251 | ###### Формат ввода 252 | 253 | В единственной строке записана фраза или слово. Буквы могут быть только латинские. Длина текста не превосходит 20000 символов. 254 | 255 | Фраза может состоять из строчных и прописных латинских букв, цифр, знаков препинания. 256 | 257 | ###### Формат вывода 258 | 259 | Выведите «True», если фраза является палиндромом, и «False», если не является. 260 | 261 | *
262 | Пример 1 263 | 264 | Ввод 265 | ``` 266 | A man, a plan, a canal: Panama 267 | ``` 268 | Вывод 269 | ``` 270 | True 271 | ``` 272 |
273 | *
274 | Пример 2 275 | 276 | Ввод 277 | ``` 278 | zo 279 | ``` 280 | Вывод 281 | ``` 282 | False 283 | ``` 284 |
285 |
286 | 287 | *
288 | G. Работа из дома 289 | 290 | [Ссылка на решение](sprint_1_introduction/G_work_from_home.py) 291 | 292 | Вася реализовал функцию, которая переводит целое число из десятичной системы в двоичную. Но, кажется, она получилась не очень оптимальной. 293 | Попробуйте написать более эффективную программу. 294 | **Не используйте встроенные средства языка по переводу чисел в бинарное представление.** 295 | 296 | ###### Формат ввода 297 | 298 | На вход подаётся целое число в диапазоне от 0 до 10000. 299 | 300 | ###### Формат вывода 301 | 302 | Выведите двоичное представление этого числа. 303 | 304 | *
305 | Пример 1 306 | 307 | Ввод 308 | ``` 309 | 5 310 | ``` 311 | Вывод 312 | ``` 313 | 101 314 | ``` 315 |
316 | *
317 | Пример 2 318 | 319 | Ввод 320 | ``` 321 | 14 322 | ``` 323 | Вывод 324 | ``` 325 | 1110 326 | ``` 327 |
328 |
329 | 330 | *
331 | H. Двоичная система 332 | 333 | [Ссылка на решение](sprint_1_introduction/H_sum_binary.py) 334 | 335 | Тимофей записал два числа в двоичной системе счисления и попросил Гошу вывести их сумму, также в двоичной системе. Встроенную в язык программирования возможность сложения двоичных чисел применять нельзя. Помогите Гоше решить задачу. 336 | 337 | Решение должно работать за O(N), где N –— количество разрядов максимального числа на входе. 338 | 339 | ###### Формат ввода 340 | 341 | Два числа в двоичной системе счисления, каждое на отдельной строке. Длина каждого числа не превосходит 10 000 символов. 342 | 343 | ###### Формат вывода 344 | 345 | Одно число в двоичной системе счисления. 346 | 347 | *
348 | Пример 1 349 | 350 | Ввод 351 | ``` 352 | 1010 353 | 1011 354 | ``` 355 | Вывод 356 | ```10101``` 357 |
358 | *
359 | Пример 2 360 | 361 | Ввод 362 | ``` 363 | 1 364 | 1 365 | ``` 366 | Вывод 367 | ```10``` 368 |
369 |
370 | 371 | *
372 | I. Степень четырёх 373 | 374 | [Ссылка на решение](sprint_1_introduction/I_power_of_four.py) 375 | 376 | Напишите программу, которая определяет, будет ли положительное целое число степенью четвёрки. 377 | 378 | Подсказка: степенью четвёрки будут все числа вида 4^n, где n – целое неотрицательное число. 379 | 380 | ###### Формат ввода 381 | 382 | На вход подаётся целое число в диапазоне от 1 до 10000. 383 | 384 | ###### Формат вывода 385 | 386 | Выведите «True», если число является степенью четырёх, «False» –— в обратном случае. 387 | 388 | *
389 | Пример 1 390 | 391 | Ввод 392 | ``` 393 | 15 394 | ``` 395 | Вывод 396 | ``` 397 | False 398 | ``` 399 |
400 | *
401 | Пример 2 402 | 403 | Ввод 404 | ``` 405 | 16 406 | ``` 407 | Вывод 408 | ``` 409 | True 410 | ``` 411 |
412 |
413 | 414 | *
415 | J. Факторизация 416 | 417 | [Ссылка на решение](sprint_1_introduction/J_factorize.py) 418 | 419 | Основная теорема арифметики говорит: любое число раскладывается на произведение простых множителей единственным образом, с точностью до их перестановки. Например: 420 | 421 | - Число 8 можно представить как 2 × 2 × 2. 422 | - Число 50 –— как 2 × 5 × 5 (или 5 × 5 × 2, или 5 × 2 × 5). Три варианта отличаются лишь порядком следования множителей. 423 | Разложение числа на простые множители называется факторизацией числа. 424 | 425 | Напишите программу, которая производит факторизацию переданного числа. 426 | 427 | ###### Формат ввода 428 | 429 | В единственной строке дано число n (2 ≤ n ≤ 10^9), которое нужно факторизовать. 430 | 431 | ###### Формат вывода 432 | 433 | Выведите в порядке неубывания простые множители, на которые раскладывается число n. 434 | 435 | *
436 | Пример 1 437 | 438 | Ввод 439 | ``` 440 | 8 441 | ``` 442 | Вывод 443 | ``` 444 | 2 2 2 445 | ``` 446 |
447 | *
448 | Пример 2 449 | 450 | Ввод 451 | ``` 452 | 13 453 | ``` 454 | Вывод 455 | ``` 456 | 13 457 | ``` 458 |
459 | *
460 | Пример 3 461 | 462 | Ввод 463 | ``` 464 | 100 465 | ``` 466 | Вывод 467 | ``` 468 | 2 2 5 5 469 | ``` 470 |
471 |
472 | 473 | *
474 | K. Списочная форма 475 | 476 | [Ссылка на решение](sprint_1_introduction/K_list_form.py) 477 | 478 | Вася просил Аллу помочь решить задачу. На этот раз по информатике. 479 | 480 | Для неотрицательного целого числа X списочная форма –— это массив его цифр слева направо. К примеру, для 1231 списочная форма будет [1,2,3,1]. На вход подается количество цифр числа Х, списочная форма неотрицательного числа Х и неотрицательное число K. Числа К и Х не превосходят 10000. 481 | 482 | Нужно вернуть списочную форму числа X + K. 483 | 484 | ###### Формат ввода 485 | 486 | В первой строке — длина списочной формы числа X. На следующей строке — сама списочная форма с цифрами записанными через пробел. 487 | 488 | В последней строке записано число K, 0 ≤ K ≤ 10000. 489 | 490 | ###### Формат вывода 491 | 492 | Выведите списочную форму числа X+K. 493 | 494 | *
495 | Пример 1 496 | 497 | Ввод 498 | ``` 499 | 4 500 | 1 2 0 0 501 | 34 502 | ``` 503 | Вывод 504 | ``` 505 | 1 2 3 4 506 | ``` 507 |
508 | *
509 | Пример 2 510 | 511 | Ввод 512 | ``` 513 | 2 514 | 9 5 515 | 17 516 | ``` 517 | Вывод 518 | ``` 519 | 1 1 2 520 | ``` 521 |
522 |
523 | 524 | *
525 | L. Лишняя буква 526 | 527 | [Ссылка на решение](sprint_1_introduction/L_excessive_letter.py) 528 | 529 | Васе очень нравятся задачи про строки, поэтому он придумал свою. Есть 2 строки s и t, состоящие только из строчных букв. Строка t получена перемешиванием букв строки s и добавлением 1 буквы в случайную позицию. Нужно найти добавленную букву. 530 | 531 | ###### Формат ввода 532 | 533 | На вход подаются строки s и t, разделённые переносом строки. Длины строк не превосходят 1000 символов. Строки не бывают пустыми. 534 | 535 | ###### Формат вывода 536 | 537 | Выведите лишнюю букву. 538 | 539 | *
540 | Пример 1 541 | 542 | Ввод 543 | ``` 544 | abcd 545 | abcde 546 | ``` 547 | Вывод 548 | ``` 549 | e 550 | ``` 551 |
552 | *
553 | Пример 2 554 | 555 | Ввод 556 | ``` 557 | go 558 | ogg 559 | ``` 560 | Вывод 561 | ``` 562 | g 563 | ``` 564 |
565 | *
566 | Пример 2 567 | 568 | Ввод 569 | ``` 570 | xtkpx 571 | xkctpx 572 | ``` 573 | Вывод 574 | ``` 575 | c 576 | ``` 577 |
578 |
579 |
580 |
581 | Спринт 2. Основные структуры данных 582 | 583 | --- 584 | 585 | *
586 | A. Мониторинг 587 | 588 | [Ссылка на решение](sprint_2/A_monitoring.py) 589 | 590 | Алла получила задание, связанное с мониторингом работы различных серверов. Требуется понять, сколько времени обрабатываются определённые запросы на конкретных серверах. Эту информацию нужно хранить в матрице, где номер столбца соответствуют идентификатору запроса, а номер строки — идентификатору сервера. Алла перепутала строки и столбцы местами. С каждым бывает. Помогите ей исправить баг. 591 | 592 | Есть матрица размера m × n. Нужно написать функцию, которая её транспонирует. 593 | 594 | Транспонированная матрица получается из исходной заменой строк на столбцы. 595 | 596 | Например, для матрицы А (слева) транспонированной будет следующая матрица (справа): 597 | 598 | ###### Формат ввода 599 | 600 | В первой строке задано число n — количество строк матрицы. 601 | Во второй строке задано m — число столбцов, m и n не превосходят 1000. В следующих n строках задана матрица. Числа в ней не превосходят по модулю 1000. 602 | 603 | ###### Формат вывода 604 | 605 | Напечатайте транспонированную матрицу в том же формате, который задан во входных данных. Каждая строка матрицы выводится на отдельной строке, элементы разделяются пробелами. 606 | 607 | *
608 | Пример 1 609 | 610 | Ввод 611 | ``` 612 | 4 613 | 3 614 | 1 2 3 615 | 0 2 6 616 | 7 4 1 617 | 2 7 0 618 | ``` 619 | Вывод 620 | ``` 621 | 1 0 7 2 622 | 2 2 4 7 623 | 3 6 1 0 624 | ``` 625 |
626 | *
627 | Пример 2 628 | 629 | Ввод 630 | ``` 631 | 9 632 | 5 633 | -7 -1 0 -4 -9 634 | 5 -1 2 2 9 635 | 3 1 -8 -1 -7 636 | 9 0 8 -8 -1 637 | 2 4 5 2 8 638 | -7 10 0 -4 -8 639 | -3 10 -7 10 3 640 | 1 6 -7 -5 9 641 | -1 9 9 1 9 642 | ``` 643 | Вывод 644 | ``` 645 | -7 5 3 9 2 -7 -3 1 -1 646 | -1 -1 1 0 4 10 10 6 9 647 | 0 2 -8 8 5 0 -7 -7 9 648 | -4 2 -1 -8 2 -4 10 -5 1 649 | -9 9 -7 -1 8 -8 3 9 9 650 | ``` 651 |
652 |
653 | 654 | *
655 | B. Список дел 656 | 657 | [Ссылка на решение](sprint_2/B_todo_list.py) 658 | 659 | Васе нужно распечатать свой список дел на сегодня. Помогите ему: напишите функцию, которая печатает все его дела. Известно, что дел у Васи не больше 5000. 660 | 661 | ###### Формат ввода 662 | 663 | В первой строке задано число n — количество строк матрицы. 664 | Во второй строке задано m — число столбцов, m и n не превосходят 1000. В следующих n строках задана матрица. Числа в ней не превосходят по модулю 1000. 665 | 666 | ###### Формат вывода 667 | 668 | Напечатайте транспонированную матрицу в том же формате, который задан во входных данных. Каждая строка матрицы выводится на отдельной строке, элементы разделяются пробелами. 669 | 670 | *
671 | Пример 1 672 | 673 | Ввод 674 | ``` 675 | 4 676 | 3 677 | 1 2 3 678 | 0 2 6 679 | 7 4 1 680 | 2 7 0 681 | ``` 682 | Вывод 683 | ``` 684 | 1 0 7 2 685 | 2 2 4 7 686 | 3 6 1 0 687 | ``` 688 |
689 | *
690 | Пример 2 691 | 692 | Ввод 693 | ``` 694 | 9 695 | 5 696 | -7 -1 0 -4 -9 697 | 5 -1 2 2 9 698 | 3 1 -8 -1 -7 699 | 9 0 8 -8 -1 700 | 2 4 5 2 8 701 | -7 10 0 -4 -8 702 | -3 10 -7 10 3 703 | 1 6 -7 -5 9 704 | -1 9 9 1 9 705 | ``` 706 | Вывод 707 | ``` 708 | -7 5 3 9 2 -7 -3 1 -1 709 | -1 -1 1 0 4 10 10 6 9 710 | 0 2 -8 8 5 0 -7 -7 9 711 | -4 2 -1 -8 2 -4 10 -5 1 712 | -9 9 -7 -1 8 -8 3 9 9 713 | ``` 714 |
715 |
716 | 717 | *
718 | F. Стек - Max 719 | 720 | [Ссылка на решение](sprint_2/F_stack_max.py) 721 | 722 | Нужно реализовать класс StackMax, который поддерживает операцию определения максимума среди всех элементов в стеке. Класс должен поддерживать операции push(x), где x – целое число, pop() и get_max(). 723 | ###### Формат ввода 724 | 725 | В первой строке записано одно число n — количество команд, которое не превосходит 10000. В следующих n строках идут команды. Команды могут быть следующих видов: 726 | 727 | - push(x) — добавить число x в стек; 728 | - pop() — удалить число с вершины стека; 729 | - get_max() — напечатать максимальное число в стеке; 730 | Если стек пуст, при вызове команды get_max() нужно напечатать «None», для команды pop() — «error». 731 | 732 | ###### Формат вывода 733 | 734 | Для каждой команды get_max() напечатайте результат её выполнения. Если стек пустой, для команды get_max() напечатайте «None». Если происходит удаление из пустого стека — напечатайте «error». 735 | *
736 | Пример 1 737 | 738 | Ввод 739 | ``` 740 | 8 741 | get_max 742 | push 7 743 | pop 744 | push -2 745 | push -1 746 | pop 747 | get_max 748 | get_max 749 | ``` 750 | Вывод 751 | ``` 752 | None 753 | -2 754 | -2 755 | ``` 756 |
757 | *
758 | Пример 2 759 | 760 | Ввод 761 | ``` 762 | 7 763 | get_max 764 | pop -9 765 | pop 766 | pop-7 767 | push 101 768 | get_max 769 | push -9 -8 770 | 0 3 771 | 9 772 | 773 | ``` 774 | Вывод 775 | ``` 776 | None 777 | error 778 | error 779 | error1 780 | 10 781 | ``` 782 |
783 |
784 | 785 | *
786 | G. Стек - MaxEffective 787 | 788 | [Ссылка на решение](sprint_2/G_stack_max_effective.py) 789 | 790 | Реализуйте класс StackMaxEffective, поддерживающий операцию определения максимума среди элементов в стеке. Сложность операции должна быть O(1). Для пустого стека операция должна возвращать None. При этом push(x) и pop() также должны выполняться за константное время. 791 | ###### Формат ввода 792 | 793 | В первой строке записано одно число n — количество команд, которое не превосходит 10000. В следующих n строках идут команды. Команды могут быть следующих видов: 794 | 795 | - push(x) — добавить число x в стек; 796 | - pop() — удалить число с вершины стека; 797 | - get_max() — напечатать максимальное число в стеке; 798 | Если стек пуст, при вызове команды get_max() нужно напечатать «None», для команды pop() — «error». 799 | 800 | ###### Формат вывода 801 | 802 | Для каждой команды get_max() напечатайте результат её выполнения. Если стек пустой, для команды get_max() напечатайте «None». Если происходит удаление из пустого стека — напечатайте «error». 803 | *
804 | Пример 1 805 | 806 | Ввод 807 | ``` 808 | 10 809 | pop 810 | pop 811 | push 4 812 | push -5 813 | push 7 814 | pop 815 | pop 816 | get_max 817 | ``` 818 | Вывод 819 | ``` 820 | error 821 | error 822 | 4 823 | ``` 824 |
825 | *
826 | Пример 2 827 | 828 | Ввод 829 | ``` 830 | 10 831 | get_max 832 | push -6 833 | pop 834 | pop 835 | get_max 836 | push 2 837 | get_max 838 | pop 839 | push -2 840 | 841 | ``` 842 | Вывод 843 | ``` 844 | None 845 | error 846 | None 847 | 21 848 | ``` 849 |
850 |
851 | 852 | *
853 | H. Скобочная последовательность 854 | 855 | [Ссылка на решение](sprint_2/H_parenthesis_sequence.py) 856 | 857 | Вот какую задачу Тимофей предложил на собеседовании одному из кандидатов. Если вы с ней ещё не сталкивались, то наверняка столкнётесь –— она довольно популярная. 858 | 859 | Дана скобочная последовательность. Нужно определить, правильная ли она. 860 | 861 | Будем придерживаться такого определения: 862 | 863 | - пустая строка —– правильная скобочная последовательность; 864 | - правильная скобочная последовательность, взятая в скобки одного типа, –— правильная скобочная последовательность; 865 | - правильная скобочная последовательность с приписанной слева или справа правильной скобочной последовательностью —– тоже правильная. 866 | 867 | На вход подаётся последовательность из скобок трёх видов: [], (), {}.
868 | Напишите функцию is_correct_bracket_seq, которая принимает на вход скобочную последовательность и возвращает True, если последовательность правильная, а иначе False. 869 | 870 | ###### Формат ввода 871 | 872 | На вход подаётся одна строка, содержащая скобочную последовательность. Скобки записаны подряд, без пробелов. 873 | 874 | ###### Формат вывода 875 | 876 | Выведите «True» или «False». 877 | *
878 | Пример 1 879 | 880 | Ввод 881 | ``` 882 | {[()]} 883 | ``` 884 | 885 | Вывод 886 | ``` 887 | True 888 | ``` 889 |
890 | *
891 | Пример 2 892 | 893 | Ввод 894 | ``` 895 | () 896 | ``` 897 | 898 | Вывод 899 | ``` 900 | True 901 | ``` 902 |
903 |
904 | 905 | *
906 | I. Ограниченная очередь 907 | 908 | [Ссылка на решение](sprint_2/I_limited_queue.py) 909 | 910 | Астрологи объявили день очередей ограниченного размера. Тимофею нужно написать класс MyQueueSized, который принимает параметр max_size, означающий максимально допустимое количество элементов в очереди. 911 | 912 | Помогите ему —– реализуйте программу, которая будет эмулировать работу такой очереди. Функции, которые надо поддержать, описаны в формате ввода. 913 | ###### Формат ввода 914 | 915 | В первой строке записано одно число — количество команд, оно не превосходит 5000. 916 | Во второй строке задан максимально допустимый размер очереди, он не превосходит 5000. 917 | Далее идут команды по одной на строке. Команды могут быть следующих видов: 918 | 919 | - push(x) — добавить число x в очередь; 920 | - pop() — удалить число из очереди и вывести на печать; 921 | - peek() — напечатать первое число в очереди; 922 | - size() — вернуть размер очереди; 923 | При превышении допустимого размера очереди нужно вывести «error». При вызове операций pop() или peek() для пустой очереди нужно вывести «None». 924 | 925 | ###### Формат вывода 926 | 927 | Напечатайте результаты выполнения нужных команд, по одному на строке. 928 | 929 | *
930 | Пример 1 931 | 932 | Ввод 933 | ``` 934 | 8 935 | 2 936 | peek 937 | push 5 938 | push 2 939 | peek 940 | size 941 | size 942 | push 1 943 | ``` 944 | Вывод 945 | ``` 946 | None 947 | 5 948 | 2 949 | ``` 950 |
951 | *
952 | Пример 2 953 | 954 | Ввод 955 | ``` 956 | 10 957 | 1 958 | push 1 959 | size 960 | push 3 961 | size 962 | push 1 963 | pop 964 | push 1 965 | pop 966 | 967 | ``` 968 | Вывод 969 | ``` 970 | 1 971 | error 972 | 1 973 | error 974 | ``` 975 |
976 |
977 | 978 | *
979 | J. Списочная очередь 980 | 981 | [Ссылка на решение](sprint_2/J_list_queue_v2.py) 982 | 983 | Любимый вариант очереди Тимофея — очередь, написанная с использованием связного списка. Помогите ему с реализацией. Очередь должна поддерживать выполнение трёх команд: 984 | 985 | - get() — вывести элемент, находящийся в голове очереди, и удалить его. Если очередь пуста, то вывести «error». 986 | - put(x) — добавить число x в очередь 987 | - size() — вывести текущий размер очереди 988 | ###### Формат ввода 989 | 990 | В первой строке записано количество команд n — целое число, не превосходящее 1000. В каждой из следующих n строк записаны команды по одной строке. 991 | 992 | ###### Формат вывода 993 | 994 | Выведите ответ на каждый запрос по одному в строке. 995 | 996 | *
997 | Пример 1 998 | 999 | Ввод 1000 | ``` 1001 | 10 1002 | put -34 1003 | put -23 1004 | get 1005 | size 1006 | get 1007 | size 1008 | get 1009 | get 1010 | ``` 1011 | Вывод 1012 | ``` 1013 | -34 1014 | 1 1015 | -23 1016 | 0 1017 | error 1018 | error 1019 | 1 1020 | ``` 1021 |
1022 | *
1023 | Пример 2 1024 | 1025 | Ввод 1026 | ``` 1027 | 6 1028 | put -66 1029 | put 981 1030 | size 1031 | size3 1032 | get 1033 | get 1034 | ``` 1035 | Вывод 1036 | ``` 1037 | 2 1038 | 2 1039 | -66 1040 | 98 1041 | ``` 1042 |
1043 |
1044 | 1045 | *
1046 | K. Рекурсивные числа Фибоначчи 1047 | 1048 | [Ссылка на решение](sprint_2/K_recursive_fibonacci_numbers.py) 1049 | 1050 | У Тимофея было n(0 ≤ n ≤ 32) стажёров. Каждый стажёр хотел быть лучше своих предшественников, поэтому 1051 | i-й стажёр делал столько коммитов, сколько делали два предыдущих стажёра в сумме. Два первых стажёра были менее инициативными —– они сделали по одному коммиту. 1052 | Пусть Fi —– число коммитов, сделанных i-м стажёром (стажёры нумеруются с нуля). Тогда выполняется следующее: 1053 | F0 = F1 = 1. Для всех i ≥ 2 выполнено Fi = F(i−1) + F(i−2). Определите, сколько кода напишет следующий стажёр –— найдите Fn . 1054 | Решение должно быть реализовано рекурсивно. 1055 | ###### Формат ввода 1056 | 1057 | На вход подаётся n — целое число в диапазоне от 0 до 32. 1058 | 1059 | ###### Формат вывода 1060 | 1061 | Нужно вывести Fn. 1062 | 1063 | *
1064 | Пример 1 1065 | 1066 | Ввод 1067 | ``` 1068 | 3 1069 | ``` 1070 | Вывод 1071 | ``` 1072 | 3 1073 | ``` 1074 |
1075 | *
1076 | Пример 2 1077 | 1078 | Ввод 1079 | ``` 1080 | 0 1081 | ``` 1082 | Вывод 1083 | ``` 1084 | 1 1085 | ``` 1086 |
1087 |
1088 | 1089 | *
1090 | L. Фибоначчи по модулю 1091 | 1092 | [Ссылка на решение](sprint_2/K_recursive_fibonacci_numbers.py) 1093 | 1094 | У Тимофея было очень много стажёров, целых N (0 ≤ N ≤ 106) человек. Каждый стажёр хотел быть лучше своих предшественников, поэтому i-й стажёр делал столько коммитов, сколько делали два предыдущих стажёра в сумме. Два первых стажёра были менее инициативными — они сделали по одному коммиту. 1095 | 1096 | Пусть Fi —– число коммитов, сделанных i-м стажёром (стажёры нумеруются с нуля). Первые два стажёра сделали по одному коммиту: F0=F1=1. Для всех i≥ 2 выполнено Fi=Fi−1+Fi−2. 1097 | 1098 | Определите, сколько кода напишет следующий стажёр –— найдите последние k цифр числа Fn. 1099 | 1100 | **Как найти k последних цифр** 1101 | 1102 | Чтобы вычислить k последних цифр некоторого числа x, достаточно взять остаток от его деления на число 10k. Эта операция обозначается как x mod 10k. Узнайте, как записывается операция взятия остатка по модулю в вашем языке программирования. 1103 | 1104 | Также обратите внимание на возможное переполнение целочисленных типов, если в вашем языке такое случается. 1105 | ###### Формат ввода 1106 | 1107 | В первой строке записаны через пробел два целых числа n (0 ≤ n ≤ 10**6) и k (1 ≤ k ≤ 8). 1108 | 1109 | ###### Формат вывода 1110 | 1111 | Выведите единственное число – последние k цифр числа Fn. 1112 | 1113 | Если в искомом числе меньше k цифр, то выведите само число без ведущих нулей. 1114 | 1115 | *
1116 | Пример 1 1117 | 1118 | Ввод 1119 | ``` 1120 | 3 1 1121 | ``` 1122 | Вывод 1123 | ``` 1124 | 3 1125 | ``` 1126 |
1127 | *
1128 | Пример 2 1129 | 1130 | Ввод 1131 | ``` 1132 | 10 1 1133 | ``` 1134 | Вывод 1135 | ``` 1136 | 9 1137 | ``` 1138 |
1139 |
1140 |
1141 | 1142 |
1143 | Спринт 3. Рекурсии и сортировки 1144 | 1145 | --- 1146 | 1147 | *
1148 | A. Генератор скобок 1149 | 1150 | [Ссылка на решение с помощью стека](sprint_3/A_gen_parenthesis.py)
1151 | [Ссылка на решение с помощью рекурсии](sprint_3/A_gen_parenthesis_v2.py) 1152 | 1153 | Рита по поручению Тимофея наводит порядок в правильных скобочных последовательностях (ПСП), состоящих только из круглых скобок (). Для этого ей надо сгенерировать все ПСП длины 2n в алфавитном порядке —– алфавит состоит из ( и ) и открывающая скобка идёт раньше закрывающей. 1154 | 1155 | Помогите Рите —– напишите программу, которая по заданному n выведет все ПСП в нужном порядке. 1156 | 1157 | Рассмотрим второй пример. Надо вывести ПСП из четырёх символов. Таких всего две: 1158 | 1159 | 1. (()) 1160 | 2. ()() 1161 | (()) идёт раньше ()(), так как первый символ у них одинаковый, а на второй позиции у первой ПСП стоит (, который идёт раньше ). 1162 | Например, для матрицы А (слева) транспонированной будет следующая матрица (справа): 1163 | 1164 | ###### Формат ввода 1165 | 1166 | На вход функция принимает n — целое число от 0 до 10. 1167 | 1168 | ###### Формат вывода 1169 | 1170 | Функция должна напечатать все возможные скобочные последовательности заданной длины в алфавитном (лексикографическом) порядке. 1171 | 1172 | *
1173 | Пример 1 1174 | 1175 | Ввод 1176 | ``` 1177 | 3 1178 | ``` 1179 | Вывод 1180 | ``` 1181 | ((())) 1182 | (()()) 1183 | (())() 1184 | ()(()) 1185 | ()()() 1186 | ``` 1187 |
1188 | *
1189 | Пример 2 1190 | 1191 | Ввод 1192 | ``` 1193 | 2 1194 | ``` 1195 | Вывод 1196 | ``` 1197 | (()) 1198 | ()() 1199 | ``` 1200 |
1201 |
1202 | 1203 | *
1204 | B. Комбинации 1205 | 1206 | [Ссылка на решение](sprint_3/B_combinations.py) 1207 | 1208 | На клавиатуре старых мобильных телефонов каждой цифре соответствовало несколько букв. Примерно так: 1209 | 1210 | 2:'abc',
1211 | 3:'def',
1212 | 4:'ghi',
1213 | 5:'jkl',
1214 | 6:'mno',
1215 | 7:'pqrs',
1216 | 8:'tuv',
1217 | 9:'wxyz' 1218 | 1219 | Вам известно в каком порядке были нажаты кнопки телефона, без учета повторов. Напечатайте все комбинации букв, которые можно набрать такой последовательностью нажатий. 1220 | 1221 | 1222 | ###### Формат ввода 1223 | 1224 | На вход подается строка, состоящая из цифр 2-9 включительно. Длина строки не превосходит 10 символов. 1225 | 1226 | ###### Формат вывода 1227 | 1228 | Выведите все возможные комбинации букв через пробел. 1229 | 1230 | *
1231 | Пример 1 1232 | 1233 | Ввод 1234 | ``` 1235 | 23 1236 | ``` 1237 | Вывод 1238 | ``` 1239 | ad ae af bd be bf cd ce cf 1240 | ``` 1241 |
1242 | *
1243 | Пример 2 1244 | 1245 | Ввод 1246 | ``` 1247 | 92 1248 | ``` 1249 | Вывод 1250 | ``` 1251 | wa wb wc xa xb xc ya yb yc za zb zc 1252 | ``` 1253 |
1254 |
1255 | 1256 | *
1257 | C. Подпоследовательность 1258 | 1259 | [Ссылка на решение](sprint_3/C_subsequence.py) 1260 | 1261 | Гоша любит играть в игру «Подпоследовательность»: даны 2 строки, и нужно понять, 1262 | является ли первая из них подпоследовательностью второй. Когда строки достаточно длинные, 1263 | очень трудно получить ответ на этот вопрос, просто посмотрев на них. Помогите Гоше написать функцию, которая решает эту задачу. 1264 | 1265 | ###### Формат ввода 1266 | 1267 | В первой строке записана строка s. 1268 | 1269 | Во второй —- строка t. 1270 | 1271 | Обе строки состоят из маленьких латинских букв, длины строк не превосходят 150000. Строки не могут быть пустыми. 1272 | 1273 | ###### Формат вывода 1274 | 1275 | Выведите True, если s является подпоследовательностью t, иначе —– False. 1276 | 1277 | *
1278 | Пример 1 1279 | 1280 | Ввод 1281 | ``` 1282 | abc 1283 | ahbgdcu 1284 | ``` 1285 | Вывод 1286 | ``` 1287 | True 1288 | ``` 1289 |
1290 | *
1291 | Пример 2 1292 | 1293 | Ввод 1294 | ``` 1295 | abcp 1296 | ahpc 1297 | ``` 1298 | Вывод 1299 | ``` 1300 | False 1301 | ``` 1302 |
1303 |
1304 | 1305 | *
1306 | D. Печеньки 1307 | 1308 | [Ссылка на решение](sprint_3/D_cookies.py) 1309 | 1310 | К Васе в гости пришли одноклассники. Его мама решила угостить ребят печеньем. 1311 | 1312 | Но не всё так просто. Печенья могут быть разного размера. А у каждого ребёнка есть фактор жадности —– минимальный размер печенья, которое он возьмёт. Нужно выяснить, сколько ребят останутся довольными в лучшем случае, когда они действуют оптимально. 1313 | 1314 | Каждый ребёнок может взять не больше одного печенья. 1315 | 1316 | ###### Формат ввода 1317 | 1318 | В первой строке записано n —– количество детей. 1319 | 1320 | Во второй —– n чисел, разделённых пробелом, каждое из которых –— фактор жадности ребёнка. Это натуральные числа, не превосходящие 1000. 1321 | 1322 | В следующей строке записано число m –— количество печенек. 1323 | 1324 | Далее —– m натуральных чисел, разделённых пробелом —– размеры печенек. Размеры печенек не превосходят 1000. 1325 | 1326 | Оба числа n и m не превосходят 10000. 1327 | 1328 | ###### Формат вывода 1329 | 1330 | Нужно вывести одно число –— количество детей, которые останутся довольными 1331 | 1332 | *
1333 | Пример 1 1334 | 1335 | Ввод 1336 | ``` 1337 | 2 1338 | 1 2 1339 | 3 1340 | 2 1 3 1341 | ``` 1342 | Вывод 1343 | ``` 1344 | 2 1345 | ``` 1346 |
1347 | *
1348 | Пример 2 1349 | 1350 | Ввод 1351 | ``` 1352 | 3 1353 | 2 1 3 1354 | 2 1355 | 1 1 1356 | ``` 1357 | Вывод 1358 | ``` 1359 | 1 1360 | ``` 1361 |
1362 |
1363 | 1364 | *
1365 | E. Покупка домов 1366 | 1367 | [Ссылка на решение](sprint_3/E_buying_houses.py) 1368 | 1369 | Тимофей решил купить несколько домов на знаменитом среди разработчиков Алгосском архипелаге. 1370 | Он нашёл n объявлений о продаже, где указана стоимость каждого дома в алгосских франках. 1371 | А у Тимофея есть k франков. Помогите ему определить, какое наибольшее количество домов на Алгосах он сможет приобрести за эти деньги. 1372 | 1373 | ###### Формат ввода 1374 | 1375 | В первой строке через пробел записаны натуральные числа n и k. 1376 | 1377 | n — количество домов, которые рассматривает Тимофей, оно не превосходит 100000; 1378 | 1379 | k — общий бюджет, не превосходит 100000; 1380 | 1381 | В следующей строке через пробел записано n стоимостей домов. Каждое из чисел не превосходит 100000. Все стоимости — натуральные числа. 1382 | 1383 | ###### Формат вывода 1384 | 1385 | Выведите одно число —– наибольшее количество домов, которое может купить Тимофей. 1386 | 1387 | *
1388 | Пример 1 1389 | 1390 | Ввод 1391 | ``` 1392 | 3 300 1393 | 999 999 999 1394 | ``` 1395 | Вывод 1396 | ``` 1397 | 0 1398 | ``` 1399 |
1400 | *
1401 | Пример 2 1402 | 1403 | Ввод 1404 | ``` 1405 | 3 1000 1406 | 350 999 200 1407 | ``` 1408 | Вывод 1409 | ``` 1410 | 2 1411 | ``` 1412 |
1413 |
1414 | 1415 | *
1416 | F. Периметр треугольника 1417 | 1418 | [Ссылка на решение](sprint_3/F_triangle_perimeter.py) 1419 | 1420 | Перед сном Рита решила поиграть в игру на телефоне. Дан массив целых чисел, в котором каждый элемент обозначает длину стороны треугольника. Нужно определить максимально возможный периметр треугольника, составленного из сторон с длинами из заданного массива. Помогите Рите скорее закончить игру и пойти спать. 1421 | 1422 | Напомним, что из трёх отрезков с длинами a ≤ b ≤ c можно составить треугольник, если выполнено **неравенство треугольника**: c < a + b 1423 | 1424 | Разберём пример: 1425 | даны длины сторон 6, 3, 3, 2. Попробуем в качестве наибольшей стороны выбрать 6. Неравенство треугольника не может выполниться, так как остались 3, 3, 2 —– максимальная сумма из них равна 6. 1426 | 1427 | Без шестёрки оставшиеся три отрезка уже образуют треугольник со сторонами 3, 3, 2. Неравенство выполняется: 3 < 3 + 2. Периметр равен 3 + 3 + 2 = 8. 1428 | 1429 | ###### Формат ввода 1430 | 1431 | В первой строке записано количество отрезков n, 3≤ n≤ 10000. 1432 | 1433 | Во второй строке записано n неотрицательных чисел, не превосходящих 10 000, –— длины отрезков. 1434 | 1435 | ###### Формат вывода 1436 | 1437 | Нужно вывести одно число —– наибольший периметр треугольника. 1438 | 1439 | Гарантируется, что тройка чисел, которая может образовать треугольник, всегда есть. 1440 | 1441 | *
1442 | Пример 1 1443 | 1444 | Ввод 1445 | ``` 1446 | 4 1447 | 6 3 3 2 1448 | ``` 1449 | Вывод 1450 | ``` 1451 | 8 1452 | ``` 1453 |
1454 | *
1455 | Пример 2 1456 | 1457 | Ввод 1458 | ``` 1459 | 6 1460 | 5 3 7 2 8 3 1461 | ``` 1462 | Вывод 1463 | ``` 1464 | 20 1465 | ``` 1466 |
1467 |
1468 | 1469 | *
1470 | G. Гардероб 1471 | 1472 | [Ссылка на решение](sprint_3/G_wardrobe.py) 1473 | 1474 | Рита решила оставить у себя одежду только трёх цветов: розового, жёлтого и малинового. 1475 | После того как вещи других расцветок были убраны, Рита захотела отсортировать 1476 | свой новый гардероб по цветам. Сначала должны идти вещи розового цвета, 1477 | потом —– жёлтого, и в конце —– малинового. Помогите Рите справиться с этой задачей. 1478 | 1479 | Примечание: попробуйте решить задачу за один проход по массиву! 1480 | 1481 | ###### Формат ввода 1482 | 1483 | В первой строке задано количество предметов в гардеробе: n –— оно не превосходит 1000000. 1484 | Во второй строке даётся массив, в котором указан цвет для каждого предмета. 1485 | Розовый цвет обозначен 0, жёлтый —– 1, малиновый –— 2. 1486 | 1487 | ###### Формат вывода 1488 | 1489 | Нужно вывести в строку через пробел цвета предметов в правильном порядке. 1490 | 1491 | *
1492 | Пример 1 1493 | 1494 | Ввод 1495 | ``` 1496 | 7 1497 | 0 2 1 2 0 0 1 1498 | ``` 1499 | Вывод 1500 | ``` 1501 | 0 0 0 1 1 2 2 1502 | ``` 1503 |
1504 | *
1505 | Пример 2 1506 | 1507 | Ввод 1508 | ``` 1509 | 5 1510 | 2 1 2 0 1 1511 | ``` 1512 | Вывод 1513 | ``` 1514 | 0 1 1 2 2 1515 | ``` 1516 |
1517 |
1518 | 1519 | *
1520 | H. Большое число 1521 | 1522 | [Ссылка на решение](sprint_3/H_big_number.py) 1523 | 1524 | Вечером ребята решили поиграть в игру «Большое число». 1525 | Даны числа. Нужно определить, какое самое большое число можно из них составить. 1526 | 1527 | ###### Формат ввода 1528 | 1529 | В первой строке записано n — количество чисел. Оно не превосходит 100. 1530 | Во второй строке через пробел записаны n неотрицательных чисел, каждое из которых не превосходит 1000. 1531 | 1532 | ###### Формат вывода 1533 | 1534 | Нужно вывести самое большое число, которое можно составить из данных чисел. 1535 | 1536 | *
1537 | Пример 1 1538 | 1539 | Ввод 1540 | ``` 1541 | 3 1542 | 15 56 2 1543 | ``` 1544 | Вывод 1545 | ``` 1546 | 56215 1547 | ``` 1548 |
1549 | *
1550 | Пример 2 1551 | 1552 | Ввод 1553 | ``` 1554 | 3 1555 | 1 783 2 1556 | ``` 1557 | Вывод 1558 | ``` 1559 | 78321 1560 | ``` 1561 |
1562 |
1563 | 1564 | *
1565 | I. Любители конференций 1566 | 1567 | [Ссылка на решение](sprint_3/I_conference_lovers.py) 1568 | 1569 | На IT-конференции присутствовали студенты из разных вузов со всей страны. Для каждого студента известен ID университета, в котором он учится. 1570 | 1571 | Тимофей предложил Рите выяснить, из каких k вузов на конференцию пришло больше всего учащихся. 1572 | 1573 | ###### Формат ввода 1574 | 1575 | В первой строке дано количество студентов в списке —– n (1 ≤ n ≤ 15 000). 1576 | 1577 | Во второй строке через пробел записаны n целых чисел —– ID вуза каждого студента. Каждое из чисел находится в диапазоне от 0 до 10 000. 1578 | 1579 | В третьей строке записано одно число k. 1580 | 1581 | ###### Формат вывода 1582 | 1583 | Выведите через пробел k ID вузов с максимальным числом участников. 1584 | Они должны быть отсортированы по убыванию популярности 1585 | (по количеству гостей от конкретного вуза). Если более одного вуза имеет одно и то же количество учащихся, 1586 | то выводить их ID нужно в порядке возрастания. 1587 | 1588 | *
1589 | Пример 1 1590 | 1591 | Ввод 1592 | ``` 1593 | 7 1594 | 1 2 3 1 2 3 4 1595 | 3 1596 | ``` 1597 | Вывод 1598 | ``` 1599 | 1 2 3 1600 | ``` 1601 |
1602 | *
1603 | Пример 2 1604 | 1605 | Ввод 1606 | ``` 1607 | 6 1608 | 1 1 1 2 2 3 1609 | 1 1610 | ``` 1611 | Вывод 1612 | ``` 1613 | 1 1614 | ``` 1615 |
1616 |
1617 | 1618 | *
1619 | J. Пузырёк 1620 | 1621 | [Ссылка на решение](sprint_3/J_bubble.py) 1622 | 1623 | Чтобы выбрать самый лучший алгоритм для решения задачи, Гоша продолжил изучать разные сортировки. 1624 | На очереди [сортировка пузырьком](https://ru.wikipedia.org/wiki/Сортировка_пузырьком) 1625 | 1626 | Её алгоритм следующий (сортируем по неубыванию): 1627 | 1628 | На каждой итерации проходим по массиву, поочередно сравнивая пары соседних элементов. Если элемент на позиции i больше элемента на позиции i + 1, меняем их местами. После первой итерации самый большой элемент всплывёт в конце массива. 1629 | Проходим по массиву, выполняя указанные действия до тех пор, пока на очередной итерации не окажется, что обмены больше не нужны, то есть массив уже отсортирован. 1630 | После не более чем n – 1 итераций выполнение алгоритма заканчивается, так как на каждой итерации хотя бы один элемент оказывается на правильной позиции. 1631 | 1632 | Помогите Гоше написать код алгоритма. 1633 | 1634 | ###### Формат ввода 1635 | 1636 | В первой строке на вход подаётся натуральное число n — длина массива, 2 ≤ n ≤ 1000. 1637 | Во второй строке через пробел записано n целых чисел. 1638 | Каждое из чисел по модулю не превосходит 1000. 1639 | 1640 | Обратите внимание, что считывать нужно только 2 строки: значение n и входной массив. 1641 | 1642 | ###### Формат вывода 1643 | 1644 | После каждого прохода по массиву, на котором какие-то элементы меняются местами, выводите его промежуточное состояние. 1645 | Таким образом, если сортировка завершена за k меняющих массив итераций, то надо вывести k строк по n чисел в каждой — элементы массива после каждой из итераций. 1646 | Если массив был изначально отсортирован, то просто выведите его. 1647 | 1648 | *
1649 | Пример 1 1650 | 1651 | Ввод 1652 | ``` 1653 | 5 1654 | 4 3 9 2 1 1655 | ``` 1656 | Вывод 1657 | ``` 1658 | 3 4 2 1 9 1659 | 3 2 1 4 9 1660 | 2 1 3 4 9 1661 | 1 2 3 4 9 1662 | ``` 1663 |
1664 | *
1665 | Пример 2 1666 | 1667 | Ввод 1668 | ``` 1669 | 5 1670 | 12 8 9 10 11 1671 | ``` 1672 | Вывод 1673 | ``` 1674 | 8 9 10 11 12 1675 | ``` 1676 |
1677 |
1678 | 1679 | *
1680 | K. Сортировка слиянием 1681 | 1682 | [Ссылка на решение](sprint_3/K_merge_sort.py) 1683 | 1684 | Гоше дали задание написать красивую сортировку слиянием. Поэтому Гоше обязательно надо реализовать отдельно функцию merge и функцию merge_sort. 1685 | 1686 | - Функция merge принимает два отсортированных массива, сливает их в один отсортированный массив и возвращает его. Если требуемая сигнатура имеет вид merge(array, left, mid, right), то первый массив задаётся полуинтервалом [left,mid) массива array, а второй – полуинтервалом [mid,right) массива array. 1687 | - Функция merge_sort принимает некоторый подмассив, который нужно отсортировать. Подмассив задаётся полуинтервалом — его началом и концом. Функция должна отсортировать передаваемый в неё подмассив, она ничего не возвращает. 1688 | - Функция merge_sort разбивает полуинтервал на две половинки и рекурсивно вызывает сортировку отдельно для каждой. Затем два отсортированных массива сливаются в один с помощью merge. 1689 | 1690 | Заметьте, что в функции передаются именно полуинтервалы [begin,end), то есть правый конец не включается. Например, если вызвать merge_sort(arr, 0, 4), где arr=[4,5,3,0,1,2], то будут отсортированы только первые четыре элемента, изменённый массив будет выглядеть как arr=[0,3,4,5,1,2]. 1691 | 1692 | Реализуйте эти две функции. 1693 | 1694 |
1695 |
1696 | 1697 | -------------------------------------------------------------------------------- /codewars/Calculating_with_Functions.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/525f3eda17c7cd9f9e000b39 2 | def zero(f=None): return 0 if f is None else int(f(0)) 3 | def one(f=None): return 1 if f is None else int(f(1)) 4 | def two(f=None): return 2 if f is None else int(f(2)) 5 | def three(f=None): return 3 if f is None else int(f(3)) 6 | def four(f=None): return 4 if f is None else int(f(4)) 7 | def five(f=None): return 5 if f is None else int(f(5)) 8 | def six(f=None): return 6 if f is None else int(f(6)) 9 | def seven(f=None): return 7 if f is None else int(f(7)) 10 | def eight(f=None): return 8 if f is None else int(f(8)) 11 | def nine(f=None): return 9 if f is None else int(f(9)) 12 | 13 | 14 | def plus(y): return lambda x: x + y 15 | def minus(y): return lambda x: x - y 16 | def times(y): return lambda x: x * y 17 | def divided_by(y): return lambda x: x / y 18 | -------------------------------------------------------------------------------- /codewars/array_diff.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/523f5d21c841566fde000009 2 | 3 | def array_diff(a: list[int], b: list[int]) -> list: 4 | for i in b: 5 | while True: 6 | try: 7 | a.remove(i) 8 | except ValueError: 9 | break 10 | return a 11 | 12 | 13 | def array_diff_good(a, b): 14 | return [x for x in a if x not in b] 15 | 16 | 17 | def test(): 18 | assert array_diff([], []) == [] 19 | assert array_diff([1, 2, 2, 2, 3], []) == [1, 2, 2, 2, 3] 20 | assert array_diff([], [1, 2, 2, 2, 3]) == [1, 2, 2, 2, 3] 21 | assert array_diff([1, 2, 2, 2, 3], [2]) == [1, 3] 22 | assert array_diff([20, -20, -2, 12, 12, -14, 14, -12, -18, 2, 17, 1, -16, 2, -18], [-18, 6, -8, -5, -5, -5, 13, -11, -9, -5, 11, 7, 3, 15]) 23 | 24 | -------------------------------------------------------------------------------- /codewars/count_smiles.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/583203e6eb35d7980400002a/python 2 | 3 | def gen_smile() -> list: 4 | smiles = [] 5 | parts = { 6 | 'eyes': [':', ';'], 7 | 'noses': ['', '-', '~'], 8 | 'mouths': [')', 'D'], 9 | } 10 | for eye in parts['eyes']: 11 | for nose in parts['noses']: 12 | for mouth in parts['mouths']: 13 | smiles.append(eye + nose + mouth) 14 | return smiles 15 | 16 | 17 | def count_smileys(arr: list) -> int: 18 | result = 0 19 | smiles = gen_smile() 20 | for smile in arr: 21 | if smile in smiles: 22 | result += 1 23 | return result 24 | 25 | 26 | def test(): 27 | assert count_smileys([]) == 0 28 | assert count_smileys([':D', ':~)', ';~D', ':)']) == 4 29 | assert count_smileys([':)', ':(', ':D', ':O', ':;']) == 2 30 | assert count_smileys([';]', ':[', ';*', ':$', ';-D']) == 1 31 | 32 | assert count_smileys_re([':D', ':~)', ';~D', ':)']) == 4 33 | 34 | 35 | def count_smileys_re(arr): 36 | from re import findall 37 | return len(list(findall(r"[:;][-~]?[)D]", " ".join(arr)))) 38 | 39 | 40 | if __name__ == '__main__': 41 | test() 42 | -------------------------------------------------------------------------------- /codewars/count_trailing_zeros.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/52f787eb172a8b4ae1000a34/python 2 | 3 | 4 | def zeros(n): 5 | if n < 5: 6 | return 0 7 | return n // 5 + zeros(n // 5) 8 | 9 | 10 | def test(): 11 | assert zeros(0) == 0 12 | assert zeros(6) == 1 13 | assert zeros(30) == 7 14 | 15 | 16 | if __name__ == '__main__': 17 | test() 18 | -------------------------------------------------------------------------------- /codewars/count_vowels.py: -------------------------------------------------------------------------------- 1 | def solution(sentence): 2 | vowels = {'a': 0, 3 | 'u': 0, 4 | 'i': 0, 5 | 'o': 0, 6 | 'e': 0,} 7 | for letter in sentence: 8 | if letter in vowels: 9 | vowels[letter] += 1 10 | return sum(vowels.values()) 11 | 12 | print(solution('abracadabra')) -------------------------------------------------------------------------------- /codewars/directions_reduction.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/550f22f4d758534c1100025a/ 2 | 3 | opposite = {'NORTH': 'SOUTH', 'EAST': 'WEST', 'SOUTH': 'NORTH', 'WEST': 'EAST'} 4 | def dirReduc(plan): 5 | new_plan = [] 6 | for d in plan: 7 | if new_plan and new_plan[-1] == opposite[d]: 8 | new_plan.pop() 9 | else: 10 | new_plan.append(d) 11 | return new_plan 12 | 13 | 14 | a = ["NORTH", "SOUTH", "SOUTH", "EAST", "WEST", "NORTH", "WEST"] 15 | 16 | print(dirReduc(a)) 17 | -------------------------------------------------------------------------------- /codewars/enough_is_enough.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/554ca54ffa7d91b236000023 2 | 3 | def delete_nth(order: list[int], max_e: int) -> list[int]: 4 | for ph in range(len(order) - 1, 0, -1): 5 | if order[:ph + 1].count(order[ph]) > max_e: 6 | order.pop(ph) 7 | return order 8 | 9 | 10 | def test(): 11 | assert delete_nth([20, 37, 20, 21], 1) == [20, 37, 21] 12 | assert delete_nth([1, 1, 3, 3, 7, 2, 2, 2, 2], 3) == [1, 1, 3, 3, 7, 2, 2, 2] 13 | 14 | 15 | if __name__ == '__main__': 16 | test() 17 | -------------------------------------------------------------------------------- /codewars/human_readable_time.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/52742f58faf5485cae000b9a/ 2 | 3 | def format_duration(seconds: int) -> str: 4 | if not seconds: 5 | return 'now' 6 | yy, seconds = seconds // (3600 * 24 * 365), seconds % (3600 * 24 * 365) 7 | dd, seconds = seconds // (3600 * 24), seconds % (3600 * 24) 8 | hh, seconds = seconds // 3600, seconds % 3600 9 | mm, ss = seconds // 60, seconds % 60 10 | units = {'year': yy, 'day': dd, 'hour': hh, 'minute': mm, 'second': ss} 11 | time = '' 12 | for unit_name, unit in units.items(): 13 | if unit: 14 | time += ', ' if time else '' 15 | time += f'{unit} {unit_name}' 16 | time += 's' if unit > 1 else '' 17 | sep_ind = time.rfind(',') 18 | if sep_ind > -1: 19 | time = time[:sep_ind] + ' and' + time[sep_ind + 1:] 20 | return time 21 | 22 | 23 | print(format_duration(1)) 24 | -------------------------------------------------------------------------------- /codewars/is_pangram.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/545cedaa9943f7fe7b000048 2 | 3 | 4 | import string 5 | 6 | 7 | def is_pangram(s): 8 | alphabet = string.ascii_lowercase 9 | s = s.lower().replace(' ', '') 10 | for letter in s: 11 | alphabet = alphabet.replace(letter, '') 12 | return False if alphabet else True 13 | 14 | 15 | def test(): 16 | phrase = 'The quick brown fox jumps over the lazy dog' 17 | phrase_2 = 'hello world' 18 | phrase_3 = 'Pack my box with five dozen liquor jugs' 19 | assert is_pangram(phrase) is True 20 | assert is_pangram(phrase_2) is False 21 | assert is_pangram(phrase_3) is True 22 | assert is_pangram('') is False 23 | 24 | 25 | if __name__ == '__main__': 26 | test() 27 | -------------------------------------------------------------------------------- /codewars/list_filtering.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/53dbd5315a3c69eed20002dd/train/python 2 | 3 | def filter_list(l): 4 | return [i for i in l if isinstance(i, int)] 5 | 6 | 7 | def test(): 8 | assert filter_list([1, 2, 'a', 'b']) == [1, 2] 9 | 10 | 11 | if __name__ == '__main__': 12 | test() 13 | -------------------------------------------------------------------------------- /codewars/max_subarray_sum.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/54521e9ec8e60bc4de000d6c/python 2 | 3 | def max_sequence(arr: list[int]): 4 | try: 5 | temp_sum = arr[0] 6 | except ValueError: 7 | return 0 8 | max_sum = temp_sum 9 | for item in arr[1:]: 10 | temp_sum = max(temp_sum + item, item) 11 | max_sum = max(temp_sum, max_sum) 12 | return max(max_sum, 0) 13 | 14 | 15 | var = [7, 4, 11, -11, 39, 36, 10, -6, 37, -10, -32, 44, -26, -34, 43, 43] 16 | sequence = max_sequence(var) 17 | assert sequence == 155 18 | -------------------------------------------------------------------------------- /codewars/millipede_of_words.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/6344701cd748a12b99c0dbc4 2 | 3 | def solution(arr: list) -> bool: 4 | ... -------------------------------------------------------------------------------- /codewars/moving_zeroes.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/52597aa56021e91c93000cb0/ 2 | from unittest import TestCase 3 | 4 | 5 | def move_zeros(arr: list[int]) -> list[int]: 6 | num = [i for i in arr if i != 0] 7 | return num + ([0] * (len(arr) - len(num))) 8 | 9 | 10 | class MyTest(TestCase): 11 | def test(self): 12 | assert move_zeros([1, 2, 0, 1, 0, 1, 0, 3, 0, 1]) == [1, 2, 1, 1, 3, 1, 0, 0, 0, 0] 13 | assert move_zeros([9, 0, 0, 9, 1, 2, 0, 1, 0, 1, 0, 3, 0, 1, 9, 0, 0, 0, 0, 9]) == [9, 9, 1, 2, 1, 1, 3, 1, 9, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 14 | assert move_zeros([0, 0]) == [0, 0] 15 | assert move_zeros([0]) == [0] 16 | -------------------------------------------------------------------------------- /codewars/multiplies_3_or_5.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/514b92a657cdc65150000006 2 | from unittest import TestCase 3 | 4 | 5 | def solution(number): 6 | return sum((i for i in range(number) if 0 in [i % 3, i % 5])) 7 | 8 | 9 | class Test(TestCase): 10 | def test_solution(self): 11 | print(solution(10)) 12 | assert solution(10) == 23 13 | assert solution(4) == 3 14 | assert solution(6) == 8 15 | assert solution(3) == 0 16 | assert solution(5) == 3 17 | 18 | 19 | -------------------------------------------------------------------------------- /codewars/permulations.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/5254ca2719453dcc0b00027d/ 2 | 3 | import itertools 4 | 5 | 6 | def permutations(s: str): 7 | s = list(itertools.permutations(s)) 8 | return sorted(list(set([''.join(s[i]) for i in range(len(s))]))) 9 | 10 | 11 | def test(): 12 | assert permutations('aabb') == ['aabb', 'abab', 'abba', 'baab', 'baba', 13 | 'bbaa'] 14 | assert permutations('a') == ['a'] 15 | 16 | 17 | if __name__ == '__main__': 18 | test() 19 | -------------------------------------------------------------------------------- /codewars/pig_latin.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/520b9d2ad5c005041100000f 2 | import re 3 | 4 | 5 | def pig_it(text: str) -> str: 6 | text = re.findall(r"\w+|[.,!?;]", text) 7 | for ind, word in enumerate(text): 8 | if word.isalpha(): 9 | text[ind] = word[1:] + word[0] + 'ay' 10 | return ' '.join(text) 11 | 12 | 13 | if __name__ == '__main__': 14 | print(pig_it('hello world !')) 15 | -------------------------------------------------------------------------------- /codewars/readable_time.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/52685f7382004e774f0001f7 2 | 3 | def make_readable(seconds: int) -> str: 4 | hh, seconds = seconds // 3600, seconds % 3600 5 | mm, seconds = seconds // 60, seconds % 60 6 | ss = seconds % 60 7 | return f'{hh:02d}:{mm:02d}:{ss:02d}' 8 | 9 | 10 | def test(): 11 | assert make_readable(120) == '00:02:00' 12 | assert make_readable(86399) == '23:59:59' 13 | assert make_readable(359999) == '99:59:59' 14 | 15 | 16 | if __name__ == '__main__': 17 | test() 18 | -------------------------------------------------------------------------------- /codewars/rgb_to_hex.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/513e08acc600c94f01000001/ 2 | 3 | def rgb(r: int, g: int, b: int) -> str: 4 | """ 5 | Return RGB values to HEX. 6 | :param r: Red 7 | :type r: int 8 | 9 | :param g: Green 10 | :type g: int 11 | 12 | :param b: Blue 13 | :type b: int 14 | 15 | :return: HEX representation 16 | :rtype: str 17 | 18 | >>> rgb(255, 255, 255) 19 | 'FFFFFF' 20 | >>> rgb(1, 2, 3) 21 | '010203' 22 | >>> rgb(-20, 275, 125) 23 | '00FF7D' 24 | 25 | """ 26 | def trunc(x): return max(0, min(255, x)) 27 | return f'{trunc(r):02X}{trunc(g):02X}{trunc(b):02X}' 28 | 29 | 30 | def test(): 31 | assert rgb(255, 255, 255) == 'FFFFFF' 32 | assert rgb(1, 2, 3) == '010203' 33 | assert rgb(-20, 275, 125) == '00FF7D' 34 | 35 | 36 | if __name__ == '__main__': 37 | import doctest 38 | doctest.testmod() 39 | -------------------------------------------------------------------------------- /codewars/rot13.py: -------------------------------------------------------------------------------- 1 | import string 2 | 3 | 4 | def rot13(message: str) -> str: 5 | alphabet = {letter: '' for letter in string.ascii_letters} 6 | lower = string.ascii_lowercase[13:] + string.ascii_lowercase[:13] 7 | upper = string.ascii_uppercase[13:] + string.ascii_uppercase[:13] 8 | shift_alphabet = lower + upper 9 | for ind, letter in enumerate(alphabet): 10 | alphabet[letter] = shift_alphabet[ind] 11 | 12 | result = '' 13 | 14 | for ind, symb in enumerate(message): 15 | if symb.isalpha(): 16 | result += alphabet[symb] 17 | else: 18 | result += symb 19 | 20 | return result 21 | 22 | 23 | def test() -> None: 24 | assert rot13('test') == 'grfg' 25 | assert rot13('Test') == 'Grfg' 26 | assert rot13('aA bB zZ 1234 *!?%') == 'nN oO mM 1234 *!?%' 27 | 28 | 29 | if __name__ == '__main__': 30 | test() 31 | -------------------------------------------------------------------------------- /codewars/simple_encryption.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/57814d79a56c88e3e0000786/ 2 | 3 | def decrypt(encrypted_text: str, n: int) -> str: 4 | if not encrypted_text: 5 | return encrypted_text 6 | length = len(encrypted_text) 7 | temp = [''] * length 8 | while n > 0: 9 | nxt = 0 10 | for ind in range(0, length, 2): 11 | temp[ind] = encrypted_text[length // 2 + nxt] 12 | nxt += 1 13 | nxt = 0 14 | for ind in range(1, length, 2): 15 | temp[ind] = encrypted_text[nxt] 16 | nxt += 1 17 | n -= 1 18 | encrypted_text = ''.join(temp) 19 | 20 | return ''.join(encrypted_text) 21 | 22 | 23 | def encrypt(text: str, n: int) -> str: 24 | if not text: 25 | return text 26 | temp = '' 27 | new_text = text 28 | while n > 0: 29 | for ind in range(1, len(new_text), 2): 30 | temp += new_text[ind] 31 | for ind in range(0, len(new_text), 2): 32 | temp += new_text[ind] 33 | new_text = temp 34 | temp = '' 35 | n -= 1 36 | 37 | return new_text 38 | 39 | 40 | def test_encrypt(): 41 | assert encrypt("012345", 1) == "135024" 42 | assert encrypt("012345", 2) == "304152" 43 | assert encrypt("012345", 3) == "012345" 44 | 45 | assert encrypt("01234", 1) == "13024" 46 | assert encrypt("01234", 2) == "32104" 47 | assert encrypt("01234", 3) == "20314" 48 | 49 | assert encrypt("01234", -1) == "01234" 50 | assert encrypt('', 2) == '' 51 | 52 | 53 | def test_decrypt(): 54 | assert decrypt('135024', 1) == '012345' 55 | assert decrypt("304152", 2) == '012345' 56 | 57 | 58 | if __name__ == '__main__': 59 | test_encrypt() 60 | test_decrypt() 61 | -------------------------------------------------------------------------------- /codewars/simple_encryption_good.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/57814d79a56c88e3e0000786/ 2 | from simple_encryption import test_decrypt, test_encrypt 3 | 4 | 5 | def decrypt(text, n): 6 | if text in ("", None): 7 | return text 8 | 9 | ndx = len(text) // 2 10 | 11 | for i in range(n): 12 | a = text[:ndx] 13 | b = text[ndx:] 14 | text = "".join(b[i:i + 1] + a[i:i + 1] for i in range(ndx + 1)) 15 | return text 16 | 17 | 18 | def encrypt(text, n): 19 | for i in range(n): 20 | text = text[1::2] + text[::2] 21 | return text 22 | 23 | 24 | def test_encrypt(): 25 | assert encrypt("012345", 1) == "135024" 26 | assert encrypt("012345", 2) == "304152" 27 | assert encrypt("012345", 3) == "012345" 28 | 29 | assert encrypt("01234", 1) == "13024" 30 | assert encrypt("01234", 2) == "32104" 31 | assert encrypt("01234", 3) == "20314" 32 | 33 | assert encrypt("01234", -1) == "01234" 34 | assert encrypt('', 2) == '' 35 | 36 | 37 | def test_decrypt(): 38 | assert decrypt('135024', 1) == '012345' 39 | assert decrypt("304152", 2) == '012345' 40 | 41 | 42 | if __name__ == '__main__': 43 | test_encrypt() 44 | test_decrypt() 45 | -------------------------------------------------------------------------------- /codewars/snail_sort.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/521c2db8ddc89b9b7a0000c1/ 2 | 3 | def snail(snail_map): 4 | length = len(snail_map) 5 | x = y = 0 6 | pivot = 0 7 | k = 0 8 | dx, dy = 0, 1 9 | result = list() 10 | for _ in range(1, length * length + 1): 11 | result.append(snail_map[x][y]) 12 | snail_map[x][y] = None 13 | if not ( 14 | 0 <= x + dx < length 15 | and 0 <= y + dy < length 16 | ) or snail_map[x + dx][y + dy] is None: 17 | pivot += 1 18 | dx, dy = dy, -dx 19 | x += dx 20 | y += dy 21 | 22 | return result 23 | 24 | 25 | print(snail([ 26 | [1, 2, 3, 4, 5], 27 | [16, 17, 18, 19, 6], 28 | [15, 24, 25, 20, 7], 29 | [14, 23, 22, 21, 8], 30 | [13, 12, 11, 10, 9] 31 | ])) 32 | print(snail([ 33 | [1, 2, 3, 4, ], 34 | [12, 13, 14, 5, ], 35 | [11, 16, 15, 6, ], 36 | [10, 9, 8, 7, ], 37 | ])) 38 | -------------------------------------------------------------------------------- /codewars/split_strings.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/515de9ae9dcfc28eb6000001/train/python 2 | 3 | def solution(text: str): 4 | if len(text) % 2 != 0: 5 | text += '_' 6 | result = [] 7 | for i in range(0, len(text) - 1, 2): 8 | result.append(f'{text[i]}' + f'{text[i + 1]}') 9 | return result 10 | 11 | 12 | tests = ( 13 | ("asdfadsf", ['as', 'df', 'ad', 'sf']), 14 | ("asdfads", ['as', 'df', 'ad', 's_']), 15 | ("", []), 16 | ("x", ["x_"]), 17 | ) 18 | 19 | text = 'asdfasd' 20 | text += '_' if len(text) % 2 else text 21 | text_format = [str(text[i] + text[i + 1]) for i in range(0, len(text), 2)] 22 | 23 | for text, expected in tests: 24 | assert solution(text) == expected 25 | print(f'test "{text}" passed') 26 | 27 | -------------------------------------------------------------------------------- /codewars/sum_positive.py: -------------------------------------------------------------------------------- 1 | def sum_positive(array: list): 2 | return sum([i for i in array if i > 0]) 3 | 4 | 5 | test = [1, -4, 5, 12] 6 | assert sum_positive(test) == 18 -------------------------------------------------------------------------------- /codewars/ten_minutes_walk.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/54da539698b8a2ad76000228/ 2 | 3 | 4 | def is_valid_walk(walk: list) -> bool: 5 | if len(walk) != 10: 6 | return False 7 | return (walk.count('n') == walk.count('s') and 8 | walk.count('w') == walk.count('e')) 9 | 10 | 11 | def test(): 12 | assert is_valid_walk(['n', 's', 'w', 'e']) is False 13 | assert is_valid_walk(['n', 's', 'w']) is False 14 | assert is_valid_walk( 15 | ['n', 's', 'n', 's', 'n', 's', 'n', 's', 'n', 's']) is True 16 | assert is_valid_walk( 17 | ['w', 'e', 'w', 'e', 'w', 'e', 'w', 'e', 'w', 'e', 'w', 'e']) is False 18 | assert is_valid_walk( 19 | ['n', 'n', 'n', 's', 'n', 's', 'n', 's', 'n', 's']) is False 20 | 21 | 22 | if __name__ == '__main__': 23 | test() 24 | -------------------------------------------------------------------------------- /codewars/the_hashtag_generator.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/52449b062fb80683ec000024/train/python 2 | 3 | def generate_hashtag(text: str) -> str: 4 | text = text.strip().split() 5 | text = list(map(str.capitalize, text)) 6 | return ''.join(['#'] + text) if 0 < sum((len(i) for i in text)) <= 140 else False 7 | 8 | 9 | if __name__ == '__main__': 10 | assert generate_hashtag(' Hello there thanks for trying my Kata') == ('HelloThereThanksForTryingMyKata') 11 | -------------------------------------------------------------------------------- /codewars/two_sum.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/52c31f8e6605bcc646000082/train/python 2 | 3 | def two_sum(numbers: list[int], target: int) -> tuple[int] or None: 4 | for i in range(len(numbers)): 5 | for j in range(i + 1, len(numbers)): 6 | if numbers[i] + numbers[j] == target: 7 | numbers[i] = None 8 | result = (i, j) 9 | return result 10 | return None 11 | 12 | 13 | assert two_sum([1, 2, 3], 4) == (0, 2) 14 | assert two_sum([1234, 5678, 9012], 14690) == (1, 2) 15 | assert two_sum([2, 2, 3], 4) == (0, 1) 16 | -------------------------------------------------------------------------------- /codewars/unique_in_order.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/54e6533c92449cc251001667/python 2 | from typing import Iterable 3 | 4 | 5 | def unique_in_order(seq): 6 | new_seq = '' 7 | for i in range(0, len(seq)): 8 | if not new_seq or str(seq[i]) != new_seq[-1]: 9 | new_seq += str(seq[i]) 10 | if isinstance(seq[0], int): 11 | new_seq = list(map(int, new_seq)) 12 | return list(new_seq) 13 | 14 | 15 | def test(): 16 | assert unique_in_order('AAAABBBCCDAABBB') == ['A', 'B', 'C', 'D', 'A', 'B'] 17 | assert unique_in_order('ABBCcAD') == ['A', 'B', 'C', 'c', 'A', 'D'] 18 | assert unique_in_order([1, 2, 2, 3, 3]) == [1, 2, 3] 19 | 20 | if __name__ == '__main__': 21 | test() 22 | 23 | -------------------------------------------------------------------------------- /codewars/your_order.py: -------------------------------------------------------------------------------- 1 | # https://www.codewars.com/kata/55c45be3b2079eccff00010f/ 2 | 3 | def order(sentence: str) -> str: 4 | words = [] 5 | for word in sentence.split(): 6 | for char in word: 7 | if char.isdigit(): 8 | words.append([word, int(char)]) 9 | words.sort(key=lambda x: x[1]) 10 | return ' '.join(i[0] for i in words) 11 | 12 | 13 | def test(): 14 | assert order('is2 Thi1s T4est 3a') == 'Thi1s is2 3a T4est' 15 | assert (order('4of Fo1r pe6ople g3ood th5e the2') 16 | == 'Fo1r the2 g3ood 4of th5e pe6ople') 17 | 18 | 19 | if __name__ == '__main__': 20 | test() 21 | 22 | -------------------------------------------------------------------------------- /eratosthenes.py: -------------------------------------------------------------------------------- 1 | def eratosthenes(n): 2 | numbers = list(range(n)) 3 | numbers[0] = numbers[1] = False 4 | for number in numbers: 5 | if numbers[number]: 6 | for j in range(number * number, n, number): 7 | numbers[j] = False 8 | return [i for i in numbers if i] 9 | 10 | 11 | print(eratosthenes(15)) 12 | -------------------------------------------------------------------------------- /leetcode/easy/1. Two Sum.py: -------------------------------------------------------------------------------- 1 | # https://leetcode.com/problems/two-sum/description/ 2 | from utils import assert_this 3 | 4 | 5 | class Solution(object): 6 | def twoSum(self, nums, target): 7 | """ 8 | :type nums: List[int] 9 | :type target: int 10 | :rtype: List[int] 11 | """ 12 | for i in range(len(nums) - 1): 13 | for j in range(i + 1, len(nums)): 14 | if nums[i] + nums[j] == target: 15 | return [i, j] 16 | 17 | return [] 18 | 19 | if __name__ == '__main__': 20 | under_test = Solution().twoSum 21 | 22 | test_cases = [ 23 | (under_test([2, 7, 11, 15], 9), [0, 1]), 24 | (under_test([3, 2, 4], 6), [1, 2]), 25 | (under_test([3, 3], 6), [0, 1]), 26 | ] 27 | 28 | for result, expected in test_cases: 29 | assert_this(result, expected) 30 | -------------------------------------------------------------------------------- /leetcode/easy/13. Roman to Integer.py: -------------------------------------------------------------------------------- 1 | # https://leetcode.com/problems/roman-to-integer/ 2 | from utils import assert_this 3 | 4 | 5 | class Solution(object): 6 | def romanToInt(self, s): 7 | """ 8 | :type s: str 9 | :rtype: int 10 | """ 11 | roman_numerals = { 12 | 'I': 1, 'V': 5, 'X': 10, 'L': 50, 13 | 'C': 100, 'D': 500, 'M': 1000 14 | } 15 | length_roman_number = len(s) 16 | arabic_number = 0 17 | for ind, roman_num in enumerate(s): 18 | # Если это число последнее или оно больше, чем следующее, то прибавляем его к результату 19 | if ind == length_roman_number -1 or roman_numerals[roman_num] >= roman_numerals[s[ind + 1]]: 20 | arabic_number += roman_numerals[roman_num] 21 | # иначе вычитаем (например, IX. Один меньше девяти, значит -1 + 10 = 9) 22 | else: 23 | arabic_number -= roman_numerals[roman_num] 24 | return arabic_number 25 | 26 | if __name__ == '__main__': 27 | under_test = Solution().romanToInt 28 | 29 | test_cases = [ 30 | (under_test('III'), 3), 31 | (under_test('LVIII'), 58), 32 | (under_test('MCMXCIV'), 1994), 33 | ] 34 | 35 | for result, expected in test_cases: 36 | assert_this(result, expected) -------------------------------------------------------------------------------- /leetcode/easy/14. Longest Common Prefix.py: -------------------------------------------------------------------------------- 1 | # https://leetcode.com/problems/longest-common-prefix/ 2 | from utils import assert_this 3 | 4 | 5 | class Solution(object): 6 | def longestCommonPrefix(self, strs): 7 | """ 8 | :type strs: List[str] 9 | :rtype: str 10 | """ 11 | prefix = '' 12 | ind = 0 13 | while True: 14 | try: 15 | if len(set([string[ind] for string in strs])) == 1: 16 | prefix += strs[0][ind] 17 | else: 18 | return prefix 19 | except IndexError: 20 | return prefix 21 | 22 | ind += 1 23 | 24 | 25 | if __name__ == '__main__': 26 | under_test = Solution().longestCommonPrefix 27 | 28 | test_cases = [ 29 | (under_test(["flower","flow","flight"]), 'fl'), 30 | (under_test(["dog","racecar","car"]), ''), 31 | ] 32 | 33 | for result, expected in test_cases: 34 | assert_this(result, expected) -------------------------------------------------------------------------------- /leetcode/easy/20. Valid Parentheses.py: -------------------------------------------------------------------------------- 1 | # https://leetcode.com/problems/valid-parentheses/description/ 2 | from utils import assert_this 3 | 4 | """ 5 | Если скобка открывается, то добавляем её во временный список 6 | Если список не пустой и скобка закрывает последнюю скобку в списке, то удаляем последнюю скобку в списке 7 | Иначе (скобка закрывающая, но она не закрывает последнюю скобку в списке) добавляем её в список 8 | 9 | Если список в итоге пустой, то возвращаем True 10 | """ 11 | 12 | 13 | class Solution(object): 14 | def isValid(self, s): 15 | """ 16 | :type s: str 17 | :rtype: bool 18 | """ 19 | brackets_map = {'(': ')', '[': ']', '{': '}'} 20 | seq = list() 21 | for bracket in s: 22 | if bracket in brackets_map.keys(): 23 | seq.append(bracket) 24 | elif bool(seq) and bracket == brackets_map[seq[-1]]: 25 | seq.pop() 26 | else: 27 | seq.append(bracket) 28 | break 29 | return not bool(seq) 30 | 31 | if __name__ == '__main__': 32 | under_test = Solution().isValid 33 | 34 | test_cases = [ 35 | (under_test("()"), True), 36 | (under_test("(()[[]{}])"), True), 37 | (under_test("(]"), False), 38 | (under_test("([])"), True), 39 | ] 40 | 41 | for result, expected in test_cases: 42 | assert_this(result, expected) -------------------------------------------------------------------------------- /leetcode/easy/9. Palindrome Number.py: -------------------------------------------------------------------------------- 1 | # https://leetcode.com/problems/palindrome-number/description/ 2 | from utils import assert_this 3 | 4 | 5 | class Solution(object): 6 | def isPalindrome(self, x): 7 | """ 8 | :type x: int 9 | :rtype: bool 10 | """ 11 | if x < 0: 12 | return False 13 | 14 | temp = x 15 | reverse = 0 16 | while temp: 17 | reverse = reverse * 10 + temp % 10 18 | temp = temp // 10 19 | 20 | return x - reverse == 0 21 | 22 | 23 | if __name__ == '__main__': 24 | under_test = Solution().isPalindrome 25 | 26 | test_cases = [ 27 | (under_test(121), True), 28 | (under_test(-121), False), 29 | (under_test(10), False), 30 | ] 31 | 32 | for result, expected in test_cases: 33 | assert_this(result, expected) 34 | -------------------------------------------------------------------------------- /leetcode/easy/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/viator3m/algorithms/5e0f8f1fa33d4861f4048497836ebaf217081fc3/leetcode/easy/__init__.py -------------------------------------------------------------------------------- /leetcode/roman_to_int.py: -------------------------------------------------------------------------------- 1 | from unittest import TestCase 2 | 3 | 4 | def roman_to_int(s: str) -> int: 5 | roman_numerals = {'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 6 | 'M': 1000} 7 | result = 0 8 | for i, c in enumerate(s): 9 | if (i + 1) == len(s) or roman_numerals[c] >= roman_numerals[s[i + 1]]: 10 | result += roman_numerals[c] 11 | else: 12 | result -= roman_numerals[c] 13 | return result 14 | 15 | 16 | class TestSolution(TestCase): 17 | def test(self): 18 | assert roman_to_int('III') == 3 19 | assert roman_to_int('LVIII') == 58 20 | assert roman_to_int('MCMXCIV') == 1994 21 | -------------------------------------------------------------------------------- /problems/2_sum.py: -------------------------------------------------------------------------------- 1 | from typing import List, Tuple, Optional 2 | from howlong import how_long 3 | 4 | 5 | @how_long 6 | def twosum_naive(array: List[int], x: int) -> Optional[Tuple[int, int]]: 7 | for i in range(len(array)): 8 | for j in range(i + 1, len(array)): 9 | if array[i] + array[j] == x: 10 | return array[i], array[j] 11 | return None 12 | 13 | 14 | @how_long 15 | def twowum_optimized(array: List[int], x: int) -> Optional[Tuple[int, int]]: 16 | array.sort() 17 | left = 0 18 | right = len(array) - 1 19 | while left < right: 20 | if array[left] + array[right] == x: 21 | return array[left], array[right] 22 | if array[left] + array[right] > x: 23 | right -= 1 24 | else: 25 | left += 1 26 | return None 27 | 28 | 29 | @how_long 30 | def twosum_with_set(array: List[int], x: int) -> Optional[Tuple[int, int]]: 31 | previous = set() 32 | for A in array: 33 | Y = x - A 34 | if Y in previous: 35 | return Y, A 36 | previous.add(A) 37 | return None 38 | 39 | array = [-9, -7, -6, -1, -1, 3] 40 | x = 2 41 | print(twosum_naive(array, x)) 42 | print(twowum_optimized(array, x)) 43 | print(twosum_with_set(array, x)) 44 | 45 | -------------------------------------------------------------------------------- /problems/a_plus_b.py: -------------------------------------------------------------------------------- 1 | # import sys 2 | # 3 | # j = sys.stdin.readline().strip() 4 | # s = sys.stdin.readline().strip() 5 | # 6 | # result = 0 7 | # for ch in s: 8 | # if ch in j: 9 | # result += 1 10 | # 11 | # print(result) 12 | 13 | # a, b = (int(input()) for _ in range(2)) 14 | # print(a + b) 15 | 16 | 17 | def double(num: int): 18 | return num * 2 19 | 20 | 21 | numbers = (1, 2, 4, 5, 10) 22 | double_numbers = tuple(map(double, numbers)) 23 | 24 | print(f'Input: {numbers}\n' 25 | f'Output: {double_numbers}') 26 | -------------------------------------------------------------------------------- /problems/howlong.py: -------------------------------------------------------------------------------- 1 | import time 2 | 3 | 4 | def how_long(func): 5 | def wrapper(*args, **kwargs): 6 | start_time = time.time() 7 | result = func(*args, **kwargs) 8 | print(f'Время выполнения {func.__name__}: {time.time() - start_time}') 9 | return result 10 | return wrapper 11 | -------------------------------------------------------------------------------- /problems/is_prime.py: -------------------------------------------------------------------------------- 1 | import sys 2 | 3 | 4 | def read_input() -> int: 5 | return int(sys.stdin.readline().strip()) 6 | 7 | 8 | def is_prime(n: int) -> bool: 9 | if n == 1: 10 | return True 11 | i = 2 12 | while i * i < n: 13 | if n % i == 0: 14 | return False 15 | i += 1 16 | return True 17 | 18 | 19 | def print_result(result) -> None: 20 | result = str(result) 21 | sys.stdout.write(result) 22 | 23 | 24 | def main() -> None: 25 | n = read_input() 26 | result = is_prime(n) 27 | print_result(result) 28 | 29 | 30 | if __name__ == '__main__': 31 | main() 32 | -------------------------------------------------------------------------------- /problems/moving_average.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | from howlong import how_long 3 | 4 | 5 | @how_long 6 | def moving_average_naive(timeseries: List[int], K: int) -> List[int or float]: 7 | result = [] 8 | for begin in range(0, len(timeseries) - (K - 1)): 9 | end = begin + K 10 | time_summ = 0 11 | time_list = timeseries[begin:end] 12 | for var in time_list: 13 | time_summ += var 14 | time_avg = round(time_summ / K, 2) 15 | result.append(time_avg) 16 | return result 17 | 18 | 19 | @how_long 20 | def moving_average_optimized(timeseries: List[int], K: int)\ 21 | -> List[int or float]: 22 | result = [] 23 | current_summ = sum(timeseries[0:K]) 24 | current_avg = current_summ / K 25 | result.append(current_avg) 26 | for i in range(len(timeseries) - K): 27 | current_summ -= timeseries[i] 28 | current_summ += timeseries[i + K] 29 | current_avg = round(current_summ / K, 2) 30 | result.append(current_avg) 31 | return result 32 | 33 | 34 | K = 3 35 | timeseries = [4,3,8,1,5,6,3] 36 | print(moving_average_naive(timeseries, K)) 37 | 38 | # moving_average_optimized(timeseries * 100000, K) 39 | -------------------------------------------------------------------------------- /problems/prime_numbers.py: -------------------------------------------------------------------------------- 1 | import sys 2 | import time 3 | from typing import List 4 | 5 | from is_prime import is_prime 6 | 7 | 8 | def read_input() -> int: 9 | return int(sys.stdin.readline().strip()) 10 | 11 | 12 | def print_result(result: List[int]) -> None: 13 | result = ' '.join(map(str, result)) 14 | sys.stdout.write(result+'\n') 15 | 16 | 17 | def prime_numbers(n: int) -> List[int]: 18 | list_of_numbers = [] 19 | for i in range(2, n + 1): 20 | if is_prime(i): 21 | list_of_numbers.append(i) 22 | return list_of_numbers 23 | 24 | 25 | def main(): 26 | n = read_input() 27 | result = prime_numbers(n) 28 | print_result(result) 29 | 30 | 31 | if __name__ == '__main__': 32 | start = time.time() 33 | main() 34 | sys.stdout.write(f'TIME TAKEN: {time.time() - start}') 35 | -------------------------------------------------------------------------------- /problems/two_chips.py: -------------------------------------------------------------------------------- 1 | from typing import Optional, List, Tuple 2 | 3 | 4 | def two_chips(array: List[int], target: int) -> Optional[Tuple[int, int]]: 5 | for i in range(len(array)): 6 | for j in range(i + 1, len(array)): 7 | if array[i] + array[j] == target: 8 | return array[i], array[j] 9 | return None 10 | 11 | 12 | def read_input() -> Tuple[List[int], int]: 13 | length = int(input()) 14 | array = list(map(int, input().strip().split())) 15 | target = int(input()) 16 | return array, target 17 | 18 | 19 | def print_result(result: Optional[Tuple[int, int]]) -> None: 20 | if result is None: 21 | print(None) 22 | else: 23 | print(' '.join(map(str, result))) 24 | 25 | 26 | array, target = read_input() 27 | print_result(two_chips(array, target)) 28 | -------------------------------------------------------------------------------- /problems/zipper_closure.py: -------------------------------------------------------------------------------- 1 | from typing import List, Tuple 2 | 3 | 4 | def zipper(a: List[int], b: List[int]) -> List[int]: 5 | result = [] 6 | for i in range(len(a)): 7 | result.append(a[i]) 8 | result.append(b[i]) 9 | return result 10 | 11 | 12 | def read_input() -> Tuple[List[int], List[int]]: 13 | n = int(input()) 14 | a = list(map(int, input().strip().split())) 15 | b = list(map(int, input().strip().split())) 16 | return a, b 17 | 18 | 19 | a, b = read_input() 20 | print(" ".join(map(str, zipper(a, b)))) 21 | -------------------------------------------------------------------------------- /sprint_1_final/A_nearest_zero.py: -------------------------------------------------------------------------------- 1 | # id 69348867 2 | 3 | from typing import Tuple, List 4 | 5 | 6 | def read_input() -> Tuple[List[int], int]: 7 | n = int(input()) 8 | street = list(map(int, input().strip().split())) 9 | return street, n 10 | 11 | 12 | def get_nearest_zero(street: List[int], n: int) -> str: 13 | result = [0] * len(street) 14 | zero_list = [i for i in range(n) if street[i] == 0] 15 | 16 | for house in range(0, zero_list[0] + 1): 17 | result[house] = zero_list[0] - house 18 | 19 | for pos in range(len(zero_list) - 1): 20 | zero_1, zero_2 = zero_list[pos], zero_list[pos + 1] 21 | for house in range(zero_1, zero_2): 22 | result[house] = min(house - zero_1, zero_2 - house) 23 | 24 | for house in range(zero_list[-1], len(street)): 25 | result[house] = house - zero_list[-1] 26 | 27 | return ' '.join(map(str, result)) 28 | 29 | 30 | def main() -> None: 31 | street, n = read_input() 32 | print(get_nearest_zero(street, n)) 33 | 34 | 35 | if __name__ == '__main__': 36 | main() 37 | -------------------------------------------------------------------------------- /sprint_1_final/B_sleight_of_hand.py: -------------------------------------------------------------------------------- 1 | # id 69345566 2 | 3 | from typing import List, Tuple 4 | 5 | 6 | def read_input() -> Tuple[int, List[List[str]]]: 7 | k = int(input()) 8 | keyboard = [list(map(str, input())) for line in range(4)] 9 | return k, keyboard 10 | 11 | 12 | def trainer(k: int, keyboard: List[List[str]]) -> int: 13 | score = 0 14 | keys = {'1': 0, '2': 0, '3': 0, '4': 0, '5': 0, 15 | '6': 0, '7': 0, '8': 0, '9': 0, '0': 0, } 16 | for line in keyboard: 17 | for key in line: 18 | if key.isdigit(): 19 | keys[key] += 1 20 | for t in range(0, 10): 21 | if keys[str(t)] and keys[str(t)] <= k + k: 22 | score += 1 23 | return score 24 | 25 | 26 | def main() -> None: 27 | k, keyboard = read_input() 28 | print(trainer(k, keyboard)) 29 | 30 | 31 | if __name__ == '__main__': 32 | main() 33 | -------------------------------------------------------------------------------- /sprint_1_final/B_sleight_of_hand_v2.py: -------------------------------------------------------------------------------- 1 | # id 69348269 2 | 3 | from typing import List, Tuple 4 | from collections import Counter 5 | 6 | 7 | def read_input() -> Tuple[int, List[List[str]]]: 8 | k = int(input()) 9 | keyboard = [list(map(str, input())) for line in range(4)] 10 | return k, keyboard 11 | 12 | 13 | def trainer(k: int, keyboard: List[List[str]]): 14 | keys = Counter(int(key) for row in keyboard for key in row if key != '.') 15 | score = sum(1 for t in range(0, 10) if keys[t] and keys[t] <= k + k) 16 | return score 17 | 18 | 19 | def main() -> None: 20 | k, keyboard = read_input() 21 | print(trainer(k, keyboard)) 22 | 23 | 24 | if __name__ == '__main__': 25 | main() 26 | -------------------------------------------------------------------------------- /sprint_1_introduction/A_func_values.py: -------------------------------------------------------------------------------- 1 | def evaluate_function(a: int, x: int, b: int, c: int) -> int: 2 | return a * x**2 + b * x + c 3 | 4 | 5 | a, x, b, c = map(int, input().strip().split()) 6 | print(evaluate_function(a, x, b, c)) 7 | -------------------------------------------------------------------------------- /sprint_1_introduction/B_even_odd.py: -------------------------------------------------------------------------------- 1 | def even_odd(a: int, b: int, c: int) -> str: 2 | all_even = (a % 2 == 0 and b % 2 == 0 and c % 2 == 0) 3 | all_odd = (a % 2 != 0 and b % 2 != 0 and c % 2 != 0) 4 | if all_even or all_odd: 5 | return 'WIN' 6 | return 'FAIL' 7 | 8 | 9 | a, b, c = map(int, input().strip().split()) 10 | result = even_odd(a, b, c) 11 | print(result) 12 | 13 | 14 | -------------------------------------------------------------------------------- /sprint_1_introduction/C_neighbors.py: -------------------------------------------------------------------------------- 1 | from typing import List, Tuple 2 | 3 | 4 | def read_matrix() -> List[List[int]]: 5 | n = int(input()) 6 | m = int(input()) 7 | matrix = [list(map(int, input().split())) for line in range(n)] 8 | return matrix 9 | 10 | 11 | def read_position() -> Tuple[int, int]: 12 | row = int(input()) 13 | col = int(input()) 14 | return row, col 15 | 16 | 17 | def find_neighbor(matrix: List[List[int]], row: int, col: int) -> str: 18 | neighbor = list() 19 | neighbor.append(matrix[row - 1][col]) if row - 1 >= 0 else None 20 | neighbor.append(matrix[row][col - 1]) if col - 1 >= 0 else None 21 | try: 22 | neighbor.append(matrix[row + 1][col]) 23 | except IndexError: 24 | pass 25 | try: 26 | neighbor.append(matrix[row][col + 1]) 27 | except IndexError: 28 | pass 29 | neighbor.sort() 30 | return ' '.join(map(str, neighbor)) 31 | 32 | 33 | def main(): 34 | matrix = read_matrix() 35 | row, col = read_position() 36 | 37 | print(find_neighbor(matrix, row, col)) 38 | 39 | 40 | if __name__ == '__main__': 41 | main() 42 | -------------------------------------------------------------------------------- /sprint_1_introduction/D_chaotic_weather.py: -------------------------------------------------------------------------------- 1 | from typing import List, Tuple 2 | 3 | 4 | def read_input() -> Tuple[int, List[int]]: 5 | n = int(input()) 6 | temperatures = list(map(int, input().strip().split())) 7 | return n, temperatures 8 | 9 | 10 | def get_weather_randomness(n: int, temperatures: List[int]) -> int: 11 | randomness = 0 12 | for i in range(1, n- 1): 13 | if temperatures[i - 1] < temperatures[i] > temperatures[i + 1]: 14 | randomness += 1 15 | try: 16 | if temperatures[0] > temperatures[1]: 17 | randomness += 1 18 | if temperatures[-1] > temperatures[-2]: 19 | randomness += 1 20 | except IndexError: 21 | randomness += 1 22 | return randomness 23 | 24 | 25 | def main(): 26 | n, temperatures = read_input() 27 | result = get_weather_randomness(n, temperatures) 28 | print(result) 29 | 30 | 31 | if __name__ == '__main__': 32 | main() 33 | -------------------------------------------------------------------------------- /sprint_1_introduction/E_longest_word.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def read_input() -> str: 5 | _ = int(input()) 6 | line = input() 7 | return line 8 | 9 | 10 | def print_result(result: str) -> None: 11 | print(result) 12 | print(len(result)) 13 | 14 | 15 | def get_longest_word(text: str) -> str: 16 | text = text.strip().split() 17 | longest = 0 18 | for i in range(1, len(text)): 19 | if len(text[i]) > len(text[longest]): 20 | longest = i 21 | return text[longest] 22 | 23 | 24 | def main() -> None: 25 | text = read_input() 26 | result = get_longest_word(text) 27 | print_result(result) 28 | 29 | 30 | if __name__ == '__main__': 31 | main() 32 | -------------------------------------------------------------------------------- /sprint_1_introduction/F_palindrome.py: -------------------------------------------------------------------------------- 1 | def is_palindrome(text: str) -> bool: 2 | text = ''.join(filter(str.isalpha, text.lower())) 3 | reversed_text = text[::-1] 4 | return text == reversed_text 5 | 6 | 7 | def main() -> None: 8 | print(is_palindrome(input())) 9 | 10 | 11 | if __name__ == '__main__': 12 | main() -------------------------------------------------------------------------------- /sprint_1_introduction/G_work_from_home.py: -------------------------------------------------------------------------------- 1 | def to_binary(n: int) -> str: 2 | binary = '' 3 | while n >= 1: 4 | res = n // 2 5 | binary += str(n % 2) 6 | n = res 7 | return binary[::-1] 8 | 9 | 10 | print(to_binary(int(input()))) 11 | -------------------------------------------------------------------------------- /sprint_1_introduction/H_sum_binary.py: -------------------------------------------------------------------------------- 1 | from itertools import zip_longest 2 | from typing import Tuple 3 | 4 | 5 | def sum_binary(x: str, y: str) -> str: 6 | summ = '' 7 | carry_one = 0 8 | 9 | for arr in zip_longest(x[::-1], y[::-1], fillvalue='0'): 10 | temp_sum = int(arr[0]) + int(arr[1]) + carry_one 11 | summ += str(temp_sum % 2) 12 | carry_one = temp_sum // 2 13 | if carry_one: 14 | summ += '1' 15 | return summ[::-1] 16 | 17 | 18 | def read_input() -> Tuple[str, str]: 19 | first_number = input().strip() 20 | second_number = input().strip() 21 | return first_number, second_number 22 | 23 | 24 | first_number, second_number = read_input() 25 | print(sum_binary(first_number, second_number)) 26 | -------------------------------------------------------------------------------- /sprint_1_introduction/I_power_of_four.py: -------------------------------------------------------------------------------- 1 | def power_of_four(n: int) -> bool: 2 | if n == 1 or n == 4: 3 | return True 4 | while n >= 4: 5 | n = n / 4 6 | if n == 4: 7 | return True 8 | return False 9 | 10 | 11 | print(power_of_four(int(input()))) 12 | -------------------------------------------------------------------------------- /sprint_1_introduction/J_factorize.py: -------------------------------------------------------------------------------- 1 | from math import sqrt 2 | from typing import List 3 | 4 | 5 | def factorize(n: int) -> List[int]: 6 | result = [] 7 | for i in range(2, int(sqrt(n))+1): 8 | while n % i == 0: 9 | result.append(i) 10 | n = n // i 11 | if n == 1: 12 | break 13 | 14 | if n > 1: 15 | result.append(n) 16 | return result 17 | 18 | 19 | result = factorize(int(input())) 20 | print(' '.join(map(str, result))) 21 | -------------------------------------------------------------------------------- /sprint_1_introduction/K_list_form.py: -------------------------------------------------------------------------------- 1 | from typing import List, Tuple 2 | 3 | 4 | def read_input() -> Tuple[List[int], int]: 5 | _ = int(input()) 6 | x = list(map(int, input().split())) 7 | k = int(input()) 8 | return x, k 9 | 10 | 11 | def get_list_form(x: List[int], k:int) -> str: 12 | x_number = int(''.join(map(str, x))) 13 | k += x_number 14 | k_list = list(map(int, str(k))) 15 | return ' '.join(map(str, k_list)) 16 | 17 | 18 | x, k = read_input() 19 | print(get_list_form(x, k)) 20 | -------------------------------------------------------------------------------- /sprint_1_introduction/L_excessive_letter.py: -------------------------------------------------------------------------------- 1 | from typing import Tuple 2 | 3 | 4 | def get_excessive_letter(shorter: str, longer: str) -> str: 5 | for letter in shorter: 6 | if letter in longer: 7 | longer = longer.replace(letter, '', 1) 8 | return longer 9 | 10 | def read_input() -> Tuple[str, str]: 11 | shorter = input().strip() 12 | longer = input().strip() 13 | return shorter, longer 14 | 15 | 16 | shorter, longer = read_input() 17 | print(get_excessive_letter(shorter, longer)) -------------------------------------------------------------------------------- /sprint_2/A_monitoring.py: -------------------------------------------------------------------------------- 1 | from typing import List, Tuple 2 | 3 | 4 | def read_input() -> Tuple[int, int, List[List[int]]]: 5 | row = int(input()) 6 | col = int(input()) 7 | matrix = [list(map(int, input().split())) for line in range(row)] 8 | return row, col, matrix 9 | 10 | 11 | def transposition(row: int, col: int, matrix: List[List[int]]): 12 | return [[matrix[i][j] for i in range(row)] for j in range(col)] 13 | 14 | 15 | def print_result(matrix): 16 | for i in range(len(matrix)): 17 | print(*matrix[i]) 18 | 19 | 20 | if __name__ == '__main__': 21 | row, col, matrix = read_input() 22 | new_matrix = transposition(row, col, matrix) 23 | print_result(new_matrix) 24 | -------------------------------------------------------------------------------- /sprint_2/B_todo_list.py: -------------------------------------------------------------------------------- 1 | def solution(node): 2 | while node: 3 | print(node.value) 4 | node = node.next_item 5 | -------------------------------------------------------------------------------- /sprint_2/C_unlovely_buisness.py: -------------------------------------------------------------------------------- 1 | def get_node_by_index(node, index: int): 2 | while index: 3 | node = node.next 4 | index -= 1 5 | return node 6 | 7 | 8 | def solution(head, index: int): 9 | if index == 0: 10 | return head.next 11 | previous_node = get_node_by_index(head, index - 1) 12 | next_node = get_node_by_index(head, index + 1) 13 | previous_node.next = next_node 14 | return head 15 | -------------------------------------------------------------------------------- /sprint_2/D_careful_mom.py: -------------------------------------------------------------------------------- 1 | # Rename function as "solution" before submitting 2 | 3 | def get_index_of_value(head, value): 4 | node = head 5 | index = 0 6 | while node is not None: 7 | if node.value == value: 8 | return index 9 | node = node.next 10 | index += 1 11 | return -1 12 | -------------------------------------------------------------------------------- /sprint_2/E_around.py: -------------------------------------------------------------------------------- 1 | # Rename function as "solution" before submitting 2 | 3 | def solution(head): 4 | node, new_head = head, head 5 | while node: 6 | node.prev, node.next = node.next, node.prev 7 | new_head = node if node else new_head 8 | node = node.prev 9 | return new_head 10 | -------------------------------------------------------------------------------- /sprint_2/F_stack_max.py: -------------------------------------------------------------------------------- 1 | class StackMax: 2 | def __init__(self): 3 | self.numbers = [] 4 | 5 | def push(self, number): 6 | self.numbers.append(number) 7 | 8 | def pop(self): 9 | if self.numbers: 10 | return self.numbers.pop() 11 | print('error') 12 | 13 | def get_max(self): 14 | print(max(self.numbers) if self.numbers else None) 15 | 16 | 17 | def read_input(): 18 | _ = int(input()) 19 | commands = [list(map(str, input().split())) for line in range(_)] 20 | return commands 21 | 22 | 23 | def main(): 24 | commands = read_input() 25 | stack = StackMax() 26 | for command in commands: 27 | try: 28 | eval(f'stack.{command[0]}({int(command[1])})') 29 | except IndexError: 30 | eval(f'stack.{command[0]}()') 31 | 32 | 33 | if __name__ == '__main__': 34 | main() 35 | -------------------------------------------------------------------------------- /sprint_2/G_stack_max_effective.py: -------------------------------------------------------------------------------- 1 | class StackMax: 2 | def __init__(self): 3 | self.numbers = [] 4 | self.max_numbers = [] 5 | 6 | def push(self, number): 7 | self.numbers.append(number) 8 | if self.max_numbers: 9 | max_n = number if number > self.max_numbers[-1]\ 10 | else self.max_numbers[-1] 11 | else: 12 | max_n = number 13 | self.max_numbers.append(max_n) 14 | 15 | def pop(self): 16 | if self.numbers: 17 | self.max_numbers.pop() 18 | return self.numbers.pop() 19 | print('error') 20 | 21 | def get_max(self): 22 | print(self.max_numbers[-1] if self.max_numbers else None) 23 | 24 | 25 | def main(): 26 | commands = int(input()) 27 | stack = StackMax() 28 | for command in range(commands): 29 | command = input().split() 30 | if command[0] == 'push': 31 | stack.push(int(command[1])) 32 | elif command[0] == 'pop': 33 | stack.pop() 34 | elif command[0] == 'get_max': 35 | stack.get_max() 36 | 37 | 38 | if __name__ == '__main__': 39 | main() 40 | -------------------------------------------------------------------------------- /sprint_2/H_parenthesis_sequence.py: -------------------------------------------------------------------------------- 1 | class Bracket: 2 | def __init__(self): 3 | self.brackets = [] 4 | 5 | def push(self, bracket): 6 | self.brackets.append(bracket) 7 | 8 | def pop(self): 9 | self.brackets.pop() 10 | 11 | def peek(self): 12 | return self.brackets[-1] 13 | 14 | def is_empty(self): 15 | return self.brackets == [] 16 | 17 | 18 | def main(): 19 | brackets_input = input() 20 | brackets = {'(': ')', '[': ']', '{': '}'} 21 | seq = Bracket() 22 | for bracket in brackets_input: 23 | if bracket in brackets.keys(): 24 | seq.push(bracket) 25 | elif not seq.is_empty() and bracket == brackets[seq.peek()]: 26 | seq.pop() 27 | else: 28 | seq.push(bracket) 29 | break 30 | print(seq.is_empty()) 31 | 32 | 33 | if __name__ == '__main__': 34 | main() 35 | -------------------------------------------------------------------------------- /sprint_2/I_limited_queue.py: -------------------------------------------------------------------------------- 1 | class Queue: 2 | def __init__(self, max_length): 3 | self.queue = [None] * max_length 4 | self.max_length = max_length 5 | self.head = 0 6 | self.tail = 0 7 | self.size = 0 8 | 9 | def push(self, item): 10 | if self.size < self.max_length: 11 | self.queue[self.tail] = item 12 | self.size += 1 13 | self.tail = (self.tail + 1) % self.max_length 14 | else: 15 | print('error') 16 | 17 | def is_empty(self): 18 | return self.size == 0 19 | 20 | def pop(self): 21 | if self.is_empty(): 22 | return None 23 | result = self.queue[self.head] 24 | self.queue[self.head] = None 25 | self.head = (self.head + 1) % self.max_length 26 | self.size -= 1 27 | return result 28 | 29 | def peek(self): 30 | return self.queue[self.head] 31 | 32 | def __str__(self): 33 | return ' '.join(map(str, self.queue)) 34 | 35 | 36 | def main(): 37 | commands = int(input()) 38 | max_length = int(input()) 39 | queue = Queue(max_length) 40 | for command in range(commands): 41 | command = input().split() 42 | if command[0] == 'push': 43 | queue.push(command[1]) 44 | elif command[0] == 'pop': 45 | print(queue.pop()) 46 | elif command[0] == 'peek': 47 | print(queue.peek()) 48 | elif command[0] == 'size': 49 | print(queue.size) 50 | 51 | 52 | if __name__ == '__main__': 53 | main() 54 | 55 | -------------------------------------------------------------------------------- /sprint_2/J_list_queue.py: -------------------------------------------------------------------------------- 1 | class ListQueue: 2 | def __init__(self): 3 | self.queue = [] 4 | self.size = 0 5 | 6 | def put(self, item): 7 | self.queue.append(item) 8 | self.size += 1 9 | 10 | def get(self): 11 | if self.size == 0: 12 | return 'error' 13 | self.size -= 1 14 | return self.queue.pop(0) 15 | 16 | 17 | def main(): 18 | commands = int(input()) 19 | queue = ListQueue() 20 | for command in range(commands): 21 | command = input().split() 22 | if command[0] == 'get': 23 | print(queue.get()) 24 | elif command[0] == 'put': 25 | queue.put(command[1]) 26 | elif command[0] == 'size': 27 | print(queue.size) 28 | 29 | 30 | if __name__ == '__main__': 31 | main() 32 | -------------------------------------------------------------------------------- /sprint_2/J_list_queue_v2.py: -------------------------------------------------------------------------------- 1 | class Node: 2 | def __init__(self, value, next=None): 3 | self.value = value 4 | self.next = next 5 | 6 | def __str__(self): 7 | return str(self.value) 8 | 9 | 10 | class ListQueue: 11 | def __init__(self, head=None, tail=None): 12 | self.head = head 13 | self.tail = tail 14 | self.size = 0 15 | 16 | def put(self, item): 17 | item = Node(item) 18 | if self.size == 0: 19 | self.head = self.tail = item 20 | 21 | else: 22 | self.tail.next = item 23 | self.tail.next.next = self.head 24 | self.tail = self.tail.next 25 | 26 | self.size += 1 27 | 28 | def get(self): 29 | if self.size == 0: 30 | return 'error' 31 | 32 | result = self.head 33 | if self.size == 1: 34 | self.tail = self.head = None 35 | else: 36 | self.head = self.tail.next.next 37 | self.tail.next = self.head 38 | self.size -= 1 39 | return result 40 | 41 | def printed_linked(self): 42 | if self.size == 0: 43 | return None 44 | node = self.head 45 | for i in range(self.size): 46 | print(node.value, end=' -> ') 47 | node = node.next 48 | print('again') 49 | 50 | 51 | def main(): 52 | list_queue = ListQueue() 53 | commands = int(input()) 54 | for command in range(commands): 55 | command = input().split() 56 | if command[0] == 'put': 57 | list_queue.put(command[1]) 58 | elif command[0] == 'get': 59 | print(list_queue.get()) 60 | elif command[0] == 'size': 61 | print(list_queue.size) 62 | 63 | 64 | if __name__ == '__main__': 65 | main() -------------------------------------------------------------------------------- /sprint_2/K_recursive_fibonacci_numbers.py: -------------------------------------------------------------------------------- 1 | def get_fibonacci_number(n): 2 | if n == 0 or n == 1: 3 | return 1 4 | return get_fibonacci_number(n - 1) + get_fibonacci_number(n - 2) 5 | 6 | 7 | def main(): 8 | number = int(input()) 9 | result = get_fibonacci_number(number) 10 | print(result) 11 | 12 | 13 | if __name__ == '__main__': 14 | main() 15 | -------------------------------------------------------------------------------- /sprint_2/L_fibonacci_modulo.py: -------------------------------------------------------------------------------- 1 | def get_fibonacci_number(number, k): 2 | num_1, num_2 = 1, 1 3 | if number <= 1: 4 | return 1 5 | else: 6 | for _ in range(number - 1): 7 | num_1, num_2 = num_2, (num_2 + num_1) % 10 ** k 8 | return num_2 9 | 10 | 11 | def main(): 12 | number, k = map(int, input().split()) 13 | result = get_fibonacci_number(number, k) 14 | print(result) 15 | 16 | 17 | if __name__ == '__main__': 18 | main() 19 | -------------------------------------------------------------------------------- /sprint_2/node_class_realisation.py: -------------------------------------------------------------------------------- 1 | from D_careful_mom import get_index_of_value 2 | 3 | 4 | class Node: 5 | def __init__(self, value, next=None, previous=None): 6 | self.value = value 7 | self.next = next 8 | self.prev = previous 9 | 10 | def __str__(self): 11 | return self.value 12 | 13 | 14 | def print_linked_link(vertex): 15 | while vertex: 16 | print(vertex.value, end=' -> ') 17 | vertex = vertex.next 18 | print('None') 19 | 20 | 21 | def get_node_by_index(node: Node, index: int) -> Node: 22 | while index: 23 | node = node.next 24 | index -= 1 25 | return node 26 | 27 | 28 | def insert_node(head: Node, index: int, value: str) -> Node: 29 | new_node = Node(value) 30 | if index == 0: 31 | new_node.next = head 32 | return new_node 33 | previous_node = get_node_by_index(head, index - 1) 34 | new_node.next = previous_node.next 35 | previous_node.next = new_node 36 | return head 37 | 38 | 39 | def delete_node(head: Node, index: int): 40 | if index == 0: 41 | return head.next 42 | previous_node = get_node_by_index(head, index - 1) 43 | next_node = get_node_by_index(head, index + 1) 44 | previous_node.next = next_node 45 | return head 46 | 47 | 48 | def list_reverse(head): 49 | node, new_head = head, head 50 | while node: 51 | node.prev, node.next = node.next, node.prev 52 | new_head = node if node else new_head 53 | node = node.prev 54 | return new_head 55 | 56 | 57 | node3 = Node('fourth') 58 | node2 = Node('third') 59 | node1 = Node('second') 60 | node0 = Node('first') 61 | 62 | node0.next = node1 63 | 64 | node1.prev = node0 65 | node1.next = node2 66 | 67 | node2.prev = node1 68 | node2.next = node3 69 | 70 | node3.prev = node2 71 | 72 | # insert_node(node0, 1, 'new_node_2') 73 | 74 | # delete_node(node0, 0) 75 | 76 | # print(get_node_by_index(node1, 2)) 77 | # print(get_index_of_value(node0, 'second')) 78 | 79 | print_linked_link(node0) 80 | 81 | print(list_reverse(node0)) 82 | 83 | print_linked_link(node3) 84 | -------------------------------------------------------------------------------- /sprint_2/queue_class_realisation.py: -------------------------------------------------------------------------------- 1 | class Queue: 2 | def __init__(self, max_length): 3 | self.queue = [None] * max_length 4 | self.max_length = max_length 5 | self.head = 0 6 | self.tail = 0 7 | self.size = 0 8 | 9 | def push(self, item): 10 | if self.size < self.max_length: 11 | self.queue[self.tail] = item 12 | self.size += 1 13 | self.tail = (self.tail + 1) % self.max_length 14 | 15 | def is_empty(self): 16 | return self.size == 0 17 | 18 | def pop(self): 19 | if self.is_empty(): 20 | return None 21 | result = self.queue[self.head] 22 | self.queue[self.head] = None 23 | self.head = (self.head + 1) % self.max_length 24 | self.size -= 1 25 | return result 26 | 27 | def __str__(self): 28 | return ' '.join(map(str, self.queue)) 29 | 30 | 31 | if __name__ == '__main__': 32 | queue = Queue(5) 33 | 34 | 35 | -------------------------------------------------------------------------------- /sprint_2/stack_class_realisation.py: -------------------------------------------------------------------------------- 1 | class Stack: 2 | def __init__(self): 3 | self.items = [] 4 | 5 | def push(self, item): 6 | self.items.append(item) 7 | 8 | def pop(self): 9 | return self.items.pop() 10 | 11 | def peek(self): 12 | return self.items[-1] 13 | 14 | def size(self): 15 | return len(self.items) 16 | 17 | def __str__(self): 18 | return '\n'.join(self.items[::-1]) 19 | 20 | 21 | fruits = Stack() 22 | 23 | fruits.push('orange') 24 | fruits.push('banana') 25 | fruits.push('apple') 26 | 27 | 28 | print(fruits) 29 | -------------------------------------------------------------------------------- /sprint_2_final/A_deque.py: -------------------------------------------------------------------------------- 1 | # id 69445419 2 | 3 | from typing import List, Optional 4 | 5 | 6 | class OverFlowError(Exception): 7 | """Ошибка переполнения очереди.""" 8 | pass 9 | 10 | 11 | class EmptyDeque(Exception): 12 | """Очередь пуста.""" 13 | pass 14 | 15 | 16 | class Deque: 17 | """Класс двухсторонней очереди.""" 18 | def __init__(self, max_length: int) -> None: 19 | self._queue: List[Optional[int]] = [None] * max_length 20 | self._max_length: int = max_length 21 | self._head: int = 0 22 | self._tail: int = 0 23 | self._size: int = 0 24 | 25 | def push_front(self, value: int) -> None: 26 | """Добавляет элемент в начало очереди.""" 27 | if self._size < self._max_length: 28 | if self.is_empty(): 29 | self._tail += 1 30 | self._queue[self._head] = value 31 | self._size += 1 32 | self._head = self.__get_new_index__(self._head, -1) 33 | else: 34 | raise OverFlowError('error') 35 | 36 | def push_back(self, value: int) -> None: 37 | """Добавляет элемент в конец очереди.""" 38 | if self._size < self._max_length: 39 | if self.is_empty(): 40 | self._head = self._max_length - 1 41 | self._queue[self._tail] = value 42 | self._size += 1 43 | self._tail = self.__get_new_index__(self._tail, 1) 44 | else: 45 | raise OverFlowError('error') 46 | 47 | def pop_front(self) -> int: 48 | """Удаляет элемент из начала очереди и возвращает его.""" 49 | if self.is_empty(): 50 | raise EmptyDeque('error') 51 | self._head = self.__get_new_index__(self._head, 1) 52 | result = self._queue[self._head] 53 | self._queue[self._head] = None 54 | self._size -= 1 55 | self.__reset_deque__() 56 | return result 57 | 58 | def pop_back(self) -> int: 59 | """Удаляет элемент из конца очереди и возвращает его.""" 60 | if self.is_empty(): 61 | raise EmptyDeque('error') 62 | self._tail = self.__get_new_index__(self._tail, -1) 63 | result = self._queue[self._tail] 64 | self._queue[self._tail] = None 65 | self._size -= 1 66 | self.__reset_deque__() 67 | return result 68 | 69 | def __get_new_index__(self, index, new): 70 | """Получение нового указателя, после добавления/удаления элемента.""" 71 | return (index + new) % self._max_length 72 | 73 | def __reset_deque__(self): 74 | """Сброс стартовых индексов очереди, если она пуста.""" 75 | if self.is_empty(): 76 | self._head = self._tail = 0 77 | 78 | def is_empty(self) -> bool: 79 | """Возвращает булево значение. 80 | True - если очередь пуста. Иначе False.""" 81 | return self._size == 0 82 | 83 | def __str__(self): 84 | return ' '.join(map(str, self._queue)) 85 | 86 | 87 | def main(): 88 | """Основная логика программы.""" 89 | comm = int(input()) 90 | max_length = int(input()) 91 | deque = Deque(max_length) 92 | 93 | for command in range(comm): 94 | command, *value = input().split() 95 | if value: 96 | try: 97 | getattr(deque, command)(int(*value)) 98 | except OverFlowError as error: 99 | print(error) 100 | else: 101 | try: 102 | print(getattr(deque, command)()) 103 | except EmptyDeque as error: 104 | print(error) 105 | 106 | 107 | if __name__ == '__main__': 108 | main() 109 | 110 | -------------------------------------------------------------------------------- /sprint_2_final/B_calculator.py: -------------------------------------------------------------------------------- 1 | # id 69445617 2 | 3 | from operator import add, sub, mul, floordiv 4 | 5 | 6 | class Numbers: 7 | """Стек для хранения чисел.""" 8 | def __init__(self): 9 | self.items = [] 10 | 11 | def push(self, item): 12 | """Добавляет новый элемент в стек.""" 13 | self.items.append(item) 14 | 15 | def pop(self): 16 | """Удаляет и возвращает последний элемент стека.""" 17 | try: 18 | return self.items.pop() 19 | except IndexError: 20 | return 21 | 22 | 23 | EXPRESSIONS = { 24 | '+': add, '-': sub, 25 | '*': mul, '/': floordiv, 26 | } 27 | 28 | 29 | def main(): 30 | """Основная логика программы.""" 31 | exp = input().split() 32 | numbers = Numbers() 33 | 34 | for symb in exp: 35 | if symb.lstrip('-').isdigit(): 36 | numbers.push(int(symb)) 37 | else: 38 | num_2, num_1 = numbers.pop(), numbers.pop() 39 | temp = EXPRESSIONS[symb](num_1, num_2) 40 | numbers.push(temp) 41 | 42 | print(numbers.pop()) 43 | 44 | 45 | if __name__ == '__main__': 46 | main() 47 | -------------------------------------------------------------------------------- /sprint_3/A_gen_parenthesis.py: -------------------------------------------------------------------------------- 1 | class Bracket: 2 | def __init__(self): 3 | self.brackets = [] 4 | 5 | def push(self, bracket): 6 | self.brackets.append(bracket) 7 | 8 | def pop(self): 9 | self.brackets.pop() 10 | 11 | def peek(self): 12 | return self.brackets[-1] 13 | 14 | def is_empty(self): 15 | return self.brackets == [] 16 | 17 | 18 | def gen_parenthesis(n, parenthesis=''): 19 | if n == 0: 20 | brackets = {'(': ')', '[': ']', '{': '}'} 21 | seq = Bracket() 22 | for bracket in parenthesis: 23 | if bracket in brackets.keys(): 24 | seq.push(bracket) 25 | elif not seq.is_empty() and bracket == brackets[seq.peek()]: 26 | seq.pop() 27 | else: 28 | seq.push(bracket) 29 | break 30 | if seq.is_empty(): 31 | print(parenthesis) 32 | else: 33 | gen_parenthesis(n - 1, parenthesis + '(') 34 | gen_parenthesis(n - 1, parenthesis + ')') 35 | 36 | 37 | if __name__ == '__main__': 38 | gen_parenthesis(2 * 2) 39 | -------------------------------------------------------------------------------- /sprint_3/A_gen_parenthesis_v2.py: -------------------------------------------------------------------------------- 1 | def gen_parenthesis(length: int, open_br: int = 0, close_br: int = 0, 2 | parenthesis: str = '') -> None: 3 | if length * 2 == len(parenthesis): 4 | print(parenthesis) 5 | if open_br < length: 6 | gen_parenthesis(length, open_br + 1, close_br, parenthesis + '(') 7 | if close_br < open_br: 8 | gen_parenthesis(length, open_br, close_br + 1, parenthesis + ')') 9 | 10 | 11 | def main(): 12 | gen_parenthesis(int(input())) 13 | 14 | 15 | if __name__ == '__main__': 16 | main() 17 | -------------------------------------------------------------------------------- /sprint_3/B_combinations.py: -------------------------------------------------------------------------------- 1 | KEYBOARD = {'2': 'abc', '3': 'def', '4': 'ghi', '5': 'jkl', 2 | '6': 'mno', '7': 'pqrs', '8': 'tuv', '9': 'wxyz' 3 | } 4 | 5 | 6 | def phone_keyboard(numbers: str, combination: str = '') -> None: 7 | if not numbers: 8 | print(combination, end=' ') 9 | return 10 | for letter in KEYBOARD[numbers[0]]: 11 | combination += letter 12 | phone_keyboard(numbers[1:], combination) 13 | combination = combination[:-1] 14 | 15 | 16 | if __name__ == '__main__': 17 | phone_keyboard(input()) 18 | -------------------------------------------------------------------------------- /sprint_3/C_subsequence.py: -------------------------------------------------------------------------------- 1 | def is_subsequence(s: str, t: str) -> bool: 2 | index = -1 3 | for letter in s: 4 | index = t.find(letter, index + 1) 5 | if index == -1: 6 | return False 7 | return True 8 | 9 | 10 | def main(): 11 | s = input() 12 | t = input() 13 | print(is_subsequence(s, t)) 14 | 15 | 16 | if __name__ == '__main__': 17 | main() 18 | -------------------------------------------------------------------------------- /sprint_3/D_cookies.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def read_input(): 5 | _ = int(input()) 6 | greed = [int(i) for i in input().split()] 7 | _ = int(input()) 8 | cookies = [int(i) for i in input().split()] 9 | return greed, cookies 10 | 11 | 12 | def how_happy(greed: List[int], cookies: List[int]): 13 | greed.sort(reverse=True), cookies.sort(reverse=True) 14 | result = 0 15 | i = 0 16 | for child in greed: 17 | if i < len(cookies) and child <= cookies[i]: 18 | i += 1 19 | result += 1 20 | return result 21 | 22 | 23 | def main(): 24 | children, cookies = read_input() 25 | print(how_happy(children, cookies)) 26 | 27 | 28 | if __name__ == '__main__': 29 | main() 30 | -------------------------------------------------------------------------------- /sprint_3/E_buying_houses.py: -------------------------------------------------------------------------------- 1 | def read_input(): 2 | n, k = map(int, input().split()) 3 | houses = [int(i) for i in input().split()] 4 | return k, houses 5 | 6 | 7 | def how_houses(houses, k): 8 | houses.sort() 9 | summary = 0 10 | quantity = 0 11 | for price in houses: 12 | if summary + price <= k: 13 | summary += price 14 | quantity += 1 15 | return quantity 16 | 17 | 18 | def main(): 19 | k, houses = read_input() 20 | print(how_houses(houses, k)) 21 | 22 | 23 | if __name__ == '__main__': 24 | main() 25 | -------------------------------------------------------------------------------- /sprint_3/F_triangle_perimeter.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def get_biggest_perimeter(sides: List[int]): 5 | sides.sort(reverse=True) 6 | c, a, b = 0, 1, 2 7 | for _ in range(len(sides) - 2): 8 | if sides[c] < (sides[a] + sides[b]): 9 | return sides[a] + sides[b] + sides[c] 10 | c, a, b = c + 1, a + 1, b + 1 11 | 12 | 13 | def main(): 14 | _ = int(input()) 15 | sides = [int(i) for i in input().split()] 16 | result = get_biggest_perimeter(sides) 17 | print(result) 18 | 19 | 20 | if __name__ == '__main__': 21 | main() 22 | -------------------------------------------------------------------------------- /sprint_3/G_wardrobe.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def counting_sort(array: List[int], k: int = 3) -> None: 5 | counted_values = [0] * k 6 | for value in array: 7 | counted_values[value] += 1 8 | 9 | for color in range(k): 10 | print((str(color) + ' ') * counted_values[color], end='') 11 | 12 | 13 | def main() -> None: 14 | _ = int(input()) 15 | nums = [int(i) for i in input().strip().split()] 16 | counting_sort(nums) 17 | 18 | 19 | if __name__ == '__main__': 20 | main() -------------------------------------------------------------------------------- /sprint_3/H_big_number.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def compare(obj_1: str, obj_2: str) -> bool: 5 | if int(obj_1 + obj_2) < int(obj_2 + obj_1): 6 | return True 7 | return False 8 | 9 | 10 | def get_big_number(array: List[str]) -> str: 11 | for i in range(1, len(array)): 12 | item_to_insert = array[i] 13 | j = i 14 | while j > 0 and compare(item_to_insert, array[j - 1]): 15 | array[j] = array[j - 1] 16 | j -= 1 17 | array[j] = item_to_insert 18 | return ''.join(array[::-1]) 19 | 20 | 21 | def main() -> None: 22 | _ = int(input()) 23 | array = [i for i in input().strip().split()] 24 | print(get_big_number(array)) 25 | 26 | 27 | if __name__ == '__main__': 28 | main() -------------------------------------------------------------------------------- /sprint_3/I_conference_lovers.py: -------------------------------------------------------------------------------- 1 | from typing import Tuple, List 2 | 3 | 4 | def read_input() -> Tuple[int, List[int], int]: 5 | students = int(input()) 6 | id_univers = [int(i) for i in input().split()] 7 | univers = int(input()) 8 | return students, id_univers, univers 9 | 10 | 11 | def counting_value(array: List[int]) -> List[List[int]]: 12 | counted_values = [[i, 0] for i in range(max(array) + 1)] 13 | for value in array: 14 | counted_values[value][1] += 1 15 | counted_values.sort(key=lambda x: x[1], reverse=True) 16 | return counted_values 17 | 18 | 19 | def get_result(array: List[List[int]], k: int) -> None: 20 | for i in range(k): 21 | print(array[i][0], end=' ') 22 | 23 | 24 | def main() -> None: 25 | students, id_univers, univers = read_input() 26 | counted_value = counting_value(id_univers) 27 | get_result(counted_value, univers) 28 | 29 | 30 | if __name__ == '__main__': 31 | main() 32 | -------------------------------------------------------------------------------- /sprint_3/J_bubble.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def bubble(array: List[int], length: int) -> None: 5 | length -= 1 6 | printed = 0 7 | for i in range(length): 8 | sorted = 0 9 | for j in range(length - i): 10 | if array[j] > array[j + 1]: 11 | array[j], array[j + 1] = array[j + 1], array[j] 12 | sorted += 1 13 | if sorted: 14 | printed += 1 15 | print(*array) 16 | if not printed: 17 | print(*array) 18 | 19 | 20 | def main(): 21 | length = int(input()) 22 | array = list(map(int, input().strip().split())) 23 | bubble(array, length) 24 | 25 | 26 | if __name__ == '__main__': 27 | main() 28 | -------------------------------------------------------------------------------- /sprint_3/K_merge_sort.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def merge(array: list, left: int, mid: int, right: int) -> List[int]: 5 | array_1 = array[left: mid] 6 | array_2 = array[mid: right] 7 | i = j = 0 8 | k = left 9 | 10 | while i < len(array_1) and j < len(array_2): 11 | if array_1[i] <= array_2[j]: 12 | array[k] = array_1[i] 13 | i += 1 14 | else: 15 | array[k] = array_2[j] 16 | j += 1 17 | k += 1 18 | 19 | while i < len(array_1): 20 | array[k] = array_1[i] 21 | i += 1 22 | k += 1 23 | while j < len(array_2): 24 | array[k] = array_2[j] 25 | j += 1 26 | k += 1 27 | return array 28 | 29 | 30 | def merge_sort(arr, left, right): 31 | if right - left <= 1: 32 | return 33 | else: 34 | mid = (left + right) // 2 35 | merge_sort(arr, left, mid) 36 | merge_sort(arr, mid, right) 37 | merge(arr, left, mid, right) 38 | 39 | 40 | def test(): 41 | a = [1, 4, 9, 2, 10, 11] 42 | b = merge(a, 0, 3, 6) 43 | expected = [1, 2, 4, 9, 10, 11] 44 | assert b == expected 45 | c = [1, 4, 2, 10, 1, 2] 46 | merge_sort(c, 0, 6) 47 | expected = [1, 1, 2, 2, 4, 10] 48 | assert c == expected 49 | -------------------------------------------------------------------------------- /sprint_3/L_two_bicycle.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def search_day(price: int, days: List, left: int, right: int): 5 | mid = (left + right) // 2 6 | if price > days[-1]: 7 | return -1 8 | elif price <= days[mid] and (price > days[mid - 1] or mid == 0): 9 | return mid + 1 10 | elif price <= days[mid]: 11 | return search_day(price, days, left, mid) 12 | elif price > days[mid]: 13 | return search_day(price, days, mid + 1, right) 14 | 15 | 16 | def main() -> None: 17 | length = int(input()) 18 | days = list(map(int, input().split())) 19 | price = int(input()) 20 | one_bicycle = search_day(price, days, 0, length) 21 | two_bicycle = search_day(2 * price, days, 0, length) 22 | print(one_bicycle, two_bicycle) 23 | 24 | 25 | if __name__ == '__main__': 26 | main() 27 | -------------------------------------------------------------------------------- /sprint_3/M_golden_middle.py: -------------------------------------------------------------------------------- 1 | from typing import List, Tuple 2 | 3 | 4 | def read_input() -> Tuple[int, int, List[int], List[int]]: 5 | n = int(input()) 6 | s = int(input()) 7 | north = list(map(int, input().split())) 8 | south = list(map(int, input().split())) 9 | return n, s, north, south 10 | 11 | 12 | def get_median(lt: int, rg: int, left: List[int], right: List[int]): 13 | array = merge(left, right) 14 | mid = len(array) // 2 15 | if len(array) % 2: 16 | return array[mid] 17 | return (array[mid] + array[mid - 1]) / 2 18 | 19 | 20 | def merge(left: List[int], right: List[int]): 21 | len_l = len(left) 22 | len_r = len(right) 23 | lt = rg = i = 0 24 | result = [0] * (len_l + len_r) 25 | 26 | while lt < len_l and rg < len_r: 27 | if left[lt] <= right[rg]: 28 | result[i] = left[lt] 29 | lt += 1 30 | else: 31 | result[i] = right[rg] 32 | rg += 1 33 | i += 1 34 | 35 | while lt < len_l: 36 | result[i] = left[lt] 37 | lt += 1 38 | i += 1 39 | while rg < len_r: 40 | result[i] = right[rg] 41 | rg += 1 42 | i += 1 43 | 44 | return result 45 | 46 | 47 | def main() -> None: 48 | n, s, north, south = read_input() 49 | print(get_median(n, s, north, south)) 50 | 51 | 52 | if __name__ == '__main__': 53 | main() 54 | -------------------------------------------------------------------------------- /sprint_3/N_flower_beds.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | n = 4 4 | flowers = [[7, 8], [2, 3], [7, 8], [6, 10]] 5 | 6 | 7 | def merge_flower_beds(beds): 8 | start, end = beds[0] 9 | next_beds = 1 10 | result = [] 11 | while next_beds < len(beds): 12 | next_start, next_end = beds[next_beds] 13 | if (start <= next_start <= end or 14 | start <= next_end <= end): 15 | start, end = min(start, next_start), max(end, next_end) 16 | else: 17 | result.append([start, end]) 18 | start, end = beds[next_beds] 19 | next_beds += 1 20 | result.append([start, end]) 21 | 22 | return result 23 | 24 | 25 | def merge_sort(flowers): 26 | if len(flowers) == 1: 27 | return flowers 28 | 29 | left: List[int] = merge_sort(flowers[0: len(flowers) // 2]) 30 | right: List[int] = merge_sort(flowers[len(flowers) // 2: len(flowers)]) 31 | 32 | result: List = [] * len(flowers) 33 | 34 | l, r = 0, 0 35 | 36 | while l < len(left) and r < len(right): 37 | if left[l] <= right[r]: 38 | result.append(left[l]) 39 | l += 1 40 | else: 41 | result.append(right[r]) 42 | r += 1 43 | 44 | while l < len(left): 45 | result.append(left[l]) 46 | l += 1 47 | while r < len(right): 48 | result.append(right[r]) 49 | r += 1 50 | 51 | return result 52 | 53 | 54 | def main(): 55 | lines = int(input()) 56 | flower_beds = [[int(i) for i in input().split()] for line in range(lines)] 57 | result = merge_flower_beds(merge_sort(flower_beds)) 58 | [print(*i) for i in result] 59 | 60 | 61 | if __name__ == '__main__': 62 | main() 63 | -------------------------------------------------------------------------------- /sprint_3/O_difference_of_indexes.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def count_less(array: List[int], desired_diff: int) -> int: 5 | count = left = 0 6 | for right, x in enumerate(array): 7 | while x - array[left] > desired_diff: 8 | left += 1 9 | count += right - left 10 | return count 11 | 12 | 13 | def smallest_distance(array: List[int], k: int) -> int: 14 | array.sort() 15 | low = 0 16 | high = array[-1] - array[0] 17 | while low < high: 18 | mid = (low + high) // 2 19 | count = count_less(array, mid) 20 | if count >= k: 21 | high = mid 22 | else: 23 | low = mid + 1 24 | 25 | return low 26 | 27 | 28 | def main() -> None: 29 | _ = int(input()) 30 | array = [int(i) for i in input().split()] 31 | k = int(input()) 32 | print(smallest_distance(array, k)) 33 | 34 | 35 | if __name__ == '__main__': 36 | main() 37 | -------------------------------------------------------------------------------- /sprint_3/P_partial_sort.py: -------------------------------------------------------------------------------- 1 | from typing import List 2 | 3 | 4 | def get_block(array: List[int]) -> int: 5 | block = values = indexes = 0 6 | for i in range(len(array)): 7 | values += array[i] 8 | indexes += i 9 | if values == indexes: 10 | block += 1 11 | values = indexes = 0 12 | i += 1 13 | return block 14 | 15 | 16 | class Test: 17 | def test_1(self): 18 | a = [3, 2, 0, 1, 4, 6, 5] 19 | assert get_block(a) == 3 20 | 21 | def test_2(self): 22 | a = [0, 1, 3, 2] 23 | assert get_block(a) == 3 24 | 25 | def test_3(self): 26 | a = [3, 6, 7, 4, 1, 5, 0, 2] 27 | assert get_block(a) == 1 28 | 29 | 30 | def main(): 31 | _, array = int(input()), [int(i) for i in input().split()] 32 | print(get_block(array)) 33 | 34 | 35 | if __name__ == '__main__': 36 | main() 37 | -------------------------------------------------------------------------------- /sprint_3_final/A_broken_array.py: -------------------------------------------------------------------------------- 1 | # id 69619798 2 | 3 | from typing import List 4 | 5 | 6 | def broken_search(nums: List[int], target: int) -> int: 7 | """Поиск в смещенном сортированном массиве. 8 | Возвращает индекс элемента. 9 | Если элемента нет в массиве, возвращает -1.""" 10 | left, right = 0, len(nums) - 1 11 | while left <= right: 12 | middle = (left + right) // 2 13 | if target == nums[middle]: 14 | return middle 15 | 16 | if nums[left] <= nums[middle]: 17 | if nums[left] <= target <= nums[middle]: 18 | right = middle - 1 19 | else: 20 | left = middle + 1 21 | 22 | else: 23 | if nums[middle] <= target <= nums[right]: 24 | left = middle + 1 25 | else: 26 | right = middle - 1 27 | return -1 28 | 29 | 30 | def main() -> None: 31 | """Основная логика программы.""" 32 | _ = int(input()) 33 | target = int(input()) 34 | arr = [int(i) for i in input().strip().split()] 35 | print(broken_search(arr, target)) 36 | 37 | 38 | if __name__ == '__main__': 39 | main() 40 | -------------------------------------------------------------------------------- /sprint_3_final/A_broken_array_recursion.py: -------------------------------------------------------------------------------- 1 | # id 69619796 2 | 3 | from typing import List 4 | 5 | 6 | def broken_search(nums: List[int], target: int, left: int = 0, 7 | right: int = None) -> int: 8 | """Поиск в смещенном сортированном массиве. 9 | Возвращает индекс элемента. 10 | Если элемента нет в массиве, возвращает -1.""" 11 | if right is None: 12 | right = len(nums) - 1 13 | if left > right: 14 | return -1 15 | middle = (left + right) // 2 16 | if target == nums[middle]: 17 | return middle 18 | 19 | if nums[left] <= nums[middle]: 20 | if nums[left] <= target <= nums[middle]: 21 | return broken_search(nums, target, left, middle - 1) 22 | return broken_search(nums, target, middle + 1, right) 23 | if nums[middle] <= target <= nums[right]: 24 | return broken_search(nums, target, middle + 1, right) 25 | return broken_search(nums, target, left, middle - 1) 26 | 27 | 28 | def main() -> None: 29 | """Основная логика программы.""" 30 | length = int(input()) 31 | target = int(input()) 32 | arr = [int(i) for i in input().strip().split()] 33 | print(broken_search(arr, target)) 34 | 35 | 36 | def test(): 37 | array = [5, 1] 38 | result = broken_search(array, 1) 39 | assert result == 1 40 | 41 | array = [3, 5, 6, 7, 9, 1, 2] 42 | result = broken_search(array, 4) 43 | assert result == -1 44 | 45 | array = [1] 46 | result = broken_search(array, 4) 47 | assert result == -1 48 | 49 | array = [1, 2, 3, 5, 6, 7, 9, 0] 50 | result = broken_search(array, 3) 51 | assert result == 2 52 | 53 | array = [1, 2, 3, 5, 6, 7, 9, 0] 54 | result = broken_search(array, 3) 55 | assert result == 2 56 | 57 | 58 | if __name__ == '__main__': 59 | main() 60 | -------------------------------------------------------------------------------- /sprint_3_final/B_quicksort_effective.py: -------------------------------------------------------------------------------- 1 | # id 69627880 2 | 3 | import random 4 | from dataclasses import dataclass 5 | from typing import List, Tuple 6 | 7 | 8 | @dataclass 9 | class Player: 10 | """Класс для представления участника соревнования.""" 11 | name: str 12 | solved: int 13 | penalty: int 14 | 15 | def __lt__(self, other): 16 | if not isinstance(other, Player): 17 | raise TypeError( 18 | f"Невозможно выполнить операцию сравнения между " 19 | f"{self.__class__.__name__} и {other.__class__.__name__}") 20 | return (-self.solved, self.penalty, self.name) < \ 21 | (-other.solved, other.penalty, other.name) 22 | 23 | def __str__(self): 24 | return self.name 25 | 26 | 27 | def partition(array: List[Player], pivot: Player, left: int, right: int) \ 28 | -> Tuple[int, int]: 29 | """Условно делит массив на две части относительно опорного элемента. 30 | Слева – элементы меньше. Справа – больше. 31 | Возвращает индексы конца левой и начала правой части. 32 | """ 33 | while left <= right: 34 | while array[left] < pivot: 35 | left += 1 36 | while pivot < array[right]: 37 | right -= 1 38 | if left <= right: 39 | array[left], array[right] = array[right], array[left] 40 | left += 1 41 | right -= 1 42 | return left, right 43 | 44 | 45 | def quicksort(array: List[Player], start: int = 0, end: int = None): 46 | """Быстрая сортировка in-place. Опорный элемент рандомный.""" 47 | if end is None: 48 | end = len(array) - 1 49 | if start >= end: 50 | return 51 | 52 | pivot = array[random.randint(start, end)] 53 | 54 | left, right = partition(array, pivot, start, end) 55 | quicksort(array, start, right) 56 | quicksort(array, left, end) 57 | 58 | 59 | def read_input() -> List[Player]: 60 | """Считывает входные данные из стандартного ввода. 61 | Преобразует их в список участников и возвращает его.""" 62 | lines = int(input()) 63 | players = [] 64 | for line in range(lines): 65 | input_data = input().split() 66 | player = Player(input_data[0], 67 | int(input_data[1]), 68 | int(input_data[2])) 69 | players.append(player) 70 | return players 71 | 72 | 73 | def main() -> None: 74 | """Основная логика программы.""" 75 | players = read_input() 76 | quicksort(players) 77 | [print(player) for player in players] 78 | 79 | 80 | def test1(): 81 | players = [ 82 | Player('za', 0, 0), 83 | Player('b', 0, 0) 84 | ] 85 | quicksort(players) 86 | assert str(players[0]) == 'b' 87 | assert str(players[1]) == 'za' 88 | 89 | 90 | def test2(): 91 | players = [ 92 | Player('alla', 4, 100), 93 | Player('gena', 6, 1000), 94 | Player('gosha', 2, 90), 95 | Player('rita', 2, 90), 96 | Player('timofey', 4, 80), 97 | ] 98 | quicksort(players) 99 | assert str(players[0]) == 'gena' 100 | assert str(players[1]) == 'timofey' 101 | assert str(players[2]) == 'alla' 102 | assert str(players[3]) == 'gosha' 103 | assert str(players[4]) == 'rita' 104 | 105 | 106 | if __name__ == '__main__': 107 | main() 108 | -------------------------------------------------------------------------------- /utils.py: -------------------------------------------------------------------------------- 1 | def assert_this(result, expected): 2 | GREEN = '\033[92m' 3 | RED = '\033[91m' 4 | RESET = '\033[0m' 5 | 6 | try: 7 | assert result == expected 8 | print(f'{GREEN}PASSED{RESET}') 9 | except AssertionError: 10 | print(f'{RED}FAILED: {result=}, {expected=}{RESET}') --------------------------------------------------------------------------------