instruction
stringclasses 10
values | inputs
dict | outputs
listlengths 1
1
| meta
dict |
|---|---|---|---|
Реши задачу по программированию. Начало функции:
{function}
Продолжи функцию так, чтобы она корректно работала.
Ответ оформи по шаблону: ```python <code>```
|
{
"function": "def odd_substring(string: str) -> str:\n \"\"\"Выберите из строки string, содержащей целое положительное число, подстроку так, чтобы она содержала наибольшее возможное нечетное число. Выведите полученную подстроку в виде строки. Если невозможно составить нечетное число, выведите пустую строку.\n Примеры:\n odd_substring(string=8016) == '801'\n odd_substring(string=54468345) == '54468345'\n \"\"\"",
"tests": "[{'string': '8016'}, {'string': '54468345'}, {'string': '34452'}, {'string': '64830463'}, {'string': '621'}, {'string': '5824344'}, {'string': '244'}, {'string': '46717'}, {'string': '014499983'}, {'string': '31657'}]"
}
|
[
""
] |
{
"id": 100,
"canonical_solution": "",
"entry_point": "odd_substring"
}
|
Тебе дана заготовка под функцию на языке Python:
{function}
Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
|
{
"function": "def index_sort(string: str) -> str:\n \"\"\"В строке string все слова разделены пробелом. В конце каждого слова содержится его индекс – порядковый номер в некотором предложении (индексы начинаются с 1). Отсортируйте слова в строке string в порядке возрастания индекса и после этого удалите индексы в конце слова. Выведите получившуюся строку предложения.\n Примеры:\n index_sort(string=Аппетит1 приходит2 во3 время4 еды5) == 'Аппетит приходит во время еды'\n index_sort(string=Без1 труда2 не3 выловишь3 и4 рыбку5 из6 пруда,7 не8 то,9 что10 сапог11) == 'Без труда не выловишь и рыбку из пруда, не то, что сапог'\n \"\"\"",
"tests": "[{'string': 'Аппетит1 приходит2 во3 время4 еды5'}, {'string': 'Без1 труда2 не3 выловишь3 и4 рыбку5 из6 пруда,7 не8 то,9 что10 сапог11'}, {'string': 'Волков1 бояться2 –3 в4 лес5 не6 ходить7'}, {'string': 'Бедность1 не2 порок3'}, {'string': 'Готовь1 сани2 летом,3 а4 телегу5 зимой6'}, {'string': 'В1 здоровом2 теле3 –4 здоровый5 дух6'}, {'string': 'Дарёному1 коню2 в3 зубы4 не5 смотрят6'}, {'string': 'Бесплатный1 сыр,2 бывает-3 только4 в5 мышеловке6'}, {'string': 'Глаза1 боятся,2 а3 руки4 делают5'}, {'string': 'Бог1 шельму=2 метит3'}]"
}
|
[
""
] |
{
"id": 101,
"canonical_solution": "",
"entry_point": "index_sort"
}
|
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}
В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
|
{
"function": "def is_pangram(string: str) -> str:\n \"\"\"Определите, является ли строка string панграммой. Панграмма – это такая строка, которая содержит все буквы русского алфавита, как минимум, один раз. Если является, выведите \"Да\", иначе, выведите \"Нет\".\n Примеры:\n is_pangram(string=Любя, съешь щипцы, — вздохнёт мэр, — кайф жгуч.) == 'Да'\n is_pangram(string=Аппетит приходит во время еды) == 'Нет'\n \"\"\"",
"tests": "[{'string': 'Любя, съешь щипцы, — вздохнёт мэр, — кайф жгуч.'}, {'string': 'Аппетит приходит во время еды'}, {'string': 'Шеф взъярён тчк щипцы с эхом гудбай Жюль'}, {'string': 'Эй, жлоб! Где туз? Прячь юных съёмщиц в шкаф'}, {'string': 'Экс-граф? Плюш изъят. Бьём чуждый цен хвощ!'}, {'string': 'Чушь: гид вёз кэб цапф, юный жмот съел хрящ'}, {'string': 'Без труда не выловишь и рыбку из пруда'}, {'string': 'Готовь сани летом, а телегу зимой'}, {'string': 'Дарёному коню в зубы не смотрят'}, {'string': ''}]"
}
|
[
""
] |
{
"id": 102,
"canonical_solution": "",
"entry_point": "is_pangram"
}
|
{function}
Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
|
{
"function": "def topk_words(string: str, number: int) -> str:\n \"\"\"В строке string все слова разделены пробелами. Выведите новую строку, которая содержит только первые number слов изначальной строки.\n Примеры:\n topk_words(string=Призрак такого сима получает ту же смертельную черту, что и пожилые симы, умершие от физических нагрузок, и ничем не отличается, number=16) == 'Призрак такого сима получает ту же смертельную черту, что и пожилые симы, умершие от физических нагрузок,'\n topk_words(string=В эту игру можно играть по самым разным сценариям, number=2) == 'В эту'\n \"\"\"",
"tests": "[{'string': 'Призрак такого сима получает ту же смертельную черту, что и пожилые симы, умершие от физических нагрузок, и ничем не отличается', 'number': 16}, {'string': 'В эту игру можно играть по самым разным сценариям', 'number': 2}, {'string': 'Однако иногда красота может оказаться не преимуществом, а препятствием', 'number': 4}, {'string': 'Даже всемогущая пунктуация не имеет власти над рыбными текстами, ведущими безорфографичный образ жизни', 'number': 4}, {'string': 'Например, гриль или плита, размещённые на ковровом покрытии, готовка на дешевой плите, а также низкий навык кулинарии или выпечки', 'number': 11}, {'string': 'Поедем туда на следующий год и будем там вовсю бросаться помидорами', 'number': 10}, {'string': 'В мире соулмейтов, каждый находит свою пару по фобии, приобретённой с рождения', 'number': 4}, {'string': 'Пожилым персонажам стоит воздерживаться от чрезмерных физических нагрузок и активного вуху, чтобы не получить перенапряжение', 'number': 10}, {'string': 'Моя сестра тратит деньги просто так', 'number': 5}, {'string': 'Моя девушка гуляет просто так', 'number': 2}]"
}
|
[
""
] |
{
"id": 103,
"canonical_solution": "",
"entry_point": "topk_words"
}
|
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами:
{function}
Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
|
{
"function": "def numbers_only(string: str) -> int:\n \"\"\"Выведите количество уникальных целых чисел, которые образовались после замены всех нечисловых символов строки string на пробелы.\n Примеры:\n numbers_only(string=тву6бчуб758гтж1и19ришиирьечхо9жгщ4йф96ящ) == 7\n numbers_only(string=з6к1241е989ъ2е2юп9н656ф7к3086стя17д2щ316ч58к491) == 12\n \"\"\"",
"tests": "[{'string': 'тву6бчуб758гтж1и19ришиирьечхо9жгщ4йф96ящ'}, {'string': 'з6к1241е989ъ2е2юп9н656ф7к3086стя17д2щ316ч58к491'}, {'string': 'ывбпоылфлоптыюловпт'}, {'string': 'яж7а9вю6псго5эъ38со7ш91ььу513уккм6щь3геш81ы14296'}, {'string': 'й1эа62р2п17м48683нх2856из7уз122й99х7э'}, {'string': 'г876ай7ьхя05зэ4932ош0р6'}, {'string': 'д5в2н4ы4т9уйд50я5и49кгю8ю'}, {'string': '2й4юсг511юзхбу298661юь858'}, {'string': ''}, {'string': 'ш1207щу828м546сег3юа5с5бе882юсв'}]"
}
|
[
""
] |
{
"id": 104,
"canonical_solution": "",
"entry_point": "numbers_only"
}
|
Решите задачу на Python. Функция:
{function}
Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
|
{
"function": "from typing import List\n\n\ndef ascending_subarray(array: List[int]) -> int:\n \"\"\"Выведите максимально возможную сумму какого-либо возрастающего непрерывного подсписка списка array, состоящего из целых чисел.\n Примеры:\n ascending_subarray(array=[11, 63, 10, 88, 0, 30, 20, 77, 70, 18, 14, 45, 51, 86]) == 196\n ascending_subarray(array=[73, 80, 65, 88, 96, 3, 35, 72, 39, 55, 47, 86]) == 249\n \"\"\"",
"tests": "[{'array': [11, 63, 10, 88, 0, 30, 20, 77, 70, 18, 14, 45, 51, 86]}, {'array': [73, 80, 65, 88, 96, 3, 35, 72, 39, 55, 47, 86]}, {'array': [18, 90, 7, 61, 71, 34]}, {'array': [6, 24, 19, 17, 9, 0, 63, 33, 53, 81, 55]}, {'array': [98, 78, 9, 93, 60, 14, 79, 92, 40]}, {'array': [69, 99, 14, 99, 89, 17, 80, 17, 41, 92, 53]}, {'array': [97, 77, 41, 3, 60, 41, 36, 40]}, {'array': [89, 45, 91, 70, 44, 83, 18, 15]}, {'array': [93, 25, 14, 51, 36, 41, 0]}, {'array': [15, 69, 74, 55, 55, 60, 57, 12, 29, 63, 57, 83, 15]}]"
}
|
[
""
] |
{
"id": 105,
"canonical_solution": "",
"entry_point": "ascending_subarray"
}
|
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция:
{function}
Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
|
{
"function": "def equal_swap(string: str, target: str) -> str:\n \"\"\"Если строку string можно сделать равной строке target путем перестановки местами ровно двух символов в string, то выведите \"Да\". Иначе, выведите \"Нет\".\n Примеры:\n equal_swap(string1=ащщснишплсдк, string2=ую) == 'Нет'\n equal_swap(string1=ес, string2=се) == 'Да'\n \"\"\"",
"tests": "[{'string1': 'ащщснишплсдк', 'string2': 'ую'}, {'string1': 'ес', 'string2': 'се'}, {'string1': 'ефдкпхтаь', 'string2': 'ааеюх'}, {'string1': 'ъж', 'string2': 'бтфьэмрл'}, {'string1': 'учднжбнхькгегл', 'string2': 'пйпфлфёиаа'}, {'string1': 'ияыэ', 'string2': 'хфолецах'}, {'string1': 'ёмбжгъцаекл', 'string2': 'ёцбжгъмаекл'}, {'string1': 'пспыожъи', 'string2': 'мжфюэмъьйуьях'}, {'string1': 'ыовухутцибуми', 'string2': 'цгё'}, {'string1': 'сцярьыйжшрцтэю', 'string2': 'сцяюьыйжшрцтэр'}]"
}
|
[
""
] |
{
"id": 106,
"canonical_solution": "",
"entry_point": "equal_swap"
}
|
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции.
Функция:
{function}
Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
|
{
"function": "def contiguous_ones(string: str) -> str:\n \"\"\"Если строка string из 0 и 1 содержит непрерывную подследовательность из 1 длиной больше 1, то выведите \"Да\". Иначе, выведите \"Нет\".\n Примеры:\n contiguous_ones(string=1111110) == 'Да'\n contiguous_ones(string=11100011) == 'Нет'\n \"\"\"",
"tests": "[{'string': '1111110'}, {'string': '11100011'}, {'string': '1100000'}, {'string': '1111000'}, {'string': '11100000'}, {'string': '101110100'}, {'string': '11000110'}, {'string': '011000011'}, {'string': '0000000'}, {'string': '010011010'}]"
}
|
[
""
] |
{
"id": 107,
"canonical_solution": "",
"entry_point": "contiguous_ones"
}
|
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции:
{function}
Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
|
{
"function": "def merge_strings(string1: str, string2: str) -> str:\n \"\"\"Соедините две строки string1 и string2 так, чтобы попеременно сначала шел символ из первой строки, затем символ из второй строки в их изначальном порядке. Если одна из строк закончится, то добавьте все оставшиеся символы другой строки в конец новой строки. Выведите получившуюся строку.\n Примеры:\n merge_strings(string1=3ащёи, string2=ьчбрйёу7е) == '3ьачщбёрийёу7е'\n merge_strings(string1=мёл, string2=эни) == 'мэёнли'\n \"\"\"",
"tests": "[{'string1': '3ащёи', 'string2': 'ьчбрйёу7е'}, {'string1': 'мёл', 'string2': 'эни'}, {'string1': 'е0э1тъ2ом', 'string2': '7ъушъеаь'}, {'string1': 'фш', 'string2': '6чн'}, {'string1': 'афжч', 'string2': '1щкаю5в1'}, {'string1': 'дфь', 'string2': '91ёх4ф'}, {'string1': 'х3гк', 'string2': 'гещсннвх'}, {'string1': 'эоэцявп', 'string2': 'шшвп8ц'}, {'string1': 'вн7шц8э', 'string2': 'лахдщ'}, {'string1': 'цх', 'string2': 'ещты6нм53'}]"
}
|
[
""
] |
{
"id": 108,
"canonical_solution": "",
"entry_point": "merge_strings"
}
|
Напиши продолжение данной функции:
{function}
Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
|
{
"function": "def beautiful_string(string: str) -> str:\n \"\"\"Строка является красивой, если в ней каждая буква встречается как в строчном, так и в прописном виде. Выведите наибольшую красивую подстроку строки string. Если таких строк больше одной, то выведите ту, что встречается раньше всего в string. Если красивых подстрок нет, то ответом будет пустая строка.\n Примеры:\n beautiful_string(string=ФлЮГегЕхаЙмЕН) == 'ГегЕ'\n beautiful_string(string=метафора) == ''\n \"\"\"",
"tests": "[{'string': 'ФлЮГегЕхаЙмЕН'}, {'string': 'метафора'}, {'string': 'щшщмфйЗЕвщуэЬэЖДЬКиЭэнйпйхчФгкДЩФхОЗыв'}, {'string': 'жтУкОцяЛзуюлгюйлкНбазиХЯЬКЩИУвчДЛыщшъБ'}, {'string': 'ПиЦРяовчтТффнщшвЕБюнчМгЭЭчЩЪфжЯвЖсчвЮ'}, {'string': 'чЫъТцъФНЮАУдФЧВБдГЪЬхэДцЙЮНршпЩЛХбЭЪрэх'}, {'string': 'фТММснЕШВЙгйЬщЕрМъПДЧЕхШДФЪдУГкЮб'}, {'string': 'ЭЩгДДцЛЛШыИЦЗбсНЦшукЖКуЧНгУЧкОЮцА'}, {'string': 'РзжкбАусжМЧДРЯДЫожЛТпЧлАМслВшйаН'}, {'string': 'ыЛщЧрдЭВХЖЪюДВйбРъШшфлпВЪпмХэреГжце'}]"
}
|
[
""
] |
{
"id": 109,
"canonical_solution": "",
"entry_point": "beautiful_string"
}
|
Реши задачу по программированию. Начало функции:
{function}
Продолжи функцию так, чтобы она корректно работала.
Ответ оформи по шаблону: ```python <code>```
|
{
"function": "from typing import List\n\n\ndef unique_numbers(array: List[int]) -> int:\n \"\"\"Дан список чисел array. Выведите сумму всех уникальных чисел данного массива. Уникальным является такое число, которое больше не встречается в списке.\n Примеры:\n unique_numbers(array=[7, 0, 2, 2, 5, 6, 5, 5, 7, 1]) == 7\n unique_numbers(array=[5, 3, 8, 1, 5, 1, 0, 6, 6, 1, 2, 2]) == 11\n \"\"\"",
"tests": "[{'array': [7, 0, 2, 2, 5, 6, 5, 5, 7, 1]}, {'array': [5, 3, 8, 1, 5, 1, 0, 6, 6, 1, 2, 2]}, {'array': [8, 9, 1, 0, 3, 7, 8, 5, 0, 4, 7, 6]}, {'array': [6, 1, 2, 0, 4]}, {'array': [8, 3, 1, 3, 2, 1, 7, 8, 2, 7, 9, 0, 0]}, {'array': [6, 8, 9, 0, 0, 6, 2, 2, 4, 7, 9, 8]}, {'array': [9, 7, 8, 9, 2, 0]}, {'array': [3, 4, 2, 1, 3, 0, 9, 2, 7, 5]}, {'array': [1, 7, 8, 7, 8, 3, 9, 4, 5, 6, 7]}, {'array': [4, 6, 8, 6, 5, 7, 3, 9, 6, 9, 7]}]"
}
|
[
""
] |
{
"id": 110,
"canonical_solution": "",
"entry_point": "unique_numbers"
}
|
Тебе дана заготовка под функцию на языке Python:
{function}
Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
|
{
"function": "def largest_box(start:int, end: int) -> int:\n \"\"\"Мячи занумерованы числами от start до end включительно. Каждый мяч кладется в коробку, номер которой равен сумме цифр номера мяча. Выведите количество мячей в наиболее заполненной мячами коробке.\n Примеры:\n largest_box(start=542, end=600) == 6\n largest_box(start=338, end=437) == 10\n \"\"\"",
"tests": "[{'start': 542, 'end': 600}, {'start': 338, 'end': 437}, {'start': 803, 'end': 824}, {'start': 620, 'end': 706}, {'start': 936, 'end': 1021}, {'start': 369, 'end': 416}, {'start': 708, 'end': 803}, {'start': 815, 'end': 880}, {'start': 645, 'end': 703}, {'start': 717, 'end': 790}]"
}
|
[
""
] |
{
"id": 111,
"canonical_solution": "",
"entry_point": "largest_box"
}
|
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}
В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
|
{
"function": "def largest_time(string: str) -> str:\n \"\"\"Замените символ \"&\" в строке string на цифру таким образом, чтобы время, которое содержится в данной строке, было наиболее поздним в рамках одних суток. Формат записи времени \"HH:MM\" от 00:00 до 23:59. Выведите полученную строку.\n Примеры:\n largest_time(string=&1:29) == '21:29'\n largest_time(string=10:&2) == '10:52'\n \"\"\"",
"tests": "[{'string': '&1:29'}, {'string': '10:&2'}, {'string': '&3:21'}, {'string': '12:&0'}, {'string': '20:&9'}, {'string': '&0:49'}, {'string': '&8:45'}, {'string': '&4:54'}, {'string': '&9:26'}, {'string': '21:3&'}]"
}
|
[
""
] |
{
"id": 112,
"canonical_solution": "",
"entry_point": "largest_time"
}
|
{function}
Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
|
{
"function": "from typing import List\n\n\ndef equal_concatenations(array1: List[str], array2: List[str]) -> int:\n \"\"\"Даны два непустых массива строк array1 и array2. Объедините все элементы в array1 в изначальном порядке в одну строку. Сделайте то же самое для array2. Определите, одинаковые ли строки получились. Если да, выведите 1, иначе выведите 0.\n Примеры:\n equal_concatenations(array1=['кяш', 'веэзю', 'им', 'дчжтущс', 'ъфла', 'ойбрц', 'хнып', 'ьг'], array2=['кяшвеэ', 'зюим', 'дчж', 'тущсъфл', 'аойбрцхн', 'ыпьг']) == 1\n equal_concatenations(array1=['фгпнъдсяэытиьежйлоюамбквзцхущшрч'], array2=['фгпэытиьежйлоюамбквзцхущшрч']) == 0\n \"\"\"",
"tests": "[{'array1': ['кяш', 'веэзю', 'им', 'дчжтущс', 'ъфла', 'ойбрц', 'хнып', 'ьг'], 'array2': ['кяшвеэ', 'зюим', 'дчж', 'тущсъфл', 'аойбрцхн', 'ыпьг']}, {'array1': ['фгпнъдсяэытиьежйлоюамбквзцхущшрч'], 'array2': ['фгпэытиьежйлоюамбквзцхущшрч']}, {'array1': ['мъчу', 'зцквюх', 'еп', 'яьжсдлфрышщгон', 'абтийэ'], 'array2': ['мъ', 'чузц', 'квюхе', 'пяьжсдлфры', 'шщгонабтийэ']}, {'array1': ['кгъяй', 'юьесу', 'лриытзшдж', 'энопвщхмц', 'афбч'], 'array2': ['офйщякув', 'хетюч', 'ьцмсшыаэд', 'ъгнрлпзбжи']}, {'array1': ['смлыгр', 'хцпнвщдъош', 'еяьжфэйбюка', 'чзути'], 'array2': ['смлы', 'грхцп', 'нвщдъо', 'шеяь', 'жфэйб', 'юкачзути']}, {'array1': ['осх', 'шалзфюуй', 'ъбщгдкн', 'трпмьэжиыц', 'чвяе'], 'array2': ['осх', 'шалзфюуйъ', 'бщгдк', 'нпмьэжиы', 'цчвяе']}, {'array1': ['зшьр', 'ялуодбэвец', 'ъсжчмйапхгщтн', 'кфиюы'], 'array2': ['зшьрял', 'уодбэвец', 'ъсжчмйапхгщтн', 'кфиюы']}, {'array1': ['йшоеяры', 'ющгавнисцт', 'ъзфбжкдул', 'хпьчэм'], 'array2': ['ьгжхдтфо', 'эемюъ', 'ялкзсуыпи', 'ашвцщбйр', 'чн']}, {'array1': ['кшф', 'йцоду', 'тмьвю', 'яхечщ', 'рзлнсыиэбъ', 'гжпа'], 'array2': ['кшфй', 'цодут', 'мьвюяхеч', 'щрзлнсы', 'иэбъг', 'жпа']}, {'array1': ['чьщыб', 'сяэшмдйлз', 'хежпнък', 'юфтгцру', 'оива'], 'array2': ['щйядт', 'эарп', 'бнмежзъ', 'ксиыг', 'увшлюьц', 'чхфо']}]"
}
|
[
""
] |
{
"id": 113,
"canonical_solution": "",
"entry_point": "equal_concatenations"
}
|
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами:
{function}
Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
|
{
"function": "from typing import List\n\n\ndef frequeny_sort(array: List[int]) -> List[int]:\n \"\"\"Отсортируйте список целых чисел array в порядке возрастания частоты появления элементов в списке. Элементы с одинаковой частотой отсортируйте по убыванию значения. Выведите получившийся список.\n Примеры:\n frequeny_sort(array=[18, 18, 3, 8, 12, 7, 15, 6, 2, 2, 14]) == [15, 14, 12, 8, 7, 6, 3, 18, 18, 2, 2]\n frequeny_sort(array=[9, 12, 17, 0, 9, 4, 10, 4, 9]) == [17, 12, 10, 0, 4, 4, 9, 9, 9]\n \"\"\"",
"tests": "[{'array': [18, 18, 3, 8, 12, 7, 15, 6, 2, 2, 14]}, {'array': [9, 12, 17, 0, 9, 4, 10, 4, 9]}, {'array': [15, 9, 2, 3, 3]}, {'array': [7, 3, 15, 3, 11]}, {'array': [2, 7, 3, 15, 6, 3]}, {'array': [11, 1, 18, 18, 15, 14, 17, 16, 13, 6]}, {'array': [15, 9, 11, 10, 9, 16, 8, 19, 0, 10, 13]}, {'array': [3, 15, 7, 19, 11, 11, 3, 13, 12, 13, 13, 10]}, {'array': [6, 16, 7, 9, 5, 13, 11, 18, 5, 12, 0, 15, 9, 16]}, {'array': [5, 11, 19, 8, 12, 1, 7]}]"
}
|
[
""
] |
{
"id": 114,
"canonical_solution": "",
"entry_point": "frequeny_sort"
}
|
Решите задачу на Python. Функция:
{function}
Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
|
{
"function": "def largest_substring(string: str) -> int:\n \"\"\"Выведите длину наибольшей непрерывной подстроки, заключенной между двумя одинаковыми символами в строке string, не считая сами данные символы. Символы-границы могут повторяться внутри подстроки. Если такой строки не существует, выведите -1.\n Примеры:\n largest_substring(string=флюгегехаймен) == 6\n largest_substring(string=метафора) == 3\n \"\"\"",
"tests": "[{'string': 'флюгегехаймен'}, {'string': 'метафора'}, {'string': 'вжзцчтэпуюымп'}, {'string': 'зяцбтвноецапшоенцо'}, {'string': 'емърпысмыъщмыъмщй'}, {'string': 'вфърйтпечйосшюрвхйшгья'}, {'string': 'южбгцгжюгфлшззбвшмефзгормдхвгсзъюлысбв'}, {'string': 'ерщднлтгсмяяаршфсэнкьрлйки'}, {'string': 'кфлмзощсяшуэщяосдовдулкцнаэнцнгав'}, {'string': 'ащйзасадхзудъьхрнъь'}, {'string': 'зъгкмжвюгжнъб'}, {'string': 'ъшпвлпцбхцг'}]"
}
|
[
""
] |
{
"id": 115,
"canonical_solution": "",
"entry_point": "largest_substring"
}
|
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция:
{function}
Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
|
{
"function": "def common_divisors(number1: int, number2: int) -> int:\n \"\"\"Выведите количество общих делителей чисел number1 и number2. Число A является делителем числа B, если B делится на A без остатка.\n Примеры:\n common_divisors(number1=63, number2=270) == 3\n common_divisors(number1=27, number2=93) == 2\n \"\"\"",
"tests": "[{'number1': 63, 'number2': 270}, {'number1': 27, 'number2': 93}, {'number1': 271, 'number2': 416}, {'number1': 138, 'number2': 155}, {'number1': 394, 'number2': 35}, {'number1': 111, 'number2': 189}, {'number1': 372, 'number2': 87}, {'number1': 53, 'number2': 381}, {'number1': 81, 'number2': 227}, {'number1': 354, 'number2': 398}]"
}
|
[
""
] |
{
"id": 116,
"canonical_solution": "",
"entry_point": "common_divisors"
}
|
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции.
Функция:
{function}
Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
|
{
"function": "from typing import List\n\n\ndef identical_subarray(array: List[int], number: int) -> int:\n \"\"\"Подпоследовательность списка array должна состоять только из одинаковых элементов, после удаления из списка array не более, чем number элементов. Определите длину наибольшей такой подпоследовательности целочисленного списка array. Выведите получившуюся длину.\n Примеры:\n identical_subarray(array=[6, 7, 7, 6, 5, 8, 2, 9, 9, 7, 8, 5, 6, 4, 7], number=9) == 3\n identical_subarray(array=[4, 3, 1, 11, 7, 8, 9, 10, 4, 3], number=1) == 1\n \"\"\"",
"tests": "[{'array': [6, 7, 7, 6, 5, 8, 2, 9, 9, 7, 8, 5, 6, 4, 7], 'number': 9}, {'array': [4, 3, 1, 11, 7, 8, 9, 10, 4, 3], 'number': 1}, {'array': [2, 2, 10, 7, 5, 9, 6, 4, 4, 8, 4, 2, 2, 1, 2, 3, 1, 10, 1, 9, 7, 7], 'number': 8}, {'array': [11, 7, 9, 10, 10, 8, 4, 5, 5, 3, 8, 1, 9, 6, 9], 'number': 9}, {'array': [11, 5, 3, 2, 8, 5, 1, 8, 6, 11, 4, 4, 9, 1, 2, 3, 3, 7, 5, 7, 7, 10, 9], 'number': 2}, {'array': [5, 11, 4, 5, 4, 7, 7, 2, 10, 8, 11, 4, 6, 6, 6, 9, 3, 7, 5, 10, 8], 'number': 1}, {'array': [3, 3, 7, 5, 5, 5, 2, 2, 2, 11, 11, 2], 'number': 5}, {'array': [6, 8, 1, 5, 6, 5, 8, 5, 8, 2, 10, 5, 2, 11, 6, 4, 1, 4, 10, 10, 3, 9], 'number': 3}, {'array': [8, 5, 4, 2, 6, 4, 8, 10, 4, 2, 6, 11, 4, 7, 8, 1, 9, 6, 6, 8, 1], 'number': 9}, {'array': [6, 2, 1, 4, 6, 7, 8, 4, 10, 11, 10, 9, 10, 10, 5, 8, 2, 4, 6], 'number': 4}]"
}
|
[
""
] |
{
"id": 117,
"canonical_solution": "",
"entry_point": "identical_subarray"
}
|
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции:
{function}
Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
|
{
"function": "def decode_message(string: str, target: str) -> str:\n \"\"\"Сделайте словарь, где в key записывается каждый из символов строки string по порядку по его первому вхождению в строку, а в value – символы русского алфавита по порядку. Используя полученные пары чисел key: value, замените все символы в строке target по словарю и выведите получившуюся строку, сохраняя пробелы на изначальных местах. Не учитывайте букву \"ё\" при кодировании и декодировании.\n Примеры:\n decode_message(string=ьсгыфлущншваяйеюдмхчиэбркпзъжцот, target=ьююлхнх юднэефнх ге гдлят лфъ) == 'аппетит приходит во время еды'\n decode_message(string=чхпбоясуьылюэтйшцегимжвдкрназфъщ, target=хяотйегз тя шйцйл) == 'бедность не порок'\n \"\"\"",
"tests": "[{'string': 'ьсгыфлущншваяйеюдмхчиэбркпзъжцот', 'target': 'ьююлхнх юднэефнх ге гдлят лфъ'}, {'string': 'чхпбоясуьылюэтйшцегимжвдкрназфъщ', 'target': 'хяотйегз тя шйцйл'}, {'string': 'бжхпнсоцяемъгэиюйфщлазывукшрчдть', 'target': 'жсц щйлнб эс хръихяуч я йржмл яц юйлнб'}, {'string': 'щлиьжвтоъфяхрпгзкбйчашумюэнедсыц', 'target': 'лвбзхщйпеф бек леищвй йгхдяг и реювхгияв'}, {'string': 'лыгмтьрхъцодсфюбжвчеакиэунязйщпш', 'target': 'ыюм уьдйсе сьчъч'}, {'string': 'плиячгьцшщаотжюэъбнрефыкдзхуйсмв', 'target': 'и цчюъюиют нгог цчюъюиущ чрф'}, {'string': 'гцмэпйианюяхсърщчкольвтдзуфшбжеы', 'target': 'мрхярм црыобкы м хйк ъй врпноб'}, {'string': 'пваыюесшцгфлндчязйоъжкьщтэбиухрм', 'target': 'ылпшп вчмойм п зъфц юелпро'}, {'string': 'бзмяеыйвщьтлсхндцэгшюроиучъапфкж', 'target': 'янгнмп эбхщ лыгнс б гылыяш вщснь'}, {'string': 'ущмзаелжцвсдпгтнихкбчэьйыфшоюряъ', 'target': 'ауиегтпб стгя м жбщо ге хпткиък'}]"
}
|
[
""
] |
{
"id": 118,
"canonical_solution": "",
"entry_point": "decode_message"
}
|
Напиши продолжение данной функции:
{function}
Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
|
{
"function": "def percentage_frequency(string: str, symbol: str) -> int:\n \"\"\"Каков процент количества появлений символа symbol от всех символов строки string? Выведите процент, округленный вниз до ближайшего целого числа.\n Примеры:\n percentage_frequency(string=флюгегехаймен, symbol=й) == 7\n percentage_frequency(string=метафора, symbol=а) == 25\n \"\"\"",
"tests": "[{'string': 'флюгегехаймен', 'symbol': 'й'}, {'string': 'метафора', 'symbol': 'а'}, {'string': 'ааааааааааааааааааааааааа', 'symbol': 'з'}, {'string': 'бйпдщвэсчьомхипцйтпчхфьтйкзцйгэбфцццкфг', 'symbol': 'ф'}, {'string': 'йишууфмпнхгэзвбфхагыхужос', 'symbol': 'э'}, {'string': 'яакйыщщрьялллкбфпжебтчгбялсымкуэффнд', 'symbol': 'к'}, {'string': 'этявопсппяссгфяжкпнчьязэтдрц', 'symbol': 'п'}, {'string': '', 'symbol': 'а'}, {'string': 'зччффгучвц', 'symbol': 'г'}, {'string': 'айцшчувжяюнлэрцэсчвъютшчкрьлтзязйидоеса', 'symbol': 'э'}]"
}
|
[
""
] |
{
"id": 119,
"canonical_solution": "",
"entry_point": "percentage_frequency"
}
|
Реши задачу по программированию. Начало функции:
{function}
Продолжи функцию так, чтобы она корректно работала.
Ответ оформи по шаблону: ```python <code>```
|
{
"function": "def minimum_inversions(number: int, target: int) -> int:\n \"\"\"Выведите, какое наименьшее количество инверсий битов числа number нужно сделать, чтобы получилось число target. Инверсия битов – это замена \"0\" на \"1\" и \"1\" на \"0\" в двоичной записи числа. Инвертировать можно как биты после первого значащего бита, так и до него.\n Примеры:\n minimum_inversions(number=469, target=380) == 4\n minimum_inversions(number=17, target=253) == 5\n \"\"\"",
"tests": "[{'number': 469, 'target': 380}, {'number': 17, 'target': 253}, {'number': 290, 'target': 102}, {'number': 348, 'target': 128}, {'number': 372, 'target': 375}, {'number': 463, 'target': 376}, {'number': 326, 'target': 137}, {'number': 97, 'target': 81}, {'number': 485, 'target': 270}, {'number': 112, 'target': 348}]"
}
|
[
""
] |
{
"id": 120,
"canonical_solution": "",
"entry_point": "minimum_inversions"
}
|
Тебе дана заготовка под функцию на языке Python:
{function}
Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
|
{
"function": "def binary_inversion(number: int) -> int:\n \"\"\"Дано число в десятичной системе счисления number. Инвертируйте биты в его двоичном представлении, запишите полученное двоичное число в обратном порядке и выведите его в десятичной системе счисления. Инверсия битов – это замена \"0\" на \"1\" и \"1\" на \"0\".\n Примеры:\n binary_inversion(number=4) == 6\n binary_inversion(number=28) == 24\n \"\"\"",
"tests": "[{'number': 4}, {'number': 28}, {'number': 841}, {'number': 1234}, {'number': 9409}, {'number': 876543}, {'number': 6}, {'number': 25}, {'number': 3721}, {'number': 49729}]"
}
|
[
""
] |
{
"id": 121,
"canonical_solution": "",
"entry_point": "binary_inversion"
}
|
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}
В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
|
{
"function": "def capitalize_title(string: str) -> str:\n \"\"\"Дана строка string, которая содержит несколько слов, разделенных пробелами. Все слова с длиной от 1 до 2 сделайте строчными буквами, а для остальных слов сделайте первую букву слова прописной, а остальные строчными. Выведите получившуюся строку.\n Примеры:\n capitalize_title(string=аппетит приходит во время еды и) == 'Аппетит Приходит во Время Еды и'\n capitalize_title(string=бедность не порок) == 'Бедность не Порок'\n \"\"\"",
"tests": "[{'string': 'аппетит приходит во время еды и'}, {'string': 'бедность не порок'}, {'string': 'без труда не выловишь и рыбку из пруда'}, {'string': 'бесплатный сыр, бывает- только в мышеловке'}, {'string': 'бог шельму= метит'}, {'string': 'в здоровом теле – здоровый дух'}, {'string': 'волков бояться – в лес не ходить'}, {'string': 'глаза боятся, а руки делают'}, {'string': 'готовь сани летом, а телегу зимой'}, {'string': 'дарёному коню в зубы не смотрят'}]"
}
|
[
""
] |
{
"id": 122,
"canonical_solution": "",
"entry_point": "capitalize_title"
}
|
{function}
Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
|
{
"function": "def double_inversion(number: int) -> str:\n \"\"\"Дано целое число number. Дважды повторите разворот цифр записи числа в обратном порядке, удаляя ведущие нули. Если полученное число равно исходному, выведите \"Да\", иначе выведите \"Нет\".\n Примеры:\n duble_inversion(number=4) == 'Да'\n duble_inversion(number=20) == 'Нет'\n \"\"\"",
"tests": "[{'number': 4}, {'number': 20}, {'number': 843}, {'number': 1230}, {'number': 9409}, {'number': 876543}, {'number': 10}, {'number': 250}, {'number': 3721}, {'number': 49729}]"
}
|
[
""
] |
{
"id": 123,
"canonical_solution": "",
"entry_point": "duble_inversion"
}
|
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами:
{function}
Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
|
{
"function": "from typing import List\n\n\ndef distinct_quadruplets(array: List[int]) -> int:\n \"\"\"Дан список целых положительных чисел array. Выведите количество четверок чисел из массива таких, что сумма первых трех равна четвертому, а также все числа разные и четвертое число строго больше любого из первых трех.\n Примеры:\n distinct_quadruplets(array=[18, 4, 19, 9, 2, 10, 14, 7, 0, 17, 14, 15, 16]) == 7\n distinct_quadruplets(array=[5, 1, 10, 10, 0, 17, 1, 0, 16, 17, 14, 7, 6, 10]) == 16\n \"\"\"",
"tests": "[{'array': [18, 4, 19, 9, 2, 10, 14, 7, 0, 17, 14, 15, 16]}, {'array': [5, 1, 10, 10, 0, 17, 1, 0, 16, 17, 14, 7, 6, 10]}, {'array': [19, 7, 8, 14, 9, 12, 8, 6, 3, 16]}, {'array': [1, 16, 11, 3, 11, 1, 18, 18, 11, 11, 3, 19, 15]}, {'array': [4, 1, 3, 12, 9, 5, 3, 12, 0, 5, 17, 19]}, {'array': [0, 10, 9, 2, 6, 11, 6, 14]}, {'array': [3, 15, 3, 6, 2, 8, 16, 17, 19]}, {'array': [19, 6, 14, 12, 18, 0, 17, 13, 0, 10, 12, 8, 15, 14]}, {'array': [10, 10, 3, 7, 6, 10, 16, 3, 3, 9, 0, 13]}, {'array': [3, 12, 10, 17, 5, 12, 7, 17, 2, 5, 13, 5]}]"
}
|
[
""
] |
{
"id": 124,
"canonical_solution": "",
"entry_point": "distinct_quadruplets"
}
|
Решите задачу на Python. Функция:
{function}
Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
|
{
"function": "from typing import List\n\n\ndef middle_index(array: List[int]) -> int:\n \"\"\"Для целочисленного списка array найдите наименьший возможный такой индекс, что сумма всех элементов левее данного индекса равна сумме элементов списка правее данного индекса. Выведите полученный индекс или -1, если такого индекса не существует.\n Примеры:\n middle_index(array=[17, 12, 6, 5, 16, 8, 10, 9, 8, 5]) == 4\n middle_index(array=[13, 12, 15, 0, 2, 11, 5, 16, 4, 7, 10]) == 5\n \"\"\"",
"tests": "[{'array': [17, 12, 6, 5, 16, 8, 10, 9, 8, 5]}, {'array': [13, 12, 15, 0, 2, 11, 5, 16, 4, 7, 10]}, {'array': [3, 2, 9, 3, 15, 4, 7, 1, 0, 15, 2, 7]}, {'array': [13, 5, 10, 13, 15, 12, 8, 18, 16, 11, 3]}, {'array': [17, 8, 3, 15, 1, 18, 2, 1, 7, 5, 9, 9, 11]}, {'array': [14, 9, 9, 7, 8, 11, 10, 1, 9, 1, 11, 7, 12, 17, 2, 9]}, {'array': [11, 19, 10, 5, 0, 9, 9, 17, 17, 17]}, {'array': [9, 2, 11, 2, 12, 14, 15, 9, 1, 5, 13, 0]}, {'array': [4, 12, 11, 18, 11, 7, 17, 6, 3, 19, 5, 12, 5, 16, 0]}, {'array': [0, 17, 17, 9, 11, 4, 11, 3, 8, 13, 15, 15, 19, 10]}]"
}
|
[
""
] |
{
"id": 125,
"canonical_solution": "",
"entry_point": "middle_index"
}
|
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция:
{function}
Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
|
{
"function": "from typing import List\n\n\ndef separate_words(array: List[str], symbol: str) -> List[str]:\n \"\"\"Разделите все строки списка array по символу symbol и выведите полученный список разделенных строк в том же порядке, в котором они были в изначальном списке.\n Примеры:\n separate_words(array=['90в$ие5д86з34гзё1', 'ё$', '89з0$5б$е74', 'ёбб$0д', 'ги71$6$66гг', '51$'], symbol=$) == ['90в', 'ие5д86з34гзё1', 'ё', '89з0', '5б', 'е74', 'ёбб', '0д', 'ги71', '6', '66гг', '51']\n separate_words(array=['94/1гбж1да43г9з', '2бе3аб/97гж0з89'], symbol=/) == ['94', '1гбж1да43г9з', '2бе3аб', '97гж0з89']\n \"\"\"",
"tests": "[{'array': ['90в$ие5д86з34гзё1', 'ё$', '89з0$5б$е74', 'ёбб$0д', 'ги71$6$66гг', '51$'], 'symbol': '$'}, {'array': ['94/1гбж1да43г9з', '2бе3аб/97гж0з89'], 'symbol': '/'}, {'array': ['14529~3014~ё', '0~69~з', '88~3и8в2557еи', '32~ёеёи', '14~бв~з'], 'symbol': '~'}, {'array': ['едвззгж/в0ед1', 'и/', '1и/з58ж930/бё2'], 'symbol': '/'}, {'array': ['з2ии709жж5+5ажзи5зз', '0+3жвдж', '31ж8ж597б7++7а9даг2аё', 'г610д318е+в27з'], 'symbol': '+'}, {'array': ['в?б?ё', '3д3дёе1е5а3?917дга0и', '0аагаи?га?34г', '68?6?90366з', 'в206адё280и??688649д6', 'ё?аж8'], 'symbol': '?'}, {'array': ['6*2аг5*б7аз666а', 'з*г6в7ёвбз0бж50вб', '0б5*06бв0*', '3ж7*в44еб88*0иа441ё0', 'е7*ёа'], 'symbol': '*'}, {'array': ['и6ж1е3жз8иб$71$0ёгзж', 'г2и8е$56вёед082$за23', '4бе2и478и$68а77$ё', '7$', '8$6зз8жб8б4аега25а$6'], 'symbol': '$'}, {'array': ['г3извиж§', 'вже2§45за3е§176в'], 'symbol': '§'}, {'array': ['9в@и82б1и3иг6в', '5г3дбд9@6аабвжа@гз', 'ё@ежб2531б4@дб', '6аё0ё82аизё6б3а3@бёв@', 'ба4бдиё89@ж99843а282', 'б9д624@ж3дж31в3'], 'symbol': '@'}]"
}
|
[
""
] |
{
"id": 126,
"canonical_solution": "",
"entry_point": "separate_words"
}
|
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции.
Функция:
{function}
Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
|
{
"function": "def achieve_number(number: int, target: int) -> int:\n \"\"\"Число называется красивым для числа target, если после совершения не более, чем number действий оно станет равно target. В качестве одного действия разрешается увеличивать target на 1 и одновременно уменьшать число на 1. Выведите максимально возможное красивое число для target.\n Примеры:\n achieve_number(number=34, target=81) == 149\n achieve_number(number=27, target=48) == 102\n \"\"\"",
"tests": "[{'number': 34, 'target': 81}, {'number': 27, 'target': 48}, {'number': 36, 'target': 71}, {'number': 46, 'target': 219}, {'number': 25, 'target': 471}, {'number': 4, 'target': 490}, {'number': 23, 'target': 433}, {'number': 21, 'target': 35}, {'number': 4, 'target': 476}, {'number': 16, 'target': 272}]"
}
|
[
""
] |
{
"id": 127,
"canonical_solution": "",
"entry_point": "achieve_number"
}
|
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции:
{function}
Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
|
{
"function": "def triple_concatenation(number: int) -> str:\n \"\"\"Соедините число number с числами 2 * number и 3 * number. Если полученное число содержит все цифры от 1 до 9, но не содержит 0, то выведите \"Да\", в ином случае выведите \"Нет\".\n Примеры:\n triple_concatenation(number=4) == 'Нет'\n triple_concatenation(number=192) == 'Да'\n \"\"\"",
"tests": "[{'number': 4}, {'number': 192}, {'number': 843}, {'number': 1230}, {'number': 273}, {'number': 876543}, {'number': 10}, {'number': 219}, {'number': 327}, {'number': 49729}]"
}
|
[
""
] |
{
"id": 128,
"canonical_solution": "",
"entry_point": "triple_concatenation"
}
|
Напиши продолжение данной функции:
{function}
Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
|
{
"function": "def truncate_number(string: str) -> str:\n \"\"\"Удалите все нули в конце числа данного на вход в формате строки string и выведите полученное число в формате строки.\n Примеры:\n truncate_number(string=618673000) == '618673'\n truncate_number(string=7819765) == '7819765'\n \"\"\"",
"tests": "[{'string': '618673000'}, {'string': '7819765'}, {'string': '915760'}, {'string': '946843000'}, {'string': '661467'}, {'string': '76862550'}, {'string': '4754120'}, {'string': '11991000'}, {'string': '9796614'}, {'string': '33296700'}]"
}
|
[
""
] |
{
"id": 129,
"canonical_solution": "",
"entry_point": "truncate_number"
}
|
Реши задачу по программированию. Начало функции:
{function}
Продолжи функцию так, чтобы она корректно работала.
Ответ оформи по шаблону: ```python <code>```
|
{
"function": "def remove_substring(string: str) -> int:\n \"\"\"В строке string вы можете неограниченное количество раз удалять вхождения построк \"АБ\" и \"ВГ\". Выведите длину наименьшей возможной строки после всех удалений.\n Примеры:\n remove_substring(string=АБАБВГ) == 0\n remove_substring(string=АБВГСДЕЖАБ) == 4\n \"\"\"",
"tests": "[{'string': 'АБАБВГ'}, {'string': 'АБВГСДЕЖАБ'}, {'string': 'АБЫЛКНВЭЫЗВГЫЗАБ'}, {'string': 'ДЛОИВАБАБЫ'}, {'string': 'ВШПНВГВБХ'}, {'string': 'ЫВЖЩШЩОАББАВ'}, {'string': 'ГВВГАББА'}, {'string': 'ВАБГ'}, {'string': 'АБЫЖДВАГВ'}, {'string': 'ШЛНПНФЫ'}]"
}
|
[
""
] |
{
"id": 130,
"canonical_solution": "",
"entry_point": "remove_substring"
}
|
Тебе дана заготовка под функцию на языке Python:
{function}
Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
|
{
"function": "def selective_sum(number: int) -> int:\n \"\"\"Найдите сумму всех чисел от 1 до number включительно таких, которые делятся на 3, 5 или 7. Выведите полученную сумму.\n Примеры:\n selective_sum(number=44) == 499\n selective_sum(number=58) == 964\n \"\"\"",
"tests": "[{'number': 44}, {'number': 58}, {'number': 96}, {'number': 42}, {'number': 3}, {'number': 19}, {'number': 46}, {'number': 18}, {'number': 37}, {'number': 49}]"
}
|
[
""
] |
{
"id": 131,
"canonical_solution": "",
"entry_point": "selective_sum"
}
|
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}
В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
|
{
"function": "from typing import List\n\n\ndef maximum_row(matrix: List[List[int]]) -> int:\n \"\"\"Найдтите наименьшую по индексу строку в бинарной матрице matrix, которая содержит наибольшее количество единиц и выведите количество единиц в этой строке.\n Примеры:\n maximum_row(matrix=[[1, 0, 0, 0, 1, 1, 1, 0], [1, 1, 0, 1, 1, 0, 0, 1], [0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 1, 1, 0, 0, 0, 0], [1, 0, 1, 1, 0, 0, 1, 1], [0, 0, 1, 0, 0, 1, 1, 0], [1, 1, 1, 0, 0, 0, 1, 0], [1, 0, 0, 1, 0, 1, 1, 1]]) == 5\n maximum_row(matrix=[[0, 1, 0, 1, 0, 1, 1, 1, 1, 1], [0, 0, 0, 1, 0, 1, 1, 1, 0, 0], [0, 1, 1, 0, 0, 0, 1, 0, 1, 0], [1, 1, 1, 0, 0, 1, 1, 1, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0, 0, 1, 0, 1, 0, 1], [0, 1, 0, 1, 0, 0, 1, 0, 0, 1], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0], [0, 0, 0, 1, 0, 0, 1, 1, 1, 1]]) == 7\n \"\"\"",
"tests": "[{'matrix': [[1, 0, 0, 0, 1, 1, 1, 0], [1, 1, 0, 1, 1, 0, 0, 1], [0, 1, 0, 0, 0, 0, 1, 0], [0, 0, 1, 1, 0, 0, 0, 0], [1, 0, 1, 1, 0, 0, 1, 1], [0, 0, 1, 0, 0, 1, 1, 0], [1, 1, 1, 0, 0, 0, 1, 0], [1, 0, 0, 1, 0, 1, 1, 1]]}, {'matrix': [[0, 1, 0, 1, 0, 1, 1, 1, 1, 1], [0, 0, 0, 1, 0, 1, 1, 1, 0, 0], [0, 1, 1, 0, 0, 0, 1, 0, 1, 0], [1, 1, 1, 0, 0, 1, 1, 1, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [1, 1, 0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0, 0, 1, 0, 1, 0, 1], [0, 1, 0, 1, 0, 0, 1, 0, 0, 1], [0, 0, 0, 1, 1, 1, 1, 1, 1, 0], [0, 0, 0, 1, 0, 0, 1, 1, 1, 1]]}, {'matrix': [[0, 1, 0, 0, 1, 0], [0, 0, 0, 1, 1, 0], [1, 0, 0, 0, 1, 1], [0, 0, 0, 0, 1, 1], [1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 0, 1]]}, {'matrix': [[0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0], [1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1], [1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1], [1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1], [1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1], [0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1], [0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0], [0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0], [1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1], [0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1], [1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0]]}, {'matrix': [[1, 1, 0, 0, 0], [1, 1, 1, 1, 1], [0, 1, 0, 0, 1], [1, 0, 0, 0, 1], [0, 0, 0, 1, 1]]}, {'matrix': [[0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1], [1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0], [0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1], [0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1], [1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0], [1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1], [0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0], [1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0], [0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0], [0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1]]}, {'matrix': [[0, 1, 0, 0, 1, 0], [1, 1, 0, 0, 1, 0], [1, 1, 1, 1, 0, 0], [0, 0, 1, 1, 0, 1], [0, 1, 0, 0, 1, 1], [0, 1, 1, 0, 1, 0]]}, {'matrix': [[1, 0, 1, 0, 1, 1, 1, 0], [0, 0, 0, 1, 1, 1, 1, 1], [0, 1, 0, 1, 1, 1, 1, 0], [1, 0, 0, 0, 0, 1, 0, 0], [1, 1, 0, 1, 0, 1, 0, 0], [0, 0, 1, 1, 0, 1, 1, 1], [1, 0, 1, 1, 0, 1, 0, 1], [1, 0, 0, 1, 1, 1, 1, 0]]}, {'matrix': [[1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1], [1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1], [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0], [0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0], [1, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1], [0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0], [1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0], [0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1], [0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1], [0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0]]}, {'matrix': [[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 1, 0, 1], [1, 0, 1, 0, 1]]}]"
}
|
[
""
] |
{
"id": 132,
"canonical_solution": "",
"entry_point": "maximum_row"
}
|
{function}
Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
|
{
"function": "def parity_sum(number: int) -> int:\n \"\"\"Дано десятичное натуральное число number. Выведите сумму количества единиц в двоичной записи number с четными индексами и количества единиц в двоичной записи number с нечетными индексами.\n Примеры:\n parity_sum(number=4) == 1\n parity_sum(number=192) == 2\n \"\"\"",
"tests": "[{'number': 4}, {'number': 192}, {'number': 843}, {'number': 1230}, {'number': 273}, {'number': 876543}, {'number': 10}, {'number': 219}, {'number': 327}, {'number': 49729}]"
}
|
[
""
] |
{
"id": 133,
"canonical_solution": "",
"entry_point": "parity_sum"
}
|
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами:
{function}
Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
|
{
"function": "from typing import List\n\n\ndef count_vowels(array: List[str], number1: int, number2: int) -> int:\n \"\"\"Выведите, сколько слов в списке array в диапазоне индексов от number1 до number2, начинаются на гласную букву и заканчиваются гласной буквой (гласные буквы: 'а', 'у', 'о', 'ы', 'и', 'э', 'я', 'ю', 'ё', 'е').\n Примеры:\n count_vowels(array=['Когда', 'юла', 'ему', 'она', 'случалось', 'ела', 'брать', 'меня', 'на', 'руки'], number1=3, number2=9) == 2\n count_vowels(array=['И', 'надо', 'усердно', 'исполняли', 'они', 'свою', 'обязанность'], number1=0, number2=6) == 4\n \"\"\"",
"tests": "[{'array': ['Когда', 'юла', 'ему', 'она', 'случалось', 'ела', 'брать', 'меня', 'на', 'руки'], 'number1': 3, 'number2': 9}, {'array': ['И', 'надо', 'усердно', 'исполняли', 'они', 'свою', 'обязанность'], 'number1': 0, 'number2': 6}, {'array': ['на', 'дворе', 'у', 'Юры', 'у', 'него', 'или', 'никогда', 'не', 'валялось', 'ни', 'сору'], 'number1': 0, 'number2': 11}, {'array': ['И', 'омега', 'глаза', 'и', 'ура', 'отделился', 'стены'], 'number1': 1, 'number2': 6}, {'array': ['замолкла', 'и', 'вздохнула,', 'а', 'потом', 'сказала', 'нам'], 'number1': 1, 'number2': 6}, {'array': ['пожертвовав', 'и', 'не', 'мною', 'одному', 'однако', 'краснощекому', 'баварскому', 'лейтенантуБыло', 'что-то', 'свое,', 'особенное,', 'в', 'складе', 'ее', 'смугловатого,', 'круглого', 'лица'], 'number1': 4, 'number2': 17}, {'array': ['вилась', 'пряталась', 'скату', 'узкая', 'лесная', 'долина'], 'number1': 3, 'number2': 5}, {'array': ['я', 'трусы', 'горшок', 'ты', 'нет', 'да', 'или', 'вилка'], 'number1': 3, 'number2': 6}, {'array': ['Когда', 'железо', 'твоя', 'киснет', 'бежит', 'ест', 'брать', 'меня', 'на', 'руки'], 'number1': 3, 'number2': 8}, {'array': ['место', 'нет', 'дорога', 'немая', 'она'], 'number1': 3, 'number2': 4}]"
}
|
[
""
] |
{
"id": 134,
"canonical_solution": "",
"entry_point": "count_vowels"
}
|
Решите задачу на Python. Функция:
{function}
Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
|
{
"function": "def minimum_split(number: int) -> int:\n \"\"\"Разделите цифры целого числа number на два отдельных числа так, чтобы сумма этих чисел была минимально возможной. Выведите полученную сумму данных чисел. Гарантируется, что number не меньше 10.\n Примеры:\n minimum_split(number=45) == 9\n minimum_split(number=192) == 21\n \"\"\"",
"tests": "[{'number': 45}, {'number': 192}, {'number': 843}, {'number': 1230}, {'number': 273}, {'number': 876543}, {'number': 10}, {'number': 219}, {'number': 327}, {'number': 49729}]"
}
|
[
""
] |
{
"id": 135,
"canonical_solution": "",
"entry_point": "minimum_split"
}
|
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция:
{function}
Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
|
{
"function": "from typing import List\n\n\ndef split_array(array: List[int]) -> List[int]:\n \"\"\"В целочисленном массиве array разделите все числа на отдельные цифры, сохранив изначальный порядок и выведите их все одним списком. Если на вход пришел пустой массив, выведите пустой массив.\n Примеры:\n split_array(array=[75, 4, 65, 45, 31, 86, 35, 63, 13, 23, 3]) == [7, 5, 4, 6, 5, 4, 5, 3, 1, 8, 6, 3, 5, 6, 3, 1, 3, 2, 3, 3]\n split_array(array=[33, 47, 68, 73, 89, 69, 37, 25, 84, 49, 16, 4, 76]) == [3, 3, 4, 7, 6, 8, 7, 3, 8, 9, 6, 9, 3, 7, 2, 5, 8, 4, 4, 9, 1, 6, 4, 7, 6]\n \"\"\"",
"tests": "[{'array': [75, 4, 65, 45, 31, 86, 35, 63, 13, 23, 3]}, {'array': [33, 47, 68, 73, 89, 69, 37, 25, 84, 49, 16, 4, 76]}, {'array': [69, 86, 94, 87, 90, 26, 99, 99, 69, 16, 93, 91, 67]}, {'array': [55, 38, 16, 37, 12, 80, 43, 49, 37, 5, 27, 82]}, {'array': [84, 3, 91, 55, 72, 26, 95, 48, 48, 7]}, {'array': [56, 0, 94, 10, 53, 6, 26, 16, 33, 4, 46]}, {'array': [24, 53, 63, 98, 9, 0, 1, 59, 12, 88, 56, 37, 14, 66]}, {'array': [68, 39, 17, 82, 74, 22, 51, 22, 36, 93, 73]}, {'array': []}, {'array': [77, 88, 8, 38, 59, 1, 53, 84, 83, 15, 5, 19, 22]}]"
}
|
[
""
] |
{
"id": 136,
"canonical_solution": "",
"entry_point": "split_array"
}
|
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции.
Функция:
{function}
Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
|
{
"function": "def alternating_sum(number: int) -> int:\n \"\"\"В целом числе number большем нуля все цифры с четными индексами имеют знак \"+\", а с нечетными – знак \"-\". Выведите сумму цифр числа number с учетом их знаков.\n Примеры:\n alternating_sum(number=4) == 4\n alternating_sum(number=192) == -6\n \"\"\"",
"tests": "[{'number': 4}, {'number': 192}, {'number': 843}, {'number': 1230}, {'number': 273}, {'number': 876543}, {'number': 10}, {'number': 219}, {'number': 327}, {'number': 49729}]"
}
|
[
""
] |
{
"id": 137,
"canonical_solution": "",
"entry_point": "alternating_sum"
}
|
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции:
{function}
Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
|
{
"function": "from typing import List\n\n\ndef find_minimum(array1: List[int], array2: List[int]) -> int:\n \"\"\"Выведите число, минимальное одновременно для двух массивов array1 и array2, отсортированных в порядке неубывания. Число должно встречаться как в первом массиве, так и во втором. Если такого числа нет или хотя бы один из массивов пуст, выведите \"-1\".\n Примеры:\n find_minimum(array1=[7, 11, 17, 21, 24, 24], array2=[7, 10, 12, 16, 20]) == 7\n find_minimum(array1=[4, 5, 7, 11, 15, 16, 21], array2=[4, 7, 10, 14, 15, 15, 17, 18, 19, 22]) == 4\n \"\"\"",
"tests": "[{'array1': [7, 11, 17, 21, 24, 24], 'array2': [7, 10, 12, 16, 20]}, {'array1': [4, 5, 7, 11, 15, 16, 21], 'array2': [4, 7, 10, 14, 15, 15, 17, 18, 19, 22]}, {'array1': [], 'array2': []}, {'array1': [23], 'array2': []}, {'array1': [1, 6, 8, 12, 15, 16, 22], 'array2': [1, 1, 5, 7, 8, 11, 15, 18, 19, 23]}, {'array1': [22], 'array2': [22]}, {'array1': [2, 3, 5, 10, 15, 16, 20, 22, 22, 23], 'array2': [2, 3, 3, 9, 13, 22]}, {'array1': [5, 7, 10, 11, 13, 15, 23], 'array2': [5, 9, 9, 13, 13, 15, 23, 23]}, {'array1': [6, 12, 12, 13, 14, 22, 24], 'array2': [6, 6, 8, 13, 14, 15, 19, 19, 21]}, {'array1': [], 'array2': [7, 11, 11, 14, 19]}]"
}
|
[
""
] |
{
"id": 138,
"canonical_solution": "",
"entry_point": "find_minimum"
}
|
Напиши продолжение данной функции:
{function}
Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
|
{
"function": "from typing import List\n\n\ndef matrix_truncation(matrix: List[List[int]]) -> int:\n \"\"\"В целочисленной матрице matrix итеративно удалите из каждой строки наибольший элемент, а затем прибавьте к ответу максимум из удаленных элементов. Какое число получится после удаления всех элементов матрицы? Выведите полученное число.\n Примеры:\n matrix_truncation(matrix=[[6, 10, 5, 1, 4, 11, 11, 10], [9, 10, 10, 12, 4, 4, 1, 3], [5, 3, 10, 7, 14, 6, 14, 11], [4, 0, 14, 8, 0, 7, 5, 11], [4, 2, 3, 10, 10, 4, 12, 13], [9, 7, 10, 2, 2, 0, 6, 7], [10, 14, 8, 12, 12, 3, 6, 12], [14, 7, 0, 8, 13, 13, 0, 1]]) == 80\n matrix_truncation(matrix=[[6, 13, 1, 11, 12, 10, 8, 9, 3], [4, 14, 5, 1, 4, 10, 13, 2, 9], [2, 10, 12, 14, 3, 0, 11, 8, 12], [12, 9, 9, 9, 2, 9, 7, 2, 8], [4, 4, 0, 4, 11, 5, 10, 10, 4], [8, 4, 6, 14, 7, 4, 14, 9, 9], [5, 5, 10, 2, 13, 2, 13, 6, 3], [3, 13, 5, 5, 11, 11, 13, 10, 9], [6, 11, 7, 11, 9, 9, 14, 14, 7]]) == 90\n \"\"\"",
"tests": "[{'matrix': [[6, 10, 5, 1, 4, 11, 11, 10], [9, 10, 10, 12, 4, 4, 1, 3], [5, 3, 10, 7, 14, 6, 14, 11], [4, 0, 14, 8, 0, 7, 5, 11], [4, 2, 3, 10, 10, 4, 12, 13], [9, 7, 10, 2, 2, 0, 6, 7], [10, 14, 8, 12, 12, 3, 6, 12], [14, 7, 0, 8, 13, 13, 0, 1]]}, {'matrix': [[6, 13, 1, 11, 12, 10, 8, 9, 3], [4, 14, 5, 1, 4, 10, 13, 2, 9], [2, 10, 12, 14, 3, 0, 11, 8, 12], [12, 9, 9, 9, 2, 9, 7, 2, 8], [4, 4, 0, 4, 11, 5, 10, 10, 4], [8, 4, 6, 14, 7, 4, 14, 9, 9], [5, 5, 10, 2, 13, 2, 13, 6, 3], [3, 13, 5, 5, 11, 11, 13, 10, 9], [6, 11, 7, 11, 9, 9, 14, 14, 7]]}, {'matrix': [[11, 7, 4, 4, 6, 12, 8, 9, 8, 13], [11, 5, 3, 13, 9, 9, 5, 7, 1, 10], [14, 10, 7, 4, 8, 3, 7, 6, 5, 2], [2, 13, 8, 12, 4, 5, 10, 10, 14, 4], [13, 2, 11, 7, 6, 6, 8, 8, 4, 11], [1, 1, 3, 11, 4, 12, 11, 6, 3, 5], [8, 0, 4, 5, 14, 5, 11, 14, 12, 10], [2, 4, 8, 1, 11, 6, 4, 12, 5, 3], [6, 1, 14, 14, 2, 1, 7, 10, 11, 5], [4, 7, 14, 4, 3, 12, 11, 3, 3, 5]]}, {'matrix': [[1, 10, 1, 1, 4, 9, 14, 6, 6, 0, 4], [11, 4, 9, 6, 8, 11, 3, 13, 6, 12, 2], [13, 6, 10, 14, 8, 8, 0, 12, 8, 10, 5], [5, 7, 0, 9, 13, 9, 1, 1, 5, 9, 13], [7, 10, 5, 11, 0, 6, 2, 9, 11, 9, 3], [2, 8, 12, 5, 2, 8, 1, 5, 11, 8, 3], [11, 1, 7, 2, 1, 5, 12, 0, 12, 12, 6], [14, 13, 13, 9, 5, 4, 2, 13, 4, 5, 2], [9, 4, 1, 3, 10, 5, 7, 0, 1, 4, 10], [3, 6, 8, 6, 14, 6, 12, 8, 9, 13, 6], [7, 1, 4, 0, 10, 13, 11, 13, 9, 4, 7]]}, {'matrix': [[7, 12, 10, 9, 8, 10], [10, 3, 8, 3, 8, 1], [1, 7, 2, 11, 12, 0], [12, 9, 10, 14, 8, 0], [13, 13, 10, 0, 8, 2], [2, 5, 5, 8, 9, 2]]}, {'matrix': [[4, 5, 6, 2, 14, 10, 11], [5, 13, 3, 13, 11, 7, 2], [1, 5, 2, 3, 3, 14, 8], [1, 14, 2, 7, 14, 2, 7], [5, 3, 10, 14, 5, 13, 0], [7, 1, 6, 14, 7, 1, 12], [11, 0, 13, 4, 14, 8, 3]]}, {'matrix': [[11, 14, 2, 2, 1, 1, 7], [1, 14, 9, 9, 14, 6, 13], [5, 12, 9, 9, 10, 9, 0], [13, 11, 6, 0, 7, 14, 3], [11, 12, 14, 8, 7, 0, 9], [10, 11, 8, 11, 5, 0, 1], [1, 3, 8, 2, 9, 10, 2]]}, {'matrix': [[5, 9, 4, 0, 14, 12, 5, 5, 11, 8], [6, 5, 0, 9, 2, 2, 1, 0, 8, 6], [9, 9, 3, 8, 13, 3, 6, 1, 9, 5], [0, 4, 8, 10, 12, 1, 12, 11, 0, 10], [10, 11, 1, 3, 8, 9, 1, 0, 14, 9], [2, 8, 11, 6, 5, 5, 6, 13, 12, 1], [11, 1, 6, 7, 1, 7, 5, 13, 13, 12], [13, 0, 8, 3, 5, 13, 1, 13, 5, 14], [13, 14, 6, 3, 1, 7, 13, 2, 2, 6], [6, 8, 14, 13, 7, 5, 4, 12, 1, 7]]}, {'matrix': [[5, 14, 7, 6, 3, 2, 5, 4, 1, 9], [12, 11, 6, 6, 2, 10, 3, 8, 2, 3], [14, 12, 11, 7, 6, 5, 4, 8, 10, 0], [14, 10, 11, 14, 7, 11, 13, 11, 4, 3], [3, 10, 5, 6, 4, 8, 6, 6, 4, 10], [14, 2, 7, 1, 14, 6, 1, 12, 4, 5], [13, 9, 14, 3, 4, 14, 11, 3, 0, 1], [4, 12, 0, 14, 13, 6, 0, 12, 7, 14], [13, 6, 5, 8, 2, 13, 4, 11, 1, 0], [8, 5, 10, 6, 7, 12, 10, 6, 2, 12]]}, {'matrix': [[0, 3, 0, 8, 3, 10, 13, 4, 1, 4, 8], [1, 7, 4, 7, 12, 13, 13, 11, 0, 1, 14], [13, 3, 13, 5, 11, 9, 12, 3, 1, 0, 6], [1, 5, 2, 10, 4, 11, 12, 6, 8, 6, 7], [5, 2, 11, 13, 7, 9, 5, 6, 13, 10, 7], [8, 13, 11, 6, 4, 12, 10, 8, 2, 10, 14], [0, 12, 13, 6, 11, 10, 5, 8, 6, 4, 5], [13, 5, 6, 10, 2, 12, 3, 3, 3, 8, 0], [0, 8, 4, 4, 9, 9, 5, 4, 10, 7, 6], [3, 5, 9, 13, 5, 2, 1, 13, 8, 3, 2], [7, 7, 13, 10, 2, 3, 12, 9, 9, 12, 6]]}]"
}
|
[
""
] |
{
"id": 139,
"canonical_solution": "",
"entry_point": "matrix_truncation"
}
|
Реши задачу по программированию. Начало функции:
{function}
Продолжи функцию так, чтобы она корректно работала.
Ответ оформи по шаблону: ```python <code>```
|
{
"function": "def equal_sums(number: int) -> int:\n \"\"\"Для целого числа number определите такое центральное число, что сумма всех чисел от 1 до центрального включительно равна сумме всех чисел от центрального числа до числа number включительно. Выведите полученное число. Если такого числа нет, то выведите -1.\n Примеры:\n equal_sums(number=1) == 1\n equal_sums(number=192) == -1\n \"\"\"",
"tests": "[{'number': 1}, {'number': 192}, {'number': 843}, {'number': 1230}, {'number': 49}, {'number': 8763}, {'number': 8}, {'number': 219}, {'number': 288}, {'number': 4979}]"
}
|
[
""
] |
{
"id": 140,
"canonical_solution": "",
"entry_point": "equal_sums"
}
|
Тебе дана заготовка под функцию на языке Python:
{function}
Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
|
{
"function": "def divide_circle(number: int) -> int:\n \"\"\"Определите, сколько необходимо сделать разрезов в окружности, чтобы получить number одинаковых частей. Разрезы можно делать либо по любому из диаметров окружности – прямая линия от одной точки окружности до другой, проходящая через центр окружности, либо по любому из ее радиусов – прямая от центра окружности до любой из точек на окружности. Выведите полученное число.\n Примеры:\n divide_circle(number=13) == 13\n divide_circle(number=12) == 6\n \"\"\"",
"tests": "[{'number': 13}, {'number': 12}, {'number': 1}, {'number': 9}, {'number': 6}, {'number': 10}, {'number': 14}, {'number': 17}, {'number': 4}, {'number': 15}]"
}
|
[
""
] |
{
"id": 141,
"canonical_solution": "",
"entry_point": "divide_circle"
}
|
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}
В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
|
{
"function": "def temperature_sum(number: float) -> float:\n \"\"\"Переведите температуру number из градусов Цельсия (Celsius) в Кельвины (Kelvin) и в градусы Фаренгейта (Fahrenheit). Округлите каждое из полученных чисел до двух знаков после запятой и выведите сумму полученных чисел, также округленную до 2 знаков после запятой.\nКельвин = Цельсий + 273.15\nФаренгейт = Цельсий * 1.80 + 32.00\n Примеры:\n temperature_sum(number=-5.72) == 289.13\n temperature_sum(number=0.85) == 307.53\n \"\"\"",
"tests": "[{'number': -5.72}, {'number': 0.85}, {'number': -3.73}, {'number': 7.65}, {'number': -6.17}, {'number': 11.42}, {'number': 6.61}, {'number': -7.84}, {'number': 11.82}, {'number': -9.67}]"
}
|
[
""
] |
{
"id": 142,
"canonical_solution": "",
"entry_point": "temperature_sum"
}
|
{function}
Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
|
{
"function": "from typing import List\n\n\ndef selective_mean(array: List[int]) -> int:\n \"\"\"Выведите среднее арифметическое всех четных чисел списка array, которые делятся на 3. Выведите ответ в виде целого числа. Если число получается нецелым, отбросьте его дробную часть. Для пустого списка выведите 0. Среднее арифметическое массива чисел равно сумме всех чисел массива, поделенной на количество чисел в массиве.\n Примеры:\n selective_mean(array=[9, 10, 3, 1, 3, 14, 12, 10]) == 12\n selective_mean(array=[]) == 0\n \"\"\"",
"tests": "[{'array': [9, 10, 3, 1, 3, 14, 12, 10]}, {'array': []}, {'array': [7, 10, 4, 5, 9, 12, 5]}, {'array': [7, 3, 9, 9, 6, 11, 7, 11]}, {'array': [6, 11, 9, 5, 5, 5, 7]}, {'array': [1, 6, 7, 4, 10, 14]}, {'array': [5, 4, 13, 11, 1, 3, 10, 6, 2, 12, 2]}, {'array': [11, 3, 7, 14, 2]}, {'array': [14, 9, 14, 9, 7, 4, 10, 1, 9]}, {'array': [9, 9, 12, 6, 3, 4]}]"
}
|
[
""
] |
{
"id": 143,
"canonical_solution": "",
"entry_point": "selective_mean"
}
|
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами:
{function}
Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
|
{
"function": "from typing import List\n\n\ndef first_extremum(array: List[int]) -> int:\n \"\"\"Дан список целых чисел array. Элемент списка называется экстремумом, если он больше своих соседей слева и справа. Крайний слева элемент всегда больше левого элемента, а крайний правый – элемента справа. Выведите индекс самого первого экстремума списка. Если такого индекса не существует, выведите -1.\n Примеры:\n first_extremum(array=[14, 4, 10, 8, 7, 13, 5, 10, 12, 6]) == 0\n first_extremum(array=[6, 9, 13, 1, 10, 8]) == 2\n \"\"\"",
"tests": "[{'array': [14, 4, 10, 8, 7, 13, 5, 10, 12, 6]}, {'array': [6, 9, 13, 1, 10, 8]}, {'array': [6, 2, 7, 14, 6, 6, 14]}, {'array': [3, 5, 12, 4, 3]}, {'array': [5, 5, 4, 8, 10, 13, 6, 9, 8]}, {'array': [13, 12, 1, 11, 8, 6, 6, 5, 7, 5, 6]}, {'array': [11, 4, 13, 6, 7, 8, 13]}, {'array': [2, 13, 3, 11, 5, 7, 8]}, {'array': [3, 13, 5, 4, 9, 2, 9, 1]}, {'array': []}]"
}
|
[
""
] |
{
"id": 144,
"canonical_solution": "",
"entry_point": "first_extremum"
}
|
Решите задачу на Python. Функция:
{function}
Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
|
{
"function": "from typing import List\n\n\ndef maximum_profit(array: List[int]) -> int:\n \"\"\"Дан список цен на облигации по дням array. Один раз за день можно либо продать, либо купить облигацию. На руках можно держать только одну облигацию. Выведите, какой максимальный доход от операций с облигациями можно получить при таких ценах. Доход не может быть меньше 0.\n Примеры:\n maximum_profit(array=[5, 13, 9, 2, 7, 7, 10, 13]) == 19\n maximum_profit(array=[5, 8, 1, 6, 12]) == 14\n \"\"\"",
"tests": "[{'array': [5, 13, 9, 2, 7, 7, 10, 13]}, {'array': [5, 8, 1, 6, 12]}, {'array': [13, 11, 5, 3, 4, 2, 3, 14, 3]}, {'array': [14, 6, 12, 8, 10]}, {'array': [11, 14, 1, 8, 10, 11, 6]}, {'array': [3, 11, 6, 9, 1, 8, 14, 9, 2]}, {'array': [12, 14, 14, 5, 9, 6]}, {'array': [5, 4, 3, 2, 1]}, {'array': [5, 4, 4, 12, 14, 10, 12, 10]}, {'array': []}]"
}
|
[
""
] |
{
"id": 145,
"canonical_solution": "",
"entry_point": "maximum_profit"
}
|
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция:
{function}
Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
|
{
"function": "from typing import List\n\n\ndef minimum_path(array: List[List[int]]) -> int:\n \"\"\"Дан треугольный массив array. Выведите минимально возможную сумму элементов пути от начала array до конца. Из индекса K текущей строки можно переместиться только в индексы K и (K + 1) следующей строки. В треугольном массиве каждый следующий элемент имеет длину на единицу больше, чем предыдущий, начиная с 1. Для пустого array минимальный путь равен 0.\n Примеры:\n minimum_path(array=[[22], [13, 18], [1, 9, 10]]) == 22\n minimum_path(array=[[22], [26, 20], [24, 31, 19], [14, 18, 17, 15], [8, 7, 14, 8, 8]]) == 22\n \"\"\"",
"tests": "[{'array': [[22], [13, 18], [1, 9, 10]]}, {'array': [[22], [26, 20], [24, 31, 19], [14, 18, 17, 15], [8, 7, 14, 8, 8]]}, {'array': [[26], [24, 27], [16, 28, 23], [13, 22, 21, 20], [8, 22, 21, 18, 19], [6, 9, 12, 7, 13, 7]]}, {'array': [[7], [6, 2], [14, 1, 10]]}, {'array': [[25], [15, 21], [15, 8, 17], [11, 11, 4, 5], [9, 10, 1, 11, 4]]}, {'array': [[27], [17, 20], [15, 18, 18], [11, 9, 4, 11], [14, 4, 2, 13, 1]]}, {'array': [[18], [9, 12], [9, 4, 14]]}, {'array': [[31], [35, 30], [36, 29, 24], [27, 23, 26, 22], [18, 17, 13, 23, 10], [8, 14, 8, 13, 11, 3]]}, {'array': [[41], [32, 40], [21, 29, 28], [17, 18, 20, 14], [23, 4, 9, 11, 16], [12, 13, 1, 5, 10, 10]]}, {'array': []}]"
}
|
[
""
] |
{
"id": 146,
"canonical_solution": "",
"entry_point": "minimum_path"
}
|
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции.
Функция:
{function}
Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
|
{
"function": "def reverse_number(number: int) -> int:\n \"\"\"Выведите цифры числа number в обратном порядке. Если число отрицательное, то сохраните отрицательный знак в начале числа.\n Примеры:\n reverse_number(number=71) == 17\n reverse_number(number=-68) == -86\n \"\"\"",
"tests": "[{'number': 71}, {'number': -68}, {'number': 0}, {'number': 36}, {'number': -41}, {'number': 85}, {'number': 22}, {'number': -56}, {'number': -26}, {'number': -69}]"
}
|
[
""
] |
{
"id": 147,
"canonical_solution": "",
"entry_point": "reverse_number"
}
|
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции:
{function}
Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
|
{
"function": "from typing import List\n\n\ndef h_index(array: List[int]) -> int:\n \"\"\"Список array содержит количества цитирований каждой из работ ученого. Выведите H-индекс ученого. H-индекс является такой максимально возможной величиной, что существует не меньше H работ ученого, которые были процитированы не менее H раз. Гарантируется, что массив содержит не менее 1 ненулевого элемента.\n Примеры:\n h_index(array=[3, 3, 5, 5, 8, 8, 8, 9, 10, 10, 10, 11, 12, 12, 14]) == 8\n h_index(array=[1, 3, 4, 5, 5, 5, 5, 8, 9, 12, 14, 14]) == 5\n \"\"\"",
"tests": "[{'array': [3, 3, 5, 5, 8, 8, 8, 9, 10, 10, 10, 11, 12, 12, 14]}, {'array': [1, 3, 4, 5, 5, 5, 5, 8, 9, 12, 14, 14]}, {'array': [1]}, {'array': [3, 9, 9, 9, 10, 11, 11, 11, 11, 12, 12, 12, 13]}, {'array': [2, 3, 3, 3, 4, 4, 4, 5, 6, 9, 12, 13, 13, 14]}, {'array': [1, 1, 2, 2, 6, 8, 8, 9, 10, 12, 13, 14]}, {'array': [1, 3, 6, 6, 9, 10, 10, 11, 11, 12]}, {'array': [2, 2, 4, 8, 8, 12, 13, 14]}, {'array': [1, 3, 4, 5, 5, 8, 8, 9, 10, 10, 10, 12, 13, 13]}, {'array': [2, 4, 4, 8, 10, 12, 12, 13]}]"
}
|
[
""
] |
{
"id": 148,
"canonical_solution": "",
"entry_point": "h_index"
}
|
Напиши продолжение данной функции:
{function}
Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
|
{
"function": "from typing import List\n\n\ndef concatenation_maximum(array: List[int]) -> str:\n \"\"\"Выведите строку, которая содержит максимально возможное число, которое можно получить конкатенацией чисел из списка array. Гарантируется, что в списке более 1 элемента.\n Примеры:\n concatenation_maximum(array=[1, 3, 1, 7]) == '7311'\n concatenation_maximum(array=[6, 6, 1, 2, 6]) == '66621'\n \"\"\"",
"tests": "[{'array': [1, 3, 1, 7]}, {'array': [6, 6, 1, 2, 6]}, {'array': [6, 3, 4, 5, 3]}, {'array': [9, 3, 7, 1]}, {'array': [7, 5, 9, 7, 5]}, {'array': [1, 9, 3, 8, 1]}, {'array': [6, 1, 6, 4, 3]}, {'array': [4, 8, 4, 3, 8, 6]}, {'array': [7, 4, 8, 3, 9]}, {'array': [9, 3, 7, 8]}]"
}
|
[
""
] |
{
"id": 149,
"canonical_solution": "",
"entry_point": "concatenation_maximum"
}
|
Реши задачу по программированию. Начало функции:
{function}
Продолжи функцию так, чтобы она корректно работала.
Ответ оформи по шаблону: ```python <code>```
|
{
"function": "from typing import List\n\n\ndef topk_elements(array: List[str], number: int) -> List[str]:\n \"\"\"Выведите number наиболее часто встречающихся элементов списка array в порядке убывания по частоте появления в списке и в лексикографическом порядке для элементов с одинаковой частотой. Гарантируется, что array не пуст, а number не меньше 1.\n Примеры:\n topk_elements(array=['Калан', 'Изгнать', 'Изгнать', 'Изгнать', 'Изгнать', 'Словесник', 'Словесник', 'Словесник', 'Диссонанс', 'Диссонанс', 'Диссонанс'], number=2) == ['Изгнать', 'Диссонанс']\n topk_elements(array=['Случай', 'Вправить', 'Калан', 'Калан', 'Аут', 'Аут', 'Жаловаться'], number=4) == ['Аут', 'Калан', 'Вправить', 'Жаловаться']\n \"\"\"",
"tests": "[{'array': ['Калан', 'Изгнать', 'Изгнать', 'Изгнать', 'Изгнать', 'Словесник', 'Словесник', 'Словесник', 'Диссонанс', 'Диссонанс', 'Диссонанс'], 'number': 2}, {'array': ['Случай', 'Вправить', 'Калан', 'Калан', 'Аут', 'Аут', 'Жаловаться'], 'number': 4}, {'array': ['Тюркология', 'Тюркология', 'Тюркология', 'Изборник', 'Изборник', 'Изборник', 'Столешница', 'Столешница', 'Столешница', 'Столешница', 'Девиация', 'Девиация', 'Дублон', 'Дублон'], 'number': 2}, {'array': ['Клоун', 'Клоун', 'Клоун', 'Втесаться', 'Метать', 'Метать', 'Метать', 'Метать', 'Пересолить', 'Пересолить', 'Пересолить', 'Пересолить', 'Подержание', 'Подержание', 'Подержание', 'Задник'], 'number': 1}, {'array': ['Калан', 'Калан', 'Калан', 'Привернуть', 'Привернуть', 'Изгнать', 'Изгнать'], 'number': 2}, {'array': ['Веко', 'Изгнать', 'Изгнать', 'Диссонанс', 'Диссонанс', 'Диссонанс'], 'number': 1}, {'array': ['Подержание', 'Подержание', 'Череп', 'Череп', 'Метать', 'Привернуть', 'Изгнать', 'Изгнать', 'Диссонанс', 'Диссонанс'], 'number': 2}, {'array': ['Задник', 'Задник', 'Работаться', 'Работаться', 'Девиация', 'Девиация', 'Девиация', 'Девиация', 'Изборник', 'Изборник', 'Изборник', 'Жим', 'Жим', 'Жим'], 'number': 1}, {'array': ['Жим', 'Вправить', 'Случай'], 'number': 2}, {'array': ['Задник', 'Задник', 'Задник', 'Задник', 'Порскать', 'Дублон', 'Втесаться', 'Втесаться'], 'number': 2}]"
}
|
[
""
] |
{
"id": 150,
"canonical_solution": "",
"entry_point": "topk_elements"
}
|
Тебе дана заготовка под функцию на языке Python:
{function}
Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
|
{
"function": "def maximum_swap(number: int) -> int:\n \"\"\"Выведите максимально возможное число, которое можно получить перестановкой любых двух цифр в числе number. Если в числе только одна цифра, то ответом будет само это число.\n Примеры:\n maximum_swap(number=1) == 1\n maximum_swap(number=192) == 912\n \"\"\"",
"tests": "[{'number': 1}, {'number': 192}, {'number': 843}, {'number': 1230}, {'number': 49}, {'number': 8763}, {'number': 8}, {'number': 219}, {'number': 288}, {'number': 4979}]"
}
|
[
""
] |
{
"id": 151,
"canonical_solution": "",
"entry_point": "maximum_swap"
}
|
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}
В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
|
{
"function": "from typing import List\n\n\ndef change_sort(array: List[int]) -> str:\n \"\"\"Определите, возможно ли сделать список array отсортированным в неубывающем порядке путем изменения только одного элемента списка. Если возможно, выведите \"Да\", иначе – \"Нет\". Пустой список отсортировать невозможно.\n Примеры:\n change_sort(array=[-5, 16, 44, 44, -57, -92, 18, -30, -33, 8, 7]) == 'Нет'\n change_sort(array=[-98, -79, -78, -48, -20, 18, 33, 28, 31, 77]) == 'Да'\n \"\"\"",
"tests": "[{'array': [-5, 16, 44, 44, -57, -92, 18, -30, -33, 8, 7]}, {'array': [-98, -79, -78, -48, -20, 18, 33, 28, 31, 77]}, {'array': [-90, -86, -83, -29, 23, 31, 36, 40, 52, 52, 65]}, {'array': [-76, -42, -59, 73, 36, -59, 93, -93, 30, -45]}, {'array': [-74, -40, -5, 5, 9, 31, 37, 50, 50, 83]}, {'array': [-96, -75, -75, -36, -35, -35, 1, 94, 12, 77]}, {'array': [-84, -48, -13, -8, -12, 10, 56, 66, 95, 99]}, {'array': [-62, -50, -41, -11, 28, 42, 66, 71, 71, 95]}, {'array': [85, -75, 43, -18, -40, -27, 82, 2, 19, 74, -20, -64, 44]}, {'array': []}]"
}
|
[
""
] |
{
"id": 152,
"canonical_solution": "",
"entry_point": "change_sort"
}
|
{function}
Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
|
{
"function": "def number_palindromes(string: str) -> int:\n \"\"\"Выведите количество подстрок в строке string, которые являются палиндромами. Палиндромом является строка, которая одинаково выглядит при чтении слева-направо и справа-налево. Подстрока из 1 символа всегда является палиндромом.\n Примеры:\n number_palindromes(string=метафора) == 8\n number_palindromes(string=флюгегехаймен) == 15\n \"\"\"",
"tests": "[{'string': 'метафора'}, {'string': 'флюгегехаймен'}, {'string': 'без труда не выловишь и рыбку из пруда'}, {'string': 'бесплатный сыр, бывает- только в мышеловке'}, {'string': 'бог шельму= метит'}, {'string': 'в здоровом теле – здоровый дух'}, {'string': 'волков бояться – в лес не ходить'}, {'string': 'глаза боятся, а руки делают'}, {'string': 'готовь сани летом, а телегу зимой'}, {'string': 'дарёному коню в зубы не смотрят'}]"
}
|
[
""
] |
{
"id": 153,
"canonical_solution": "",
"entry_point": "number_palindromes"
}
|
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами:
{function}
Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
|
{
"function": "def squares_factorization(number: int) -> str:\n \"\"\"Определите, существуют ли ровно два целых числа, сумма квадратов которых дает в точности число number. Если существует, выведите \"Да\", иначе – \"Нет\".\n Примеры:\n squares_factorization(number=80) == 'Да'\n squares_factorization(number=21) == 'Нет'\n \"\"\"",
"tests": "[{'number': 80}, {'number': 21}, {'number': 1}, {'number': 44}, {'number': 34}, {'number': 89}, {'number': 53}, {'number': 95}, {'number': 64}, {'number': 0}]"
}
|
[
""
] |
{
"id": 154,
"canonical_solution": "",
"entry_point": "squares_factorization"
}
|
Решите задачу на Python. Функция:
{function}
Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
|
{
"function": "def complex_product(string1: str, string2: str) -> str:\n \"\"\"Даны две строки string1 и string2, которые содержат по одному комплексному числу. Комплексные числа — это числа вида a + b i , где a , b — вещественные числа, i — мнимая единица, то есть число, для которого выполняется равенство: i^2 = − 1. Проведите умножение данных комплексных чисел и выведите получившееся число в виде строки с аналогичным форматированием.\n Примеры:\n complex_product(string1=15+72i, string2=-30+-36i) == '2142-2700i'\n complex_product(string1=53+-78i, string2=86+50i) == '8458-4058i'\n \"\"\"",
"tests": "[{'string1': '15+72i', 'string2': '-30+-36i'}, {'string1': '53+-78i', 'string2': '86+50i'}, {'string1': '14+-95i', 'string2': '-10+1i'}, {'string1': '-77+69i', 'string2': '73+-41i'}, {'string1': '58+85i', 'string2': '80+-45i'}, {'string1': '-80+28i', 'string2': '74+18i'}, {'string1': '57+-63i', 'string2': '-73+6i'}, {'string1': '-61+-4i', 'string2': '28+-92i'}, {'string1': '91+-20i', 'string2': '-15+49i'}, {'string1': '-73+35i', 'string2': '-91+-84i'}]"
}
|
[
""
] |
{
"id": 155,
"canonical_solution": "",
"entry_point": "complex_product"
}
|
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция:
{function}
Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
|
{
"function": "def reach_number(number: int) -> str:\n \"\"\"Определите, можно ли из точки 0 координатной прямой попасть в точку number, если разрешается сделать любое количество действий. В одном действии разрешается прибавить к текущей координате номер действия иил вычесть его. Если да, выведите минимальное количество действий, необходимое для попадания в точку number из точки 0. Если нет, выведите -1.\n Примеры:\n reach_number(number=1) == 1\n reach_number(number=192) == 20\n \"\"\"",
"tests": "[{'number': 1}, {'number': 192}, {'number': 843}, {'number': 1230}, {'number': 49}, {'number': 8763}, {'number': 8}, {'number': 219}, {'number': 288}, {'number': 4979}]"
}
|
[
""
] |
{
"id": 156,
"canonical_solution": "",
"entry_point": "reach_number"
}
|
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции.
Функция:
{function}
Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
|
{
"function": "def words_only(string: str) -> str:\n \"\"\"Дана строка string, которая состоит из алфавитных, цифровых и пунктуационных символов. Удалите из строки все неалфавитные символы, сохранив изначальный порядок остальных символов, и выведите получившуюся строку.\n Примеры:\n words_only(string=е2хм77м5) == 'ехмм'\n words_only(string=яо8ота92и5) == 'яоотаи'\n \"\"\"",
"tests": "[{'string': 'е2хм77м5'}, {'string': 'яо8ота92и5'}, {'string': ''}, {'string': 'лу3ж050д5'}, {'string': 'ынт76ф40тщ2й'}, {'string': 'л37кцуа7цфсж0'}, {'string': '9рфъбт0афо7'}, {'string': 'лс6с2нна'}, {'string': '0зг96й992р'}, {'string': '123456789-='}]"
}
|
[
""
] |
{
"id": 157,
"canonical_solution": "",
"entry_point": "words_only"
}
|
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции:
{function}
Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
|
{
"function": "def break_palindrome(string: str) -> str:\n \"\"\"Дана строка string, которая содержит палиндром. Замените один символ в строке так, чтобы она перестала быть палиндромом и была минимальной из возможных в лексикографическом порядке. Если такой замены не существует, выведите пустую строку. Строка А лексикографически меньше строки В (той же длины), если в первой позиции слева, где А и В различаются, А имеет символ строго меньший (идет раньше в алфавите), чем соответствующий символ в В.\n Примеры:\n break_palindrome(string=атзттзта) == 'аазттзта'\n break_palindrome(string=цшшц) == 'ашшц'\n \"\"\"",
"tests": "[{'string': 'атзттзта'}, {'string': 'цшшц'}, {'string': ''}, {'string': 'туиддиут'}, {'string': 'хюввюх'}, {'string': 'ьпъъпь'}, {'string': 'ржщщжр'}, {'string': 'нщннщн'}, {'string': 'мпсааспм'}, {'string': 'а'}]"
}
|
[
""
] |
{
"id": 158,
"canonical_solution": "",
"entry_point": "break_palindrome"
}
|
Напиши продолжение данной функции:
{function}
Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
|
{
"function": "from typing import List\n\n\ndef matrix_difference(matrix: List[List[int]], number: int) -> int:\n \"\"\"Дана матрица целых чисел matrix и целое число number. Выберите из каждой строки матрицы по одному числу так, чтобы абсолютное значение разности суммы этих чисел и number была минимально возможным. Выведите значение получившейся абсолютной разности. Гарантируется, что matrix всегда имеет не менее 1 элемента.\n Примеры:\n matrix_difference(matrix=[[3, 3, 20, 49], [26, 17, 0, 10], [40, 4, 28, 48], [15, 5, 0, 27]], number=63) == 0\n matrix_difference(matrix=[[35, 19, 46, 34, 44], [21, 9, 33, 33, 44], [5, 35, 44, 36, 34], [25, 34, 49, 6, 19], [11, 47, 40, 26, 20]], number=40) == 10\n \"\"\"",
"tests": "[{'matrix': [[3, 3, 20, 49], [26, 17, 0, 10], [40, 4, 28, 48], [15, 5, 0, 27]], 'number': 63}, {'matrix': [[35, 19, 46, 34, 44], [21, 9, 33, 33, 44], [5, 35, 44, 36, 34], [25, 34, 49, 6, 19], [11, 47, 40, 26, 20]], 'number': 40}, {'matrix': [[7, 8, 16], [19, 30, 7], [30, 40, 45]], 'number': 30}, {'matrix': [[5, 45, 23, 15, 10, 22], [44, 2, 37, 12, 3, 6], [1, 5, 30, 46, 24, 17], [38, 38, 24, 9, 18, 4], [38, 15, 24, 34, 29, 42], [35, 25, 45, 17, 39, 31]], 'number': 13}, {'matrix': [[27, 45, 38, 39, 44], [40, 41, 26, 9, 18], [2, 3, 4, 18, 42], [22, 33, 42, 14, 37], [37, 14, 29, 27, 4]], 'number': 18}, {'matrix': [[26, 1, 20, 32], [34, 46, 8, 42], [25, 13, 2, 19], [10, 13, 40, 10]], 'number': 3}, {'matrix': [[6, 1, 15, 37, 36, 45], [33, 8, 14, 5, 2, 33], [21, 21, 13, 18, 32, 25], [23, 10, 18, 23, 42, 45], [23, 9, 6, 30, 29, 8], [49, 47, 19, 48, 43, 36]], 'number': 30}, {'matrix': [[6, 43, 43], [21, 28, 45], [41, 8, 38]], 'number': 7}, {'matrix': [[16, 10, 12, 8, 37, 11], [5, 41, 14, 6, 33, 11], [30, 3, 7, 47, 36, 37], [49, 37, 48, 31, 5, 9], [15, 48, 23, 15, 25, 19], [1, 15, 6, 36, 2, 1]], 'number': 49}, {'matrix': [[49, 0, 47, 47], [39, 22, 42, 0], [14, 33, 33, 36], [5, 16, 3, 31]], 'number': 68}]"
}
|
[
""
] |
{
"id": 159,
"canonical_solution": "",
"entry_point": "matrix_difference"
}
|
Реши задачу по программированию. Начало функции:
{function}
Продолжи функцию так, чтобы она корректно работала.
Ответ оформи по шаблону: ```python <code>```
|
{
"function": "from typing import List\n\n\ndef missing_binary(array: List[str]) -> str:\n \"\"\"Дан массив строк array, состоящий из двоичных чисел одинаковой длины. Определите двоичное число такой же длины, как числа в array, которого не хватает и выведите его в формате строки. Гарантируется, что ответ уникален.\n Примеры:\n missing_binary(array=['1']) == '0'\n missing_binary(array=['00', '10', '11']) == '01'\n \"\"\"",
"tests": "[{'array': ['1']}, {'array': ['0']}, {'array': ['00', '10', '11']}, {'array': ['00', '01', '11']}, {'array': ['000', '001', '010', '011', '101', '110', '111']}, {'array': ['0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1101', '1110', '1111']}, {'array': ['0000', '0001', '0010', '0011', '0100', '0101', '0110', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111']}, {'array': ['00000', '00001', '00010', '00011', '00100', '00110', '00111', '01000', '01001', '01010', '01011', '01100', '01101', '01110', '01111', '10000', '10001', '10010', '10011', '10100', '10101', '10110', '10111', '11000', '11001', '11010', '11011', '11100', '11101', '11110', '11111']}, {'array': ['000000', '000001', '000010', '000011', '000100', '000101', '000110', '000111', '001000', '001001', '001010', '001011', '001100', '001101', '001110', '001111', '010000', '010001', '010010', '010011', '010100', '010101', '010110', '010111', '011000', '011001', '011010', '011011', '011100', '011101', '011110', '011111', '100000', '100001', '100010', '100011', '100100', '100101', '100110', '100111', '101000', '101001', '101010', '101011', '101100', '101101', '101110', '101111', '110000', '110001', '110010', '110011', '110100', '110101', '110110', '110111', '111000', '111001', '111010', '111011', '111100', '111101', '111111']}, {'array': ['0000000', '0000001', '0000010', '0000011', '0000100', '0000101', '0000110', '0000111', '0001000', '0001001', '0001010', '0001011', '0001100', '0001101', '0001110', '0001111', '0010000', '0010001', '0010010', '0010011', '0010100', '0010101', '0010110', '0010111', '0011000', '0011001', '0011010', '0011011', '0011100', '0011101', '0011110', '0011111', '0100000', '0100001', '0100010', '0100011', '0100100', '0100101', '0100110', '0100111', '0101000', '0101001', '0101010', '0101011', '0101100', '0101101', '0101110', '0101111', '0110000', '0110001', '0110010', '0110011', '0110100', '0110101', '0110110', '0110111', '0111000', '0111001', '0111010', '0111011', '0111100', '0111101', '0111110', '0111111', '1000000', '1000001', '1000010', '1000011', '1000100', '1000101', '1000110', '1000111', '1001000', '1001001', '1001010', '1001011', '1001101', '1001110', '1001111', '1010000', '1010001', '1010010', '1010011', '1010100', '1010101', '1010110', '1010111', '1011000', '1011001', '1011010', '1011011', '1011100', '1011101', '1011110', '1011111', '1100000', '1100001', '1100010', '1100011', '1100100', '1100101', '1100110', '1100111', '1101000', '1101001', '1101010', '1101011', '1101100', '1101101', '1101110', '1101111', '1110000', '1110001', '1110010', '1110011', '1110100', '1110101', '1110110', '1110111', '1111000', '1111001', '1111010', '1111011', '1111100', '1111101', '1111110', '1111111']}]"
}
|
[
""
] |
{
"id": 160,
"canonical_solution": "",
"entry_point": "missing_binary"
}
|
Тебе дана заготовка под функцию на языке Python:
{function}
Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
|
{
"function": "def maximum_insert(number: int, string: str) -> str:\n \"\"\"Дана строка string, которая содержит целое число, а также цифра number. Вставьте цифру number на какую-либо позицию в строке string так, чтобы число в строке string стало максимально возможным. Запрещено вставлять number перед отрицательным знаком. Выведите полученную строку, удалив ведущие нули в числе, если они есть.\n Примеры:\n maximum_insert(number=5, string=10) == '510'\n maximum_insert(number=5, string=7909) == '79509'\n \"\"\"",
"tests": "[{'number': 5, 'string': '10'}, {'number': 5, 'string': '7909'}, {'number': 8, 'string': '4622'}, {'number': 2, 'string': '3149'}, {'number': 5, 'string': '-884'}, {'number': 9, 'string': '6657'}, {'number': 7, 'string': '5992'}, {'number': 4, 'string': '9241'}, {'number': 7, 'string': '-11'}, {'number': 0, 'string': '-1'}]"
}
|
[
""
] |
{
"id": 161,
"canonical_solution": "",
"entry_point": "maximum_insert"
}
|
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}
В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
|
{
"function": "def truncate_string(string: str) -> int:\n \"\"\"Дана строка string, в которой только 3 уникальных символа. Вам разрешается одновременно удалять символы из начала и конца строки при условии, что они одинаковы. Проведите все возможные удаления и выведите длину оставшейся строки.\n Примеры:\n truncate_string(string=аааааааааа) == 0\n truncate_string(string=абвабвабв) == 9\n \"\"\"",
"tests": "[{'string': 'аааааааааа'}, {'string': 'абвабвабв'}, {'string': 'аааагггг'}, {'string': 'даббадд'}, {'string': ''}, {'string': 'еже'}, {'string': 'келек'}, {'string': 'ахаххапхаха'}, {'string': 'узи'}, {'string': 'выпвыпвып'}]"
}
|
[
""
] |
{
"id": 162,
"canonical_solution": "",
"entry_point": "truncate_string"
}
|
{function}
Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
|
{
"function": "from typing import List\n\n\ndef absolute_difference(array: List[int]) -> List[int]:\n \"\"\"Дан список целых чисел array. Абсолютная разность числа и массива определяется, как сумма абсолютных значений разностей данного числа и всех элементов массива. Постройте и выведите новый список, в котором каждый элемент равен абсолютной разности элемента с тем же индексом в array и списка array.\n Примеры:\n absolute_difference(array=[51, -68, -92, -23, -56, 79, -40, 9, 36, -63]) == [-677, 275, 419, 143, 209, 209, -29, 167, 329, -463]\n absolute_difference(array=[-36, 62, -66, -51, -5, 34, 2, -67, -52, 41, 91, -9]) == [376, -604, 420, 330, 146, 68, 68, -70, -10, 548, 948, -52]\n \"\"\"",
"tests": "[{'array': [51, -68, -92, -23, -56, 79, -40, 9, 36, -63]}, {'array': [-36, 62, -66, -51, -5, 34, 2, -67, -52, 41, 91, -9]}, {'array': [86, -1, -61, 89, 50, -13, -77, 35, 41, -16]}, {'array': [16, 9, 57, 29, -15, 22, -59, 44, 40, 18, -21, -86]}, {'array': [-47, 74, -12, 17, 14, 4, 73, -26, -33, 60]}, {'array': [-2, -76, 68, 20, 84, 99, -29, 89, -73, 57, -77, -54]}, {'array': [-81, -44, -64, 24, 57, 76, -64, -26, 91, 96, 66, 84]}, {'array': [-52, 75, 22, -8, 89, 18, 62, -57, -62, 39, 2, -95]}, {'array': [19, 3, 3, -11, 10, 19, -69, -60, -90, 22, 74, -81, 98, -63]}, {'array': [-32, -73, -21, 81, 61, -15, -97, -43, -15, -71, 18, 18, -99, -4]}]"
}
|
[
""
] |
{
"id": 163,
"canonical_solution": "",
"entry_point": "absolute_difference"
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.