Dataset Viewer
Auto-converted to Parquet
instruction
stringclasses
10 values
inputs
dict
outputs
listlengths
1
1
meta
dict
Реши задачу по программированию. Начало функции: {function} Продолжи функцию так, чтобы она корректно работала. Ответ оформи по шаблону: ```python <code>```
{ "function": "def count_tens(number: int) -> int:\n \"\"\"Выведите число десятков в натуральном числе number.\n Примеры:\n count_tens(number=1) == 0\n count_tens(number=10) == 1\n \"\"\"", "tests": "[{'number': 1}, {'number': 10}, {'number': 23}, {'number': 123456}, {'number': 666}, {'number': 409}, {'number': 81}, {'number': 42587}, {'number': 987346}, {'number': 1987347}]" }
[ "" ]
{ "id": 0, "canonical_solution": "", "entry_point": "count_tens" }
Тебе дана заготовка под функцию на языке Python: {function} Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
{ "function": "def sum_digits(number: int) -> int:\n \"\"\"Выведите сумму цифр натурального числа number.\n Примеры:\n sum_digits(number=1) == 1\n sum_digits(number=10) == 1\n \"\"\"", "tests": "[{'number': 1}, {'number': 10}, {'number': 23}, {'number': 123456}, {'number': 666}, {'number': 409}, {'number': 81}, {'number': 42587}, {'number': 987346}, {'number': 1987347}]" }
[ "" ]
{ "id": 1, "canonical_solution": "", "entry_point": "sum_digits" }
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров. Функция: {function} В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
{ "function": "def clock_time(number: int) -> str:\n \"\"\"Выведите сколько времени покажут часы, запущенные в полночь, спустя number секунд. Используйте 24-часовую систему. Выведите ответ в формате: HH:MM:SS. Если минуты или секунды меньше 10, добавьте в начало 0.\n Примеры:\n clock_time(number=25446) == '7:04:06'\n clock_time(number=78799) == '21:53:19'\n \"\"\"", "tests": "[{'number': 25446}, {'number': 78799}, {'number': 53553}, {'number': 72451}, {'number': 82128}, {'number': 15544}, {'number': 99469}, {'number': 59489}, {'number': 37318}, {'number': 169}]" }
[ "" ]
{ "id": 2, "canonical_solution": "", "entry_point": "clock_time" }
{function} Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
{ "function": "def count_seconds(initial_time: str, final_time: str) -> int:\n \"\"\"Вычислите сколько секунд прошло между тем, когда часы показывали initial_time и final_time. Между данными временными точками может пройти не более одних суток.\n Примеры:\n count_seconds(initial_time=00:00:00, final_time=00:00:00) == 0\n count_seconds(initial_time=00:00:00, final_time=23:59:59) == 86399\n \"\"\"", "tests": "[{'initial_time': '00:00:00', 'final_time': '00:00:00'}, {'initial_time': '00:00:00', 'final_time': '23:59:59'}, {'initial_time': '3:09:37', 'final_time': '23:15:12'}, {'initial_time': '03:09:37', 'final_time': '23:15:12'}, {'initial_time': '4:19:34', 'final_time': '18:49:53'}, {'initial_time': '10:02:52', 'final_time': '10:28:17'}, {'initial_time': '7:28:13', 'final_time': '11:43:35'}, {'initial_time': '19:20:41', 'final_time': '22:22:42'}, {'initial_time': '09:45:40', 'final_time': '15:46:31'}, {'initial_time': '18:20:48', 'final_time': '18:20:48'}]" }
[ "" ]
{ "id": 3, "canonical_solution": "", "entry_point": "count_seconds" }
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами: {function} Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
{ "function": "def count_steps(required: int, forward_step: int, backward_step:int) -> int:\n \"\"\"Шкала прогресса за один шаг заполняется на forward_step процентов, а затем сразу убывает на backward_step процентов. Выведите, за сколько шагов на шкале прогресса будет достигнута отметка required процентов, если известно, что forward_step > backward_step.\n Примеры:\n count_steps(required=100, forward_step=6, backward_step=5) == 95\n count_steps(required=90, forward_step=20, backward_step=12) == 10\n \"\"\"", "tests": "[{'required': 100, 'forward_step': 6, 'backward_step': 5}, {'required': 90, 'forward_step': 20, 'backward_step': 12}, {'required': 85, 'forward_step': 5, 'backward_step': 1}, {'required': 80, 'forward_step': 53, 'backward_step': 52}, {'required': 70, 'forward_step': 9, 'backward_step': 8}, {'required': 60, 'forward_step': 50, 'backward_step': 7}, {'required': 50, 'forward_step': 22, 'backward_step': 6}, {'required': 25, 'forward_step': 11, 'backward_step': 5}, {'required': 10, 'forward_step': 13, 'backward_step': 2}, {'required': 5, 'forward_step': 2, 'backward_step': 1}]" }
[ "" ]
{ "id": 4, "canonical_solution": "", "entry_point": "count_steps" }
Решите задачу на Python. Функция: {function} Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
{ "function": "from typing import List\n\n\ndef same_quarter(coordinatesA: List[int], coordinatesB: List[int]) -> str:\n \"\"\"На основании списка координат coordinatesA первой точки и списка координат coordinatesB второй точки, определите, лежат ли они в одной четверти декартовой системы координат. Если лежат, выведите \"Да\", если не лежат - \"Нет\".\n Примеры:\n same_quarter(coordinatesA=[5, 2941], coordinatesB=[9391, 7]) == 'Да'\n same_quarter(coordinatesA=[7801, 99], coordinatesB=[65, -547]) == 'Нет'\n \"\"\"", "tests": "[{'coordinatesA': [5, 2941], 'coordinatesB': [9391, 7]}, {'coordinatesA': [7801, 99], 'coordinatesB': [65, -547]}, {'coordinatesA': [23, -1594], 'coordinatesB': [31, 1810]}, {'coordinatesA': [1361, -9115], 'coordinatesB': [3174, -2099]}, {'coordinatesA': [57, -450], 'coordinatesB': [-66, 2581]}, {'coordinatesA': [7278, -4977], 'coordinatesB': [-4955, -5038]}, {'coordinatesA': [-767, 6064], 'coordinatesB': [62, -36]}, {'coordinatesA': [-8678, 4798], 'coordinatesB': [-4602, 9514]}, {'coordinatesA': [-19, 11], 'coordinatesB': [-5209, -9375]}, {'coordinatesA': [-1141, -4], 'coordinatesB': [-4194, -1]}]" }
[ "" ]
{ "id": 5, "canonical_solution": "", "entry_point": "same_quarter" }
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция: {function} Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
{ "function": "def same_entrance(first_number: int, second_number: int) -> str:\n \"\"\"Определите, могут ли квартиры с номерами first_number и second_number быть первой и последней квартирой в одном подъезде дома? В доме больше одного подъезда, в каждом подъезде всегда одинаковое количество квартир. Нумерация квартир начинается с единицы. Если могут, выведите \"Да\", иначе – \"Нет\".\n Примеры:\n same_entrance(first_number=33, second_number=3) == 'Нет'\n same_entrance(first_number=25, second_number=2) == 'Нет'\n \"\"\"", "tests": "[{'first_number': 33, 'second_number': 3}, {'first_number': 25, 'second_number': 2}, {'first_number': 4, 'second_number': 6}, {'first_number': 253, 'second_number': 254}, {'first_number': 1, 'second_number': 2}, {'first_number': 255, 'second_number': 65535}, {'first_number': 54475474574, 'second_number': 9876342156547}, {'first_number': 144, 'second_number': 4}, {'first_number': 44, 'second_number': 44}, {'first_number': 45, 'second_number': 22}]" }
[ "" ]
{ "id": 6, "canonical_solution": "", "entry_point": "same_entrance" }
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции. Функция: {function} Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
{ "function": "def split_wood(length: int, width: int, number: int) -> str:\n \"\"\"Определите, можно ли отделить от шахматной доски размером length на width ровно number прямоугольников в одно действие. Отделять прямоугольники можно только по прямой линии (разрезать на две части по прямой). Например, нельзя разрезать квадраты шахматной доски по диагонали. Если да, выведите \"Да\", иначе – \"Нет\".\n Примеры:\n split_wood(length=3, width=3, number=2) == 'Нет'\n split_wood(length=50, width=1, number=3) == 'Да'\n \"\"\"", "tests": "[{'length': 3, 'width': 3, 'number': 2}, {'length': 50, 'width': 1, 'number': 3}, {'length': 1, 'width': 23, 'number': 1}, {'length': 33, 'width': 66, 'number': 222}, {'length': 22, 'width': 13, 'number': 3}, {'length': 2, 'width': 3, 'number': 5}, {'length': 2, 'width': 3, 'number': 2}, {'length': 3, 'width': 5, 'number': 7}, {'length': 2, 'width': 1, 'number': 5}, {'length': 3003, 'width': 505, 'number': 1010}]" }
[ "" ]
{ "id": 7, "canonical_solution": "", "entry_point": "split_wood" }
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции: {function} Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
{ "function": "def is_acute(lengthA: int, lengthB: int, lengthC: int) -> str:\n \"\"\"Определите на основании длин трех сторон треугольника: lengthA, lengthB, lengthC, является ли данный треугольник остроугольным. Треугольник является остроугольным, если сумма квадратов длин его двух сторон меньше квадрата третьей стороны для любой из сторон. Выведите \"Да\", если является, и \"Нет\", если не является.\n Примеры:\n is_acute(lengthA=3, lengthB=3, lengthC=2) == 'Да'\n is_acute(lengthA=50, lengthB=1, lengthC=3) == 'Нет'\n \"\"\"", "tests": "[{'lengthA': 3, 'lengthB': 3, 'lengthC': 2}, {'lengthA': 50, 'lengthB': 1, 'lengthC': 3}, {'lengthA': 1, 'lengthB': 23, 'lengthC': 1}, {'lengthA': 33, 'lengthB': 66, 'lengthC': 222}, {'lengthA': 22, 'lengthB': 20, 'lengthC': 12}, {'lengthA': 2, 'lengthB': 3, 'lengthC': 5}, {'lengthA': 2, 'lengthB': 3, 'lengthC': 2}, {'lengthA': 3, 'lengthB': 5, 'lengthC': 7}, {'lengthA': 10, 'lengthB': 6, 'lengthC': 9}, {'lengthA': 300, 'lengthB': 505, 'lengthC': 610}]" }
[ "" ]
{ "id": 8, "canonical_solution": "", "entry_point": "is_acute" }
Напиши продолжение данной функции: {function} Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
{ "function": "def place_inside(lengthA: int, widthA: int, heightA: int, lengthB: int, widthB: int, heightB: int) -> str:\n \"\"\"На основании длины lengthA, ширины widthA и высоты heightA первой коробки и длины lengthB, ширины widthB и высоты heightB второй коробки определите, можно ли поместить одну из данных коробок в другую. Поворачивать коробки можно только вокруг их ребер под прямыми углами. Если можно, выведите \"Да\", иначе – \"Нет\".\n Примеры:\n place_inside(lengthA=3, widthA=1, heightA=5, lengthB=88, widthB=1, heightB=4) == 'Да'\n place_inside(lengthA=3, widthA=5, heightA=7, lengthB=9, widthB=10, heightB=11) == 'Да'\n \"\"\"", "tests": "[{'lengthA': 3, 'widthA': 1, 'heightA': 5, 'lengthB': 88, 'widthB': 1, 'heightB': 4}, {'lengthA': 3, 'widthA': 5, 'heightA': 7, 'lengthB': 9, 'widthB': 10, 'heightB': 11}, {'lengthA': 0, 'widthA': 0, 'heightA': 0, 'lengthB': 8, 'widthB': 1, 'heightB': 40}, {'lengthA': 3, 'widthA': 2, 'heightA': 5, 'lengthB': 0, 'widthB': 0, 'heightB': 0}, {'lengthA': 20, 'widthA': 20, 'heightA': 20, 'lengthB': 20, 'widthB': 20, 'heightB': 20}, {'lengthA': 19, 'widthA': 20, 'heightA': 20, 'lengthB': 20, 'widthB': 19, 'heightB': 20}, {'lengthA': 190, 'widthA': 20, 'heightA': 200, 'lengthB': 200, 'widthB': 19, 'heightB': 200}, {'lengthA': 20, 'widthA': 20, 'heightA': 20, 'lengthB': 20, 'widthB': 20, 'heightB': 20}, {'lengthA': 2088888, 'widthA': 543987, 'heightA': 343765, 'lengthB': 765679, 'widthB': 5689589, 'heightB': 12358569}, {'lengthA': 136639, 'widthA': 546, 'heightA': 2357870987, 'lengthB': 1235654, 'widthB': 67989, 'heightB': 23345}]" }
[ "" ]
{ "id": 9, "canonical_solution": "", "entry_point": "place_inside" }
Реши задачу по программированию. Начало функции: {function} Продолжи функцию так, чтобы она корректно работала. Ответ оформи по шаблону: ```python <code>```
{ "function": "def factorization(number: int) -> str:\n \"\"\"Вам дано число number. Определите, можно ли его представить, как сумму некоторого количества троек и пятерок. Если можно, выведите \"Да\", иначе – \"Нет\".\n Примеры:\n factorization(number=1) == 'Нет'\n factorization(number=3) == 'Да'\n \"\"\"", "tests": "[{'number': 1}, {'number': 3}, {'number': 4}, {'number': 7}, {'number': 2}, {'number': 10}, {'number': 88}, {'number': 927}, {'number': 1453}, {'number': 9837246}]" }
[ "" ]
{ "id": 10, "canonical_solution": "", "entry_point": "factorization" }
Тебе дана заготовка под функцию на языке Python: {function} Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
{ "function": "def solve_equation(A: float, B: float, C: float, D: float) -> int:\n \"\"\"На основании коэффициентов A, B, C, D определите, имеет ли решения уравнение (Ax + B) / (Cx + D) = 0. Если у уравнения есть хотя бы одно решение, выведите \"1\". Если ни одного решения, выведите \"0\".\n Примеры:\n solve_equation(A=3, B=-3, C=2, D=500) == 1\n solve_equation(A=30, B=-3, C=2, D=-2) == 0\n \"\"\"", "tests": "[{'A': 3, 'B': -3, 'C': 2, 'D': 500}, {'A': 30, 'B': -3, 'C': 2, 'D': -2}, {'A': 300000.0, 'B': 5000.0, 'C': 15000.0, 'D': 25}, {'A': 0, 'B': 0, 'C': 2, 'D': -2}, {'A': 300000.0, 'B': 5000.0, 'C': 15000.0, 'D': 25}, {'A': 0, 'B': 0, 'C': 0, 'D': 0}, {'A': 12, 'B': 6, 'C': 4, 'D': 2}, {'A': 100, 'B': -4, 'C': 9, 'D': -200}, {'A': 1, 'B': 8, 'C': 9, 'D': 5}, {'A': -3, 'B': 300, 'C': -20, 'D': 0.5}]" }
[ "" ]
{ "id": 11, "canonical_solution": "", "entry_point": "solve_equation" }
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров. Функция: {function} В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
{ "function": "def sum_squares(number: int) -> int:\n \"\"\"Дано натуральное число number. Выведите сумму квадратов всех натуральных чисел до number включительно. Гарантируется, что number не превосходит 100.\n Примеры:\n sum_squares(number=66) == 98021\n sum_squares(number=58) == 66729\n \"\"\"", "tests": "[{'number': 66}, {'number': 58}, {'number': 30}, {'number': 8}, {'number': 17}, {'number': 2}, {'number': 88}, {'number': 5}, {'number': 51}, {'number': 6}]" }
[ "" ]
{ "id": 12, "canonical_solution": "", "entry_point": "sum_squares" }
{function} Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
{ "function": "def least_divider(number: int) -> int:\n \"\"\"Выведите наименьший не равный 1 натуральный делитель числа number.\n Примеры:\n least_divider(number=933) == 3\n least_divider(number=846) == 2\n \"\"\"", "tests": "[{'number': 933}, {'number': 846}, {'number': 302}, {'number': 761}, {'number': 666}, {'number': 352}, {'number': 40}, {'number': 158}, {'number': 473}, {'number': 503}]" }
[ "" ]
{ "id": 13, "canonical_solution": "", "entry_point": "least_divider" }
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами: {function} Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
{ "function": "def closest_degree(number: int) -> int:\n \"\"\"Выведите наименьшее возможное число такое, что 2 в степени данного числа не меньше числа number. Гарантируется, что number не превосходит 1000000.\n Примеры:\n closest_degree(number=2) == 1\n closest_degree(number=28) == 5\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 387}, {'number': 1234}, {'number': 3568}, {'number': 876543}, {'number': 13}, {'number': 927}, {'number': 1453}, {'number': 98376}]" }
[ "" ]
{ "id": 14, "canonical_solution": "", "entry_point": "closest_degree" }
Решите задачу на Python. Функция: {function} Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
{ "function": "from typing import List\n\n\ndef second_maximum(array: List[int]) -> int:\n \"\"\"Выведите значение второго по величине максимума в списке array. Гарантируется, что array содержит не менее двух элементов.\n Примеры:\n second_maximum(array=[-96, -97, -27, -30, 93]) == -27\n second_maximum(array=[-77, 67, 19, -71, 93, -50, -100, -77, 3, 51]) == 67\n \"\"\"", "tests": "[{'array': [-96, -97, -27, -30, 93]}, {'array': [-77, 67, 19, -71, 93, -50, -100, -77, 3, 51]}, {'array': [29, -78, 73, -25, -18, -15, -4, 71, -48, 89, 95]}, {'array': [-40, 46, -55, -98, 81, 92, 44, 16, 30]}, {'array': [78, 45, -49, -84, 46, -28, 76, -98, -14, 44, 83, 57, 39]}, {'array': [18, 90, -37, 28, 20, -17, -96, 83, -47, 22]}, {'array': [59, -22, -78, 32, 33, 94, -70, -50]}, {'array': [-32, -11, 5, 23, 61, 55, -5, -60, -29]}, {'array': [30, 87, -32, 53, -29, -70, -38, -46, -98, -39]}, {'array': [6, -75, 66, -52, -77, 5, 93, -39, -3, 74]}]" }
[ "" ]
{ "id": 15, "canonical_solution": "", "entry_point": "second_maximum" }
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция: {function} Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
{ "function": "from typing import List\n\n\ndef max_equal_subseq(array: List[int]) -> int:\n \"\"\"Выведите длину наибольшей подряд идущей подпоследовательности из одинаковых чисел в последовательности array.\n Примеры:\n max_equal_subseq(array=[1, 5, 9, 7, 2, 6, 1, 2, 4, 9, 1]) == 1\n max_equal_subseq(array=[2, 7, 7, 7, 3, 7, 5, 2, 1, 3]) == 3\n \"\"\"", "tests": "[{'array': [1, 5, 9, 7, 2, 6, 1, 2, 4, 9, 1]}, {'array': [2, 7, 7, 7, 3, 7, 5, 2, 1, 3]}, {'array': [7, 2, 7, 9, 5, 1, 4]}, {'array': [4, 2, 1, 6, 2, 7, 1, 2]}, {'array': [6, 6, 1, 3, 7, 2, 1, 7, 3, 5, 8, 2]}, {'array': [4, 1, 3, 4, 9, 1, 6, 2, 1, 4]}, {'array': [9, 6, 1, 5, 1, 2, 9]}, {'array': [1, 2, 5, 1, 4, 5, 6, 1, 6, 4, 5, 7, 4]}, {'array': [4, 2, 5, 7, 5, 2, 1, 6, 6, 7, 1, 6, 7, 4]}, {'array': [1, 7, 3, 4, 4, 9, 2]}]" }
[ "" ]
{ "id": 16, "canonical_solution": "", "entry_point": "max_equal_subseq" }
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции. Функция: {function} Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
{ "function": "def sum_inverse_squares(number: int) -> float:\n \"\"\"Выведите сумму ряда обратных квадратов от 1 до числа number включительно (гарантируется, что number не превосходит 100). Ряд обратных квадратов – это последовательность чисел, каждое из которых представлено в виде (1/x) в квадрате. Округлите ответ до 2 знаков после запятой.\n Примеры:\n sum_inverse_squares(number=1) == 1.0\n sum_inverse_squares(number=2) == 1.25\n \"\"\"", "tests": "[{'number': 1}, {'number': 2}, {'number': 3}, {'number': 4}, {'number': 5}, {'number': 6}, {'number': 7}, {'number': 8}, {'number': 9}, {'number': 10}]" }
[ "" ]
{ "id": 17, "canonical_solution": "", "entry_point": "sum_inverse_squares" }
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции: {function} Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
{ "function": "def number_words(string: str) -> int:\n \"\"\"Выведите количество слов в строке string. Словом считаются любые последовательности символов, которые отделены друг от друга пробелами.\n Примеры:\n number_words(string=Аппетит приходит во время еды) == 5\n number_words(string=Бедность не порок) == 3\n \"\"\"", "tests": "[{'string': 'Аппетит приходит во время еды'}, {'string': 'Бедность не порок'}, {'string': 'Без труда не выловишь и рыбку из пруда'}, {'string': 'Бесплатный сыр, бывает- только в мышеловке'}, {'string': 'Бог шельму= метит'}, {'string': 'В здоровом теле – здоровый дух'}, {'string': 'Волков бояться – в лес не ходить'}, {'string': 'Глаза боятся, а руки делают'}, {'string': 'Готовь сани летом, а телегу зимой'}, {'string': 'Дарёному коню в зубы не смотрят'}]" }
[ "" ]
{ "id": 18, "canonical_solution": "", "entry_point": "number_words" }
Напиши продолжение данной функции: {function} Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
{ "function": "def swap_words(string: str) -> str:\n \"\"\"В строке string из двух слов, разделенных пробелом, поменяйте местами слова и выведите получившуюся строку. Гарантируется, что string всегда содержит ровно два слова, разделенных пробелом.\n Примеры:\n swap_words(string=Аппетит приходиты) == 'приходиты Аппетит'\n swap_words(string=Бедность не) == 'не Бедность'\n \"\"\"", "tests": "[{'string': 'Аппетит приходиты'}, {'string': 'Бедность не'}, {'string': 'Без труда'}, {'string': 'Бесплатный сыр,'}, {'string': 'Бог шельму='}, {'string': 'В здоровом'}, {'string': 'Волков бояться'}, {'string': 'Глаза боятся,'}, {'string': 'Готовь сани'}, {'string': 'Дарёному коню'}]" }
[ "" ]
{ "id": 19, "canonical_solution": "", "entry_point": "swap_words" }
Реши задачу по программированию. Начало функции: {function} Продолжи функцию так, чтобы она корректно работала. Ответ оформи по шаблону: ```python <code>```
{ "function": "def second_index(string: str, symbol: str) -> int:\n \"\"\"Выведите индекс второго вхождения символа symbol в строке string. Если второго вхождения нет, а также если строка string не содержит символ symbol, выведите число 0.\n Примеры:\n second_index(string=wxapqc, symbol=a) == 0\n second_index(string=wetzjoqbzy, symbol=x) == 0\n \"\"\"", "tests": "[{'string': 'wxapqc', 'symbol': 'a'}, {'string': 'wetzjoqbzy', 'symbol': 'x'}, {'string': 'ptejfoqxrgnhllyfblh', 'symbol': 'l'}, {'string': 'ayobteexn', 'symbol': 'e'}, {'string': 'swgbefreqscaiwtzxm', 'symbol': 'w'}, {'string': 'dfhto', 'symbol': 'n'}, {'string': 'wjf', 'symbol': 'w'}, {'string': 'wetzsmlnlsiaqzjoqbzy', 'symbol': 'l'}, {'string': 'slgyafufrlifznesy', 'symbol': 'f'}, {'string': 'ohnipkzzyaawkhln', 'symbol': 'z'}]" }
[ "" ]
{ "id": 20, "canonical_solution": "", "entry_point": "second_index" }
Тебе дана заготовка под функцию на языке Python: {function} Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
{ "function": "def quadratic_equation(A: int, B: int, C: int) -> str:\n \"\"\"Даны коэффициенты квадратного трехчлена: A, B, C. Коэффициенты всегда являются целыми числами. Определите, есть ли у квадратного уравнения Ax ** 2 + Bx + C = 0 хотя бы одно решение. Если есть, выведите \"Да\", иначе выведите \"Нет\".\n Примеры:\n quadratic_equation(A=3, B=-3, C=2) == 'Нет'\n quadratic_equation(A=0, B=-1, C=3) == 'Да'\n \"\"\"", "tests": "[{'A': 3, 'B': -3, 'C': 2}, {'A': 0, 'B': -1, 'C': 3}, {'A': 1, 'B': 0, 'C': 1}, {'A': -33, 'B': 66, 'C': 222}, {'A': 22, 'B': 13, 'C': 3}, {'A': 2, 'B': 3, 'C': 5}, {'A': -3, 'B': -3, 'C': 1}, {'A': 3, 'B': 5, 'C': 7}, {'A': -2, 'B': -1, 'C': -5}, {'A': -3003, 'B': 505, 'C': 222}]" }
[ "" ]
{ "id": 21, "canonical_solution": "", "entry_point": "quadratic_equation" }
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров. Функция: {function} В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
{ "function": "def solve_system(A: int, B: int, C: int, D: int, E: int, F: int) -> str:\n \"\"\"По данным коэффициентам A, B, C, D, E, F определите, имеет ли решения система из двух линейных уравнений: (1) Ax + By = E, (2) Cx + Dy = F. Коэффициенты всегда являются целыми числами. Если система с данными значениями коэффициентов имеет решения, выведите \"Да\", иначе выведите \"Нет\".\n Примеры:\n solve_system(A=3, B=-3, C=0, D=0, E=0, F=2000) == 'Нет'\n solve_system(A=0, B=-1, C=3, D=2, E=12, F=2) == 'Да'\n \"\"\"", "tests": "[{'A': 3, 'B': -3, 'C': 0, 'D': 0, 'E': 0, 'F': 2000}, {'A': 0, 'B': -1, 'C': 3, 'D': 2, 'E': 12, 'F': 2}, {'A': 1, 'B': 20, 'C': 20, 'D': 400, 'E': 1, 'F': 404}, {'A': -33, 'B': 66, 'C': 222, 'D': 1000, 'E': 99, 'F': 1001}, {'A': 0, 'B': 0, 'C': 3, 'D': 15000, 'E': 88, 'F': 20000}, {'A': 2, 'B': 3, 'C': 5, 'D': 1, 'E': 98, 'F': 2}, {'A': -3, 'B': -3, 'C': 1, 'D': 200, 'E': 55, 'F': 300}, {'A': 3, 'B': 5, 'C': 7, 'D': 1000, 'E': 99, 'F': 1001}, {'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'F': 0}, {'A': -3003, 'B': 505, 'C': 222, 'D': 30, 'E': 60, 'F': 199}]" }
[ "" ]
{ "id": 22, "canonical_solution": "", "entry_point": "solve_system" }
{function} Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
{ "function": "def sparse_string(string: str, symbol: str) -> str:\n \"\"\"Выведите исходную строку string, вставив между всеми ее символами специальный символ symbol.\n Примеры:\n sparse_string(string=ddd, symbol=) == 'ddd'\n sparse_string(string=Мало теН половин , symbol= ) == 'М а л о т е Н п о л о в и н '\n \"\"\"", "tests": "[{'string': 'ddd', 'symbol': ''}, {'string': 'Мало теН половин ', 'symbol': ' '}, {'string': 'Мал0половин', 'symbol': '\\xa0'}, {'string': '\\nНет\\t', 'symbol': '\\r'}, {'string': 'Аргентина манит, кого бы вы думали?', 'symbol': '🙏'}, {'string': 'Добро поржаловать `\\xa0в\\xa0` Жи', 'symbol': '\\xa0'}, {'string': 'Вот это поворот!', 'symbol': '*'}, {'string': 'Следи за cобой будь оcторожен', 'symbol': '|'}, {'string': 'Мёрзни-мёрзни, волчий хвост!', 'symbol': '\\u200b'}, {'string': '\"И городу дорог огород у дороги\"', 'symbol': '\"'}]" }
[ "" ]
{ "id": 23, "canonical_solution": "", "entry_point": "sparse_string" }
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами: {function} Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
{ "function": "from typing import List\n\n\ndef select_squares(array: List[int]) -> List[int]:\n \"\"\"Выберите из массива array все квадраты целых чисел и выведите их в том порядке, в котором они указаны в массиве. Гарантируется, что array не пуст. Если в array нет ни одного подходящего под условие числа, выведите пустой список.\n Примеры:\n select_squares(array=[10, 36, 21, 80, 93, 4]) == [36, 4]\n select_squares(array=[35, 18, 4, 15, 62, 72]) == [4]\n \"\"\"", "tests": "[{'array': [10, 36, 21, 80, 93, 4]}, {'array': [35, 18, 4, 15, 62, 72]}, {'array': [37, 43, 32, 84, 38, 38, 67, 28, 50, 25]}, {'array': [23, 49, 42, 92, 38, 4, 34, 97, 71, 10, 63, 19, 63]}, {'array': [53, 39, 16, 98, 13, 7, 64, 88, 96, 73, 29, 81]}, {'array': [85, 78, 42, 38, 42, 40, 85, 51, 13, 92]}, {'array': [38, 45, 66, 10, 80, 52, 70, 93, 12, 52]}, {'array': [72, 12, 59, 31, 84, 38, 20, 97, 23, 46, 3, 32, 85, 99]}, {'array': [24, 55, 87, 47, 43, 55, 20, 31]}, {'array': [73, 78, 35, 23, 8, 89, 94, 22]}]" }
[ "" ]
{ "id": 24, "canonical_solution": "", "entry_point": "select_squares" }
Решите задачу на Python. Функция: {function} Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
{ "function": "from typing import List\n\n\ndef count_zeros(array: List[int]) -> int:\n \"\"\"В массиве array посчитайте количество нулей и выведите его.\n Примеры:\n count_zeros(array=[3, 5, 2, 2, 7, 5]) == 0\n count_zeros(array=[3, 0, 4, 2, 8, 4, 0]) == 2\n \"\"\"", "tests": "[{'array': [3, 5, 2, 2, 7, 5]}, {'array': [3, 0, 4, 2, 8, 4, 0]}, {'array': [4, 8, 4, 0, 3, 5, 0, 6, 1, 8, 7, 9]}, {'array': [5, 3, 3, 8, 7, 2, 2, 0, 8, 0, 3]}, {'array': [8, 8, 4, 0, 2, 0, 9, 2, 6, 7, 8, 7, 9]}, {'array': [2, 0, 8, 2, 8, 9, 5, 3]}, {'array': [2, 6, 9, 8, 4, 7, 6, 0, 0, 3, 6, 0, 7]}, {'array': [4, 3, 6, 9, 4, 0, 4, 5, 4, 3, 7, 9, 6, 2]}, {'array': [4, 3, 6, 6, 0, 9, 0, 6, 8, 0, 0]}, {'array': [3, 1, 6, 7, 5, 8, 4, 7, 5, 0, 5, 6, 0, 2]}]" }
[ "" ]
{ "id": 25, "canonical_solution": "", "entry_point": "count_zeros" }
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция: {function} Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
{ "function": "def count_palindromes(first_number: int, last_number: int) -> int:\n \"\"\"Выведите, сколько чисел между четырёхзначными числами first_number и last_number, включая их, являются палиндромами. Отрицательные числа не считаются палиндромами.\n Примеры:\n count_palindromes(first_number=3003, last_number=6006) == 31\n count_palindromes(first_number=2500, last_number=2508) == -1\n \"\"\"", "tests": "[{'first_number': 3003, 'last_number': 6006}, {'first_number': 2500, 'last_number': 2508}, {'first_number': -4708, 'last_number': 6006}, {'first_number': 2537, 'last_number': 2547}, {'first_number': 1000, 'last_number': 2000}, {'first_number': 2555, 'last_number': 6553}, {'first_number': 5447, 'last_number': 5574}, {'first_number': 1440, 'last_number': 4444}, {'first_number': -4444, 'last_number': 4444}, {'first_number': 4553, 'last_number': 2002}]" }
[ "" ]
{ "id": 26, "canonical_solution": "", "entry_point": "count_palindromes" }
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции. Функция: {function} Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
{ "function": "from typing import List\n\n\ndef odd_maximum(array: List[int]) -> int:\n \"\"\"Среди всех чисел в списке array найдите наибольшее нечетное число и выведите его. Если такого числа нет, выведите \"-1\".\n Примеры:\n odd_maximum(array=[87, 11, 74, 33, 94, 52]) == 87\n odd_maximum(array=[17, 7, 78, 36, 64]) == 17\n \"\"\"", "tests": "[{'array': [87, 11, 74, 33, 94, 52]}, {'array': [17, 7, 78, 36, 64]}, {'array': [11, 92, 67, 47, 34, 77, 42, 49, 17, 13, 89, 2, 27]}, {'array': [33, 34, 36, 1, 67, 32, 72, 95, 1, 43, 52, 42]}, {'array': [24, 64, 60, 46, 62]}, {'array': [72, 7, 62, 5, 90, 13, 12, 92, 32]}, {'array': [53, 43, 69, 88, 22]}, {'array': [30, 50, 41, 44, 55, 22, 39, 43, 44, 84, 51]}, {'array': [39, 29, 70, 5, 93, 1, 2]}, {'array': [85, 11, 89, 83, 15, 68, 53, 90, 26]}]" }
[ "" ]
{ "id": 27, "canonical_solution": "", "entry_point": "odd_maximum" }
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции: {function} Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
{ "function": "from typing import List\n\n\ndef count_pairs(array: List[int]) -> int:\n \"\"\"Сколько в массиве array пар одинаковых элементов? Любые два одинаковых по значению элемента array с разными индексами образуют пару, каждый элемент может входить только в одну пару. Выведите количество пар.\n Примеры:\n count_pairs(array=[1, 5, 5, 6, 3, 2, 3, 9, 6, 3, 8, 6, 3, 9]) == 11\n count_pairs(array=[7, 6, 6, 2, 1, 7, 8, 8, 3, 6]) == 5\n \"\"\"", "tests": "[{'array': [1, 5, 5, 6, 3, 2, 3, 9, 6, 3, 8, 6, 3, 9]}, {'array': [7, 6, 6, 2, 1, 7, 8, 8, 3, 6]}, {'array': [4, 1, 1, 7, 8]}, {'array': [5, 6, 8, 3, 7, 3, 4, 7, 3]}, {'array': [9, 8, 2, 3, 7, 8, 7]}, {'array': [2, 7, 0, 8, 1, 7, 4, 8]}, {'array': [6, 4, 2, 6, 9, 7, 5, 5, 5, 8, 0, 8, 0, 3]}, {'array': [1, 2, 4, 5, 3, 2, 1, 1, 0, 9, 3, 6, 8, 9]}, {'array': [3, 5, 0, 9, 7, 0, 8, 2, 0, 1, 6, 8, 2]}, {'array': [4, 7, 2, 3, 4, 4, 9, 8, 1, 7, 7]}]" }
[ "" ]
{ "id": 28, "canonical_solution": "", "entry_point": "count_pairs" }
Напиши продолжение данной функции: {function} Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
{ "function": "from typing import List\n\n\ndef squeeze_array(array: List[int]) -> List[int]:\n \"\"\"Переместите все элементы массива array со значением 0 в конец списка, сохранив порядок всех остальных элементов. Выведите полученный список.\n Примеры:\n squeeze_array(array=[]) == []\n squeeze_array(array=[3, 2, 3, 2, 3, 1]) == [3, 2, 3, 2, 3, 1]\n \"\"\"", "tests": "[{'array': []}, {'array': [3, 2, 3, 2, 3, 1]}, {'array': [1, 1, 4, 2, 4]}, {'array': [2, 0, 3, 3, 1, 0, 4, 2, 0]}, {'array': [3, 2, 4, 0, 3, 0, 1, 3, 2, 1, 4, 1, 4]}, {'array': [3, 2, 3, 4, 0, 0, 1, 3, 2]}, {'array': [3, 1, 1, 1, 3]}, {'array': [0, 1, 1, 0, 0, 0, 4, 4]}, {'array': [2, 0, 0, 2, 3, 1, 2, 0, 1]}, {'array': [1, 0, 4, 2, 4, 1, 3, 3, 2, 0]}]" }
[ "" ]
{ "id": 29, "canonical_solution": "", "entry_point": "squeeze_array" }
Реши задачу по программированию. Начало функции: {function} Продолжи функцию так, чтобы она корректно работала. Ответ оформи по шаблону: ```python <code>```
{ "function": "from typing import List\n\n\ndef max_product(array: List[int]) -> int:\n \"\"\"В массиве array найдите три числа, которые дают наибольшее произведение и выведите значение данного произведения. Гарантируется, что array содержит не меньше 3 элементов.\n Примеры:\n max_product(array=[-11, -2, 2, -8, 2, -3, 19, 14, -9, -4, 14]) == 3724\n max_product(array=[18, 16, -1, 9, -16, -6, -4, -1, 17, 18, -7, -16, -14, 6]) == 5508\n \"\"\"", "tests": "[{'array': [-11, -2, 2, -8, 2, -3, 19, 14, -9, -4, 14]}, {'array': [18, 16, -1, 9, -16, -6, -4, -1, 17, 18, -7, -16, -14, 6]}, {'array': [17, 3, 0]}, {'array': [-8, 7, -20, 6, 8, -19, -16, -19, -8, -14, -16]}, {'array': [-15, 10, -5, 17, -7, -20, -12, 3, -18, -7, 10, -15]}, {'array': [-9, 4, 4, 5, 12, 0, -14, -18, -16, 7]}, {'array': [18, -1, 14, 0, 4, -19]}, {'array': [19, 7, 9, 6, -7, -9, 18, 9, -11, -5, 12]}, {'array': [13, -5, 8, 15, -4, 10, 4, 3]}, {'array': [1, 4, -1, -9, 5, 13, -13, 16, -16, -20]}]" }
[ "" ]
{ "id": 30, "canonical_solution": "", "entry_point": "max_product" }
Тебе дана заготовка под функцию на языке Python: {function} Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
{ "function": "from typing import List\n\n\ndef array_xor(arrayA: List[int], arrayB: List[int]) -> List[int]:\n \"\"\"Выполните поэлементное сложение по модулю два двух непустых массивов одинаковой длины из нулей и единиц: arrayA и arrayB. В сложении по модулю два ноль получается из пар (0, 0) и (1, 1). В остальных случаях получается единица. Выведите получившийся массив.\n Примеры:\n array_xor(arrayA=[1, 1, 1, 0, 1, 1, 1, 1], arrayB=[1, 1, 0, 0, 1, 0, 0, 0]) == [0, 0, 1, 0, 0, 1, 1, 1]\n array_xor(arrayA=[0, 0, 1, 0, 1, 1, 1], arrayB=[1, 1, 0, 0, 1, 1, 1]) == [1, 1, 1, 0, 0, 0, 0]\n \"\"\"", "tests": "[{'arrayA': [1, 1, 1, 0, 1, 1, 1, 1], 'arrayB': [1, 1, 0, 0, 1, 0, 0, 0]}, {'arrayA': [0, 0, 1, 0, 1, 1, 1], 'arrayB': [1, 1, 0, 0, 1, 1, 1]}, {'arrayA': [0, 1, 0], 'arrayB': [0, 1, 0]}, {'arrayA': [0, 0], 'arrayB': [0, 1]}, {'arrayA': [0, 0, 1, 1, 1, 0, 1, 1, 0], 'arrayB': [1, 1, 1, 0, 1, 0, 0, 0, 0]}, {'arrayA': [0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0], 'arrayB': [0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1]}, {'arrayA': [0, 1], 'arrayB': [0, 1]}, {'arrayA': [1, 0, 0, 0, 1, 1, 0, 1], 'arrayB': [1, 0, 0, 1, 0, 1, 1, 1]}, {'arrayA': [1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1], 'arrayB': [0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0]}, {'arrayA': [0, 1, 1, 0, 1], 'arrayB': [0, 1, 0, 1, 0]}]" }
[ "" ]
{ "id": 31, "canonical_solution": "", "entry_point": "array_xor" }
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров. Функция: {function} В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
{ "function": "def dirichlet_rabbits(num_cages: int, num_rabbits: int) -> int:\n \"\"\"Если есть num_cages клеток для кроликов, по которым рассадили num_rabbits кроликов, то какое наибольшее количество кроликов может оказаться в одной клетке? Кролики рассаживаются по клеткам равномерно. Это значит, что можно сажать кролика только в клетку, в которой меньше всего кроликов. Выведите получившееся число.\n Примеры:\n dirichlet_rabbits(num_cages=33, num_rabbits=3) == 1\n dirichlet_rabbits(num_cages=25, num_rabbits=2) == 1\n \"\"\"", "tests": "[{'num_cages': 33, 'num_rabbits': 3}, {'num_cages': 25, 'num_rabbits': 2}, {'num_cages': 4, 'num_rabbits': 6}, {'num_cages': 253, 'num_rabbits': 254}, {'num_cages': 1, 'num_rabbits': 0}, {'num_cages': 255, 'num_rabbits': 65535}, {'num_cages': 54475474574, 'num_rabbits': 9876342156547}, {'num_cages': 44, 'num_rabbits': 144}, {'num_cages': 22, 'num_rabbits': 44}, {'num_cages': 22, 'num_rabbits': 45}]" }
[ "" ]
{ "id": 32, "canonical_solution": "", "entry_point": "dirichlet_rabbits" }
{function} Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
{ "function": "def fibonacci_strings(number: int) -> str:\n \"\"\"Вам дано положительное число number, которому соответствует строка. Выведите ее. Строки для числа строятся следующим образом: если number равен 1, то строка равна \"a\", если number равен 2, то строка равна \"b\", а для всех number больше 2 строка является конкатенацией строк с номерами (number - 2) и (number - 1). Гарантируется, что number не превосходит 10.\n Примеры:\n fibonacci_strings(number=1) == 'a'\n fibonacci_strings(number=2) == 'b'\n \"\"\"", "tests": "[{'number': 1}, {'number': 2}, {'number': 3}, {'number': 4}, {'number': 5}, {'number': 6}, {'number': 7}, {'number': 8}, {'number': 9}, {'number': 10}]" }
[ "" ]
{ "id": 33, "canonical_solution": "", "entry_point": "fibonacci_strings" }
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами: {function} Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
{ "function": "def vendor_change(X: int, Y: int, Z: int, T: int) -> int:\n \"\"\"Если товар стоит X рублей и Y копеек, а покупатель заплатил продавцу Z рублей и T копеек, то сколько копеек должна составить сдача? Гарантируется, что покупатель заплатил не более 100 рублей за товар. Выведите получившееся число.\n Примеры:\n vendor_change(X=3, Y=-3, Z=2, T=500) == 403\n vendor_change(X=300, Y=0, Z=2000, T=5) == 170005\n \"\"\"", "tests": "[{'X': 3, 'Y': -3, 'Z': 2, 'T': 500}, {'X': 300, 'Y': 0, 'Z': 2000, 'T': 5}, {'X': 30, 'Y': 60, 'Z': 199, 'T': 10}, {'X': 2, 'Y': 12, 'Z': 2, 'T': 12}, {'X': 200, 'Y': 55, 'Z': 300, 'T': 55}, {'X': 1000, 'Y': 99, 'Z': 1001, 'T': 98}, {'X': 1, 'Y': 98, 'Z': 2, 'T': 0}, {'X': 400, 'Y': 1, 'Z': 404, 'T': 66}, {'X': 15000, 'Y': 88, 'Z': 20000, 'T': 0}, {'X': 202000, 'Y': 33, 'Z': 202000, 'T': 44}]" }
[ "" ]
{ "id": 34, "canonical_solution": "", "entry_point": "vendor_change" }
Решите задачу на Python. Функция: {function} Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
{ "function": "def extract_string(string: str, symbol: str) -> str:\n \"\"\"Разверните в обратном порядке подстроку строки string, которая заключена между первым и последним вхождениями символа symbol в string. Остальные символы оригинальной строки должны остаться на своих изначальных местах. Если symbol встречается в string 1 или 0 раз, то выведите \"Нет\".\n Примеры:\n extract_string(string=, symbol=) == 'Нет'\n extract_string(string=Мало теН половин , symbol= ) == 'Мало ниволоп Нет '\n \"\"\"", "tests": "[{'string': '', 'symbol': ''}, {'string': 'Мало теН половин ', 'symbol': ' '}, {'string': 'Мало теН половин', 'symbol': ' '}, {'string': '\\rтеН\\r', 'symbol': '\\r'}, {'string': '🙏аргентинаманит🙏 кого бы вы думали?', 'symbol': '🙏'}, {'string': 'Добро поржаловать `\\xa0в\\xa0` Жи', 'symbol': '\\xa0'}, {'string': 'Вот это поворот!', 'symbol': '\\xa0'}, {'string': 'Следи за cобой будь оcторожен', 'symbol': 'c'}, {'string': 'Мёрзни-\\u200bмёрзни, волчий хвост!', 'symbol': ','}, {'string': '\"И городу дорог огород у дороги\"', 'symbol': '\"'}]" }
[ "" ]
{ "id": 35, "canonical_solution": "", "entry_point": "extract_string" }
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция: {function} Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
{ "function": "from typing import List\n\n\ndef count_combinations(array: List[int]) -> int:\n \"\"\"Вам дан массив array из длин отрезков. Сколько есть способов выбрать из данного массива три элемента, из которых получится невырожденный треугольник? Невырожденным является треугольник, у которого всегда одна сторона меньше суммы двух других. Гарантируется, что массив array содержит от 3 до 20 чисел. Выведите получившееся число.\n Примеры:\n count_combinations(array=[5, 4, 1, 5, 1, 6, 4, 9, 6, 6, 8]) == 88\n count_combinations(array=[1, 1, 6, 6, 7, 3]) == 6\n \"\"\"", "tests": "[{'array': [5, 4, 1, 5, 1, 6, 4, 9, 6, 6, 8]}, {'array': [1, 1, 6, 6, 7, 3]}, {'array': [6, 2, 2, 9, 7, 8, 6, 7, 4, 5, 7]}, {'array': [5, 7, 3, 4, 3, 7]}, {'array': [7, 7, 4, 9, 2, 2, 2, 9, 4, 7, 7, 5, 2]}, {'array': [6, 9, 1, 7, 6, 2, 3, 7]}, {'array': [5, 9, 6, 6, 6]}, {'array': [9, 1, 1, 8, 1, 7, 4, 4, 6, 4, 4, 8, 5, 4]}, {'array': [3, 8, 8, 1, 5, 4, 1, 1]}, {'array': [6, 8, 9, 1, 1, 9, 9]}]" }
[ "" ]
{ "id": 36, "canonical_solution": "", "entry_point": "count_combinations" }
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции. Функция: {function} Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
{ "function": "def triangle_perimeter(A: int, B: int, C: int, D: int, E: int, F: int) -> float:\n \"\"\"Вам даны координаты трех вершин треугольника в декартовой системе координат: первая вершина (A, B), вторая вершина (C, D), третья вершина (E, F). Вычислите и выведите периметр данного треугольника. Периметр треугольника равен сумме длин его сторон. Считайте, что три вершины всегда образуют треугольник. Округлите ответ до 2 знаков после запятой.\n Примеры:\n triangle_perimeter(A=3, B=-3, C=0, D=0, E=0, F=2000) == 4007.24\n triangle_perimeter(A=0, B=-1, C=3, D=2, E=12, F=2) == 25.61\n \"\"\"", "tests": "[{'A': 3, 'B': -3, 'C': 0, 'D': 0, 'E': 0, 'F': 2000}, {'A': 0, 'B': -1, 'C': 3, 'D': 2, 'E': 12, 'F': 2}, {'A': 1, 'B': 20, 'C': 20, 'D': 400, 'E': 1, 'F': 404}, {'A': -33, 'B': 66, 'C': 222, 'D': 1000, 'E': 99, 'F': 1001}, {'A': 0, 'B': 0, 'C': 3, 'D': 15000, 'E': 88, 'F': 20000}, {'A': 2, 'B': 3, 'C': 5, 'D': 1, 'E': 98, 'F': 2}, {'A': -3, 'B': -3, 'C': 1, 'D': 200, 'E': 55, 'F': 300}, {'A': 3, 'B': 5, 'C': 7, 'D': 1000, 'E': 99, 'F': 1001}, {'A': 0, 'B': 0, 'C': 0, 'D': 0, 'E': 0, 'F': 0}, {'A': -3003, 'B': 505, 'C': 222, 'D': 30, 'E': 60, 'F': 199}]" }
[ "" ]
{ "id": 37, "canonical_solution": "", "entry_point": "triangle_perimeter" }
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции: {function} Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
{ "function": "def closest_fibonacci(number: int) -> int:\n \"\"\"Выведите ближайшее к числу number число Фибоначчи. Близость одного числа к другому определяется, как модуль разности данных чисел. Числа Фибоначчи – это такие числа, каждое из которых равно сумме двух предыдущих, а первое и второе равны единице. Если есть два подходящих под условие числа, выведите наименьшее из них.\n Примеры:\n closest_fibonacci(number=2) == 2\n closest_fibonacci(number=28) == 34\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 387}, {'number': 1234}, {'number': 3568}, {'number': 876543}, {'number': 13}, {'number': 927}, {'number': 1453}, {'number': 98376}]" }
[ "" ]
{ "id": 38, "canonical_solution": "", "entry_point": "closest_fibonacci" }
Напиши продолжение данной функции: {function} Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
{ "function": "def sum_closest(number: int) -> int:\n \"\"\"Дано натуральное число number. Выведите сумму следующего за ним числа и предыдущего.\n Примеры:\n sum_closest(number=2) == 4\n sum_closest(number=28) == 56\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 387}, {'number': 1234}, {'number': 3568}, {'number': 876543}, {'number': 13}, {'number': 927}, {'number': 1453}, {'number': 98376}]" }
[ "" ]
{ "id": 39, "canonical_solution": "", "entry_point": "sum_closest" }
Реши задачу по программированию. Начало функции: {function} Продолжи функцию так, чтобы она корректно работала. Ответ оформи по шаблону: ```python <code>```
{ "function": "def find_distance(speed: int, length: int, time: int) -> int:\n \"\"\"Велосипедист начал движение по кольцевой трассе со скоростью speed километров в час. Длина трассы составляет length километров. На какой отметке трассы остановится велосипедист через time часов? После того, как велосипедист проедет всю трассу, он попадет снова на отметку 0 километров и начнет проезжать трассу заново. Выведите получившееся число.\n Примеры:\n find_distance(speed=3, length=3, time=2) == 0\n find_distance(speed=50, length=51, time=1) == 50\n \"\"\"", "tests": "[{'speed': 3, 'length': 3, 'time': 2}, {'speed': 50, 'length': 51, 'time': 1}, {'speed': 10, 'length': 23, 'time': 1}, {'speed': 33, 'length': 66, 'time': 222}, {'speed': 22, 'length': 20, 'time': 12}, {'speed': 2, 'length': 3, 'time': 5}, {'speed': 2, 'length': 5, 'time': 2}, {'speed': 3, 'length': 22, 'time': 7}, {'speed': 10, 'length': 6, 'time': 9}, {'speed': 300, 'length': 505, 'time': 610}]" }
[ "" ]
{ "id": 40, "canonical_solution": "", "entry_point": "find_distance" }
Тебе дана заготовка под функцию на языке Python: {function} Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
{ "function": "def find_maximum(A: int, B: int) -> int:\n \"\"\"Даны два целых числа A и B. Если первое число больше второго, выведите число 1, иначе выведите число 2. Если число A равно числу B, то вывести нужно число 2.\n Примеры:\n find_maximum(A=33, B=3) == 1\n find_maximum(A=25, B=2) == 1\n \"\"\"", "tests": "[{'A': 33, 'B': 3}, {'A': 25, 'B': 2}, {'A': 4, 'B': 6}, {'A': 253, 'B': 254}, {'A': 1, 'B': 0}, {'A': 255, 'B': 65535}, {'A': 54475474574, 'B': 9876342156547}, {'A': 144, 'B': 4}, {'A': 44, 'B': 44}, {'A': 45, 'B': 22}]" }
[ "" ]
{ "id": 41, "canonical_solution": "", "entry_point": "find_maximum" }
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров. Функция: {function} В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
{ "function": "def leap_year(number: int) -> str:\n \"\"\"Определите, является ли год с номером number високосным. Високосный год либо делится на 400, либо не делится на 100 и делится на 4. Выведите \"Да\", если является, иначе выведите \"Нет\".\n Примеры:\n leap_year(number=2) == 'Нет'\n leap_year(number=28) == 'Да'\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 400}, {'number': 1234}, {'number': 3568}, {'number': 8765}, {'number': 13}, {'number': 927}, {'number': 1200}, {'number': 1000}]" }
[ "" ]
{ "id": 42, "canonical_solution": "", "entry_point": "leap_year" }
{function} Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
{ "function": "def chess_field(coordinateA: str, coordinateB: str) -> str:\n \"\"\"Вам даны координаты двух фигур на шахматной доске в формате строки: буквы и цифры без разделителя (А5, В7 и т.п.): coordinateA, coordinateB. Определите, одинаковые ли цвета у ячеек, на которых расположены данные фигуры. Если одинаковые, выведите \"Да\", иначе выведите \"Нет\".\n Примеры:\n chess_field(coordinateA=B5, coordinateB=D6) == 'Нет'\n chess_field(coordinateA=B2, coordinateB=C1) == 'Да'\n \"\"\"", "tests": "[{'coordinateA': 'B5', 'coordinateB': 'D6'}, {'coordinateA': 'B2', 'coordinateB': 'C1'}, {'coordinateA': 'H5', 'coordinateB': 'A4'}, {'coordinateA': 'H1', 'coordinateB': 'D1'}, {'coordinateA': 'E8', 'coordinateB': 'C7'}, {'coordinateA': 'G3', 'coordinateB': 'A1'}, {'coordinateA': 'C3', 'coordinateB': 'D3'}, {'coordinateA': 'F5', 'coordinateB': 'E2'}, {'coordinateA': 'G8', 'coordinateB': 'F5'}, {'coordinateA': 'H7', 'coordinateB': 'H1'}]" }
[ "" ]
{ "id": 43, "canonical_solution": "", "entry_point": "chess_field" }
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами: {function} Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
{ "function": "def find_missing(string: str, shuffle: str) -> str:\n \"\"\"Вам даны оригинальная строка string и измененная строка shuffle, которая получена случайным перемешиванием символов строки string с добавлением одного дополнительного символа. Выведите добавленный к shuffle символ.\n Примеры:\n find_missing(string=заполучить, shuffle=пзуичлтоаьз) == 'з'\n find_missing(string=жаловаться, shuffle=ясвлоатаьжь) == 'ь'\n \"\"\"", "tests": "[{'string': 'заполучить', 'shuffle': 'пзуичлтоаьз'}, {'string': 'жаловаться', 'shuffle': 'ясвлоатаьжь'}, {'string': 'пересолить', 'shuffle': 'силетепьоро'}, {'string': 'подержание', 'shuffle': 'жрианопедеш'}, {'string': 'работаться', 'shuffle': 'ааятсртьобщ'}, {'string': 'столешница', 'shuffle': 'аиолнтешцст'}, {'string': 'тюркология', 'shuffle': 'оюокияртглч'}, {'string': 'привернуть', 'shuffle': 'рептинвьурд'}, {'string': 'протерпеть', 'shuffle': 'еотпьрептрш'}, {'string': 'бортпроводник', 'shuffle': 'орокдтпбвиорнк'}]" }
[ "" ]
{ "id": 44, "canonical_solution": "", "entry_point": "find_missing" }
Решите задачу на Python. Функция: {function} Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
{ "function": "from typing import List\n\n\ndef arithmetic_mean(array: List[int]) -> float:\n \"\"\"Дан массив из чисел array. Найдите среднее арифметическое данного массива. Среднее арифметическое массива чисел равно сумме всех чисел массива, поделенной на количество чисел в массиве. Гарантируется, что массив имеет хотя бы один элемент. Выведите получившееся число, округленное до 2 знаков после запятой.\n Примеры:\n arithmetic_mean(array=[68, -65, 7, -8, -88, 80, 23, -72, 65]) == 1.11\n arithmetic_mean(array=[-15, 2, -28, -20, -8, -81, -87, 78, 68, -5]) == -9.6\n \"\"\"", "tests": "[{'array': [68, -65, 7, -8, -88, 80, 23, -72, 65]}, {'array': [-15, 2, -28, -20, -8, -81, -87, 78, 68, -5]}, {'array': [9, 6, 14, 56, 95, 13, 84, -40, 90, 23, -87]}, {'array': [46, -73, 67, 29, 20, 41, 12, 7, 43]}, {'array': [-12, -34, 39, 56, 74, -96, 63]}, {'array': [36, 32, 10, -96, 69, -48, -64, 5, -53, -57]}, {'array': [-91, -13, -15, 25, -53, 58, 88, -93, -67, 2]}, {'array': [15, 27, 35, 70, 91, 77, 5, -51, 44, 44, -30, -60]}, {'array': [-90, 0, -15, -85, -29, 81, -66, -42]}, {'array': [42, -75, 69, 39, 58, -68, -54, -77, 4, -89, -87, 97, 24]}]" }
[ "" ]
{ "id": 45, "canonical_solution": "", "entry_point": "arithmetic_mean" }
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция: {function} Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
{ "function": "from typing import List\n\n\ndef geometric_mean(array: List[int]) -> float:\n \"\"\"Дан массив из чисел array. Найдите среднее геометрическое данного массива. Среднее геометрическое массива равно произведению всех чисел массива, из которого взят арифметический корень степени равной количеству элементов в массиве. Гарантируется, что массив имеет хотя бы один элемент. Выведите получившееся число, округленное до 2 знаков после запятой.\n Примеры:\n geometric_mean(array=[8, 6, 5, 4, 9, 3]) == 5.44\n geometric_mean(array=[8, 4, 8, 9, 1, 5, 7, 8, 6, 1, 7, 1, 2, 1]) == 3.57\n \"\"\"", "tests": "[{'array': [8, 6, 5, 4, 9, 3]}, {'array': [8, 4, 8, 9, 1, 5, 7, 8, 6, 1, 7, 1, 2, 1]}, {'array': [9, 9, 6, 2, 4, 1, 4, 3, 9, 3]}, {'array': [2, 9, 3, 8, 1, 1, 6]}, {'array': [9, 6, 5, 1, 7, 8, 3]}, {'array': [8, 7, 9, 9, 7, 9, 2, 6, 2, 8]}, {'array': [1, 8, 7, 9, 9]}, {'array': [2, 4, 4, 5, 3, 7, 8, 6]}, {'array': [5, 6, 3, 5, 9, 3, 1, 3, 6, 8, 4, 1, 9]}, {'array': [9, 9, 3, 3, 5, 3, 9, 5, 1, 1, 4, 3, 3]}]" }
[ "" ]
{ "id": 46, "canonical_solution": "", "entry_point": "geometric_mean" }
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции. Функция: {function} Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
{ "function": "from typing import List\n\n\ndef garmonic_mean(array: List[int]) -> float:\n \"\"\"Дан массив из чисел array. Найдите среднее гармоническое данного массива. Среднее гармоническое массива равно частному размера массива и суммы чисел, которые равны обратным элементам массива (единица разделить на элемент массива). Гарантируется, что массив имеет хотя бы один элемент. Выведите получившееся число, округленное до 2 знаков после запятой.\n Примеры:\n garmonic_mean(array=[9, 1, 5, 9, 9, 9, 6, 5, 6]) == 4.13\n garmonic_mean(array=[6, 7, 9, 1, 6]) == 3.15\n \"\"\"", "tests": "[{'array': [9, 1, 5, 9, 9, 9, 6, 5, 6]}, {'array': [6, 7, 9, 1, 6]}, {'array': [8, 1, 8, 1, 2, 6, 4, 9, 2, 6, 4, 9]}, {'array': [9, 5, 4, 3, 7, 4, 8, 6, 4]}, {'array': [4, 5, 2, 7, 9, 6, 6, 9, 4, 2, 2, 1, 1]}, {'array': [8, 6, 1, 6, 4, 2, 5, 9, 8, 9, 5]}, {'array': [2, 9, 6, 5, 4, 4, 9, 5, 1, 4, 6, 2, 9]}, {'array': [2, 9, 9, 8, 9, 1, 3]}, {'array': [4, 3, 2, 8, 3, 1, 2, 4, 6, 4, 2]}, {'array': [9, 3, 6, 7, 3, 4, 4, 3]}]" }
[ "" ]
{ "id": 47, "canonical_solution": "", "entry_point": "garmonic_mean" }
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции: {function} Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
{ "function": "from typing import List\n\n\ndef array_mode(array: List[int]) -> int:\n \"\"\"Дан массив из чисел array. Найдите моду данного массива. Модой массива чисел является число, которое встречается в данном массиве чаще всего. Если таких значений больше, чем одно, то выведите наименьшее из них. Если в массиве нет ни одной моды, выведите минимальный элемент массива. Гарантируется, что массив не пуст.\n Примеры:\n array_mode(array=[4, 2, 7, 9, 1, 5, 6, 9, 6, 6, 7, 1, 6, 6]) == 6\n array_mode(array=[6, 9, 7, 7, 4]) == 7\n \"\"\"", "tests": "[{'array': [4, 2, 7, 9, 1, 5, 6, 9, 6, 6, 7, 1, 6, 6]}, {'array': [6, 9, 7, 7, 4]}, {'array': [3, 3, 5, 6, 5, 9, 4, 7]}, {'array': [6, 3, 2, 3, 7, 3, 8]}, {'array': [8, 2, 2, 2, 4, 6, 8, 9, 4, 9, 6, 2, 8]}, {'array': [1, 1, 6, 2, 5, 7, 8]}, {'array': [5, 6, 1, 2, 4, 9, 4, 4, 6, 6, 1, 8, 5, 5]}, {'array': [6, 5, 3, 5, 7, 7, 2, 6, 6, 8, 7, 8]}, {'array': [8, 2, 6, 3, 7]}, {'array': [5, 4, 3, 5, 8, 5]}]" }
[ "" ]
{ "id": 48, "canonical_solution": "", "entry_point": "array_mode" }
Напиши продолжение данной функции: {function} Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
{ "function": "def change_symbol(string: str, symbol: str, another_symbol: str) -> str:\n \"\"\"В строке string замените все вхождения символа symbol на another_symbol. Выведите получившуюся строку.\n Примеры:\n change_symbol(string=@$улк, symbol=$, another_symbol=0) == '@0улк'\n change_symbol(string=й§чей*р/пи?ъгмр, symbol=/, another_symbol=3) == 'й§чей*р3пи?ъгмр'\n \"\"\"", "tests": "[{'string': '@$улк', 'symbol': '$', 'another_symbol': '0'}, {'string': 'й§чей*р/пи?ъгмр', 'symbol': '/', 'another_symbol': '3'}, {'string': 'тун+?е~§г?', 'symbol': '~', 'another_symbol': '1'}, {'string': '§вхгз/ыйуч*з', 'symbol': '/', 'another_symbol': '2'}, {'string': 'яю/цанйю+р+веёсо*нз', 'symbol': '+', 'another_symbol': '1'}, {'string': 'ткёё?§в', 'symbol': '?', 'another_symbol': '9'}, {'string': 'ивт$у*й', 'symbol': '*', 'another_symbol': '8'}, {'string': '/зляе/втд$жгкъф§*', 'symbol': '$', 'another_symbol': '7'}, {'string': '/у§пн', 'symbol': '§', 'another_symbol': '2'}, {'string': 'п/?@та@геььз*пёяфоцх', 'symbol': '@', 'another_symbol': '4'}]" }
[ "" ]
{ "id": 49, "canonical_solution": "", "entry_point": "change_symbol" }
Реши задачу по программированию. Начало функции: {function} Продолжи функцию так, чтобы она корректно работала. Ответ оформи по шаблону: ```python <code>```
{ "function": "from typing import List\n\n\ndef minimum_shift(array: List[int]) -> int:\n \"\"\"Дан массив натуральных чисел array. Сколько циклических сдвигов вправо нужно сделать в данном массиве, чтобы он стал отсортированным? Выведите получившееся число. Если сдвигами отсортировать массив невозможно, то выведите \"-1\".\n Примеры:\n minimum_shift(array=[14, 3, 12, 13, 14]) == 4\n minimum_shift(array=[9, 9, 8, 3, 1, 7, 6, 4, 6, 6, 5]) == -1\n \"\"\"", "tests": "[{'array': [14, 3, 12, 13, 14]}, {'array': [9, 9, 8, 3, 1, 7, 6, 4, 6, 6, 5]}, {'array': [1, 2, 11, 12, 12]}, {'array': [9, 5, 4, 9, 4, 3, 8, 7, 5, 3, 7, 2, 9, 9]}, {'array': [14, 3, 4, 8, 10]}, {'array': [7, 9, 7, 5, 8, 1, 1, 5, 7]}, {'array': [9, 6, 3, 1, 3, 8, 1, 1, 3, 4, 7, 8, 9, 5]}, {'array': [4, 5, 9, 13, 1]}, {'array': [8, 9, 13, 3, 6, 6]}, {'array': [1, 4, 7, 10, 12]}]" }
[ "" ]
{ "id": 50, "canonical_solution": "", "entry_point": "minimum_shift" }
Тебе дана заготовка под функцию на языке Python: {function} Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
{ "function": "def are_coprime(A: int, B: int) -> str:\n \"\"\"Определите, являются ли целые положительные числа A и B взаимно простыми? Взаимно простые числа не имеют общих делителей кроме 1. Если являются, выведите \"Да\", иначе выведите \"Нет\".\n Примеры:\n are_coprime(A=33, B=3) == 'Нет'\n are_coprime(A=25, B=2) == 'Да'\n \"\"\"", "tests": "[{'A': 33, 'B': 3}, {'A': 25, 'B': 2}, {'A': 4, 'B': 6}, {'A': 253, 'B': 254}, {'A': 1, 'B': 0}, {'A': 255, 'B': 65535}, {'A': 54475474574, 'B': 9876342156547}, {'A': 144, 'B': 4}, {'A': 44, 'B': 44}, {'A': 45, 'B': 22}]" }
[ "" ]
{ "id": 51, "canonical_solution": "", "entry_point": "are_coprime" }
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров. Функция: {function} В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
{ "function": "def even_indicies(string: str) -> str:\n \"\"\"Дана строка string. Выведите строку, которая состоит из всех символов string, имеющих четный индекс. Если строка пустая, выведите ее.\n Примеры:\n even_indicies(string=Флюгегехаймен) == 'Фюееамн'\n even_indicies(string=метафора) == 'мтфр'\n \"\"\"", "tests": "[{'string': 'Флюгегехаймен'}, {'string': 'метафора'}, {'string': 'опщчтыклбуд'}, {'string': 'щфоцржусх'}, {'string': 'жвасчднтбр'}, {'string': 'овьцртгдся'}, {'string': 'тцсчюхаиовупгн'}, {'string': 'яысмънфпб'}, {'string': 'члзтуэбныещмокфъад'}, {'string': 'рщлэт'}]" }
[ "" ]
{ "id": 52, "canonical_solution": "", "entry_point": "even_indicies" }
{function} Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
{ "function": "def find_lcm(A: int, B: int) -> int:\n \"\"\"Выведите наименьшее общее кратное чисел A и B. Наименьшее общее кратное двух чисел – это такое число, которое делится без остатка и на A, и на B и является наименьшим возможным таким числом.\n Примеры:\n find_lcm(A=33, B=3) == 33\n find_lcm(A=25, B=2) == 50\n \"\"\"", "tests": "[{'A': 33, 'B': 3}, {'A': 25, 'B': 2}, {'A': 4, 'B': 6}, {'A': 253, 'B': 254}, {'A': 1, 'B': 0}, {'A': 255, 'B': 65535}, {'A': 54475474574, 'B': 9876342156547}, {'A': 144, 'B': 4}, {'A': 43, 'B': 45}, {'A': 85, 'B': 22}]" }
[ "" ]
{ "id": 53, "canonical_solution": "", "entry_point": "find_lcm" }
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами: {function} Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
{ "function": "from typing import List\n\n\ndef max_count(array: List[int]) -> int:\n \"\"\"Вам дан массив из целых чисел array, отсортированный в порядке неубывания. Каких чисел в массиве больше: положительных или отрицательных? Выведите число 1, если положительных, число -1, если отрицательных, и число 0, если их поровну. Число 0 в массиве не считается ни положительным, ни отрицательным. Гарантируется, что массив не пуст. Если массив содержит только число 0, в ответе выведите число 0.\n Примеры:\n max_count(array=[-42, 43, 12, 36, 9, 17, -38, -9, 9, 46, -2]) == 1\n max_count(array=[-8, -25, 4, -2, 49, -14]) == -1\n \"\"\"", "tests": "[{'array': [-42, 43, 12, 36, 9, 17, -38, -9, 9, 46, -2]}, {'array': [-8, -25, 4, -2, 49, -14]}, {'array': [10, 37, 49, 33, 39, -39, -30, 30]}, {'array': [32, 0, -49, 13, 39, -13, -44, 21, -33, -45, 22]}, {'array': [-50, 1, -25, -26, -11, 35, 2]}, {'array': [-43, 0, -38, 39, -7, -31]}, {'array': [30, -48, -14, 26, 11, 31, 38]}, {'array': [-5, 34, 1, -38, 38, 27, -21, -45, -3, 26, 31, 43]}, {'array': [-24, 12, -32, -2, 46, 29]}, {'array': [33, -16, -22, 39, 23, -16, 33, 49, 47, 6, 1, 40, 34, -9]}]" }
[ "" ]
{ "id": 54, "canonical_solution": "", "entry_point": "max_count" }
Решите задачу на Python. Функция: {function} Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
{ "function": "from typing import List\n\n\ndef split_digits(array: List[int]) -> int:\n \"\"\"Дан непустой список чисел array. Отделите все цифры, чтобы получился список всех цифр данного массива и выведите длину данного списка.\n Примеры:\n split_digits(array=[96, 12, 17, 15, 2, 43, 13, 39, 60, 73, 89, 70]) == 23\n split_digits(array=[41, 50, 20, 70, 88, 12, 70]) == 14\n \"\"\"", "tests": "[{'array': [96, 12, 17, 15, 2, 43, 13, 39, 60, 73, 89, 70]}, {'array': [41, 50, 20, 70, 88, 12, 70]}, {'array': [15, 10, 74, 10, 89, 36, 18, 5, 56, 67]}, {'array': [43, 18, 75, 41, 1, 86, 30, 43, 62, 30, 93]}, {'array': [15, 99, 51, 82, 15, 69]}, {'array': [84, 35, 25, 49, 95, 58, 57, 57, 38, 71, 60, 41]}, {'array': [43, 40, 58, 10, 64]}, {'array': [73, 60, 76, 2, 91, 99, 44, 4, 97]}, {'array': [60, 73, 43, 16, 89, 22, 3, 89, 27]}, {'array': [62, 30, 20, 74, 23, 29, 16, 93, 12, 21, 94, 80, 38]}]" }
[ "" ]
{ "id": 55, "canonical_solution": "", "entry_point": "split_digits" }
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция: {function} Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
{ "function": "def formate_date(date: dict) -> str:\n \"\"\"Дан словарь date, содержащий дату. Ключи словаря: год, месяц, день. Приведите дату к формату \"YY-MM-DD\" и выведите получившуюся строку. Если число дней или номер месяца являются однозначным числом, дополните такое число слева нулем.\n Примеры:\n formate_date(date={'год': 2023, 'месяц': 3, 'день': 12}) == '23-03-12'\n formate_date(date={'год': 1989, 'месяц': 1, 'день': 17}) == '89-01-17'\n \"\"\"", "tests": "[{'date': {'год': 2023, 'месяц': 3, 'день': 12}}, {'date': {'год': 1989, 'месяц': 1, 'день': 17}}, {'date': {'год': 1990, 'месяц': 8, 'день': 14}}, {'date': {'год': 1918, 'месяц': 1, 'день': 27}}, {'date': {'год': 1914, 'месяц': 9, 'день': 6}}, {'date': {'год': 2004, 'месяц': 1, 'день': 11}}, {'date': {'год': 1921, 'месяц': 9, 'день': 22}}, {'date': {'год': 1936, 'месяц': 12, 'день': 28}}, {'date': {'год': 1909, 'месяц': 9, 'день': 27}}, {'date': {'год': 2019, 'месяц': 3, 'день': 3}}]" }
[ "" ]
{ "id": 56, "canonical_solution": "", "entry_point": "formate_date" }
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции. Функция: {function} Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
{ "function": "def russian_round(number: float) -> int:\n \"\"\"Округлите число number по российским правилам: если дробная часть числа равна или больше 0.5, то число округляется вверх, иначе – вниз. Выведите полученное число.\n Примеры:\n russian_round(number=19.51035) == 20\n russian_round(number=13.53934) == 14\n \"\"\"", "tests": "[{'number': 19.51035}, {'number': 13.53934}, {'number': 17.55757}, {'number': 1.43237}, {'number': 11.67251}, {'number': 11.59171}, {'number': 16.24636}, {'number': 16.26078}, {'number': 12.24728}, {'number': 2.04019}]" }
[ "" ]
{ "id": 57, "canonical_solution": "", "entry_point": "russian_round" }
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции: {function} Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
{ "function": "def inverse_vowels(string: str) -> str:\n \"\"\"Измените строку string так, чтобы все гласные буквы в ней шли в обратном порядке относительно изначального порядка. Выведите получившуюся строку. Гласными являются буквы: а, о, и, у, е, ю, я, э, ы. Данные буквы могут встречаться в любом регистре.\n Примеры:\n inverse_vowels(string=Флюгегехаймен) == 'Флегагехеймюн'\n inverse_vowels(string=метафора-анаформа) == 'матофара-анофарме'\n \"\"\"", "tests": "[{'string': 'Флюгегехаймен'}, {'string': 'метафора-анаформа'}, {'string': 'фвьъыткиеплщклчкдтрпбррлкъъчюрямйьзх'}, {'string': 'тцнсщячбеоагясшжацбспарлшыуыцясьойтэшшытяю'}, {'string': 'ммйывуяяиттхфбнкгшьктачдучичц'}, {'string': 'ищснечицсвпбчвыэпииртикиоьбофътнднвтхиождйзв'}, {'string': 'иглюбгбшблиикаавмувпйфебр'}, {'string': 'выитшшчвяьучхпныюцфагжъошпфчттьрв'}, {'string': 'ялышшбтъцшщсрхтхюьебгвшвфмцгтюшж'}, {'string': 'эхнзыидаэзьцюцмзщгпэйтбфгфнал'}]" }
[ "" ]
{ "id": 58, "canonical_solution": "", "entry_point": "inverse_vowels" }
Напиши продолжение данной функции: {function} Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
{ "function": "def make_binary(number: int) -> int:\n \"\"\"Вам дано положительное число number в десятичной системе исчисления. Выведите данное число в двоичной системе исчисления.\n Примеры:\n make_binary(number=2) == 10\n make_binary(number=28) == 11100\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 400}, {'number': 1234}, {'number': 3568}, {'number': 8765}, {'number': 13}, {'number': 927}, {'number': 1200}, {'number': 1000}]" }
[ "" ]
{ "id": 59, "canonical_solution": "", "entry_point": "make_binary" }
Реши задачу по программированию. Начало функции: {function} Продолжи функцию так, чтобы она корректно работала. Ответ оформи по шаблону: ```python <code>```
{ "function": "def hex_sum(A: int, B: int) -> str:\n \"\"\"Вам даны два числа в двоичной системе исчисления: A и B. Сложите данные числа и выведите результат сложения в шестнадцатиричной системе исчисления в виде строки.\n Примеры:\n hex_sum(A=1010, B=11100) == '26'\n hex_sum(A=110010, B=10001001) == 'bb'\n \"\"\"", "tests": "[{'A': 1010, 'B': 11100}, {'A': 110010, 'B': 10001001}, {'A': 1001010, 'B': 10111000100010}, {'A': 1111010010, 'B': 10}, {'A': 11110111101, 'B': 1011011110}, {'A': 11101000, 'B': 111}, {'A': 110001, 'B': 11100}, {'A': 1, 'B': 11010100110110}, {'A': 101, 'B': 11001001100}, {'A': 10110111, 'B': 1100101}]" }
[ "" ]
{ "id": 60, "canonical_solution": "", "entry_point": "hex_sum" }
Тебе дана заготовка под функцию на языке Python: {function} Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
{ "function": "from typing import List\n\n\ndef missing_number(array: List[int]) -> int:\n \"\"\"Дан массив чисел array, который включает в себя все целые числа отрезка от нуля до количества чисел в массиве, кроме одного числа. Выведите число, которое пропущено. Гарантируется, что в массиве более одного элемента.\n Примеры:\n missing_number(array=[7, 3, 5, 1, 0, 2, 6]) == 4\n missing_number(array=[5, 7, 1, 10, 6, 2, 8, 0, 9, 4]) == 3\n \"\"\"", "tests": "[{'array': [7, 3, 5, 1, 0, 2, 6]}, {'array': [5, 7, 1, 10, 6, 2, 8, 0, 9, 4]}, {'array': [6, 1, 5, 0, 4, 3]}, {'array': [0, 7, 3, 2, 8, 4, 10, 9, 1, 6, 11]}, {'array': [1, 3, 8, 7, 4, 0, 2, 6, 5, 9]}, {'array': [8, 3, 2, 7, 4, 6, 5, 0]}, {'array': [1, 7, 8, 10, 4, 3, 5, 2, 6, 0]}, {'array': [11, 0, 4, 6, 5, 10, 8, 7, 9, 1, 3]}, {'array': [1, 7, 9, 3, 10, 2, 11, 8, 0, 6, 12, 5]}, {'array': [2, 5, 1, 6, 0, 4]}]" }
[ "" ]
{ "id": 61, "canonical_solution": "", "entry_point": "missing_number" }
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров. Функция: {function} В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
{ "function": "def is_ugly(number: int) -> str:\n \"\"\"Определите, является ли число number некрасивым. Некрасивое число – это такое число, которое делится только на 2, 3 и 5 (необязательно все сразу) без остатка. Если число некрасивое, выведите \"Да\", иначе выведите \"Нет\".\n Примеры:\n is_ugly(number=45) == 'Да'\n is_ugly(number=44) == 'Нет'\n \"\"\"", "tests": "[{'number': 45}, {'number': 44}, {'number': 21}, {'number': 83}, {'number': 70}, {'number': 19}, {'number': 9}, {'number': 80}, {'number': 50}, {'number': 65}]" }
[ "" ]
{ "id": 62, "canonical_solution": "", "entry_point": "is_ugly" }
{function} Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
{ "function": "def add_digits(number: int) -> int:\n \"\"\"Вам дано положительное целое число number. Складывайте все цифры данного числа до тех пор пока не останется всего одной цифры. Выведите получившуюся цифру.\n Примеры:\n add_digits(number=2) == 2\n add_digits(number=28) == 1\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 387}, {'number': 1234}, {'number': 3568}, {'number': 876543}, {'number': 13}, {'number': 927}, {'number': 1453}, {'number': 98376}]" }
[ "" ]
{ "id": 63, "canonical_solution": "", "entry_point": "add_digits" }
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами: {function} Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
{ "function": "def is_anagram(string: str, another_string: str) -> str:\n \"\"\"Определите, является ли строка string анаграммой строки another_string. Строка является анаграммой другой строки если состоит из тех же символов, что и изначальная строка, но в другом порядке. Если является, выведите \"Да\", иначе выведите \"Нет\".\n Примеры:\n is_anagram(string=заполучить, another_string=ьоачиузлпт) == 'Да'\n is_anagram(string=жаловаться, another_string=пхкэгткуйн) == 'Нет'\n \"\"\"", "tests": "[{'string': 'заполучить', 'another_string': 'ьоачиузлпт'}, {'string': 'жаловаться', 'another_string': 'пхкэгткуйн'}, {'string': 'дублон', 'another_string': 'ыгъсес'}, {'string': 'бортпроводник', 'another_string': 'товнордобпирк'}, {'string': 'диссонанс', 'another_string': 'аинондссс'}, {'string': 'изборник', 'another_string': 'лнфаыцяе'}, {'string': 'флюгегехаймен', 'another_string': 'ехлйнафеемггю'}, {'string': 'метафора', 'another_string': 'рфмаеоат'}, {'string': 'словесник', 'another_string': 'кндцмцаще'}, {'string': 'девиация', 'another_string': 'рфтейпек'}]" }
[ "" ]
{ "id": 64, "canonical_solution": "", "entry_point": "is_anagram" }
Решите задачу на Python. Функция: {function} Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
{ "function": "def is_isomorphic(stringA: str, stringB: str) -> str:\n \"\"\"Определите, являются ли строки stringA и stringB изморфными по отношению друг к другу. Две строки изоморфны, если символы одной строки могут быть заменены на другие, и получится вторая строка. Заменять разрешается все вхождения одного символа на другой символ одновременно. Если являются, выведите \"Да\", иначе выведите \"Нет\".\n Примеры:\n is_isomorphic(stringA=флюгегехаймен, stringB=щбятутуйвдсуз) == 'Да'\n is_isomorphic(stringA=словесник, stringB=кзжидъшун) == 'Нет'\n \"\"\"", "tests": "[{'stringA': 'флюгегехаймен', 'stringB': 'щбятутуйвдсуз'}, {'stringA': 'словесник', 'stringB': 'кзжидъшун'}, {'stringA': 'метафора', 'stringB': 'эзведяне'}, {'stringA': 'бортпроводник', 'stringB': 'лжвъцвжшжябою'}, {'stringA': 'девиация', 'stringB': 'иечобгмб'}, {'stringA': 'дублон', 'stringB': 'тяэтзм'}, {'stringA': 'жаловаться', 'stringB': 'пмвчихйфьй'}, {'stringA': 'диссонанс', 'stringB': 'ыеггкьбьг'}, {'stringA': 'заполучить', 'stringB': 'взкеьующон'}, {'stringA': 'изборник', 'stringB': 'эуэщяжге'}]" }
[ "" ]
{ "id": 65, "canonical_solution": "", "entry_point": "is_isomorphic" }
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция: {function} Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
{ "function": "def last_word(string: str) -> int:\n \"\"\"Выведите длину последнего слова в строке string. Словом считается совокупность непробельных символов в строке, слева и справа от которого есть пробельный символ или начало/конец строки. Если строка пустая, выведите 0.\n Примеры:\n last_word(string=Аппетит приходит во время еды) == 3\n last_word(string=Бедность не порок) == 5\n \"\"\"", "tests": "[{'string': 'Аппетит приходит во время еды'}, {'string': 'Бедность не порок'}, {'string': 'Без труда не выловишь и рыбку из пруда'}, {'string': 'Бесплатный сыр, бывает- только в мышеловке'}, {'string': 'Бог шельму= метит'}, {'string': 'В здоровом теле – здоровый дух'}, {'string': 'Волков бояться – в лес не ходить'}, {'string': 'Глаза боятся, а руки делают'}, {'string': 'Готовь сани летом, а телегу зимой'}, {'string': 'Дарёному коню в зубы не смотрят'}]" }
[ "" ]
{ "id": 66, "canonical_solution": "", "entry_point": "last_word" }
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции. Функция: {function} Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
{ "function": "from typing import List\n\n\ndef transpose_array(array: List[List[int]]) -> List[List[int]]:\n \"\"\"Вам дан непустой двумерный массив array в виде списка списков. Данный массив представляет собой квадратную матрицу. Транспонируйте данный массив и выведите результат. Транспонирование двумерного массива эквивалентно его перевороту вокруг основной диагонали (диагональ из левого верхнего элемена, идущая по всем элементам, у которых индекс троки и столбца совпадает) или замене индексов строк на индексы столбцов и наоборот.\n Примеры:\n transpose_array(array=[[3, 5, 12, 13, 11], [6, 12, 5, 1, 5], [5, 8, 6, 4, 13], [3, 6, 2, 4, 8], [14, 6, 8, 9, 4]]) == [[3, 6, 5, 3, 14], [5, 12, 8, 6, 6], [12, 5, 6, 2, 8], [13, 1, 4, 4, 9], [11, 5, 13, 8, 4]]\n transpose_array(array=[[4, 5, 12, 11, 4, 10], [6, 6, 1, 13, 6, 6], [5, 13, 7, 4, 13, 4], [3, 4, 4, 10, 5, 8], [6, 6, 4, 12, 6, 10], [7, 8, 4, 12, 6, 5]]) == [[4, 6, 5, 3, 6, 7], [5, 6, 13, 4, 6, 8], [12, 1, 7, 4, 4, 4], [11, 13, 4, 10, 12, 12], [4, 6, 13, 5, 6, 6], [10, 6, 4, 8, 10, 5]]\n \"\"\"", "tests": "[{'array': [[3, 5, 12, 13, 11], [6, 12, 5, 1, 5], [5, 8, 6, 4, 13], [3, 6, 2, 4, 8], [14, 6, 8, 9, 4]]}, {'array': [[4, 5, 12, 11, 4, 10], [6, 6, 1, 13, 6, 6], [5, 13, 7, 4, 13, 4], [3, 4, 4, 10, 5, 8], [6, 6, 4, 12, 6, 10], [7, 8, 4, 12, 6, 5]]}, {'array': [[12, 8, 3, 1], [7, 11, 1, 3], [10, 12, 5, 3], [11, 6, 2, 10]]}, {'array': [[4, 14, 14, 12, 14, 5], [1, 5, 14, 7, 8, 4], [3, 8, 4, 7, 10, 3], [6, 2, 8, 9, 11, 14], [12, 9, 5, 5, 4, 6], [2, 3, 3, 7, 8, 6]]}, {'array': [[12, 5, 8, 2], [11, 13, 9, 14], [8, 6, 9, 1], [5, 5, 12, 7]]}, {'array': [[7, 1, 3, 10, 13], [2, 14, 13, 7, 8], [12, 1, 14, 9, 11], [10, 8, 10, 1, 12], [12, 10, 1, 6, 12]]}, {'array': [[2, 10, 4, 7, 10], [6, 11, 6, 12, 1], [2, 10, 12, 14, 4], [14, 7, 3, 9, 6], [3, 4, 14, 8, 14]]}, {'array': [[10, 13, 5, 14], [4, 3, 3, 5], [11, 8, 11, 13], [3, 4, 10, 13]]}, {'array': [[1, 7, 6, 10, 7, 14], [5, 9, 8, 6, 10, 4], [8, 9, 4, 4, 8, 12], [1, 13, 8, 3, 2, 3], [14, 10, 4, 11, 9, 4], [13, 4, 12, 6, 13, 2]]}, {'array': [[9, 7, 6, 11, 4, 11, 14], [6, 4, 7, 14, 14, 3, 8], [13, 7, 10, 5, 9, 14, 14], [8, 7, 11, 8, 1, 3, 1], [7, 5, 11, 3, 13, 5, 13], [7, 3, 7, 2, 11, 14, 1], [11, 12, 13, 12, 7, 8, 14]]}]" }
[ "" ]
{ "id": 67, "canonical_solution": "", "entry_point": "transpose_array" }
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции: {function} Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
{ "function": "def perfect_number(number: int) -> str:\n \"\"\"Определите, является ли число number красивым. Красивое число – это такое число, которое равно сумме своих натуральных делителей (не включая само число number). Выведите \"Да\", если является. Иначе, выведите \"Нет\".\n Примеры:\n perfect_number(number=2) == 'Нет'\n perfect_number(number=28) == 'Да'\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 387}, {'number': 1234}, {'number': 3568}, {'number': 876543}, {'number': 6}, {'number': 0}, {'number': 8128}, {'number': 98376}]" }
[ "" ]
{ "id": 68, "canonical_solution": "", "entry_point": "perfect_number" }
Напиши продолжение данной функции: {function} Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
{ "function": "from typing import List\n\n\ndef hour_glass(array: List[int], number: int) -> int:\n \"\"\"Песочные часы отмеряют number секунд. Дан список array, который содержит время в секундах, когда песочные часы переворачиваются. Если песочные часы не закончили работу, но были перевернуты, то время их работы начинает течь заново. Выведите, сколько времени суммарно проработают песочные часы.\n Примеры:\n hour_glass(array=[0, 5, 8, 12, 15, 18, 22, 25, 28, 28, 33, 37], number=2) == 22\n hour_glass(array=[0, 4, 9, 14, 14, 17, 19], number=3) == 17\n \"\"\"", "tests": "[{'array': [0, 5, 8, 12, 15, 18, 22, 25, 28, 28, 33, 37], 'number': 2}, {'array': [0, 4, 9, 14, 14, 17, 19], 'number': 3}, {'array': [0, 5, 11, 16, 16, 23], 'number': 4}, {'array': [1, 5, 7, 11, 15, 16, 21, 25, 29, 29, 29, 30, 33], 'number': 2}, {'array': [0, 1, 10, 11, 21], 'number': 5}, {'array': [0, 4, 6, 8, 9, 10, 11], 'number': 2}, {'array': [1, 8, 14, 22, 30, 35, 42, 47, 52, 61, 66, 68], 'number': 4}, {'array': [1, 3, 7, 11, 18, 20, 28, 30, 34, 36], 'number': 4}, {'array': [0, 5, 15, 19, 30, 38, 42, 42, 45, 47], 'number': 5}, {'array': [1, 7, 14, 15, 16, 18, 25, 26, 30], 'number': 3}]" }
[ "" ]
{ "id": 69, "canonical_solution": "", "entry_point": "hour_glass" }
Реши задачу по программированию. Начало функции: {function} Продолжи функцию так, чтобы она корректно работала. Ответ оформи по шаблону: ```python <code>```
{ "function": "def bit_inversion(number: int) -> int:\n \"\"\"Дано целое положительное число number. Инвертируйте все биты в двоичной записи данного числа. Выведите получившееся число в десятичной системе исчисления.\n Примеры:\n bit_inversion(number=2) == 1\n bit_inversion(number=28) == 3\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 387}, {'number': 1234}, {'number': 3568}, {'number': 876543}, {'number': 6}, {'number': 496}, {'number': 8128}, {'number': 98376}]" }
[ "" ]
{ "id": 70, "canonical_solution": "", "entry_point": "bit_inversion" }
Тебе дана заготовка под функцию на языке Python: {function} Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
{ "function": "def build_ladder(number: int) -> int:\n \"\"\"Лестницы строится из кирпичей. Каждый новый уровень лестницы требует количества кирпичей, которое равно порядковому уровню лестницы, начиная с 1. Последний этаж летницы может быть не достроен. Выведите, сколько полных этажей лестницы можно построить из number кирпичей.\n Примеры:\n build_ladder(number=2) == 1\n build_ladder(number=28) == 7\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 387}, {'number': 1234}, {'number': 3568}, {'number': 876543}, {'number': 6}, {'number': 496}, {'number': 8128}, {'number': 98376}]" }
[ "" ]
{ "id": 71, "canonical_solution": "", "entry_point": "build_ladder" }
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров. Функция: {function} В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
{ "function": "def string_sum(string1: str, string2: str) -> str:\n \"\"\"Два положительных челых числа даны в виде строк string1 и string2. Сложите эти числа и выведите ответ в виде строки. Гарантируется, что величина чисел соответствует типу данных int32.\n Примеры:\n string_sum(string1=411465, string2=218778) == '630243'\n string_sum(string1=552226, string2=754815) == '1307041'\n \"\"\"", "tests": "[{'string1': '411465', 'string2': '218778'}, {'string1': '552226', 'string2': '754815'}, {'string1': '785473', 'string2': '247575'}, {'string1': '540860', 'string2': '146017'}, {'string1': '828385', 'string2': '517570'}, {'string1': '195231', 'string2': '2895'}, {'string1': '731218', 'string2': '928361'}, {'string1': '777711', 'string2': '962434'}, {'string1': '833956', 'string2': '843254'}, {'string1': '642317', 'string2': '597263'}]" }
[ "" ]
{ "id": 72, "canonical_solution": "", "entry_point": "string_sum" }
{function} Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
{ "function": "from typing import List\n\n\ndef largest_triangle(array: List[List[int]]) -> float:\n \"\"\"На вход дан список array из пар координат точек в декартовой системе координат. Найдите три точки, которые формируют наибольший по площади треугольник и выведите его площадь. Считайте, в массиве есть как минимум одна тройка точек, которые формируют треугольник. Точки всегда лежат в первой четверти системы координат. Округлите ответ до 2 знаков после запятой.\n Примеры:\n largest_triangle(array=[[5, 3], [5, 1], [4, 7], [6, 4], [5, 6], [2, 1]]) == 9.0\n largest_triangle(array=[[4, 8], [4, 6], [3, 1], [9, 2], [4, 9], [7, 2], [7, 7], [7, 9], [1, 1]]) == 30.5\n \"\"\"", "tests": "[{'array': [[5, 3], [5, 1], [4, 7], [6, 4], [5, 6], [2, 1]]}, {'array': [[4, 8], [4, 6], [3, 1], [9, 2], [4, 9], [7, 2], [7, 7], [7, 9], [1, 1]]}, {'array': [[4, 7], [5, 1], [7, 8], [5, 8], [4, 8], [5, 4]]}, {'array': [[3, 8], [8, 4], [8, 2], [3, 8], [2, 8], [7, 6], [4, 3], [2, 4], [7, 9]]}, {'array': [[3, 1], [8, 8], [6, 4], [7, 9], [8, 2], [6, 7], [5, 6], [1, 6]]}, {'array': [[6, 9], [8, 1], [3, 4], [3, 4], [5, 5], [8, 2]]}, {'array': [[2, 4], [3, 8], [9, 2], [1, 8], [4, 6], [8, 5], [5, 8], [4, 7]]}, {'array': [[5, 2], [9, 4], [4, 9], [8, 5], [3, 2], [1, 5], [7, 3], [8, 9]]}, {'array': [[3, 1], [2, 2], [7, 6], [8, 2], [2, 6], [1, 5]]}, {'array': [[8, 5], [5, 8], [6, 3], [5, 9], [1, 7], [9, 1], [9, 4], [7, 7]]}]" }
[ "" ]
{ "id": 73, "canonical_solution": "", "entry_point": "largest_triangle" }
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами: {function} Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
{ "function": "def cyclic_shift(string: str, target: str) -> str:\n \"\"\"Если строка string может стать равной строке target после конечного числа циклических сдвигов влево всех символов строки string, то выведите \"Да\". Иначе, выведите \"Нет\". Циклический сдвиг влево экивалентен тому, что у каждого элемента массива, кроме первого, из индекса вычитается единица, а индекс первого элемента становится равным индексу последнего элемента.\n Примеры:\n cyclic_shift(string=аои, target=оиа) == 'Да'\n cyclic_shift(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": 74, "canonical_solution": "", "entry_point": "cyclic_shift" }
Решите задачу на Python. Функция: {function} Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
{ "function": "from typing import List\n\n\ndef smallest_symbol(array: List[str], symbol: str) -> str:\n \"\"\"Если в непустом списке array существуют символы, которые лексикографически больше символа symbol, то выведите лексикографически наименьший из этих символов. Иначе, выведите первый символ списка array. По лексикографическому порядку один символ меньше другого, если идет раньше его в алфавите.\n Примеры:\n smallest_symbol(array=['х', 'щ', 'з', 'ж', 'й', 'ж', 'к', 'ф', 'т', 'е', 'ф'], symbol=х) == 'щ'\n smallest_symbol(array=['о', 'а', 'х', 'г', 'п', 'э', 'б', 'щ', 'п', 'щ', 'ч', 'с', 'в', 'н', 'э', 'х'], symbol=л) == 'н'\n \"\"\"", "tests": "[{'array': ['х', 'щ', 'з', 'ж', 'й', 'ж', 'к', 'ф', 'т', 'е', 'ф'], 'symbol': 'х'}, {'array': ['о', 'а', 'х', 'г', 'п', 'э', 'б', 'щ', 'п', 'щ', 'ч', 'с', 'в', 'н', 'э', 'х'], 'symbol': 'л'}, {'array': ['т', 'ц', 'д', 'ш', 'й', 'к', 'й', 'а', 'з', 'е', 'ь', 'е', 'р'], 'symbol': 'о'}, {'array': ['ф', 'ц', 'ъ', 'ф', 'в', 'н', 'и', 'ф', 'х', 'е', 'я', 'к', 'ы', 'в', 'ю', 'у'], 'symbol': 'ю'}, {'array': ['л', 'й', 'т', 'ш', 'о', 'т', 'з', 'г', 'ъ', 'ю'], 'symbol': 'ь'}, {'array': ['ч', 'э', 'ю', 'а', 'у', 'э', 'х', 'е', 'у', 'я', 'й', 'к', 'г'], 'symbol': 'м'}, {'array': ['и', 'ж', 'щ', 'т', 'д', 'н', 'х', 'в', 'х', 'х', 'н', 'в', 'э', 'б', 'к', 'т'], 'symbol': 'ж'}, {'array': ['н', 'м', 'л', 'п', 'ч', 'п', 'ю', 'г', 'я', 'х', 'и', 'щ', 'ь', 'э', 'у'], 'symbol': 'д'}, {'array': ['п', 'ш', 'ш', 'н', 'м', 'ф', 'х', 'у', 'к', 'в', 'ц', 'р', 'т', 'б'], 'symbol': 'о'}, {'array': ['ж', 'с', 'ъ', 'н', 'ж', 'н', 'н', 'б', 'э', 'ю'], 'symbol': 'ъ'}]" }
[ "" ]
{ "id": 75, "canonical_solution": "", "entry_point": "smallest_symbol" }
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция: {function} Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
{ "function": "def selfdividing_sum(start:int, end: int) -> int:\n \"\"\"Выведите, сколько чисел между start и end (включительно) делятся на все свои цифры. Нули в числах игнорируйте.\n Примеры:\n selfdividing_sum(start=59, end=4828) == 225\n selfdividing_sum(start=59, end=451) == 40\n \"\"\"", "tests": "[{'start': 59, 'end': 4828}, {'start': 59, 'end': 451}, {'start': 17, 'end': 17}, {'start': 73, 'end': 2418}, {'start': 83, 'end': 917}, {'start': 53, 'end': 5027}, {'start': 54, 'end': 1764}, {'start': 20, 'end': 3306}, {'start': 40, 'end': 4001}, {'start': 16, 'end': 19}]" }
[ "" ]
{ "id": 76, "canonical_solution": "", "entry_point": "selfdividing_sum" }
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции. Функция: {function} Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
{ "function": "from typing import List\n\n\ndef array_search(array: List[int], number: int) -> int:\n \"\"\"Если число number встречается в списке array, который отсортирован в порядке неубывания, выведите число 1, иначе выведите число 0.\n Примеры:\n array_search(array=[-8, -7, -3, -3, -2, 6, 9, 10, 11, 11, 12, 16], number=0) == 0\n array_search(array=[-10, -8, 0, 1, 3, 3, 8, 9, 10, 11, 13, 17, 19], number=13) == 1\n \"\"\"", "tests": "[{'array': [-8, -7, -3, -3, -2, 6, 9, 10, 11, 11, 12, 16], 'number': 0}, {'array': [-10, -8, 0, 1, 3, 3, 8, 9, 10, 11, 13, 17, 19], 'number': 13}, {'array': [-10, -9, -6, -2, 2, 5, 9, 12, 12, 13, 14], 'number': -8}, {'array': [-9, -5, -2, 4, 15], 'number': 0}, {'array': [-10, -9, 5, 5, 7, 8, 8, 10, 11, 12, 13], 'number': 12}, {'array': [-7, -2, 0, 2, 5, 5, 10, 12, 12, 13, 15], 'number': 5}, {'array': [-1, 1, 4, 5, 6, 9, 11, 11, 13, 14], 'number': 8}, {'array': [-8, -5, -3, -3, 5, 5, 10, 12, 14, 15, 17], 'number': 2}, {'array': [-7, 1, 8, 10, 14], 'number': 4}, {'array': [-8, -6, -4, -3, -3, -2, 1, 2, 6, 7, 7, 14, 17, 18], 'number': 1}]" }
[ "" ]
{ "id": 77, "canonical_solution": "", "entry_point": "array_search" }
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции: {function} Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
{ "function": "from typing import List\n\n\ndef diagonal_sum(matrix: List[List[int]]) -> int:\n \"\"\"Выведите сумму всех чисел на главной и побочной диагонали квадратной матрицы matrix (тех, что не попали на главную диагональ). Главная диагональ начинается в левом верхнем элементе и идет вправо вниз по диагонали. Побочная диагональ начинается в левом нижнем углу и идет по диагонали вправо вверх.\n Примеры:\n diagonal_sum(matrix=[[1, 1, 4, 8, 1], [9, 7, 2, 3, 1], [7, 4, 1, 1, 9], [8, 3, 6, 4, 4], [9, 5, 2, 9, 9]]) == 38\n diagonal_sum(matrix=[[1, 5, 6, 9, 4, 9], [6, 8, 9, 3, 4, 7], [3, 4, 7, 9, 8, 5], [9, 2, 3, 8, 9, 6], [2, 4, 8, 9, 3, 4], [6, 9, 6, 4, 8, 6]]) == 68\n \"\"\"", "tests": "[{'matrix': [[1, 1, 4, 8, 1], [9, 7, 2, 3, 1], [7, 4, 1, 1, 9], [8, 3, 6, 4, 4], [9, 5, 2, 9, 9]]}, {'matrix': [[1, 5, 6, 9, 4, 9], [6, 8, 9, 3, 4, 7], [3, 4, 7, 9, 8, 5], [9, 2, 3, 8, 9, 6], [2, 4, 8, 9, 3, 4], [6, 9, 6, 4, 8, 6]]}, {'matrix': [[1, 8, 6, 4, 3], [8, 5, 9, 1, 2], [6, 2, 2, 2, 5], [3, 7, 4, 3, 9], [9, 4, 4, 2, 2]]}, {'matrix': [[6, 3, 7, 8, 5, 3], [9, 7, 8, 6, 4, 7], [4, 1, 2, 1, 6, 7], [1, 6, 5, 5, 6, 8], [8, 5, 7, 3, 7, 9], [4, 9, 8, 6, 2, 4]]}, {'matrix': [[1, 1, 2, 2], [2, 7, 8, 4], [8, 6, 2, 4], [7, 3, 1, 7]]}, {'matrix': [[6, 7, 3], [4, 8, 9], [8, 7, 6]]}, {'matrix': [[4, 7, 4, 1], [3, 3, 3, 4], [1, 6, 4, 6], [6, 1, 9, 8]]}, {'matrix': [[3, 1, 7, 3], [6, 6, 2, 6], [7, 2, 1, 2], [9, 6, 6, 9]]}, {'matrix': [[2, 9, 3, 1, 1], [9, 2, 9, 4, 1], [9, 7, 4, 2, 3], [4, 5, 8, 8, 5], [5, 3, 6, 7, 3]]}, {'matrix': [[1, 5, 7], [6, 5, 4], [2, 4, 7]]}]" }
[ "" ]
{ "id": 78, "canonical_solution": "", "entry_point": "diagonal_sum" }
Напиши продолжение данной функции: {function} Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
{ "function": "from typing import List\n\n\ndef string_shuffle(string: str, array: List[int]) -> str:\n \"\"\"Перемешайте символы строки string так, чтобы символ с индексом i стал символом с индексом array[i], где array – список целых чисел от 0 до длины string минус 1. Выведите полученную строку.\n Примеры:\n string_shuffle(string=лташбпркцк, array=[7, 2, 3, 5, 8, 0, 9, 4, 1, 6]) == 'пцтакшклбр'\n string_shuffle(string=юязшьщзсрхнае, array=[10, 6, 9, 2, 7, 5, 12, 0, 1, 11, 3, 8, 4]) == 'сршнещяьазюхз'\n \"\"\"", "tests": "[{'string': 'лташбпркцк', 'array': [7, 2, 3, 5, 8, 0, 9, 4, 1, 6]}, {'string': 'юязшьщзсрхнае', 'array': [10, 6, 9, 2, 7, 5, 12, 0, 1, 11, 3, 8, 4]}, {'string': 'цзлусьъкхп', 'array': [3, 1, 4, 5, 8, 0, 7, 9, 6, 2]}, {'string': 'еябцтнибэлшолцчклййфвьрюеошъоь', 'array': [5, 3, 16, 6, 22, 18, 27, 26, 23, 14, 4, 25, 24, 19, 13, 11, 21, 9, 15, 20, 8, 0, 2, 10, 12, 29, 1, 7, 17, 28]}, {'string': 'йзхедщьчуъкхпгоощьэнлшгон', 'array': [9, 14, 17, 7, 3, 1, 18, 22, 20, 4, 6, 10, 24, 0, 13, 23, 8, 19, 15, 5, 16, 2, 12, 11, 21]}, {'string': 'внлкшзггнзрдблуоущбжпеочсбтш', 'array': [13, 14, 23, 10, 8, 1, 3, 5, 26, 12, 19, 16, 20, 9, 7, 15, 27, 4, 17, 18, 11, 6, 25, 0, 22, 21, 24, 2]}, {'string': 'рреопищьхштьмгызямйпег', 'array': [7, 17, 6, 0, 12, 21, 11, 19, 9, 18, 13, 4, 10, 3, 20, 15, 16, 14, 2, 1, 8, 5]}, {'string': 'ядмтщпымкмгрмэвътмндйэт', 'array': [11, 0, 6, 9, 17, 4, 1, 14, 2, 18, 13, 5, 16, 7, 10, 8, 19, 20, 21, 15, 22, 3, 12]}, {'string': 'яугоюфагымк', 'array': [8, 9, 10, 1, 6, 5, 7, 2, 4, 0, 3]}, {'string': 'чьэтпхшхщяскдеьжвццйкфх', 'array': [8, 21, 17, 18, 13, 2, 15, 10, 11, 7, 20, 9, 3, 16, 22, 4, 0, 6, 12, 5, 1, 19, 14]}]" }
[ "" ]
{ "id": 79, "canonical_solution": "", "entry_point": "string_shuffle" }
Реши задачу по программированию. Начало функции: {function} Продолжи функцию так, чтобы она корректно работала. Ответ оформи по шаблону: ```python <code>```
{ "function": "from typing import List\n\n\ndef unequal_pairs(array: List[int]) -> int:\n \"\"\"Выведите количество таких пар чисел в списке array, в которых первое число равно второму, но индекс первого числа строго меньше индекса второго числа в array.\n Примеры:\n unequal_pairs(array=[9, 7, 3, 3, 5, 2, 3, 4, 9, 4]) == 5\n unequal_pairs(array=[5, 6, 8, 4, 3]) == 0\n \"\"\"", "tests": "[{'array': [9, 7, 3, 3, 5, 2, 3, 4, 9, 4]}, {'array': [5, 6, 8, 4, 3]}, {'array': [3, 3, 2, 9, 7, 6, 4, 2, 3, 9, 4, 2, 6, 5]}, {'array': []}, {'array': [2, 7, 4, 9, 5, 9, 1, 1, 4, 9, 4]}, {'array': [3, 5, 4, 4, 2, 2, 9]}, {'array': [1, 6, 9, 2, 3, 6, 3]}, {'array': [2, 5, 9, 3, 1]}, {'array': [2, 8, 9, 1, 6, 6, 7, 3, 2, 7, 7]}, {'array': [9, 1, 3, 6, 5, 7]}]" }
[ "" ]
{ "id": 80, "canonical_solution": "", "entry_point": "unequal_pairs" }
Тебе дана заготовка под функцию на языке Python: {function} Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
{ "function": "from typing import List\n\n\ndef shuffle_pairs(array: List[int]) -> List[int]:\n \"\"\"В списке array длины 2 * N перегруппируйте элементы так, чтобы они шли парами в порядке array[i], array[N + i] для всех i от 0 до (N-1). Выведите полученный список. гарантируется, что N не больше 1000.\n Примеры:\n shuffle_pairs(array=[8, 6, 2, 9, 2, 1, 1, 7, 2, 7, 1, 1, 9, 7, 2, 8]) == [8, 2, 6, 7, 2, 1, 9, 1, 2, 9, 1, 7, 1, 2, 7, 8]\n shuffle_pairs(array=[6, 5, 7, 6, 4, 1, 2, 5, 6, 4]) == [6, 1, 5, 2, 7, 5, 6, 6, 4, 4]\n \"\"\"", "tests": "[{'array': [8, 6, 2, 9, 2, 1, 1, 7, 2, 7, 1, 1, 9, 7, 2, 8]}, {'array': [6, 5, 7, 6, 4, 1, 2, 5, 6, 4]}, {'array': [4, 9]}, {'array': [3, 2, 7, 8, 8, 2]}, {'array': [9, 3, 9, 5, 4, 3, 5, 5, 5, 7, 9, 9, 9, 9, 8, 1, 7, 8]}, {'array': [1, 5, 2, 6]}, {'array': [8, 8, 8, 8, 7, 1, 9, 9, 7, 3, 3, 4, 3, 8, 4, 3]}, {'array': [6, 3, 9, 4, 6, 7]}, {'array': [3, 7, 8, 6, 8, 5, 3, 5, 6, 6, 9, 1, 7, 3, 6, 8]}, {'array': [1, 4, 4, 9, 5, 5, 1, 6, 1, 7, 7, 9, 6, 8, 8, 8, 1, 1]}]" }
[ "" ]
{ "id": 81, "canonical_solution": "", "entry_point": "shuffle_pairs" }
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров. Функция: {function} В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
{ "function": "from typing import List\n\n\ndef peculiar_numbers(matrix: List[List[int]]) -> List[int]:\n \"\"\"Красивым числом в матрице называется такое число, которое является строго наименьшим в своей строке и строго наибольшим в своем столбце. Выведите все уникальные красивые числа матрицы matrix в виде списка в порядке возрастания. Если таких чисел нет, выведите пустой список.\n Примеры:\n peculiar_numbers(matrix=[[4, 84, 8, 7, 91], [54, 65, 63, 24, 68], [77, 71, 78, 51, 67], [70, 87, 16, 20, 27], [95, 92, 98, 19, 48]]) == [51]\n peculiar_numbers(matrix=[[33, 10, 32, 35, 75, 82], [52, 18, 29, 12, 48, 94], [75, 86, 32, 19, 84, 91], [41, 75, 85, 12, 7, 31], [25, 6, 11, 18, 14, 44], [44, 96, 97, 42, 91, 95]]) == [42]\n \"\"\"", "tests": "[{'matrix': [[4, 84, 8, 7, 91], [54, 65, 63, 24, 68], [77, 71, 78, 51, 67], [70, 87, 16, 20, 27], [95, 92, 98, 19, 48]]}, {'matrix': [[33, 10, 32, 35, 75, 82], [52, 18, 29, 12, 48, 94], [75, 86, 32, 19, 84, 91], [41, 75, 85, 12, 7, 31], [25, 6, 11, 18, 14, 44], [44, 96, 97, 42, 91, 95]]}, {'matrix': [[40, 56, 90, 19, 87, 87], [79, 27, 59, 11, 40, 46], [28, 52, 6, 17, 68, 87], [90, 57, 78, 72, 69, 72], [98, 18, 24, 39, 89, 45], [59, 37, 98, 13, 1, 91]]}, {'matrix': [[35, 22, 1, 35, 37], [35, 3, 69, 38, 87], [71, 54, 98, 77, 66], [99, 20, 51, 82, 91], [36, 12, 54, 90, 9]]}, {'matrix': [[67, 97, 4, 24, 19], [68, 58, 90, 26, 65], [96, 30, 37, 26, 57], [21, 74, 23, 2, 76], [80, 79, 75, 18, 43]]}, {'matrix': [[69, 76, 48, 72, 29], [8, 35, 35, 45, 27], [90, 70, 85, 79, 60], [71, 13, 2, 40, 60], [94, 19, 11, 58, 3]]}, {'matrix': [[8, 27, 60, 53, 74], [15, 61, 48, 85, 24], [91, 66, 77, 86, 87], [12, 13, 46, 59, 9], [53, 56, 53, 61, 54]]}, {'matrix': [[78, 62, 88, 97, 63], [33, 5, 44, 53, 16], [64, 11, 59, 1, 69], [29, 43, 99, 46, 46], [82, 42, 5, 99, 93]]}, {'matrix': [[90, 69, 42, 81, 29, 68, 81], [37, 65, 45, 8, 6, 6, 20], [17, 48, 24, 63, 5, 1, 19], [33, 88, 26, 99, 20, 72, 14], [30, 25, 47, 88, 28, 31, 84], [5, 38, 91, 62, 19, 8, 13], [57, 49, 74, 87, 26, 66, 65]]}, {'matrix': [[16, 52, 64, 62, 99], [36, 40, 45, 26, 81], [87, 29, 90, 9, 62], [45, 8, 8, 69, 7], [76, 57, 64, 75, 60]]}]" }
[ "" ]
{ "id": 82, "canonical_solution": "", "entry_point": "peculiar_numbers" }
{function} Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
{ "function": "def single_change(number: int) -> int:\n \"\"\"Выведите максимально возможное число, которое можно получить из числа number заменой только одной цифры в нем на 6 или 9. Число number состоит только из 6 и 9.\n Примеры:\n single_change(number=6) == 9\n single_change(number=69) == 99\n \"\"\"", "tests": "[{'number': 6}, {'number': 69}, {'number': 999}, {'number': 6969}, {'number': 9696}, {'number': 9999}, {'number': 669}, {'number': 96969}, {'number': 6699}, {'number': 9}]" }
[ "" ]
{ "id": 83, "canonical_solution": "", "entry_point": "single_change" }
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами: {function} Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
{ "function": "def digits_difference(number: int) -> int:\n \"\"\"Выведите разность между произведением цифр числа number и суммой его цифр.\n Примеры:\n digits_difference(number=2) == 0\n digits_difference(number=28) == 6\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 387}, {'number': 1234}, {'number': 3568}, {'number': 876543}, {'number': 6}, {'number': 496}, {'number': 8128}, {'number': 98376}]" }
[ "" ]
{ "id": 84, "canonical_solution": "", "entry_point": "digits_difference" }
Решите задачу на Python. Функция: {function} Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
{ "function": "from typing import List\n\n\ndef merge_arrays(array1: List[int], array2: List[int]) -> List[int]:\n \"\"\"Сформируйте список чисел так, чтобы в его начале шли все числа списка array1, которые также встречаются в списке array2 в порядке их вхождения в array2, а затем шли все остальные элементы array1 в порядке возрастания. Выведите полученный список.\n Примеры:\n merge_arrays(array1=[27, 30, 10, 11, 37, 38, 6, 9, 3, 33, 30, 13, 15], array2=[32, 15, 34, 37, 3, 38, 3]) == [15, 37, 3, 38, 6, 9, 10, 11, 13, 27, 30, 30, 33]\n merge_arrays(array1=[39, 3, 17, 3, 36, 22, 8, 2, 21, 36, 33, 5, 28, 17], array2=[2, 20, 38, 4, 7, 8, 33, 3]) == [2, 8, 33, 3, 3, 5, 17, 17, 21, 22, 28, 36, 36, 39]\n \"\"\"", "tests": "[{'array1': [27, 30, 10, 11, 37, 38, 6, 9, 3, 33, 30, 13, 15], 'array2': [32, 15, 34, 37, 3, 38, 3]}, {'array1': [39, 3, 17, 3, 36, 22, 8, 2, 21, 36, 33, 5, 28, 17], 'array2': [2, 20, 38, 4, 7, 8, 33, 3]}, {'array1': [4, 3, 23, 9, 18, 20, 32, 18, 34, 33, 4, 33, 23], 'array2': [16, 18, 12, 9, 12, 38, 21, 32]}, {'array1': [19, 30, 5, 12, 24, 24, 16, 12, 15, 16, 33, 31], 'array2': [1, 16, 14, 10, 7, 38, 10, 38, 6]}, {'array1': [15, 31, 1, 2, 8, 28, 9, 23, 14, 6, 12, 1, 7], 'array2': [18, 20, 36, 17, 25, 6, 9]}, {'array1': [21, 2, 21, 23, 12, 2, 36, 35, 23, 8, 7, 5, 10, 8], 'array2': [12, 27, 28, 13, 7, 32, 27]}, {'array1': [31, 26, 22, 1, 17, 11, 27, 9, 15, 31, 2, 39, 1, 20], 'array2': [21, 28, 39, 17, 30, 17, 2]}, {'array1': [17, 35, 17, 17, 33, 21, 12, 10, 3, 22, 14, 23], 'array2': [22, 9, 21, 38, 20, 3, 7, 1]}, {'array1': [30, 2, 1, 4, 18, 34, 17, 29, 7, 3, 31, 25], 'array2': [34, 33, 12, 17, 19, 28, 21, 38, 28]}, {'array1': [8, 22, 23, 31, 35, 34, 9, 15, 31, 20, 8, 27], 'array2': [6, 17, 35, 18, 20, 22, 13, 25]}]" }
[ "" ]
{ "id": 85, "canonical_solution": "", "entry_point": "merge_arrays" }
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция: {function} Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
{ "function": "from typing import List\n\n\ndef double_zeros(array: List[int]) -> int:\n \"\"\"В списке array перенесите все ненулевые элементы в конец списка в порядке их появления в списке, а количество нулей в начале списка удвойте. Выведите сумму полученного списка с 0 индекса до индекса длины изначального списка. Если список пуст, выведите 0. Если в исходном списке нет нулей, ответом будет сумма всех элементов списка.\n Примеры:\n double_zeros(array=[0, 0, 2, 0, 0, 3]) == 5\n double_zeros(array=[4, 4, 2, 0, 0, 0, 0, 4, 3, 0, 0]) == 17\n \"\"\"", "tests": "[{'array': [0, 0, 2, 0, 0, 3]}, {'array': [4, 4, 2, 0, 0, 0, 0, 4, 3, 0, 0]}, {'array': [1, 1, 2, 4, 2, 1]}, {'array': [1, 4, 3, 1, 2, 0, 0, 4, 1]}, {'array': [0, 0, 3, 2, 3, 1]}, {'array': [0, 0, 0, 0, 3, 1, 1, 4, 4]}, {'array': [2, 1, 2, 2, 4, 4, 4, 4, 0, 0, 4, 3, 0, 0]}, {'array': [4, 4, 2, 4, 4, 2, 3]}, {'array': []}, {'array': [0, 0, 0, 0, 0, 0]}]" }
[ "" ]
{ "id": 86, "canonical_solution": "", "entry_point": "double_zeros" }
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции. Функция: {function} Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
{ "function": "def delete_primitives(string: str) -> int:\n \"\"\"Минимальная корректная скобочная последовательность (состоит из двух скобок), называется примитивом. Удалите из строки со скобочной последовательностью string все примитивы. Если при удалении примитивов возникают новые примитивы, их тоже нужно удалить. Выведите длину оставшейся после удаления всех возможных примитивов строки. Скобки могут быть трех видов: круглые, квадратные и фигурные - данные виды скобок не взимозаменяемы и независимы друг от друга.\n Примеры:\n delete_primitives(string=[ ] [ ] [ ] [ ] ( [ ] { } ) ( { } ( ) )) == 0\n delete_primitives(string=} { ( ] [ { [ ( ) ) ( )) == 8\n \"\"\"", "tests": "[{'string': '[ ] [ ] [ ] [ ] ( [ ] { } ) ( { } ( ) )'}, {'string': '} { ( ] [ { [ ( ) ) ( )'}, {'string': '[ ] [ ] [ ] [ { } ] ( { ( [ ] ( ) ) } )'}, {'string': '{ ) } ( [ ] ) [ ) } ] )'}, {'string': ') [ ] ) { { ] ( [ [ } { ( ( { ] } } ) )'}, {'string': '[ ] [ ] [ ] [ ] ( ) { { ( ) ( ) } } { }'}, {'string': '[ [ ( ) { } ] ]'}, {'string': '[ { [ } { { ] ] ) ( } )'}, {'string': '( [ ] ) ( { [ ] } { } )'}, {'string': '[ ] [ ] [ ] [ { } ( { } { } ) ] { [ ] }'}]" }
[ "" ]
{ "id": 87, "canonical_solution": "", "entry_point": "delete_primitives" }
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции: {function} Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
{ "function": "from typing import List\n\n\ndef common_symbols(array: List[str]) -> List[str]:\n \"\"\"В списке строк array найдите символы, которые встречаются в каждой из строк и выведите список из данных символов в лексикографическом порядке.\n Примеры:\n common_symbols(array=['ежззхкющц', 'скщйбвпьк', 'щчыв', 'огкээр', 'ячюпшм', 'щщсдткчвяа']) == []\n common_symbols(array=['иннторяъф', 'еттижоъыфнюъ', 'умнтоюиьыяхй', 'ифчукоызгээ', 'исоэжнб']) == ['и', 'о']\n \"\"\"", "tests": "[{'array': ['ежззхкющц', 'скщйбвпьк', 'щчыв', 'огкээр', 'ячюпшм', 'щщсдткчвяа']}, {'array': ['иннторяъф', 'еттижоъыфнюъ', 'умнтоюиьыяхй', 'ифчукоызгээ', 'исоэжнб']}, {'array': ['оащцтъшбвк', 'зкцаханфрс', 'эцюшэпчаювоз', 'алцоккщзаж', 'ииаяхжщбакц']}, {'array': ['ляькыакв', 'ьбокцхлощдз', 'тавэысжэчрр', 'яцк', 'нпеюф']}, {'array': ['цуюътнэ', 'лэркщмфжпфвю', 'пщщвьунюэйев', 'фсскчлцэуяюъ', 'лдчютйхсэу']}, {'array': ['рбумивджн', 'жюьюцеид', 'имзвцмпмсоэ', 'ззши', 'окэ', 'ребягщоумйую', 'юмаычук', 'окзсчсчежрн']}, {'array': ['соькехти', 'ьъийсзоукмаб', 'коцспямпшгг', 'ъытммсзщка', 'квас']}, {'array': ['ешккихху', 'крненкхукси', 'ьйгфвцхуцхшг', 'тбюфдухдфщгс', 'блухэяпач']}, {'array': ['мсешаокпбф', 'бтцдчийч', 'тммтьц', 'омд', 'ыфбамзф', 'цвхьт', 'пстытажъмзя', 'иющъфш', 'зкбьеен', 'птлгчжы', 'евыум', 'ощицг']}, {'array': ['хгмщоцэкегэю', 'пэгофтцаыщу', 'цчмгхащ', 'шщтбъгюыдип', 'ыуфсущугь']}]" }
[ "" ]
{ "id": 88, "canonical_solution": "", "entry_point": "common_symbols" }
Напиши продолжение данной функции: {function} Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
{ "function": "from typing import List\n\n\ndef parity_sort(array: List[int]) -> List[int]:\n \"\"\"Перенесите все четные элементы списка array в его начало, отсортировав их в порядке возрастания. В конце списка должны идти его нечетные элементы также в порядке возрастания. Выведите полученный список.\n Примеры:\n parity_sort(array=[21, 93, 25, 24, 68, 22, 42, 52, 42, 48, 94, 85, 36]) == [22, 24, 36, 42, 42, 48, 52, 68, 94, 21, 25, 85, 93]\n parity_sort(array=[79, 66, 65, 28, 53, 72, 86, 25, 64, 59, 50, 41, 54]) == [28, 50, 54, 64, 66, 72, 86, 25, 41, 53, 59, 65, 79]\n \"\"\"", "tests": "[{'array': [21, 93, 25, 24, 68, 22, 42, 52, 42, 48, 94, 85, 36]}, {'array': [79, 66, 65, 28, 53, 72, 86, 25, 64, 59, 50, 41, 54]}, {'array': [89, 97, 62, 28, 94]}, {'array': [2, 28, 56, 89, 51, 96]}, {'array': [45, 39, 16, 13, 1, 54, 28, 69, 96, 1, 1, 13, 23, 55]}, {'array': [8, 32, 32, 56, 9, 85, 91, 77, 93]}, {'array': [59, 94, 6, 19, 3, 35, 24, 95, 4]}, {'array': [51, 26, 46, 82, 34, 84, 43, 67, 78, 96, 76, 54, 56, 81]}, {'array': [43, 81, 36, 16, 79, 19, 42, 77, 8, 45, 8, 19]}, {'array': [98, 65, 37, 93, 6, 32]}]" }
[ "" ]
{ "id": 89, "canonical_solution": "", "entry_point": "parity_sort" }
Реши задачу по программированию. Начало функции: {function} Продолжи функцию так, чтобы она корректно работала. Ответ оформи по шаблону: ```python <code>```
{ "function": "def beautiful_number(number: int) -> str:\n \"\"\"Число называется красивым, если путем конечного числа разрешенных операций оно превращается в 1. Разрешенным действием для числа является его замена на сумму квадратов его цифр. Определите, является ли число number красивым. Если да, то выведите \"Да\", иначе выведите \"Нет\". Если разрешенные операции приводят к бесконечному циклу повторяющихся результатов, то такое число не является красивым.\n Примеры:\n beautiful_number(number=2) == 'Нет'\n beautiful_number(number=28) == 'Да'\n \"\"\"", "tests": "[{'number': 2}, {'number': 28}, {'number': 387}, {'number': 1234}, {'number': 3568}, {'number': 876543}, {'number': 6}, {'number': 496}, {'number': 8128}, {'number': 98376}]" }
[ "" ]
{ "id": 90, "canonical_solution": "", "entry_point": "beautiful_number" }
Тебе дана заготовка под функцию на языке Python: {function} Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию.
{ "function": "from typing import List\n\n\ndef symmetic_difference(set1: set, set2: set) -> List[int]:\n \"\"\"Даны два списка чисел: set1 и set2. Преобразуйте списки в множества. Выведите симметрическую разность множест в виде отсортированного по возрастанию списка. Симметрическая разность множеств – это совокупность элементов этих множеств, которые есть только в одном из них.\n Примеры:\n symmetic_difference(set1=[2, 3, 5, 6, 7, 8, 11], set2=[3, 4, 5, 7, 8, 9, 11]) == [2, 4, 6, 9]\n symmetic_difference(set1=[2, 3, 4, 5, 7, 8, 10, 11], set2=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) == [1, 6, 9]\n \"\"\"", "tests": "[{'set1': [2, 3, 5, 6, 7, 8, 11], 'set2': [3, 4, 5, 7, 8, 9, 11]}, {'set1': [2, 3, 4, 5, 7, 8, 10, 11], 'set2': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}, {'set1': [1, 2, 4, 5, 7, 10, 11], 'set2': [1, 2, 3, 4, 5, 7, 8, 9, 10, 11]}, {'set1': [1, 2, 3, 4, 5, 7, 8, 10, 11], 'set2': [1, 3, 4, 6, 7, 9, 10, 11]}, {'set1': [1, 3, 4, 5, 6, 7, 8, 9, 11], 'set2': [1, 3, 4, 5, 6, 7, 8, 9, 11]}, {'set1': [1, 2, 3, 4, 6, 9, 10, 11], 'set2': [2, 3, 4, 6, 7, 8, 10, 11]}, {'set1': [1, 2, 3, 4, 7, 8, 9, 10, 11], 'set2': [1, 4, 5, 6, 8, 9, 11]}, {'set1': [1, 2, 3, 4, 6, 7, 8, 9, 10], 'set2': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}, {'set1': [1, 2, 5, 6, 7, 8, 9, 10, 11], 'set2': [1, 2, 3, 4, 7, 8, 9, 11]}, {'set1': [1, 2, 5, 6, 7, 9, 10], 'set2': [1, 2, 4, 7, 8, 10, 11]}]" }
[ "" ]
{ "id": 91, "canonical_solution": "", "entry_point": "symmetic_difference" }
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров. Функция: {function} В качестве ответа напиши только продолжение функции. Не пиши ничего другого, не веди диалог, не приводи рассуждений, пиши только ответ. Начни ответ с табуляции. Не считывай данные через input или sys. Используй markdown разметку, чтобы выделить написанный тобой код (пример оформления: ```python <code>```).
{ "function": "from typing import List\n\n\ndef set_complement(set1: set, set2: set) -> List[int]:\n \"\"\"Даны два списка чисел: set1 и set2. Преобразуйте списки в множества. Выведите дополнение set1 до set2 в виде отсортированного по возрастанию списка. Дополнением множества до другого множества являются элементы, которые есть во втором множестве и нет в первом.\n Примеры:\n set_complement(set1=[2, 3, 4, 5, 6, 7, 8, 9, 10, 11], set2=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]) == [1]\n set_complement(set1=[2, 3, 6, 7, 8, 9, 10, 11], set2=[1, 2, 3, 4, 7, 9, 10, 11]) == [1, 4]\n \"\"\"", "tests": "[{'set1': [2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 'set2': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}, {'set1': [2, 3, 6, 7, 8, 9, 10, 11], 'set2': [1, 2, 3, 4, 7, 9, 10, 11]}, {'set1': [1, 2, 4, 5, 6, 7, 8, 9, 10, 11], 'set2': [1, 2, 4, 5, 6, 9, 11]}, {'set1': [1, 2, 4, 5, 6, 7, 8, 9, 11], 'set2': [1, 2, 3, 4, 5, 7, 8, 9, 10]}, {'set1': [1, 3, 4, 5, 6, 7, 10, 11], 'set2': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]}, {'set1': [1, 5, 6, 7, 8, 10, 11], 'set2': [1, 4, 5, 6, 7, 9]}, {'set1': [2, 6, 7, 9, 11], 'set2': [2, 3, 5, 6, 7, 9, 10, 11]}, {'set1': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], 'set2': [1, 2, 4, 6, 7, 8, 9]}, {'set1': [1, 2, 3, 6, 7, 8, 9, 10], 'set2': [4, 5, 6, 7, 8, 9, 10, 11]}, {'set1': [1, 2, 3, 4, 5, 6, 7, 8, 9, 11], 'set2': [2, 4, 6, 7, 8]}]" }
[ "" ]
{ "id": 92, "canonical_solution": "", "entry_point": "set_complement" }
{function} Это начало функции на языке Python. Закончите ее, то есть напишите недостающий кусок, который реализует логику работы функции в соответствии с описанием из документации и приведенными тестами. Пишите только недостающий кусок. Соблюдайте отступы и поместите код внутрь markdown шаблона ```python PYTHON_CODE```
{ "function": "from typing import List\n\n\ndef words_dictionary(array: List[str]) -> dict:\n \"\"\"Дан список слов array. Создайте словарь, где ключами будут слова из списка, а значениями – порядковые номера данных слов в списке. Выведите получившийся словарь. Гарантируется, что слова в списке уникальные.\n Примеры:\n words_dictionary(array=['зэшхкхэр', 'ъщнкшбжм', 'агшф', 'птчую', 'лбфигхъймщв', 'ющкйь', 'они', 'тфуенбжгтаэе', 'узчг', 'уяпрбздихчъ', 'лгйрцжюпца']) == {'зэшхкхэр': 0, 'ъщнкшбжм': 1, 'агшф': 2, 'птчую': 3, 'лбфигхъймщв': 4, 'ющкйь': 5, 'они': 6, 'тфуенбжгтаэе': 7, 'узчг': 8, 'уяпрбздихчъ': 9, 'лгйрцжюпца': 10}\n words_dictionary(array=['вгньшфбяпр', 'чрзшгасаро', 'щьырбв', 'жфг', 'рфгмьеуацй', 'ьдбринс', 'мнзиъгушаь', 'ъзьыпю']) == {'вгньшфбяпр': 0, 'чрзшгасаро': 1, 'щьырбв': 2, 'жфг': 3, 'рфгмьеуацй': 4, 'ьдбринс': 5, 'мнзиъгушаь': 6, 'ъзьыпю': 7}\n \"\"\"", "tests": "[{'array': ['зэшхкхэр', 'ъщнкшбжм', 'агшф', 'птчую', 'лбфигхъймщв', 'ющкйь', 'они', 'тфуенбжгтаэе', 'узчг', 'уяпрбздихчъ', 'лгйрцжюпца']}, {'array': ['вгньшфбяпр', 'чрзшгасаро', 'щьырбв', 'жфг', 'рфгмьеуацй', 'ьдбринс', 'мнзиъгушаь', 'ъзьыпю']}, {'array': ['нуичл', 'юфкдлшзй', 'нъж', 'юзщ', 'ицщчешжзв', 'счхжржтъпуар', 'ияэьяьщ']}, {'array': ['внащьнд', 'мывблх', 'рюеь', 'аждэжгж', 'юлрилмкпк', 'сярнсшпл', 'йвая', 'ддцрмцбм', 'ъщяжхарс', 'аъйгу', 'жхцчлкл']}, {'array': ['пиря', 'ынхйыщжйън', 'хршйхзсб', 'лхчуяж', 'эцкгщыбсщшщк', 'таущзнт', 'эсигро']}, {'array': ['лдфшц', 'зршмъм', 'шзгыл', 'ревв', 'теыьп', 'щцафдщфцвжщ', 'ъаъчщтуаъч', 'ъяйпкябиуге']}, {'array': ['дкб', 'эзврцчу', 'ъюоткеьилзю', 'ксюгасъхкцдж', 'ыоюз', 'мцинчгч', 'штженайюонд', 'зчжяюф', 'хэлюды']}, {'array': ['эхюгбыэскх', 'ейеьчрвлди', 'тямьяцкацх', 'хббцащсц', 'аль', 'гнфляэмр', 'ыжцчщьюф', 'бйвбэщ']}, {'array': ['пндищнщй', 'омонфп', 'гэггчългф', 'уейябмдку', 'аофшею', 'эдпдьтяи', 'юыьбыу', 'южуфююсущ', 'зкяксьсйън', 'крйапуоцщтх', 'ююи', 'фиьйнму']}, {'array': ['глуйящ', 'цлйвешюсфкж', 'кхюо', 'дщброхз', 'попежпбчэ', 'слйеьшцщсери', 'ньпхххофьпх', 'лчеэшяндечр', 'бввящшвэй', 'шдслуию', 'гфвдч', 'кдгя', 'юфулэзп']}]" }
[ "" ]
{ "id": 93, "canonical_solution": "", "entry_point": "words_dictionary" }
Вы - программист на Python, который умеет решать алгоритмические задачи. Посмотрите на начало функции с док-строкой и тестами: {function} Закончите функцию, соблюдая отступы и синтаксис Python. Код должен быть помещен внутрь блока ```python PYTHON_CODE```
{ "function": "from typing import List\n\n\ndef prefix_string(string: str, array: List[str]) -> str:\n \"\"\"Дана непустая строка string и непустой список строк array. Определите, является ли строка префиксом списка. Строка называется префиксом списка, если строка в точности равна конкатенации первых N слов из списка. Выведите \"Да\", если является, и \"Нет\", если не является.\n Примеры:\n prefix_string(string=флюгегехаймен, array=['флю', 'гег', 'еха', 'ймен', 'питон']) == 'Да'\n prefix_string(string=программирование, array=['про', 'грам', 'иро', 'вание', 'на', 'си']) == 'Нет'\n \"\"\"", "tests": "[{'string': 'флюгегехаймен', 'array': ['флю', 'гег', 'еха', 'ймен', 'питон']}, {'string': 'программирование', 'array': ['про', 'грам', 'иро', 'вание', 'на', 'си']}, {'string': 'метафора', 'array': ['ме', 'тафо', 'ра', 'текста', 'в', 'тексте']}, {'string': 'кяшвеэзюимдчжтущсъфлаойбрцхныпьг', 'array': ['кяш', 'веэзю', 'им', 'дчжтущс', 'ъфла', 'ойбрц', 'хнып', 'ьг']}, {'string': 'мъчузцквюхепяьжсдлфрышщгонабтийэ', 'array': ['мъчу', 'зцквюх', 'еп', 'яьжсдлфрышщгон', 'абтийэ']}, {'string': 'фгпэытиьежйлоюамбквзцхущшрч', 'array': ['фгпнъдсяэытиьежйлоюамбквзцхущшрч']}, {'string': 'смлыгрхцпнвщдъошеяьжфэйбюкачзути', 'array': ['смлыгр', 'хцпнвщдъош', 'еяьжфэйбюка', 'чзути', 'кек']}, {'string': 'чьщсяэшмдзхежпюфтгцоива', 'array': ['чьщыб', 'сяэшмдйлз', 'хежпнък', 'юфтгцру', 'оива']}, {'string': 'кшфйцодутмьвюяхечщрзлнсыиэбъгжпа', 'array': ['кшф', 'йцоду', 'тмьвю', 'яхечщ', 'рзлнсыиэбъ', 'гжпа', 'гойдф', 'атом']}, {'string': 'йшоярыгавниъзфбжкдхпьэм', 'array': ['йшоеяры', 'ющгавнисцт', 'ъзфбжкдул', 'хпьчэм', 'вфылорп', 'ыровиа']}]" }
[ "" ]
{ "id": 94, "canonical_solution": "", "entry_point": "prefix_string" }
Решите задачу на Python. Функция: {function} Продолжите функцию так, чтобы она выполняла задачу, прописанную в док-строке, а также проходила тесты, которые приводятся. Не пишите функцию целиком - только продолжение функции выше. Верните продолжение функции, используя для кода markdown шаблон ```python CODE```, с соблюдением отступов. Начните ответ с табуляции.
{ "function": "def three_divisors(number: int) -> str:\n \"\"\"Дано целое число number. Определите количество натуральных делитетей данного числа. Выведите \"Да\", если таких делителей в точности 3. Иначе, выведите \"Нет\".\n Примеры:\n three_divisors(number=4) == 'Да'\n three_divisors(number=28) == 'Нет'\n \"\"\"", "tests": "[{'number': 4}, {'number': 28}, {'number': 841}, {'number': 1234}, {'number': 9409}, {'number': 876543}, {'number': 6}, {'number': 25}, {'number': 3721}, {'number': 49729}]" }
[ "" ]
{ "id": 95, "canonical_solution": "", "entry_point": "three_divisors" }
Напиши, как нужно продолжить функцию на Python, чтобы она корректно работала, имела функционал, прописанный в док-строке, и проходила тесты. Функция: {function} Напиши ответ на языке Python. Не веди диалог. Пиши сразу ответ - продолжение функции, начиная с табуляции, внутри markdown шаблона (```python <code>```)
{ "function": "def alphabet_encoding(number: int, string: str) -> int:\n \"\"\"Дана строка string и натуральное число number. Замените в string все буквы на их порядковые номера в русском алфавите. Для получившегося числа преобразуйте его в сумму его цифр number раз. Выведите получившееся число в целочисленном виде.\n Примеры:\n alphabet_encoding(string=флюгегехаймен, number=4) == 6\n alphabet_encoding(string=метафора, number=3) == 3\n \"\"\"", "tests": "[{'string': 'флюгегехаймен', 'number': 4}, {'string': 'метафора', 'number': 3}, {'string': 'йсучиюывдум', 'number': 3}, {'string': 'щбфсхяясйгыгнгнфщщ', 'number': 3}, {'string': 'удлшмдуыхшьхмъйвцяьрзятфъшыфднйу', 'number': 3}, {'string': 'еяиичсняхпщссюниьдвахыф', 'number': 3}, {'string': 'фююейяысачхвкяфйфгъфлбчпнмкю', 'number': 3}, {'string': 'вюччцлшаевюасхлйюьбсжмч', 'number': 1}, {'string': 'кпкдйбняомбфьчябмыэвхдйдрбэфэрзмдч', 'number': 4}, {'string': 'аршэядцепйцнчфытъкщщщпхъдр', 'number': 3}]" }
[ "" ]
{ "id": 96, "canonical_solution": "", "entry_point": "alphabet_encoding" }
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции. Функция: {function} Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```)
{ "function": "def unique_frequency(string: str) -> str:\n \"\"\"Дана строка string. Определите, одинаково ли число вхождений в строку для каждого уникального символа из string. Выведите \"Да\", если одинаково. Иначе, выведите \"Нет\".\n Примеры:\n unique_frequency(string=шаллаш) == 'Да'\n unique_frequency(string=аффирмации) == 'Нет'\n \"\"\"", "tests": "[{'string': 'шаллаш'}, {'string': 'аффирмации'}, {'string': 'йвоюфациылрм'}, {'string': 'лвопаицрмф'}, {'string': 'йдмыфпуицаов'}, {'string': 'алюфвойуцмп'}, {'string': 'вомрафыцйл'}, {'string': 'выйооцдййлмалурылфйлффаююроццавуювыиу'}, {'string': 'ыырювувюиюрфропыыфуиповммпоуриыацлыицаыйирццв'}, {'string': 'ппайфлиавапдмвмцвмпйдфуоююыицувфю'}]" }
[ "" ]
{ "id": 97, "canonical_solution": "", "entry_point": "unique_frequency" }
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции: {function} Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```).
{ "function": "def pythagorean_triplets(number: int) -> int:\n \"\"\"Дано целое положительное число number. Выведите количество троек целых чисел, каждое из которых больше или равно 1 и меньше или равно number, таких, что сумма квадратов первых двух чисел равна квадрату второго.\n Примеры:\n pythagorean_triplets(number=13) == 6\n pythagorean_triplets(number=10) == 4\n \"\"\"", "tests": "[{'number': 13}, {'number': 10}, {'number': 40}, {'number': 37}, {'number': 35}, {'number': 31}, {'number': 28}, {'number': 4}, {'number': 12}, {'number': 14}]" }
[ "" ]
{ "id": 98, "canonical_solution": "", "entry_point": "pythagorean_triplets" }
Напиши продолжение данной функции: {function} Ответ начни с табуляции, используй markdown (```python CODE```), не веди диалог и не приводи рассуждения, пояснения, не пиши комментарии к кому, не объявляй классы и не выходи за пределы тела данной функции.
{ "function": "from typing import List\n\n\ndef shuffle_array(array: List[int]) -> List[int]:\n \"\"\"Дан список array из целых чисел от 0 до длины array минус 1 включительно. Постройте на основе списка array новый список, i-й элемент которого равен array[array[i]] для всех i от 0 до длины списка array. Выведите полученный список.\n Примеры:\n shuffle_array(array=[1, 0, 3, 2, 4]) == [0, 1, 2, 3, 4]\n shuffle_array(array=[5, 1, 0, 4, 2, 3]) == [3, 1, 5, 2, 0, 4]\n \"\"\"", "tests": "[{'array': [1, 0, 3, 2, 4]}, {'array': [5, 1, 0, 4, 2, 3]}, {'array': [3, 5, 0, 7, 4, 6, 1, 2]}, {'array': [1, 4, 7, 5, 3, 6, 2, 0]}, {'array': [8, 7, 6, 9, 4, 2, 1, 0, 3, 11, 5, 10]}, {'array': [5, 6, 2, 4, 7, 8, 3, 0, 1]}, {'array': [0, 3, 5, 1, 4, 6, 2, 7]}, {'array': [3, 0, 2, 6, 7, 1, 4, 5]}, {'array': [7, 3, 6, 1, 12, 2, 11, 0, 10, 5, 4, 13, 9, 8]}, {'array': [1, 4, 3, 0, 2]}]" }
[ "" ]
{ "id": 99, "canonical_solution": "", "entry_point": "shuffle_array" }
End of preview. Expand in Data Studio

ruCodeEval

Task Description

Russian Code Evaluation (ruCodeEval) is the Russian analog of the original HumanEval dataset, created to evaluate the ability of language models to generate code in the Python programming language to solve simple problems. The dataset contains 164 tasks and aims to measure the functional correctness of code generation based on information from the function's documentation lines—a text description of the function's operation and several examples of results for different input data.

This set is a private analogue of ruHumanEval.

Evaluated skills: Instruction Following, Code Perception, Completion, Algorithms & Data Structures

Contributors: Artem Chervyakov, Albina Akhmetgareeva, Katerina Kolomeytseva, Anastasia Kozlova, Alena Fenogenova

Motivation

This task tests the ability of models to generate simple Python programs based on a description (condition) in natural language. Since large models have in their training corpus a proportion of texts (programs) written in various programming languages, they are assumed to have the ability to understand and write code for simple tasks.

Dataset Description

Data fields

  • instruction is a string containing instructions for the task;
  • inputs is a dictionary that contains the following information:
    • function is a line containing the function signature, as well as its docstring in the form of an unwritten function;
    • tests is a list of dictionaries that contain input data of test cases for a given task (variants of input data on which the final function code is tested);
  • outputs is a two-dimensional array of size (n_samples, n_tests), where n_samples is the number of samples required to calculate the pass@k metric, n_tests is the number of test cases in tests; each list in the outputs is the same and contains correct answers to all test cases as strings;
  • meta is a dictionary containing meta information:
    • id is an integer indicating the index of the example;
    • canonical_solution is the canonical solution;
    • entry_point is the function name.

Data formatting example

Below is an example from the dataset:

{
    "instruction": "Необходимо реализовать логику на языке Python для следующей программы\n{function}",
    "inputs": {
        "function": "\n\ndef greatest_common_divisor(a: int, b: int) -> int:\n    \"\"\"Верните наибольший общий делитель двух целых чисел a и b.\n    Примеры: \n        greatest_common_divisor(3, 5) \n        1 \n        greatest_common_divisor(25, 15) \n        5\n    \"\"\"",
        "tests": "[{'a': 100, 'b': 50}, {'a': 98, 'b': 56}, {'a': 540, 'b': 288}, {'a': 81, 'b': 27}, {'a': 33, 'b': 55}, {'a': 7, 'b': 13}, {'a': 14, 'b': 28}, {'a': 10, 'b': 25}, {'a': 12, 'b': 54}, {'a': 21, 'b': 35}]"
    },
    "outputs": [
        "50",
        "14",
        "36",
        "27",
        "11",
        "1",
        "14",
        "5",
        "6",
        "7"
    ],
    "meta": {
        "id": 13,
        "canonical_solution": "\n\n    def query_gcd(a: int, b: int) -> int:\n        return a if b == 0 else query_gcd(b, a % b)\n    return query_gcd(a, b)    \n\n",
        "entry_point": "greatest_common_divisor"
    }
}

Prompts

For this task 10 prompts of varying difficulty were created. Example:

"Допишите код на языке Python в соответствии с условием, приведенным в описании\n{function}"

Dataset Creation

The test set was manually collected from open sources according to the format of the original open set openai_humaneval, adjusted the dataset to avoid data leakage in training and took into account the corrections described in [2].

Evaluation

Metrics

The model is evaluated using the pass@k metric, which is computed as follows:

pass@k:=Eproblems[1(nck)(nk)] pass@k:=\mathbb{E}_{problems}\left[1-\frac{\binom{n-c}{k}}{\binom{n}{k}}\right]

Notation: n is the total number of generated solution options, c is the number of solutions that are correct, k is the selected indicator, how many options are taken into account.

To calculate pass@k, n ≥ k solutions are generated for each problem and are run through test cases (we use n = 10 and k ≤ 10 and an average of 10 test cases per problem). Then, the number of the correct solutions is calculated (c ≤ n). The solution is considered to be correct if it passes all test cases. That means the result of running solutions on test cases should be equal to the correct answers (outputs) for one problem. Such an evaluation process yields an unbiased score.

References

[1] Chen, Mark, et al. "Evaluating large language models trained on code." arXiv preprint arXiv:2107.03374 (2021).

[2] Jiawei Liu, Chunqiu Steven Xia, Yuyao Wang, Lingming Zhang Is Your Code Generated by ChatGPT Really Correct? Rigorous Evaluation of Large Language Models for Code Generation.

Downloads last month
185

Collection including MERA-evaluation/ruCodeEval