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':... | [
""
] | {
"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}... | [
""
] | {
"id": 1,
"canonical_solution": "",
"entry_point": "sum_digits"
} |
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}... | {
"function": "def clock_time(number: int) -> str:\n \"\"\"Выведите сколько времени покажут часы, запущенные в полночь, спустя number секунд. Используйте 24-часовую систему. Выведите ответ в формате: HH:MM:SS. Если минуты или секунды меньше 10, добавьте в начало 0.\n Примеры:\n clock_time(number=25446) ==... | [
""
] | {
"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=... | [
""
] | {
"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 процентов, если из... | [
""
] | {
"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 второй точки, определите, лежат ли они в одной четверти декартовой системы координат. Если лежат, вы... | [
""
] | {
"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 быть первой и последней квартирой в одном подъезде дома? В доме больше одного подъезда, в каждом подъезде всегда одинаковое количество квартир. Нумерация ква... | [
""
] | {
"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 прямоугольников в одно действие. Отделять прямоугольники можно только по прямой линии (разрезать на две части по прямой). Например, нельзя разре... | [
""
] | {
"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, является ли данный треугольник остроугольным. Треугольник является остроугольным, если сумма квадратов длин его двух сторон меньше квадрата третьей... | [
""
] | {
"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 второй коробки определите, можно ли поместить одну из данных ко... | [
""
] | {
"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 ... | [
""
] | {
"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 s... | [
""
] | {
"id": 11,
"canonical_solution": "",
"entry_point": "solve_equation"
} |
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}... | {
"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 \"\"\""... | [
""
] | {
"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},... | [
""
] | {
"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 \"\"\"",
... | [
""
] | {
"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_maxi... | [
""
] | {
"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_sub... | [
""
] | {
"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) в квадрате. Округлите отв... | [
""
] | {
"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=Бедность не ... | [
""
] | {
"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=Аппетит приходиты) == 'прих... | [
""
] | {
"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 se... | [
""
] | {
"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 ... | [
""
] | {
"id": 21,
"canonical_solution": "",
"entry_point": "quadratic_equation"
} |
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}... | {
"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. Коэффициенты всегда являются целыми числами. Если система с данными значениями ... | [
""
] | {
"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= ) == 'М а л о т е Н п... | [
""
] | {
"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 нет ни одного подходящего под условие числа, выведит... | [
""
] | {
"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... | [
""
] | {
"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, la... | [
""
] | {
"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=[... | [
""
] | {
"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 Примеры:\... | [
""
] | {
"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_arra... | [
""
] | {
"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, ... | [
""
] | {
"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). В остальны... | [
""
] | {
"id": 31,
"canonical_solution": "",
"entry_point": "array_xor"
} |
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}... | {
"function": "def dirichlet_rabbits(num_cages: int, num_rabbits: int) -> int:\n \"\"\"Если есть num_cages клеток для кроликов, по которым рассадили num_rabbits кроликов, то какое наибольшее количество кроликов может оказаться в одной клетке? Кролики рассаживаются по клеткам равномерно. Это значит, что можно сажат... | [
""
] | {
"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 строка я... | [
""
] | {
"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 ... | [
""
] | {
"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 встречает... | [
""
] | {
"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 из длин отрезков. Сколько есть способов выбрать из данного массива три элемента, из которых получится невырожденный треугольник? Невырожденным является треугольник, у которого всегда одна сторо... | [
""
] | {
"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). Вычислите и выведите периметр данного треугольника. Периметр треу... | [
""
] | {
"id": 37,
"canonical_solution": "",
"entry_point": "triangle_perimeter"
} |
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции:
{function}
Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```). | {
"function": "def closest_fibonacci(number: int) -> int:\n \"\"\"Выведите ближайшее к числу number число Фибоначчи. Близость одного числа к другому определяется, как модуль разности данных чисел. Числа Фибоначчи – это такие числа, каждое из которых равно сумме двух предыдущих, а первое и второе равны единице. Есл... | [
""
] | {
"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'... | [
""
] | {
"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 часов? После того, как велосипедист проеде... | [
""
] | {
"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 ... | [
""
] | {
"id": 41,
"canonical_solution": "",
"entry_point": "find_maximum"
} |
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}... | {
"function": "def leap_year(number: int) -> str:\n \"\"\"Определите, является ли год с номером number високосным. Високосный год либо делится на 400, либо не делится на 100 и делится на 4. Выведите \"Да\", если является, иначе выведите \"Нет\".\n Примеры:\n leap_year(number=2) == 'Нет'\n leap_year(... | [
""
] | {
"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. Определите, одинаковые ли цвета у ячеек, на которых расположены данные фигуры. Если одинако... | [
""
] | {
"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 fin... | [
""
] | {
"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. Найдите среднее арифметическое данного массива. Среднее арифметическое массива чисел равно сумме всех чисел массива, поделенной на количество чисел в массиве. Гарантируется, что массив име... | [
""
] | {
"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. Найдите среднее геометрическое данного массива. Среднее геометрическое массива равно произведению всех чисел массива, из которого взят арифметический корень степени равной количеству элемен... | [
""
] | {
"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. Найдите среднее гармоническое данного массива. Среднее гармоническое массива равно частному размера массива и суммы чисел, которые равны обратным элементам массива (единица разделить на элем... | [
""
] | {
"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. Найдите моду данного массива. Модой массива чисел является число, которое встречается в данном массиве чаще всего. Если таких значений больше, чем одно, то выведите наименьшее из них. Если в масс... | [
""
] | {
"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(strin... | [
""
] | {
"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. Сколько циклических сдвигов вправо нужно сделать в данном массиве, чтобы он стал отсортированным? Выведите получившееся число. Если сдвигами отсортировать массив невозможно, то выведи... | [
""
] | {
"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_... | [
""
] | {
"id": 51,
"canonical_solution": "",
"entry_point": "are_coprime"
} |
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}... | {
"function": "def even_indicies(string: str) -> str:\n \"\"\"Дана строка string. Выведите строку, которая состоит из всех символов string, имеющих четный индекс. Если строка пустая, выведите ее.\n Примеры:\n even_indicies(string=Флюгегехаймен) == 'Фюееамн'\n even_indicies(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... | [
""
] | {
"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, если и... | [
""
] | {
"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, ... | [
""
] | {
"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 ... | [
""
] | {
"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=... | [
""
] | {
"id": 57,
"canonical_solution": "",
"entry_point": "russian_round"
} |
Прочитайте сигнатуру функции с названием и параметрами, док-строку с описанием основного функционала и тестами - данными для проверки работоспособности функции. Напишите продолжение функции:
{function}
Код нужно написать, используя синтаксис markdown (```python PYTHON_CODE```). | {
"function": "def inverse_vowels(string: str) -> str:\n \"\"\"Измените строку string так, чтобы все гласные буквы в ней шли в обратном порядке относительно изначального порядка. Выведите получившуюся строку. Гласными являются буквы: а, о, и, у, е, ю, я, э, ы. Данные буквы могут встречаться в любом регистре.\n ... | [
""
] | {
"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}, {... | [
""
] | {
"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) =... | [
""
] | {
"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, который включает в себя все целые числа отрезка от нуля до количества чисел в массиве, кроме одного числа. Выведите число, которое пропущено. Гарантируется, что в массиве более одного элемента.\... | [
""
] | {
"id": 61,
"canonical_solution": "",
"entry_point": "missing_number"
} |
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}... | {
"function": "def is_ugly(number: int) -> str:\n \"\"\"Определите, является ли число number некрасивым. Некрасивое число – это такое число, которое делится только на 2, 3 и 5 (необязательно все сразу) без остатка. Если число некрасивое, выведите \"Да\", иначе выведите \"Нет\".\n Примеры:\n is_ugly(number... | [
""
] | {
"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 \"\"\"",
"... | [
""
] | {
"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. Строка является анаграммой другой строки если состоит из тех же символов, что и изначальная строка, но в другом порядке. Если является, выведите \"Да\", иначе выве... | [
""
] | {
"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 изморфными по отношению друг к другу. Две строки изоморфны, если символы одной строки могут быть заменены на другие, и получится вторая строка. Заменять разрешается все вхождения одного сим... | [
""
] | {
"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=... | [
""
] | {
"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 в виде списка списков. Данный массив представляет собой квадратную матрицу. Транспонируйте данный массив и выведите результат. Транспонирование двумерного масс... | [
""
] | {
"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_numb... | [
""
] | {
"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, который содержит время в секундах, когда песочные часы переворачиваются. Если песочные часы не закончили работу, но были перевернуты, то время их работы ... | [
""
] | {
"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 \"\"... | [
""
] | {
"id": 70,
"canonical_solution": "",
"entry_point": "bit_inversion"
} |
Тебе дана заготовка под функцию на языке Python:
{function}
Напиши продолжение для этой заготовки так, чтобы функция правильно работала. Соблюдай синтаксис Python, используй markdown разметку, чтобы оформить код (```python <code>```), и начни свой ответ с табуляции, так как ты продолжаешь функцию. | {
"function": "def build_ladder(number: int) -> int:\n \"\"\"Лестницы строится из кирпичей. Каждый новый уровень лестницы требует количества кирпичей, которое равно порядковому уровню лестницы, начиная с 1. Последний этаж летницы может быть не достроен. Выведите, сколько полных этажей лестницы можно построить из n... | [
""
] | {
"id": 71,
"canonical_solution": "",
"entry_point": "build_ladder"
} |
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}... | {
"function": "def string_sum(string1: str, string2: str) -> str:\n \"\"\"Два положительных челых числа даны в виде строк string1 и string2. Сложите эти числа и выведите ответ в виде строки. Гарантируется, что величина чисел соответствует типу данных int32.\n Примеры:\n string_sum(string1=411465, string2=... | [
""
] | {
"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 из пар координат точек в декартовой системе координат. Найдите три точки, которые формируют наибольший по площади треугольник и выведите его площадь. Считайте, в массиве есть как мини... | [
""
] | {
"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, то выведите \"Да\". Иначе, выведите \"Нет\". Циклический сдвиг влево экивалентен тому, что у каждого элемента ма... | [
""
] | {
"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. По ... | [
""
] | {
"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 \"\"\"",
... | [
""
] | {
"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, ... | [
""
] | {
"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 (тех, что не попали на главную диагональ). Главная диагональ начинается в левом верхнем элементе и идет вправо вниз по диагонали.... | [
""
] | {
"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 ... | [
""
] | {
"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,... | [
""
] | {
"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 Пример... | [
""
] | {
"id": 81,
"canonical_solution": "",
"entry_point": "shuffle_pairs"
} |
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}... | {
"function": "from typing import List\n\n\ndef peculiar_numbers(matrix: List[List[int]]) -> List[int]:\n \"\"\"Красивым числом в матрице называется такое число, которое является строго наименьшим в своей строке и строго наибольшим в своем столбце. Выведите все уникальные красивые числа матрицы matrix в виде списк... | [
""
] | {
"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 ... | [
""
] | {
"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}, {'... | [
""
] | {
"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... | [
""
] | {
"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 индекса до индекса длины изначального спи... | [
""
] | {
"id": 86,
"canonical_solution": "",
"entry_point": "double_zeros"
} |
Ваша задача - закончить функцию на языке Python, соблюдая синтаксис Python. Оценивается только продолжение функции - не нужно писать ничего другого, кроме кода для данной функции.
Функция:
{function}
Ответ оформите в стиле markdown для кода на Python (обычно в markdown код помещают между ```python и ```) | {
"function": "def delete_primitives(string: str) -> int:\n \"\"\"Минимальная корректная скобочная последовательность (состоит из двух скобок), называется примитивом. Удалите из строки со скобочной последовательностью 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=['ежззхкющц', 'скщйбвпьк',... | [
""
] | {
"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 Примеры... | [
""
] | {
"id": 89,
"canonical_solution": "",
"entry_point": "parity_sort"
} |
Реши задачу по программированию. Начало функции:
{function}
Продолжи функцию так, чтобы она корректно работала.
Ответ оформи по шаблону: ```python <code>``` | {
"function": "def beautiful_number(number: int) -> str:\n \"\"\"Число называется красивым, если путем конечного числа разрешенных операций оно превращается в 1. Разрешенным действием для числа является его замена на сумму квадратов его цифр. Определите, является ли число number красивым. Если да, то выведите \"Да... | [
""
] | {
"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. Преобразуйте списки в множества. Выведите симметрическую разность множест в виде отсортированного по возрастанию списка. Симметрическая разность множеств – это совокуп... | [
""
] | {
"id": 91,
"canonical_solution": "",
"entry_point": "symmetic_difference"
} |
Ты - программист на Python. Тебе дано начало функции, в котором есть сигнатура с названием функции и принимаемыми на вход параметрами, док-строка, которая содержит описание принципа работы функции, тесты, которые показывают результат работы готовой функции при передаче в нее определенных параметров.
Функция:
{function}... | {
"function": "from typing import List\n\n\ndef set_complement(set1: set, set2: set) -> List[int]:\n \"\"\"Даны два списка чисел: set1 и set2. Преобразуйте списки в множества. Выведите дополнение set1 до set2 в виде отсортированного по возрастанию списка. Дополнением множества до другого множества являются элемент... | [
""
] | {
"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 Пр... | [
""
] | {
"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 слов из спи... | [
""
] | {
"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) ==... | [
""
] | {
"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 раз. Выведите получившееся число в целочисленном вид... | [
""
] | {
"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_fr... | [
""
] | {
"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_t... | [
""
] | {
"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. Выведите п... | [
""
] | {
"id": 99,
"canonical_solution": "",
"entry_point": "shuffle_array"
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.