Instruction:
Реши задачу по программированию
{function}

def count_tens(number: int) -> int:
    """Выведите число десятков в натуральном числе number.
    Примеры:
       count_tens(number=1) == 0
       count_tens(number=10) == 1
    """

def count_tens(number: int) -> int:
    return (number // 10) % 10


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def sum_digits(number: int) -> int:
    """Выведите сумму цифр натурального числа number.
    Примеры:
       sum_digits(number=1) == 1
       sum_digits(number=10) == 1
    """

def sum_digits(number: int) -> int:
    digits = list(str(number))
    digits = list(map(int, digits))
    return sum(digits)


Instruction:
Напишите программу по строке документации
{function}

def clock_time(number: int) -> str:
    """Выведите сколько времени покажут часы, запущенные в полночь, спустя number секунд. Используйте 24-часовую систему. Выведите ответ в формате: HH:MM:SS. Если минуты или секунды меньше 10, добавьте в начало 0.
    Примеры:
       clock_time(number=25446) == '7:04:06'
       clock_time(number=78799) == '21:53:19'
    """

def clock_time(number: int) -> str:
    seconds = number % 60
    hours = number // 3600 % 24
    minutes = number // 60 % 60
    return f'{hours}:{minutes // 10}{minutes % 10}:{seconds // 10}{seconds % 10}'


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def count_seconds(initial_time: str, final_time: str) -> int:
    """Вычислите сколько секунд прошло между тем, когда часы показывали initial_time и final_time. Между данными временными точками может пройти не более одних суток.
    Примеры:
       count_seconds(initial_time=00:00:00, final_time=00:00:00) == 0
       count_seconds(initial_time=00:00:00, final_time=23:59:59) == 86399
    """

def count_seconds(initial_time: str, final_time: str) -> int:
    in_time = initial_time.split(':')
    out_time = final_time.split(':')
    time1 = int(in_time[0]) * 3600 + int(in_time[1]) * 60 + int(in_time[2])
    time2 = int(out_time[0]) * 3600 + int(out_time[1]) * 60 + int(out_time[2])
    return time2 - time1


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

def count_steps(required: int, forward_step: int, backward_step:int) -> int:
    """Шкала прогресса за один шаг заполняется на forward_step процентов, а затем сразу убывает на backward_step процентов. Выведите, за сколько шагов на шкале прогресса будет достигнута отметка required процентов, если известно, что forward_step > backward_step.
    Примеры:
       count_steps(required=100, forward_step=6, backward_step=5) == 95
       count_steps(required=90, forward_step=20, backward_step=12) == 10
    """

[{'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}]

def count_steps(required: int, forward_step: int, backward_step:int) -> int:
    return (required - forward_step - 1) // (forward_step - backward_step) + 2


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

from typing import List

def same_quarter(coordinatesA: List[int], coordinatesB: List[int]) -> str:
    """На основании списка координат coordinatesA первой точки и списка координат coordinatesB второй точки, определите, лежат ли они в одной четверти декартовой системы координат. Если лежат, выведите "Да", если не лежат - "Нет".
    Примеры:
       same_quarter(coordinatesA=[5, 2941], coordinatesB=[9391, 7]) == 'Да'
       same_quarter(coordinatesA=[7801, 99], coordinatesB=[65, -547]) == 'Нет'
    """

from typing import List

def same_quarter(coordinatesA: List[int], coordinatesB: List[int]) -> str:
    x, y, z, r = coordinatesA[0], coordinatesA[1], coordinatesB[0], coordinatesB[1]
    if x > 0 and y > 0 and z > 0 and r > 0:
        return 'Да'
    elif x < 0 and y < 0 and z < 0 and r < 0:
        return 'Да'
    elif x > 0 and y < 0 and z > 0 and r < 0:
        return 'Да'
    elif x < 0 and y > 0 and z < 0 and r > 0:
        return 'Да'
    else:
        return 'Нет'


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def same_entrance(first_number: int, second_number: int) -> str:
    """Определите, могут ли квартиры с номерами first_number и second_number быть первой и последней квартирой в одном подъезде дома? В доме больше одного подъезда, в каждом подъезде всегда одинаковое количество квартир. Нумерация квартир начинается с единицы. Если могут, выведите "Да", иначе – "Нет".
    Примеры:
       same_entrance(first_number=33, second_number=3) == 'Нет'
       same_entrance(first_number=25, second_number=2) == 'Нет'
    """

[{'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}]

def same_entrance(first_number: int, second_number: int) -> str:
    if (first_number-1) % (second_number-first_number+1) == 0:
        return 'Да'
    else:
        return 'Нет'


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def split_wood(length: int, width: int, number: int) -> str:
    """Определите, можно ли отделить от шахматной доски размером length на width ровно number прямоугольников в одно действие. Отделять прямоугольники можно только по прямой линии (разрезать на две части по прямой). Например, нельзя разрезать квадраты шахматной доски по диагонали. Если да, выведите "Да", иначе – "Нет".
    Примеры:
       split_wood(length=3, width=3, number=2) == 'Нет'
       split_wood(length=50, width=1, number=3) == 'Да'
    """

def split_wood(length: int, width: int, number: int) -> str:
    if number <= width * length and (number % width == 0 or number % length == 0):
        return 'Да'
    else:
        return 'Нет'


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def is_acute(lengthA: int, lengthB: int, lengthC: int) -> str:
    """Определите на основании длин трех сторон треугольника: lengthA, lengthB, lengthC, является ли данный треугольник остроугольным. Треугольник является остроугольным, если сумма квадратов длин его двух сторон меньше квадрата третьей стороны для любой из сторон. Выведите "Да", если является, и "Нет", если не является.
    Примеры:
       is_acute(lengthA=3, lengthB=3, lengthC=2) == 'Да'
       is_acute(lengthA=50, lengthB=1, lengthC=3) == 'Нет'
    """

[{'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}]

def is_acute(lengthA: int, lengthB: int, lengthC: int) -> str:
    a = lengthA
    b = lengthB
    c = lengthC
    if (a >= b + c) or (b >= a + c) or (c >= b + a):
        return 'Нет'
    elif (a**2 == b**2 + c**2) or (b**2 == a**2 + c**2) or (c**2 == b**2 + a**2):
        return 'Нет'
    elif (a**2 > b**2 + c**2) or (b**2 > a**2 + c**2) or (c**2 > b**2 + a**2):
        return 'Нет'
    else:
        return 'Да'


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def place_inside(lengthA: int, widthA: int, heightA: int, lengthB: int, widthB: int, heightB: int) -> str:
    """На основании длины lengthA, ширины widthA и высоты heightA первой коробки и длины lengthB, ширины widthB и высоты heightB второй коробки определите, можно ли поместить одну из данных коробок в другую. Поворачивать коробки можно только вокруг их ребер под прямыми углами. Если можно, выведите "Да", иначе – "Нет".
    Примеры:
       place_inside(lengthA=3, widthA=1, heightA=5, lengthB=88, widthB=1, heightB=4) == 'Да'
       place_inside(lengthA=3, widthA=5, heightA=7, lengthB=9, widthB=10, heightB=11) == 'Да'
    """

def place_inside(lengthA: int, widthA: int, heightA: int, lengthB: int, widthB: int, heightB: int) -> str:
    a1 = lengthA
    b1 = widthA
    c1 = heightA
    a2 = lengthB
    b2 = widthB
    c2 = heightB
    if a1 > b1:
        (a1, b1) = (b1, a1)
    if b1 > c1:
        (b1, c1) = (c1, b1)
    if a1 > b1:
        (a1, b1) = (b1, a1)
    if a2 > b2:
        (a2, b2) = (b2, a2)
    if b2 > c2:
        (b2, c2) = (c2, b2)
    if a2 > b2:
        (a2, b2) = (b2, a2)
    if a1 == a2 and b1 == b2 and c1 == c2:
        return 'Нет'
    elif a1 <= a2 and b1 <= b2 and c1 <= c2:
        return 'Да'
    elif a1 >= a2 and b1 >= b2 and c1 >= c2:
        return 'Да'
    else:
        return 'Нет'


Instruction:
Реши задачу по программированию
{function}

def factorization(number: int) -> str:
    """Вам дано число number. Определите, можно ли его представить, как сумму некоторого количества троек и пятерок. Если можно, выведите "Да", иначе – "Нет".
    Примеры:
       factorization(number=1) == 'Нет'
       factorization(number=3) == 'Да'
    """

def factorization(number: int) -> str:
    k = number
    if (k == 3) or (k == 5) or (k == 6) or (k > 7):
        return "Да"
    else:
        return "Нет"


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def solve_equation(A: float, B: float, C: float, D: float) -> int:
    """На основании коэффициентов A, B, C, D определите, имеет ли решения уравнение (Ax + B) / (Cx + D) = 0. Если у уравнения есть хотя бы одно решение, выведите "1". Если ни одного решения, выведите "0".
    Примеры:
       solve_equation(A=3, B=-3, C=2, D=500) == 1
       solve_equation(A=30, B=-3, C=2, D=-2) == 0
    """

def solve_equation(A: float, B: float, C: float, D: float) -> int:
    if C == 0 and D == 0:
        return 0
    if A == 0 and B == 0:
        return 1
    elif A == 0 or B * C == A * D:
        return 0
    elif B % A == 0:
        return 1
    else:
        return 0


Instruction:
Напишите программу по строке документации
{function}

def sum_squares(number: int) -> int:
    """Дано натуральное число number. Выведите сумму квадратов всех натуральных чисел до number включительно. Гарантируется, что number не превосходит 100.
    Примеры:
       sum_squares(number=66) == 98021
       sum_squares(number=58) == 66729
    """

def sum_squares(number: int) -> int:
    i = 1
    summa = 0
    while i<=number:
        summa = summa + i**2
        i = i + 1
    return summa


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def least_divider(number: int) -> int:
    """Выведите наименьший не равный 1 натуральный делитель числа number.
    Примеры:
       least_divider(number=933) == 3
       least_divider(number=846) == 2
    """

def least_divider(number: int) -> int:
    i = 2
    while i <= number:
        if number % i == 0:
            return i
        i += 1


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

def closest_degree(number: int) -> int:
    """Выведите наименьшее возможное число такое, что 2 в степени данного числа не меньше числа number. Гарантируется, что number не превосходит 1000000.
    Примеры:
       closest_degree(number=2) == 1
       closest_degree(number=28) == 5
    """

def closest_degree(number: int) -> int:
    k = 0
    while (1 << k) < number:
        k += 1
    return k


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

from typing import List

def second_maximum(array: List[int]) -> int:
    """Выведите значение второго по величине максимума в списке array. Гарантируется, что array содержит не менее двух элементов.
    Примеры:
       second_maximum(array=[-96, -97, -27, -30, 93]) == -27
       second_maximum(array=[-77, 67, 19, -71, 93, -50, -100, -77, 3, 51]) == 67
    """

from typing import List

def second_maximum(array: List[int]) -> int:
    maxx = array[0]
    t = 0
    for i in array[1:]:
        if i > maxx:
            t = maxx
            maxx = i
        elif i > t:
            t = i
    return t


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

from typing import List

def max_equal_subseq(array: List[int]) -> int:
    """Выведите длину наибольшей подряд идущей подпоследовательности из одинаковых чисел в последовательности array.
    Примеры:
       max_equal_subseq(array=[1, 5, 9, 7, 2, 6, 1, 2, 4, 9, 1]) == 1
       max_equal_subseq(array=[2, 7, 7, 7, 3, 7, 5, 2, 1, 3]) == 3
    """

from typing import List

def max_equal_subseq(array: List[int]) -> int:
    prev = -1
    curr_rep_len = 0
    max_rep_len = 0
    for element in array:
        if prev == element:
            curr_rep_len += 1
        else:
            prev = element
            max_rep_len = max(max_rep_len, curr_rep_len)
            curr_rep_len = 1
    max_rep_len = max(max_rep_len, curr_rep_len)
    return max_rep_len


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def sum_inverse_squares(number: int) -> float:
    """Выведите сумму ряда обратных квадратов от 1 до числа number включительно (гарантируется, что number не превосходит 100). Ряд обратных квадратов – это последовательность чисел, каждое из которых представлено в виде (1/x) в квадрате. Округлите ответ до 2 знаков после запятой.
    Примеры:
       sum_inverse_squares(number=1) == 1.0
       sum_inverse_squares(number=2) == 1.25
    """

def sum_inverse_squares(number: int) -> float:
    s = 0
    i = 1
    for i in range(1, number + 1):
        s += 1/ (i ** 2)

    return round(s, 2)


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def number_words(string: str) -> int:
    """Выведите количество слов в строке string. Словом считаются любые последовательности символов, которые отделены друг от друга пробелами.
    Примеры:
       number_words(string=Аппетит приходит во время еды) == 5
       number_words(string=Бедность не порок) == 3
    """

[{'string': 'Аппетит приходит во время еды'}, {'string': 'Бедность не порок'}, {'string': 'Без труда не выловишь и рыбку из пруда'}, {'string': 'Бесплатный сыр, бывает- только в мышеловке'}, {'string': 'Бог шельму= метит'}, {'string': 'В здоровом теле – здоровый дух'}, {'string': 'Волков бояться – в лес не ходить'}, {'string': 'Глаза боятся, а руки делают'}, {'string': 'Готовь сани летом, а телегу зимой'}, {'string': 'Дарёному коню в зубы не смотрят'}]

def number_words(string: str) -> int:
    return len(string.split())


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def swap_words(string: str) -> str:
    """В строке string из двух слов, разделенных пробелом, поменяйте местами слова и выведите получившуюся строку. Гарантируется, что string всегда содержит ровно два слова, разделенных пробелом.
    Примеры:
       swap_words(string=Аппетит приходиты) == 'приходиты Аппетит'
       swap_words(string=Бедность не) == 'не Бедность'
    """

[{'string': 'Аппетит приходиты'}, {'string': 'Бедность не'}, {'string': 'Без труда'}, {'string': 'Бесплатный сыр,'}, {'string': 'Бог шельму='}, {'string': 'В здоровом'}, {'string': 'Волков бояться'}, {'string': 'Глаза боятся,'}, {'string': 'Готовь сани'}, {'string': 'Дарёному коню'}]

def swap_words(string: str) -> str:
    d = string.split()[1] + " " + string.split()[0]
    return d


Instruction:
Реши задачу по программированию
{function}

def second_index(string: str, symbol: str) -> int:
    """Выведите индекс второго вхождения символа symbol в строке string. Если второго вхождения нет, а также если строка string не содержит символ symbol, выведите число 0.
    Примеры:
       second_index(string=wxapqc, symbol=a) == 0
       second_index(string=wetzjoqbzy, symbol=x) == 0
    """

[{'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'}]

def second_index(string: str, symbol: str) -> int:
    if symbol not in string:
        return 0
    else:
        string_new = string[string.find(symbol) + 1:]
        if symbol not in string_new:
            return 0
        else:
            return string.find(symbol, string.find(symbol) + 1)


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def quadratic_equation(A: int, B: int, C: int) -> str:
    """Даны коэффициенты квадратного трехчлена: A, B, C. Коэффициенты всегда являются целыми числами. Определите, есть ли у квадратного уравнения Ax ** 2 + Bx + C = 0 хотя бы одно решение. Если есть, выведите "Да", иначе выведите "Нет".
    Примеры:
       quadratic_equation(A=3, B=-3, C=2) == 'Нет'
       quadratic_equation(A=0, B=-1, C=3) == 'Да'
    """

def quadratic_equation(A: int, B: int, C: int) -> str:
    d = B ** 2 - 4 * A * C
    if A == 0:
        if B == 0 and C == 0:
            return 'Да'
        elif B == 0 and C != 0:
            return 'Нет'
        elif B != 0 and C == 0:
            return 'Да'
        elif B != 0 and C != 0:
            return 'Да'
    else:
        if d > 0:
            if A != 0:
                return 'Да'
        elif d == 0:
            return 'Да'
        elif d < 0:
            return 'Нет'


Instruction:
Напишите программу по строке документации
{function}

def solve_system(A: int, B: int, C: int, D: int, E: int, F: int) -> str:
    """По данным коэффициентам A, B, C, D, E, F определите, имеет ли решения система из двух линейных уравнений: (1) Ax + By = E, (2) Cx + Dy = F. Коэффициенты всегда являются целыми числами. Если система с данными значениями коэффициентов имеет решения, выведите "Да", иначе выведите "Нет".
    Примеры:
       solve_system(A=3, B=-3, C=0, D=0, E=0, F=2000) == 'Нет'
       solve_system(A=0, B=-1, C=3, D=2, E=12, F=2) == 'Да'
    """

def solve_system(A: int, B: int, C: int, D: int, E: int, F: int) -> str:
    T = A * D - B * C
    X = E * D - B * F
    Y = A * F - C * E
    if T != 0:
        return 'Да'
    else:
        if A == 0 and B == 0 and C == 0 and D == 0 and E == 0 and F == 0:
            return 'Да'
        elif (A == 0 and B == 0 and E != 0) or (C == 0 and D == 0 and F != 0):
            return 'Нет'
        elif X != 0 or Y != 0:
            return 'Нет'
        elif A == 0 and C == 0 and B != 0:
            return 'Да'
        elif A == 0 and C == 0 and D != 0:
            return 'Да'
        elif B == 0 and D == 0 and A != 0:
            return 'Да'
        elif B == 0 and D == 0 and C != 0:
            return 'Да'
        elif B != 0:
            return 'Да'
        elif D != 0:
            return 'Да'


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def sparse_string(string: str, symbol: str) -> str:
    """Выведите исходную строку string, вставив между всеми ее символами специальный символ symbol.
    Примеры:
       sparse_string(string=ddd, symbol=) == 'ddd'
       sparse_string(string=Мало теН половин , symbol= ) == 'М а л о   т е Н   п о л о в и н   '
    """

[{'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': '"'}]

def sparse_string(string: str, symbol: str) -> str:
    n = string[0]
    i = 1
    while i < len(string):
        n = n + symbol + string[i]
        i += 1
    return n


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

from typing import List

def select_squares(array: List[int]) -> List[int]:
    """Выберите из массива array все квадраты целых чисел и выведите их в том порядке, в котором они указаны в массиве. Гарантируется, что array не пуст. Если в array нет ни одного подходящего под условие числа, выведите пустой список.
    Примеры:
       select_squares(array=[10, 36, 21, 80, 93, 4]) == [36, 4]
       select_squares(array=[35, 18, 4, 15, 62, 72]) == [4]
    """

from typing import List

def select_squares(array: List[int]) -> List[int]:
    nums = []
    for i in array:
        if (i ** 0.5) % 1 == 0:
            nums.append(i)
    return nums


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

from typing import List

def count_zeros(array: List[int]) -> int:
    """В массиве array посчитайте количество нулей и выведите его.
    Примеры:
       count_zeros(array=[3, 5, 2, 2, 7, 5]) == 0
       count_zeros(array=[3, 0, 4, 2, 8, 4, 0]) == 2
    """

from typing import List

def count_zeros(array: List[int]) -> int:
    s=0
    for i in array:
        if i == 0:
            s+=1
    return s


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def count_palindromes(first_number: int, last_number: int) -> int:
    """Выведите, сколько чисел между четырёхзначными числами first_number и last_number, включая их, являются палиндромами. Отрицательные числа не считаются палиндромами.
    Примеры:
       count_palindromes(first_number=3003, last_number=6006) == 31
       count_palindromes(first_number=2500, last_number=2508) == -1
    """

[{'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}]

def count_palindromes(first_number: int, last_number: int) -> int:
    cnt = 0
    for i in range(first_number, last_number+1):
        s=str(i)
        if s == s[::-1]:
            cnt += 1
    if cnt:
        return cnt
    else:
        return -1


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

from typing import List

def odd_maximum(array: List[int]) -> int:
    """Среди всех чисел в списке array найдите наибольшее нечетное число и выведите его. Если такого числа нет, выведите "-1".
    Примеры:
       odd_maximum(array=[87, 11, 74, 33, 94, 52]) == 87
       odd_maximum(array=[17, 7, 78, 36, 64]) == 17
    """

from typing import List

def odd_maximum(array: List[int]) -> int:
    tmp = sorted(array)[::-1]
    for elem in tmp:
        if elem % 2 == 1:
            return elem
    return -1


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

from typing import List

def count_pairs(array: List[int]) -> int:
    """Сколько в массиве array пар одинаковых элементов? Любые два одинаковых по значению элемента array с разными индексами образуют пару, каждый элемент может входить только в одну пару. Выведите количество пар.
    Примеры:
       count_pairs(array=[1, 5, 5, 6, 3, 2, 3, 9, 6, 3, 8, 6, 3, 9]) == 11
       count_pairs(array=[7, 6, 6, 2, 1, 7, 8, 8, 3, 6]) == 5
    """

from typing import List

def count_pairs(array: List[int]) -> int:
    sum = 0

    for i in range(len(array)):
        for j in range(i + 1, len(array)):
            if array[i] == array[j]:
                sum += 1

    return sum


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

from typing import List

def squeeze_array(array: List[int]) -> List[int]:
    """Переместите все элементы массива array со значением 0 в конец списка, сохранив порядок всех остальных элементов. Выведите полученный список.
    Примеры:
       squeeze_array(array=[]) == []
       squeeze_array(array=[3, 2, 3, 2, 3, 1]) == [3, 2, 3, 2, 3, 1]
    """

from typing import List

def squeeze_array(array: List[int]) -> List[int]:
    return sorted(array, key=lambda x: not x)


Instruction:
Реши задачу по программированию
{function}

from typing import List

def max_product(array: List[int]) -> int:
    """В массиве array найдите три числа, которые дают наибольшее произведение и выведите значение данного произведения. Гарантируется, что array содержит не меньше 3 элементов.
    Примеры:
       max_product(array=[-11, -2, 2, -8, 2, -3, 19, 14, -9, -4, 14]) == 3724
       max_product(array=[18, 16, -1, 9, -16, -6, -4, -1, 17, 18, -7, -16, -14, 6]) == 5508
    """

from typing import List

def max_product(array: List[int]) -> int:
    a = sorted(array)
    if a[0] * a[1] * a[len(a) - 1] >= a[len(a) - 3] * a[len(a) - 2] * a[len(a) - 1]:
        return a[0] * a[1] * a[len(a) - 1]
    else:
        return a[len(a) - 2] * a[len(a) - 1] * a[len(a) - 3]


Instruction:
Реализуй функцию(ии) на языке Python
{function}

from typing import List

def array_xor(arrayA: List[int], arrayB: List[int]) -> List[int]:
    """Выполните поэлементное сложение по модулю два двух непустых массивов одинаковой длины из нулей и единиц: arrayA и arrayB. В сложении по модулю два ноль получается из пар (0, 0) и (1, 1). В остальных случаях получается единица. Выведите получившийся массив.
    Примеры:
       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]
       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]
    """

from typing import List

def array_xor(arrayA: List[int], arrayB: List[int]) -> List[int]:
    new = []
    for i in range(len(arrayA)):
        num = arrayA[i] ^ arrayB[i]
        new.append(num)
    return new


Instruction:
Напишите программу по строке документации
{function}

def dirichlet_rabbits(num_cages: int, num_rabbits: int) -> int:
    """Если есть num_cages клеток для кроликов, по которым рассадили num_rabbits кроликов, то какое наибольшее количество кроликов может оказаться в одной клетке? Кролики рассаживаются по клеткам равномерно. Это значит, что можно сажать кролика только в клетку, в которой меньше всего кроликов. Выведите получившееся число.
    Примеры:
       dirichlet_rabbits(num_cages=33, num_rabbits=3) == 1
       dirichlet_rabbits(num_cages=25, num_rabbits=2) == 1
    """

def dirichlet_rabbits(num_cages: int, num_rabbits: int) -> int:
    if num_rabbits % num_cages == 0:
        return num_rabbits // num_cages
    else:
        return num_rabbits // num_cages + 1


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def fibonacci_strings(number: int) -> str:
    """Вам дано положительное число number, которому соответствует строка. Выведите ее. Строки для числа строятся следующим образом: если number равен 1, то строка равна "a", если number равен 2, то строка равна "b", а для всех number больше 2 строка является конкатенацией строк с номерами (number - 2) и (number - 1). Гарантируется, что number не превосходит 10.
    Примеры:
       fibonacci_strings(number=1) == 'a'
       fibonacci_strings(number=2) == 'b'
    """

def fibonacci_strings(number: int) -> str:
    if number == 1:
        return 'a'
    elif number == 2:
        return 'b'
    else:
        return fibonacci_strings(number - 2) + fibonacci_strings(number - 1)


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

def vendor_change(X: int, Y: int, Z: int, T: int) -> int:
    """Если товар стоит X рублей и Y копеек, а покупатель заплатил продавцу Z рублей и T копеек, то сколько копеек должна составить сдача? Гарантируется, что покупатель заплатил не более 100 рублей за товар. Выведите получившееся число.
    Примеры:
       vendor_change(X=3, Y=-3, Z=2, T=500) == 403
       vendor_change(X=300, Y=0, Z=2000, T=5) == 170005
    """

def vendor_change(X: int, Y: int, Z: int, T: int) -> int:
    e = Z*100 + T - (X*100 + Y)
    return e


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def extract_string(string: str, symbol: str) -> str:
    """Разверните в обратном порядке подстроку строки string, которая заключена между первым и последним вхождениями символа symbol в string. Остальные символы оригинальной строки должны остаться на своих изначальных местах. Если symbol встречается в string 1 или 0 раз, то выведите "Нет".
    Примеры:
       extract_string(string=, symbol=) == 'Нет'
       extract_string(string=Мало теН половин , symbol= ) == 'Мало ниволоп Нет '
    """

[{'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': '"'}]

def extract_string(string: str, symbol: str) -> str:
    a = []
    for i in range(len(string)):
        if string[i] == symbol:
            a.append(i)
    if len(a) < 2:
        return 'Нет'
    else:
        n = string[a[0] + 1:a[-1]]
        return string[0:a[0] + 1] + n[::-1] + string[a[-1]:]


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

from typing import List

def count_combinations(array: List[int]) -> int:
    """Вам дан массив array из длин отрезков. Сколько есть способов выбрать из данного массива три элемента, из которых получится невырожденный треугольник? Невырожденным является треугольник, у которого всегда одна сторона меньше суммы двух других. Гарантируется, что массив array содержит от 3 до 20 чисел. Выведите получившееся число.
    Примеры:
       count_combinations(array=[5, 4, 1, 5, 1, 6, 4, 9, 6, 6, 8]) == 88
       count_combinations(array=[1, 1, 6, 6, 7, 3]) == 6
    """

from typing import List

def count_combinations(array: List[int]) -> int:
    a = sorted(array)
    m = 0
    for i in range(len(a)):
        for j in range(i + 1, len(a)):
            for k in range(j + 1, len(a)):
                if a[i] + a[j] > a[k]:
                    m += 1
    return m


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def triangle_perimeter(A: int, B: int, C: int, D: int, E: int, F: int) -> float:
    """Вам даны координаты трех вершин треугольника в декартовой системе координат: первая вершина (A, B), вторая вершина (C, D), третья вершина (E, F). Вычислите и выведите периметр данного треугольника. Периметр треугольника равен сумме длин его сторон. Считайте, что три вершины всегда образуют треугольник. Округлите ответ до 2 знаков после запятой.
    Примеры:
       triangle_perimeter(A=3, B=-3, C=0, D=0, E=0, F=2000) == 4007.24
       triangle_perimeter(A=0, B=-1, C=3, D=2, E=12, F=2) == 25.61
    """

def triangle_perimeter(A: int, B: int, C: int, D: int, E: int, F: int) -> float:
    import math
    def dist(x1, y1, x2, y2):
        l = (x1 - x2)**2 + (y1 - y2)**2
        return math.sqrt(l)
    def per(x1, y1, x2, y2, x3, y3):
        return dist(x1, y1, x2, y2) + dist(x3, y3, x2, y2) + dist(x1, y1, x3, y3)
    return round(per(A, B, C, D, E, F), 2)


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def closest_fibonacci(number: int) -> int:
    """Выведите ближайшее к числу number число Фибоначчи. Близость одного числа к другому определяется, как модуль разности данных чисел. Числа Фибоначчи – это такие числа, каждое из которых равно сумме двух предыдущих, а первое и второе равны единице. Если есть два подходящих под условие числа, выведите наименьшее из них.
    Примеры:
       closest_fibonacci(number=2) == 2
       closest_fibonacci(number=28) == 34
    """

def closest_fibonacci(number: int) -> int:
    if number <= 1:
        return 1
    elif number == 2:
        return 2
    else:
        triplet = [1, 1, 2]
        while not (triplet[0] < number and triplet[-1] > number):
            n1, n2, n3 = triplet
            new = n2 + n3
            triplet = [n2, n3, new]
        diff = float('inf')
        for elem in triplet:
            if abs(elem - number) < diff:
                num = elem
                diff = abs(elem - number)
    return num


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def sum_closest(number: int) -> int:
    """Дано натуральное число number. Выведите сумму следующего за ним числа и предыдущего.
    Примеры:
       sum_closest(number=2) == 4
       sum_closest(number=28) == 56
    """

def sum_closest(number: int) -> int:
    return (number - 1) + (number + 1)


Instruction:
Реши задачу по программированию
{function}

def find_distance(speed: int, length: int, time: int) -> int:
    """Велосипедист начал движение по кольцевой трассе со скоростью speed километров в час. Длина трассы составляет length километров. На какой отметке трассы остановится велосипедист через time часов? После того, как велосипедист проедет всю трассу, он попадет снова на отметку 0 километров и начнет проезжать трассу заново. Выведите получившееся число.
    Примеры:
       find_distance(speed=3, length=3, time=2) == 0
       find_distance(speed=50, length=51, time=1) == 50
    """

def find_distance(speed: int, length: int, time: int) -> int:
    dist = speed * time
    return dist % length


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def find_maximum(A: int, B: int) -> int:
    """Даны два целых числа A и B. Если первое число больше второго, выведите число 1, иначе выведите число 2. Если число A равно числу B, то вывести нужно число 2.
    Примеры:
       find_maximum(A=33, B=3) == 1
       find_maximum(A=25, B=2) == 1
    """

def find_maximum(A: int, B: int) -> int:
    if A > B:
        return 1
    else:
        return 2


Instruction:
Напишите программу по строке документации
{function}

def leap_year(number: int) -> str:
    """Определите, является ли год с номером number високосным. Високосный год либо делится на 400, либо не делится на 100 и делится на 4. Выведите "Да", если является, иначе выведите "Нет".
    Примеры:
       leap_year(number=2) == 'Нет'
       leap_year(number=28) == 'Да'
    """

def leap_year(number: int) -> str:
    if number % 400 == 0 or number % 4 == 0 and number % 100 != 0:
        return 'Да'
    else:
        return 'Нет'


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def chess_field(coordinateA: str, coordinateB: str) -> str:
    """Вам даны координаты двух фигур на шахматной доске в формате строки: буквы и цифры без разделителя (А5, В7 и т.п.): coordinateA, coordinateB. Определите, одинаковые ли цвета у ячеек, на которых расположены данные фигуры. Если одинаковые, выведите "Да", иначе выведите "Нет".
    Примеры:
       chess_field(coordinateA=B5, coordinateB=D6) == 'Нет'
       chess_field(coordinateA=B2, coordinateB=C1) == 'Да'
    """

[{'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'}]

def chess_field(coordinateA: str, coordinateB: str) -> str:
    x = coordinateA[0]
    y = int(coordinateA[1])
    z = coordinateB[0]
    v = int(coordinateB[1])
    mapping = {k:v for v, k in dict(enumerate(list('ABCDEFGH'), start=1)).items()}
    x = mapping[x]
    z = mapping[z]
    if ((x + z) % 2 ==  (y + v) % 2):
        return "Да"
    else:
        return "Нет"


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

def find_missing(string: str, shuffle: str) -> str:
    """Вам даны оригинальная строка string и измененная строка shuffle, которая получена случайным перемешиванием символов строки string с добавлением одного дополнительного символа. Выведите добавленный к shuffle символ.
    Примеры:
       find_missing(string=заполучить, shuffle=пзуичлтоаьз) == 'з'
       find_missing(string=жаловаться, shuffle=ясвлоатаьжь) == 'ь'
    """

[{'string': 'заполучить', 'shuffle': 'пзуичлтоаьз'}, {'string': 'жаловаться', 'shuffle': 'ясвлоатаьжь'}, {'string': 'пересолить', 'shuffle': 'силетепьоро'}, {'string': 'подержание', 'shuffle': 'жрианопедеш'}, {'string': 'работаться', 'shuffle': 'ааятсртьобщ'}, {'string': 'столешница', 'shuffle': 'аиолнтешцст'}, {'string': 'тюркология', 'shuffle': 'оюокияртглч'}, {'string': 'привернуть', 'shuffle': 'рептинвьурд'}, {'string': 'протерпеть', 'shuffle': 'еотпьрептрш'}, {'string': 'бортпроводник', 'shuffle': 'орокдтпбвиорнк'}]

def find_missing(string: str, shuffle: str) -> str:
    s=sorted(string)
    t=sorted(shuffle)
    i=0
    j=0
    while i<len(s) and j<len(t):
        if s[i]!=t[j]:
            return t[j]
        i+=1
        j+=1

    return t[-1]


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

from typing import List

def arithmetic_mean(array: List[int]) -> float:
    """Дан массив из чисел array. Найдите среднее арифметическое данного массива. Среднее арифметическое массива чисел равно сумме всех чисел массива, поделенной на количество чисел в массиве. Гарантируется, что массив имеет хотя бы один элемент. Выведите получившееся число, округленное до 2 знаков после запятой.
    Примеры:
       arithmetic_mean(array=[68, -65, 7, -8, -88, 80, 23, -72, 65]) == 1.11
       arithmetic_mean(array=[-15, 2, -28, -20, -8, -81, -87, 78, 68, -5]) == -9.6
    """

from typing import List

def arithmetic_mean(array: List[int]) -> float:
    return round(sum(array) / len(array), 2)


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

from typing import List

def geometric_mean(array: List[int]) -> float:
    """Дан массив из чисел array. Найдите среднее геометрическое данного массива. Среднее геометрическое массива равно произведению всех чисел массива, из которого взят арифметический корень степени равной количеству элементов в массиве. Гарантируется, что массив имеет хотя бы один элемент. Выведите получившееся число, округленное до 2 знаков после запятой.
    Примеры:
       geometric_mean(array=[8, 6, 5, 4, 9, 3]) == 5.44
       geometric_mean(array=[8, 4, 8, 9, 1, 5, 7, 8, 6, 1, 7, 1, 2, 1]) == 3.57
    """

from typing import List

def geometric_mean(array: List[int]) -> float:
    cnt = 1
    for i in range(len(array)):
        cnt *= array[i]
    return round(cnt ** (1 / len(array)), 2)


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

from typing import List

def garmonic_mean(array: List[int]) -> float:
    """Дан массив из чисел array. Найдите среднее гармоническое данного массива. Среднее гармоническое массива равно частному размера массива и суммы чисел, которые равны обратным элементам массива (единица разделить на элемент массива). Гарантируется, что массив имеет хотя бы один элемент. Выведите получившееся число, округленное до 2 знаков после запятой.
    Примеры:
       garmonic_mean(array=[9, 1, 5, 9, 9, 9, 6, 5, 6]) == 4.13
       garmonic_mean(array=[6, 7, 9, 1, 6]) == 3.15
    """

from typing import List

def garmonic_mean(array: List[int]) -> float:
    cnt = 0
    for i in range(len(array)):
        cnt += 1 / array[i]
    return round(len(array) / cnt, 2)


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

from typing import List

def array_mode(array: List[int]) -> int:
    """Дан массив из чисел array. Найдите моду данного массива. Модой массива чисел является число, которое встречается в данном массиве чаще всего. Если таких значений больше, чем одно, то выведите наименьшее из них. Если в массиве нет ни одной моды, выведите минимальный элемент массива. Гарантируется, что массив не пуст.
    Примеры:
       array_mode(array=[4, 2, 7, 9, 1, 5, 6, 9, 6, 6, 7, 1, 6, 6]) == 6
       array_mode(array=[6, 9, 7, 7, 4]) == 7
    """

from typing import List

def array_mode(array: List[int]) -> int:
    from collections import Counter
    c = Counter(array)
    return min([k for k, v in c.items() if v == c.most_common(1)[0][1]])


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def change_symbol(string: str, symbol: str, another_symbol: str) -> str:
    """В строке string замените все вхождения символа symbol на another_symbol. Выведите получившуюся строку.
    Примеры:
       change_symbol(string=@$улк, symbol=$, another_symbol=0) == '@0улк'
       change_symbol(string=й§чей*р/пи?ъгмр, symbol=/, another_symbol=3) == 'й§чей*р3пи?ъгмр'
    """

[{'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'}]

def change_symbol(string: str, symbol: str, another_symbol: str) -> str:
    s = string.replace(symbol, another_symbol)
    return s


Instruction:
Реши задачу по программированию
{function}

from typing import List

def minimum_shift(array: List[int]) -> int:
    """Дан массив натуральных чисел array. Сколько циклических сдвигов вправо нужно сделать в данном массиве, чтобы он стал отсортированным? Выведите получившееся число. Если сдвигами отсортировать массив невозможно, то выведите "-1".
    Примеры:
       minimum_shift(array=[14, 3, 12, 13, 14]) == 4
       minimum_shift(array=[9, 9, 8, 3, 1, 7, 6, 4, 6, 6, 5]) == -1
    """

from typing import List

def minimum_shift(array: List[int]) -> int:
    if array==sorted(array): return 0
    c=0
    for i in range(len(array)):
        array=array[-1:]+array[:-1]
        c+=1
        if array==sorted(array): return c
    return -1


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def are_coprime(A: int, B: int) -> str:
    """Определите, являются ли целые положительные числа A и B взаимно простыми? Взаимно простые числа не имеют общих делителей кроме 1. Если являются, выведите "Да", иначе выведите "Нет".
    Примеры:
       are_coprime(A=33, B=3) == 'Нет'
       are_coprime(A=25, B=2) == 'Да'
    """

def are_coprime(A: int, B: int) -> str:
    def gcd(x, y):
        while y != 0:
            (x, y) = (y, x % y)
        return x
    if gcd(A, B) == 1:
        return "Да"
    else:
        return "Нет"


Instruction:
Напишите программу по строке документации
{function}

def even_indicies(string: str) -> str:
    """Дана строка string. Выведите строку, которая состоит из всех символов string, имеющих четный индекс. Если строка пустая, выведите ее.
    Примеры:
       even_indicies(string=Флюгегехаймен) == 'Фюееамн'
       even_indicies(string=метафора) == 'мтфр'
    """

[{'string': 'Флюгегехаймен'}, {'string': 'метафора'}, {'string': 'опщчтыклбуд'}, {'string': 'щфоцржусх'}, {'string': 'жвасчднтбр'}, {'string': 'овьцртгдся'}, {'string': 'тцсчюхаиовупгн'}, {'string': 'яысмънфпб'}, {'string': 'члзтуэбныещмокфъад'}, {'string': 'рщлэт'}]

def even_indicies(string: str) -> str:
    return string[::2]


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def find_lcm(A: int, B: int) -> int:
    """Выведите наименьшее общее кратное чисел A и B. Наименьшее общее кратное двух чисел – это такое число, которое делится без остатка и на A, и на B и является наименьшим возможным таким числом.
    Примеры:
       find_lcm(A=33, B=3) == 33
       find_lcm(A=25, B=2) == 50
    """

def find_lcm(A: int, B: int) -> int:
    import math
    return (A * B) // math.gcd(A, B)


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

from typing import List

def max_count(array: List[int]) -> int:
    """Вам дан массив из целых чисел array, отсортированный в порядке неубывания. Каких чисел в массиве больше: положительных или отрицательных? Выведите число 1, если положительных, число -1, если отрицательных, и число 0, если их поровну. Число 0 в массиве не считается ни положительным, ни отрицательным. Гарантируется, что массив не пуст. Если массив содержит только число 0, в ответе выведите число 0.
    Примеры:
       max_count(array=[-42, 43, 12, 36, 9, 17, -38, -9, 9, 46, -2]) == 1
       max_count(array=[-8, -25, 4, -2, 49, -14]) == -1
    """

from typing import List

def max_count(array: List[int]) -> int:
    positive=0
    negative=0
    for i in range(len(array)):
        if array[i]<0:
            negative+=1
        elif array[i]>0 and array[i]!=0:
            positive+=1
    if positive > negative:
        return 1
    elif positive < negative:
        return -1
    else:
        return 0


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

from typing import List

def split_digits(array: List[int]) -> int:
    """Дан непустой список чисел array. Отделите все цифры, чтобы получился список всех цифр данного массива и выведите длину данного списка.
    Примеры:
       split_digits(array=[96, 12, 17, 15, 2, 43, 13, 39, 60, 73, 89, 70]) == 23
       split_digits(array=[41, 50, 20, 70, 88, 12, 70]) == 14
    """

from typing import List

def split_digits(array: List[int]) -> int:
    new = []
    for i in array:
        ob = list(str(i))
        new += ob
    return len(new)


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def formate_date(date: dict) -> str:
    """Дан словарь date, содержащий дату. Ключи словаря: год, месяц, день. Приведите дату к формату "YY-MM-DD" и выведите получившуюся строку. Если число дней или номер месяца являются однозначным числом, дополните такое число слева нулем.
    Примеры:
       formate_date(date={'год': 2023, 'месяц': 3, 'день': 12}) == '23-03-12'
       formate_date(date={'год': 1989, 'месяц': 1, 'день': 17}) == '89-01-17'
    """

def formate_date(date: dict) -> str:
    year, month, day = date.values()
    return f"{str(year)[2:]}-{month // 10}{month % 10}-{day // 10}{day % 10}"


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def russian_round(number: float) -> int:
    """Округлите число number по российским правилам: если дробная часть числа равна или больше 0.5, то число округляется вверх, иначе – вниз. Выведите полученное число.
    Примеры:
       russian_round(number=19.51035) == 20
       russian_round(number=13.53934) == 14
    """

def russian_round(number: float) -> int:
    return int(number + 0.5)


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def inverse_vowels(string: str) -> str:
    """Измените строку string так, чтобы все гласные буквы в ней шли в обратном порядке относительно изначального порядка. Выведите получившуюся строку. Гласными являются буквы: а, о, и, у, е, ю, я, э, ы. Данные буквы могут встречаться в любом регистре.
    Примеры:
       inverse_vowels(string=Флюгегехаймен) == 'Флегагехеймюн'
       inverse_vowels(string=метафора-анаформа) == 'матофара-анофарме'
    """

[{'string': 'Флюгегехаймен'}, {'string': 'метафора-анаформа'}, {'string': 'фвьъыткиеплщклчкдтрпбррлкъъчюрямйьзх'}, {'string': 'тцнсщячбеоагясшжацбспарлшыуыцясьойтэшшытяю'}, {'string': 'ммйывуяяиттхфбнкгшьктачдучичц'}, {'string': 'ищснечицсвпбчвыэпииртикиоьбофътнднвтхиождйзв'}, {'string': 'иглюбгбшблиикаавмувпйфебр'}, {'string': 'выитшшчвяьучхпныюцфагжъошпфчттьрв'}, {'string': 'ялышшбтъцшщсрхтхюьебгвшвфмцгтюшж'}, {'string': 'эхнзыидаэзьцюцмзщгпэйтбфгфнал'}]

def inverse_vowels(string: str) -> str:
    v = {'а', 'о', 'и', 'у', 'е', 'ю', 'я', 'э', 'ы', 'А', 'О', 'И', 'У', 'Е', 'Ю', 'Я', 'Э', 'Ы'}
    a = [f for f in string[::-1] if f in v]
    n = ''
    j = 0
    for i in string:
        if i in v:
            n += a[j]
            j += 1
        else:
            n += i
    return n


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

def make_binary(number: int) -> int:
    """Вам дано положительное число number в десятичной системе исчисления. Выведите данное число в двоичной системе исчисления.
    Примеры:
       make_binary(number=2) == 10
       make_binary(number=28) == 11100
    """

def make_binary(number: int) -> int:
    return int(bin(number)[2:])


Instruction:
Реши задачу по программированию
{function}

def hex_sum(A: int, B: int) -> str:
    """Вам даны два числа в двоичной системе исчисления: A и B. Сложите данные числа и выведите результат сложения в шестнадцатиричной системе исчисления в виде строки.
    Примеры:
       hex_sum(A=1010, B=11100) == '26'
       hex_sum(A=110010, B=10001001) == 'bb'
    """

def hex_sum(A: int, B: int) -> str:
    return hex(int(f'0b{int(A)}', 2) + int(f'0b{int(B)}', 2))[2:]


Instruction:
Реализуй функцию(ии) на языке Python
{function}

from typing import List

def missing_number(array: List[int]) -> int:
    """Дан массив чисел array, который включает в себя все целые числа отрезка от нуля до количества чисел в массиве, кроме одного числа. Выведите число, которое пропущено. Гарантируется, что в массиве более одного элемента.
    Примеры:
       missing_number(array=[7, 3, 5, 1, 0, 2, 6]) == 4
       missing_number(array=[5, 7, 1, 10, 6, 2, 8, 0, 9, 4]) == 3
    """

from typing import List

def missing_number(array: List[int]) -> int:
    return list(set(range(0,len(array)+1)).difference(set(array)))[0]


Instruction:
Напишите программу по строке документации
{function}

def is_ugly(number: int) -> str:
    """Определите, является ли число number некрасивым. Некрасивое число – это такое число, которое делится только на 2, 3 и 5 (необязательно все сразу) без остатка. Если число некрасивое, выведите "Да", иначе выведите "Нет".
    Примеры:
       is_ugly(number=45) == 'Да'
       is_ugly(number=44) == 'Нет'
    """

def is_ugly(number: int) -> str:
    if number <= 0:
        return "Нет"
    while number % 2 == 0:
        number /= 2
    while number % 3 == 0:
        number /= 3
    while number % 5 == 0:
        number /= 5
    return "Да" if number == 1 else "Нет"


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def add_digits(number: int) -> int:
    """Вам дано положительное целое число number. Складывайте все цифры данного числа до тех пор пока не останется всего одной цифры. Выведите получившуюся цифру.
    Примеры:
       add_digits(number=2) == 2
       add_digits(number=28) == 1
    """

def add_digits(number: int) -> int:
    while number >= 10:
        number = sum(int(i) for i in str(number))
    return number


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

def is_anagram(string: str, another_string: str) -> str:
    """Определите, является ли строка string анаграммой строки another_string. Строка является анаграммой другой строки если состоит из тех же символов, что и изначальная строка, но в другом порядке. Если является, выведите "Да", иначе выведите "Нет".
    Примеры:
       is_anagram(string=заполучить, another_string=ьоачиузлпт) == 'Да'
       is_anagram(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': 'кндцмцаще'}, {'string': 'девиация', 'another_string': 'рфтейпек'}]

def is_anagram(string: str, another_string: str) -> str:
    if len(string) != len(another_string):
        return False

    countS, countT = {}, {}

    for i in range(len(string)):
        countS[string[i]] = 1 + countS.get(string[i], 0)
        countT[another_string[i]] = 1 + countT.get(another_string[i], 0)
    if countS == countT:
        return "Да"
    return "Нет"


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def is_isomorphic(stringA: str, stringB: str) -> str:
    """Определите, являются ли строки stringA и stringB изморфными по отношению друг к другу. Две строки изоморфны, если символы одной строки могут быть заменены на другие, и получится вторая строка. Заменять разрешается все вхождения одного символа на другой символ одновременно. Если являются, выведите "Да", иначе выведите "Нет".
    Примеры:
       is_isomorphic(stringA=флюгегехаймен, stringB=щбятутуйвдсуз) == 'Да'
       is_isomorphic(stringA=словесник, stringB=кзжидъшун) == 'Нет'
    """

[{'stringA': 'флюгегехаймен', 'stringB': 'щбятутуйвдсуз'}, {'stringA': 'словесник', 'stringB': 'кзжидъшун'}, {'stringA': 'метафора', 'stringB': 'эзведяне'}, {'stringA': 'бортпроводник', 'stringB': 'лжвъцвжшжябою'}, {'stringA': 'девиация', 'stringB': 'иечобгмб'}, {'stringA': 'дублон', 'stringB': 'тяэтзм'}, {'stringA': 'жаловаться', 'stringB': 'пмвчихйфьй'}, {'stringA': 'диссонанс', 'stringB': 'ыеггкьбьг'}, {'stringA': 'заполучить', 'stringB': 'взкеьующон'}, {'stringA': 'изборник', 'stringB': 'эуэщяжге'}]

def is_isomorphic(stringA: str, stringB: str) -> str:
    d = {}
    seen = set()
    for i, j in zip(stringA, stringB):
        if i in d:
            if d[i] != j:
                return "Нет"
        else:
            if j in seen:
                return "Нет"
            seen.add(j)
            d[i] = j
    return "Да"


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def last_word(string: str) -> int:
    """Выведите длину последнего слова в строке string. Словом считается совокупность непробельных символов в строке, слева и справа от которого есть пробельный символ или начало/конец строки. Если строка пустая, выведите 0.
    Примеры:
       last_word(string=Аппетит приходит во время еды) == 3
       last_word(string=Бедность не порок) == 5
    """

def last_word(string: str) -> int:
    string = string.strip()
    length = 0

    for i in range(len(string) - 1, -1, -1):
        if string[i] == ' ':
            break
        length += 1

    return length


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

from typing import List

def transpose_array(array: List[List[int]]) -> List[List[int]]:
    """Вам дан непустой двумерный массив array в виде списка списков. Данный массив представляет собой квадратную матрицу. Транспонируйте данный массив и выведите результат. Транспонирование двумерного массива эквивалентно его перевороту вокруг основной диагонали (диагональ из левого верхнего элемена, идущая по всем элементам, у которых индекс троки и столбца совпадает) или замене индексов строк на индексы столбцов и наоборот.
    Примеры:
       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]]
       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]]
    """

from typing import List

def transpose_array(array: List[List[int]]) -> List[List[int]]:
    return list(map(list, zip(*array)))


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def perfect_number(number: int) -> str:
    """Определите, является ли число number красивым. Красивое число – это такое число, которое равно сумме своих натуральных делителей (не включая само число number). Выведите "Да", если является. Иначе, выведите "Нет".
    Примеры:
       perfect_number(number=2) == 'Нет'
       perfect_number(number=28) == 'Да'
    """

def perfect_number(number: int) -> str:
    if number==1: return "Нет"
    answer = 1
    i = 2
    while i*i<number:
        if number%i==0: answer+=i+number//i
        i+=1
    if i*i==number: answer+=i
    if answer==number:
        return "Да"
    return "Нет"


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

from typing import List

def hour_glass(array: List[int], number: int) -> int:
    """Песочные часы отмеряют number секунд. Дан список array, который содержит время в секундах, когда песочные часы переворачиваются. Если песочные часы не закончили работу, но были перевернуты, то время их работы начинает течь заново. Выведите, сколько времени суммарно проработают песочные часы.
    Примеры:
       hour_glass(array=[0, 5, 8, 12, 15, 18, 22, 25, 28, 28, 33, 37], number=2) == 22
       hour_glass(array=[0, 4, 9, 14, 14, 17, 19], number=3) == 17
    """

from typing import List

def hour_glass(array: List[int], number: int) -> int:
    total = 0
    l = len(array)
    for i in range(l):
        if i < l - 1:
            if array[i] + number - 1 < array[i+1]:
                total += number
            else:
                total += array[i+1] - array[i]
        else:
            total += number
    return total


Instruction:
Реши задачу по программированию
{function}

def bit_inversion(number: int) -> int:
    """Дано целое положительное число number. Инвертируйте все биты в двоичной записи данного числа. Выведите получившееся число в десятичной системе исчисления.
    Примеры:
       bit_inversion(number=2) == 1
       bit_inversion(number=28) == 3
    """

def bit_inversion(number: int) -> int:
    com = ''
    while number > 0 :

        if number % 2 == 1:
            com += '0'
        else:
            com += '1'
        number = number // 2
    return int(com[::-1],2)


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def build_ladder(number: int) -> int:
    """Лестницы строится из кирпичей. Каждый новый уровень лестницы требует количества кирпичей, которое равно порядковому уровню лестницы, начиная с 1. Последний этаж летницы может быть не достроен. Выведите, сколько полных этажей лестницы можно построить из number кирпичей.
    Примеры:
       build_ladder(number=2) == 1
       build_ladder(number=28) == 7
    """

def build_ladder(number: int) -> int:
    f = 1
    l = number

    while f<=l:
        mid = (f+l)//2
        temp = (mid*(mid+1))//2
        if temp == number:
            return mid
        elif temp > number:
            l = mid-1
        else:
            f = mid+1
    return l


Instruction:
Напишите программу по строке документации
{function}

def string_sum(string1: str, string2: str) -> str:
    """Два положительных челых числа даны в виде строк string1 и string2. Сложите эти числа и выведите ответ в виде строки. Гарантируется, что величина чисел соответствует типу данных int32.
    Примеры:
       string_sum(string1=411465, string2=218778) == '630243'
       string_sum(string1=552226, string2=754815) == '1307041'
    """

def string_sum(string1: str, string2: str) -> str:
    def str2int(num):
        numDict = {'0' : 0, '1' : 1, '2' : 2, '3' : 3, '4' : 4, '5' : 5,
                '6' : 6, '7' : 7, '8' : 8, '9' : 9}
        output = 0
        for d in num:
            output = output * 10 + numDict[d]
        return output
    return str(str2int(string1) + str2int(string2))


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

from typing import List

def largest_triangle(array: List[List[int]]) -> float:
    """На вход дан список array из пар координат точек в декартовой системе координат. Найдите три точки, которые формируют наибольший по площади треугольник и выведите его площадь. Считайте, в массиве есть как минимум одна тройка точек, которые формируют треугольник. Точки всегда лежат в первой четверти системы координат. Округлите ответ до 2 знаков после запятой.
    Примеры:
       largest_triangle(array=[[5, 3], [5, 1], [4, 7], [6, 4], [5, 6], [2, 1]]) == 9.0
       largest_triangle(array=[[4, 8], [4, 6], [3, 1], [9, 2], [4, 9], [7, 2], [7, 7], [7, 9], [1, 1]]) == 30.5
    """

from typing import List

def largest_triangle(array: List[List[int]]) -> float:
    area = 0
    for i in range(len(array)-2):
        x1,y1 = array[i]
        for j in range(i+1,len(array)-1):
            x2,y2 = array[j]
            for k in range(j+1,len(array)):
                x3,y3 = array[k]
                curr_area = abs(0.5*(x1*(y2-y3)+x2*(y3-y1)+x3*(y1-y2)))
                if (curr_area > area):
                    area = curr_area
    return round(area, 2)


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

def cyclic_shift(string: str, target: str) -> str:
    """Если строка string может стать равной строке target после конечного числа циклических сдвигов влево всех символов строки string, то выведите "Да". Иначе, выведите "Нет". Циклический сдвиг влево экивалентен тому, что у каждого элемента массива, кроме первого, из индекса вычитается единица, а индекс первого элемента становится равным индексу последнего элемента.
    Примеры:
       cyclic_shift(string=аои, target=оиа) == 'Да'
       cyclic_shift(string=омчшалш, target=лэвыеейэ) == 'Нет'
    """

[{'string': 'аои', 'target': 'оиа'}, {'string': 'омчшалш', 'target': 'лэвыеейэ'}, {'string': 'ыпоиеыева', 'target': 'еыеваыпои'}, {'string': 'вммой', 'target': 'ымэд'}, {'string': 'рвилгхй', 'target': 'оуяэич'}, {'string': 'ыукдлмьмапбо', 'target': 'апбоыукдлмьм'}, {'string': 'хос', 'target': 'осх'}, {'string': 'хюу', 'target': 'ухю'}, {'string': 'фыпмыдщфшкрпк', 'target': 'щфшккфыпмыд'}, {'string': 'нуи', 'target': 'уин'}]

def cyclic_shift(string: str, target: str) -> str:
    if len(string) == len(target) and string in target+target:
        return "Да"
    return "Нет"


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

from typing import List

def smallest_symbol(array: List[str], symbol: str) -> str:
    """Если в непустом списке array существуют символы, которые лексикографически больше символа symbol, то выведите лексикографически наименьший из этих символов. Иначе, выведите первый символ списка array. По лексикографическому порядку один символ меньше другого, если идет раньше его в алфавите.
    Примеры:
       smallest_symbol(array=['х', 'щ', 'з', 'ж', 'й', 'ж', 'к', 'ф', 'т', 'е', 'ф'], symbol=х) == 'щ'
       smallest_symbol(array=['о', 'а', 'х', 'г', 'п', 'э', 'б', 'щ', 'п', 'щ', 'ч', 'с', 'в', 'н', 'э', 'х'], symbol=л) == 'н'
    """

from typing import List

def smallest_symbol(array: List[str], symbol: str) -> str:
    sorted_with_letter = sorted(set(array+[symbol]))
    index_target = sorted_with_letter.index(symbol)
    if index_target == len(sorted_with_letter)-1:
        return sorted_with_letter[0]
    return sorted_with_letter[index_target+1]


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def selfdividing_sum(start:int, end: int) -> int:
    """Выведите, сколько чисел между start и end (включительно) делятся на все свои цифры. Нули в числах игнорируйте.
    Примеры:
       selfdividing_sum(start=59, end=4828) == 225
       selfdividing_sum(start=59, end=451) == 40
    """

def selfdividing_sum(start:int, end: int) -> int:
    a = []
    for i in range(start, end+1):
        if len(str(i)) == sum(1 if int(j)!=0 and i%int(j)==0 else 0 for j in str(i)): a.append(i)
    return len(a)


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

from typing import List

def array_search(array: List[int], number: int) -> int:
    """Если число number встречается в списке array, который отсортирован в порядке неубывания, выведите число 1, иначе выведите число 0.
    Примеры:
       array_search(array=[-8, -7, -3, -3, -2, 6, 9, 10, 11, 11, 12, 16], number=0) == 0
       array_search(array=[-10, -8, 0, 1, 3, 3, 8, 9, 10, 11, 13, 17, 19], number=13) == 1
    """

from typing import List

def array_search(array: List[int], number: int) -> int:
    if number in array:
        return 1
    return 0


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

from typing import List

def diagonal_sum(matrix: List[List[int]]) -> int:
    """Выведите сумму всех чисел на главной и побочной диагонали квадратной матрицы matrix (тех, что не попали на главную диагональ). Главная диагональ начинается в левом верхнем элементе и идет вправо вниз по диагонали. Побочная диагональ начинается в левом нижнем углу и идет по диагонали вправо вверх.
    Примеры:
       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
       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
    """

from typing import List

def diagonal_sum(matrix: List[List[int]]) -> int:
    l,s=len(matrix),0
    for i in range(l):
        if i==l-i-1:
            s+=matrix[i][i]
        else:
            s+=matrix[i][i]+matrix[i][l-i-1]
    return s


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

from typing import List

def string_shuffle(string: str, array: List[int]) -> str:
    """Перемешайте символы строки string так, чтобы символ с индексом i стал символом с индексом array[i], где array – список целых чисел от 0 до длины string минус 1. Выведите полученную строку.
    Примеры:
       string_shuffle(string=лташбпркцк, array=[7, 2, 3, 5, 8, 0, 9, 4, 1, 6]) == 'пцтакшклбр'
       string_shuffle(string=юязшьщзсрхнае, array=[10, 6, 9, 2, 7, 5, 12, 0, 1, 11, 3, 8, 4]) == 'сршнещяьазюхз'
    """

from typing import List

def string_shuffle(string: str, array: List[int]) -> str:
    answer = [0] * len(array)
    for idx, letter in zip(array, string):
        answer[idx] = letter
    return ''.join(answer)


Instruction:
Реши задачу по программированию
{function}

from typing import List

def unequal_pairs(array: List[int]) -> int:
    """Выведите количество таких пар чисел в списке array, в которых первое число равно второму, но индекс первого числа строго меньше индекса второго числа в array.
    Примеры:
       unequal_pairs(array=[9, 7, 3, 3, 5, 2, 3, 4, 9, 4]) == 5
       unequal_pairs(array=[5, 6, 8, 4, 3]) == 0
    """

from typing import List

def unequal_pairs(array: List[int]) -> int:
    numFreqMp = {}
    answer = 0
    for num in array:
        answer += numFreqMp.get(num, 0)
        numFreqMp[num] = numFreqMp.get(num, 0) + 1
    return answer


Instruction:
Реализуй функцию(ии) на языке Python
{function}

from typing import List

def shuffle_pairs(array: List[int]) -> List[int]:
    """В списке array длины 2 * N перегруппируйте элементы так, чтобы они шли парами в порядке array[i], array[N + i] для всех i от 0 до (N-1). Выведите полученный список. гарантируется, что N не больше 1000.
    Примеры:
       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]
       shuffle_pairs(array=[6, 5, 7, 6, 4, 1, 2, 5, 6, 4]) == [6, 1, 5, 2, 7, 5, 6, 6, 4, 4]
    """

from typing import List

def shuffle_pairs(array: List[int]) -> List[int]:
    n = len(array) // 2
    arr1=[]
    arr2=[]
    arr3=[]
    for i in range(n):
        arr1.append(array[i])
    for i in range(n,2*n):
        arr2.append(array[i])
    for i in range(n):
        arr3.append(arr1[i])
        arr3.append(arr2[i])
    return arr3


Instruction:
Напишите программу по строке документации
{function}

from typing import List

def peculiar_numbers(matrix: List[List[int]]) -> List[int]:
    """Красивым числом в матрице называется такое число, которое является строго наименьшим в своей строке и строго наибольшим в своем столбце. Выведите все уникальные красивые числа матрицы matrix в виде списка в порядке возрастания. Если таких чисел нет, выведите пустой список.
    Примеры:
       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]
       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]
    """

from typing import List

def peculiar_numbers(matrix: List[List[int]]) -> List[int]:
    minrow = {min(r) for r in matrix}
    maxcol = {max(c) for c in zip(*matrix)}
    return sorted(list(minrow & maxcol))


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def single_change(number: int) -> int:
    """Выведите максимально возможное число, которое можно получить из числа number заменой только одной цифры в нем на 6 или 9. Число number состоит только из 6 и 9.
    Примеры:
       single_change(number=6) == 9
       single_change(number=69) == 99
    """

def single_change(number: int) -> int:
    m=number
    s=(str(number))
    for i in range(len(s)):
        if s[i]=="6":
            temp=(int(s[:i]+"9"+s[i+1:]))
        else:
            temp=(int(s[:i]+"6"+s[i+1:]))
        m=max(m,temp)
    return m


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

def digits_difference(number: int) -> int:
    """Выведите разность между произведением цифр числа number и суммой его цифр.
    Примеры:
       digits_difference(number=2) == 0
       digits_difference(number=28) == 6
    """

def digits_difference(number: int) -> int:
    s = 0
    mult = 1
    while number > 0:
        digit = number%10
        s += digit
        mult *= digit
        number = number//10
    return mult-s


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

from typing import List

def merge_arrays(array1: List[int], array2: List[int]) -> List[int]:
    """Сформируйте список чисел так, чтобы в его начале шли все числа списка array1, которые также встречаются в списке array2 в порядке их вхождения в array2, а затем шли все остальные элементы array1 в порядке возрастания. Выведите полученный список.
    Примеры:
       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]
       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]
    """

from typing import List

def merge_arrays(array1: List[int], array2: List[int]) -> List[int]:
    sorted_lst = []
    arr = array1[:]
    for x in array2:
        while x in arr:
            sorted_lst.append(x)
            arr.remove(x)

    return(sorted_lst+sorted(arr))


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

from typing import List

def double_zeros(array: List[int]) -> int:
    """В списке array перенесите все ненулевые элементы в конец списка в порядке их появления в списке, а количество нулей в начале списка удвойте. Выведите сумму полученного списка с 0 индекса до индекса длины изначального списка. Если список пуст, выведите 0. Если в исходном списке нет нулей, ответом будет сумма всех элементов списка.
    Примеры:
       double_zeros(array=[0, 0, 2, 0, 0, 3]) == 5
       double_zeros(array=[4, 4, 2, 0, 0, 0, 0, 4, 3, 0, 0]) == 17
    """

from typing import List

def double_zeros(array: List[int]) -> int:
    l = len(array)
    i = 0
    while i < l:
        if array[i] == 0:
            array.insert(i+1, 0)
            array.pop()
            i += 1
        i += 1
    return sum(array)


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def delete_primitives(string: str) -> int:
    """Минимальная корректная скобочная последовательность (состоит из двух скобок), называется примитивом. Удалите из строки со скобочной последовательностью string все примитивы. Если при удалении примитивов возникают новые примитивы, их тоже нужно удалить. Выведите длину оставшейся после удаления всех возможных примитивов строки. Скобки могут быть трех видов: круглые, квадратные и фигурные - данные виды скобок не взимозаменяемы и независимы друг от друга.
    Примеры:
       delete_primitives(string=[ ] [ ] [ ] [ ] ( [ ] { } ) ( { } ( ) )) == 0
       delete_primitives(string=} { ( ] [ { [ ( ) ) ( )) == 8
    """

def delete_primitives(string: str) -> int:
    text = string.replace(' ', '')
    while '()' in text or '[]' in text or '{}' in text:
        if '()' in text:
            text = text.replace('()', '')
        if '[]' in text:
            text = text.replace('[]', '')
        if '{}' in text:
            text = text.replace('{}', '')
    return len(text)


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

from typing import List

def common_symbols(array: List[str]) -> List[str]:
    """В списке строк array найдите символы, которые встречаются в каждой из строк и выведите список из данных символов в лексикографическом порядке.
    Примеры:
       common_symbols(array=['ежззхкющц', 'скщйбвпьк', 'щчыв', 'огкээр', 'ячюпшм', 'щщсдткчвяа']) == []
       common_symbols(array=['иннторяъф', 'еттижоъыфнюъ', 'умнтоюиьыяхй', 'ифчукоызгээ', 'исоэжнб']) == ['и', 'о']
    """

[{'array': ['ежззхкющц', 'скщйбвпьк', 'щчыв', 'огкээр', 'ячюпшм', 'щщсдткчвяа']}, {'array': ['иннторяъф', 'еттижоъыфнюъ', 'умнтоюиьыяхй', 'ифчукоызгээ', 'исоэжнб']}, {'array': ['оащцтъшбвк', 'зкцаханфрс', 'эцюшэпчаювоз', 'алцоккщзаж', 'ииаяхжщбакц']}, {'array': ['ляькыакв', 'ьбокцхлощдз', 'тавэысжэчрр', 'яцк', 'нпеюф']}, {'array': ['цуюътнэ', 'лэркщмфжпфвю', 'пщщвьунюэйев', 'фсскчлцэуяюъ', 'лдчютйхсэу']}, {'array': ['рбумивджн', 'жюьюцеид', 'имзвцмпмсоэ', 'ззши', 'окэ', 'ребягщоумйую', 'юмаычук', 'окзсчсчежрн']}, {'array': ['соькехти', 'ьъийсзоукмаб', 'коцспямпшгг', 'ъытммсзщка', 'квас']}, {'array': ['ешккихху', 'крненкхукси', 'ьйгфвцхуцхшг', 'тбюфдухдфщгс', 'блухэяпач']}, {'array': ['мсешаокпбф', 'бтцдчийч', 'тммтьц', 'омд', 'ыфбамзф', 'цвхьт', 'пстытажъмзя', 'иющъфш', 'зкбьеен', 'птлгчжы', 'евыум', 'ощицг']}, {'array': ['хгмщоцэкегэю', 'пэгофтцаыщу', 'цчмгхащ', 'шщтбъгюыдип', 'ыуфсущугь']}]

from typing import List

def common_symbols(array: List[str]) -> List[str]:
    if len(array) < 2:
        return array
    res = []
    word1 = set(array[0])
    for char in word1:
        frequency = min([word.count(char) for word in array])
        res += [char] * frequency
    return sorted(res)


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

from typing import List

def parity_sort(array: List[int]) -> List[int]:
    """Перенесите все четные элементы списка array в его начало, отсортировав их в порядке возрастания. В конце списка должны идти его нечетные элементы также в порядке возрастания. Выведите полученный список.
    Примеры:
       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]
       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]
    """

from typing import List

def parity_sort(array: List[int]) -> List[int]:
    odd = list(filter(lambda x: x % 2 == 1, array))
    even = list(filter(lambda x: x % 2 == 0, array))
    return sorted(even) + sorted(odd)


Instruction:
Реши задачу по программированию
{function}

def beautiful_number(number: int) -> str:
    """Число называется красивым, если путем конечного числа разрешенных операций оно превращается в 1. Разрешенным действием для числа является его замена на сумму квадратов его цифр. Определите, является ли число number красивым. Если да, то выведите "Да", иначе выведите "Нет". Если разрешенные операции приводят к бесконечному циклу повторяющихся результатов, то такое число не является красивым.
    Примеры:
       beautiful_number(number=2) == 'Нет'
       beautiful_number(number=28) == 'Да'
    """

def beautiful_number(number: int) -> str:
    visted = set()

    while number != 1 and number not in visted:
        visted.add(number)
        number = sum(int(digit) ** 2 for digit in str(number))
    if number == 1:
        return "Да"
    return "Нет"


Instruction:
Реализуй функцию(ии) на языке Python
{function}

from typing import List

def symmetic_difference(set1: set, set2: set) -> List[int]:
    """Даны два списка чисел: set1 и set2. Преобразуйте списки в множества. Выведите симметрическую разность множест в виде отсортированного по возрастанию списка. Симметрическая разность множеств – это совокупность элементов этих множеств, которые есть только в одном из них.
    Примеры:
       symmetic_difference(set1=[2, 3, 5, 6, 7, 8, 11], set2=[3, 4, 5, 7, 8, 9, 11]) == [2, 4, 6, 9]
       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]
    """

from typing import List

def symmetic_difference(set1: set, set2: set) -> List[int]:
    return sorted(list(set(set1).symmetric_difference(set(set2))))


Instruction:
Напишите программу по строке документации
{function}

from typing import List

def set_complement(set1: set, set2: set) -> List[int]:
    """Даны два списка чисел: set1 и set2. Преобразуйте списки в множества. Выведите дополнение set1 до set2 в виде отсортированного по возрастанию списка. Дополнением множества до другого множества являются элементы, которые есть во втором множестве и нет в первом.
    Примеры:
       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]
       set_complement(set1=[2, 3, 6, 7, 8, 9, 10, 11], set2=[1, 2, 3, 4, 7, 9, 10, 11]) == [1, 4]
    """

from typing import List

def set_complement(set1: set, set2: set) -> List[int]:
    return sorted(list(set(set2).difference(set(set1))))


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

from typing import List

def words_dictionary(array: List[str]) -> dict:
    """Дан список слов array. Создайте словарь, где ключами будут слова из списка, а значениями – порядковые номера данных слов в списке. Выведите получившийся словарь. Гарантируется, что слова в списке уникальные.
    Примеры:
       words_dictionary(array=['зэшхкхэр', 'ъщнкшбжм', 'агшф', 'птчую', 'лбфигхъймщв', 'ющкйь', 'они', 'тфуенбжгтаэе', 'узчг', 'уяпрбздихчъ', 'лгйрцжюпца']) == {'зэшхкхэр': 0, 'ъщнкшбжм': 1, 'агшф': 2, 'птчую': 3, 'лбфигхъймщв': 4, 'ющкйь': 5, 'они': 6, 'тфуенбжгтаэе': 7, 'узчг': 8, 'уяпрбздихчъ': 9, 'лгйрцжюпца': 10}
       words_dictionary(array=['вгньшфбяпр', 'чрзшгасаро', 'щьырбв', 'жфг', 'рфгмьеуацй', 'ьдбринс', 'мнзиъгушаь', 'ъзьыпю']) == {'вгньшфбяпр': 0, 'чрзшгасаро': 1, 'щьырбв': 2, 'жфг': 3, 'рфгмьеуацй': 4, 'ьдбринс': 5, 'мнзиъгушаь': 6, 'ъзьыпю': 7}
    """

[{'array': ['зэшхкхэр', 'ъщнкшбжм', 'агшф', 'птчую', 'лбфигхъймщв', 'ющкйь', 'они', 'тфуенбжгтаэе', 'узчг', 'уяпрбздихчъ', 'лгйрцжюпца']}, {'array': ['вгньшфбяпр', 'чрзшгасаро', 'щьырбв', 'жфг', 'рфгмьеуацй', 'ьдбринс', 'мнзиъгушаь', 'ъзьыпю']}, {'array': ['нуичл', 'юфкдлшзй', 'нъж', 'юзщ', 'ицщчешжзв', 'счхжржтъпуар', 'ияэьяьщ']}, {'array': ['внащьнд', 'мывблх', 'рюеь', 'аждэжгж', 'юлрилмкпк', 'сярнсшпл', 'йвая', 'ддцрмцбм', 'ъщяжхарс', 'аъйгу', 'жхцчлкл']}, {'array': ['пиря', 'ынхйыщжйън', 'хршйхзсб', 'лхчуяж', 'эцкгщыбсщшщк', 'таущзнт', 'эсигро']}, {'array': ['лдфшц', 'зршмъм', 'шзгыл', 'ревв', 'теыьп', 'щцафдщфцвжщ', 'ъаъчщтуаъч', 'ъяйпкябиуге']}, {'array': ['дкб', 'эзврцчу', 'ъюоткеьилзю', 'ксюгасъхкцдж', 'ыоюз', 'мцинчгч', 'штженайюонд', 'зчжяюф', 'хэлюды']}, {'array': ['эхюгбыэскх', 'ейеьчрвлди', 'тямьяцкацх', 'хббцащсц', 'аль', 'гнфляэмр', 'ыжцчщьюф', 'бйвбэщ']}, {'array': ['пндищнщй', 'омонфп', 'гэггчългф', 'уейябмдку', 'аофшею', 'эдпдьтяи', 'юыьбыу', 'южуфююсущ', 'зкяксьсйън', 'крйапуоцщтх', 'ююи', 'фиьйнму']}, {'array': ['глуйящ', 'цлйвешюсфкж', 'кхюо', 'дщброхз', 'попежпбчэ', 'слйеьшцщсери', 'ньпхххофьпх', 'лчеэшяндечр', 'бввящшвэй', 'шдслуию', 'гфвдч', 'кдгя', 'юфулэзп']}]

from typing import List

def words_dictionary(array: List[str]) -> dict:
    return {k:v for v, k in dict(enumerate(array)).items()}


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

from typing import List

def prefix_string(string: str, array: List[str]) -> str:
    """Дана непустая строка string и непустой список строк array. Определите, является ли строка префиксом списка. Строка называется префиксом списка, если строка в точности равна конкатенации первых N слов из списка. Выведите "Да", если является, и "Нет", если не является.
    Примеры:
       prefix_string(string=флюгегехаймен, array=['флю', 'гег', 'еха', 'ймен', 'питон']) == 'Да'
       prefix_string(string=программирование, array=['про', 'грам', 'иро', 'вание', 'на', 'си']) == 'Нет'
    """

[{'string': 'флюгегехаймен', 'array': ['флю', 'гег', 'еха', 'ймен', 'питон']}, {'string': 'программирование', 'array': ['про', 'грам', 'иро', 'вание', 'на', 'си']}, {'string': 'метафора', 'array': ['ме', 'тафо', 'ра', 'текста', 'в', 'тексте']}, {'string': 'кяшвеэзюимдчжтущсъфлаойбрцхныпьг', 'array': ['кяш', 'веэзю', 'им', 'дчжтущс', 'ъфла', 'ойбрц', 'хнып', 'ьг']}, {'string': 'мъчузцквюхепяьжсдлфрышщгонабтийэ', 'array': ['мъчу', 'зцквюх', 'еп', 'яьжсдлфрышщгон', 'абтийэ']}, {'string': 'фгпэытиьежйлоюамбквзцхущшрч', 'array': ['фгпнъдсяэытиьежйлоюамбквзцхущшрч']}, {'string': 'смлыгрхцпнвщдъошеяьжфэйбюкачзути', 'array': ['смлыгр', 'хцпнвщдъош', 'еяьжфэйбюка', 'чзути', 'кек']}, {'string': 'чьщсяэшмдзхежпюфтгцоива', 'array': ['чьщыб', 'сяэшмдйлз', 'хежпнък', 'юфтгцру', 'оива']}, {'string': 'кшфйцодутмьвюяхечщрзлнсыиэбъгжпа', 'array': ['кшф', 'йцоду', 'тмьвю', 'яхечщ', 'рзлнсыиэбъ', 'гжпа', 'гойдф', 'атом']}, {'string': 'йшоярыгавниъзфбжкдхпьэм', 'array': ['йшоеяры', 'ющгавнисцт', 'ъзфбжкдул', 'хпьчэм', 'вфылорп', 'ыровиа']}]

from typing import List

def prefix_string(string: str, array: List[str]) -> str:
    i = 0
    for word in array:
        if string[i:i+len(word)] != word: return "Нет"
        i += len(word)
        if i == len(string): return "Да"
    return "Нет"


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

def three_divisors(number: int) -> str:
    """Дано целое число number. Определите количество натуральных делитетей данного числа. Выведите "Да", если таких делителей в точности 3. Иначе, выведите "Нет".
    Примеры:
       three_divisors(number=4) == 'Да'
       three_divisors(number=28) == 'Нет'
    """

def three_divisors(number: int) -> str:
    cnt=2
    for i in range(2,number//2+1):
        if number%i==0:
            cnt+=1
        if cnt>3:
            return "Нет"
    if cnt!=3:
        return "Нет"
    return "Да"


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def alphabet_encoding(number: int, string: str) -> int:
    """Дана строка string и натуральное число number. Замените в string все буквы на их порядковые номера в русском алфавите. Для получившегося числа преобразуйте его в сумму его цифр number раз. Выведите получившееся число в целочисленном виде.
    Примеры:
       alphabet_encoding(string=флюгегехаймен, number=4) == 6
       alphabet_encoding(string=метафора, number=3) == 3
    """

[{'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}]

def alphabet_encoding(number: int, string: str) -> int:
    res=""
    for i in string:
        n=ord(i)-1071
        res+=str(n)
    for i in range(number):
        string=0
        for i in res:
            string+=int(i)
        res=str(string)
    return string


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def unique_frequency(string: str) -> str:
    """Дана строка string. Определите, одинаково ли число вхождений в строку для каждого уникального символа из string. Выведите "Да", если одинаково. Иначе, выведите "Нет".
    Примеры:
       unique_frequency(string=шаллаш) == 'Да'
       unique_frequency(string=аффирмации) == 'Нет'
    """

[{'string': 'шаллаш'}, {'string': 'аффирмации'}, {'string': 'йвоюфациылрм'}, {'string': 'лвопаицрмф'}, {'string': 'йдмыфпуицаов'}, {'string': 'алюфвойуцмп'}, {'string': 'вомрафыцйл'}, {'string': 'выйооцдййлмалурылфйлффаююроццавуювыиу'}, {'string': 'ыырювувюиюрфропыыфуиповммпоуриыацлыицаыйирццв'}, {'string': 'ппайфлиавапдмвмцвмпйдфуоююыицувфю'}]

def unique_frequency(string: str) -> str:
    j=[]
    for i in set(string):
        j.append(string.count(i))
    if len(set(j))!=1:
        return "Нет"
    return "Да"


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def pythagorean_triplets(number: int) -> int:
    """Дано целое положительное число number. Выведите количество троек целых чисел, каждое из которых больше или равно 1 и меньше или равно number, таких, что сумма квадратов первых двух чисел равна квадрату второго.
    Примеры:
       pythagorean_triplets(number=13) == 6
       pythagorean_triplets(number=10) == 4
    """

def pythagorean_triplets(number: int) -> int:
    count = 0
    sqrt = 0
    for i in range(1,number-1):
        for j in range(i+1, number):
            sqrt = ((i*i) + (j*j)) ** 0.5
            if sqrt % 1 == 0 and sqrt <= number:
                count += 2
    return count


Instruction:
Дан шаблон функции(ий) с описанием работы этой функции в качестве условия задачи. Допишите программу
{function}

from typing import List

def shuffle_array(array: List[int]) -> List[int]:
    """Дан список array из целых чисел от 0 до длины array минус 1 включительно. Постройте на основе списка array новый список, i-й элемент которого равен array[array[i]] для всех i от 0 до длины списка array. Выведите полученный список.
    Примеры:
       shuffle_array(array=[1, 0, 3, 2, 4]) == [0, 1, 2, 3, 4]
       shuffle_array(array=[5, 1, 0, 4, 2, 3]) == [3, 1, 5, 2, 0, 4]
    """

from typing import List

def shuffle_array(array: List[int]) -> List[int]:
    ans = []
    for i in range(len(array)):
        ans.append(array[array[i]])
    return ans


Instruction:
Реши задачу по программированию
{function}

def odd_substring(string: str) -> str:
    """Выберите из строки string, содержащей целое положительное число, подстроку так, чтобы она содержала наибольшее возможное нечетное число. Выведите полученную подстроку в виде строки. Если невозможно составить нечетное число, выведите пустую строку.
    Примеры:
       odd_substring(string=8016) == '801'
       odd_substring(string=54468345) == '54468345'
    """

def odd_substring(string: str) -> str:
    i = len(string) - 1
    while i >= 0:
        if int(string[i])%2 == 1:
            return string[:i+1]
        i -= 1
    return ''


Instruction:
Реализуй функцию(ии) на языке Python
{function}

def index_sort(string: str) -> str:
    """В строке string все слова разделены пробелом. В конце каждого слова содержится его индекс – порядковый номер в некотором предложении (индексы начинаются с 1). Отсортируйте слова в строке string в порядке возрастания индекса и после этого удалите индексы в конце слова. Выведите получившуюся строку предложения.
    Примеры:
       index_sort(string=Аппетит1 приходит2 во3 время4 еды5) == 'Аппетит приходит во время еды'
       index_sort(string=Без1 труда2 не3 выловишь3 и4 рыбку5 из6 пруда,7 не8 то,9 что10 сапог11) == 'Без труда не выловишь и рыбку из пруда, не то, что сапог'
    """

[{'string': 'Аппетит1 приходит2 во3 время4 еды5'}, {'string': 'Без1 труда2 не3 выловишь3 и4 рыбку5 из6 пруда,7 не8 то,9 что10 сапог11'}, {'string': 'Волков1 бояться2 –3 в4 лес5 не6 ходить7'}, {'string': 'Бедность1 не2 порок3'}, {'string': 'Готовь1 сани2 летом,3 а4 телегу5 зимой6'}, {'string': 'В1 здоровом2 теле3 –4 здоровый5 дух6'}, {'string': 'Дарёному1 коню2 в3 зубы4 не5 смотрят6'}, {'string': 'Бесплатный1 сыр,2 бывает-3 только4 в5 мышеловке6'}, {'string': 'Глаза1 боятся,2 а3 руки4 делают5'}, {'string': 'Бог1 шельму=2 метит3'}]

def index_sort(string: str) -> str:
    a=string[::-1].split();a.sort();r=[]
    for word in a:r.append(word[1:][::-1])
    return " ".join(r)


Instruction:
Напишите программу по строке документации
{function}

def is_pangram(string: str) -> str:
    """Определите, является ли строка string панграммой. Панграмма – это такая строка, которая содержит все буквы русского алфавита, как минимум, один раз. Если является, выведите "Да", иначе, выведите "Нет".
    Примеры:
       is_pangram(string=Любя, съешь щипцы, — вздохнёт мэр, — кайф жгуч.) == 'Да'
       is_pangram(string=Аппетит приходит во время еды) == 'Нет'
    """

[{'string': 'Любя, съешь щипцы, — вздохнёт мэр, — кайф жгуч.'}, {'string': 'Аппетит приходит во время еды'}, {'string': 'Шеф взъярён тчк щипцы с эхом гудбай Жюль'}, {'string': 'Эй, жлоб! Где туз? Прячь юных съёмщиц в шкаф'}, {'string': 'Экс-граф? Плюш изъят. Бьём чуждый цен хвощ!'}, {'string': 'Чушь: гид вёз кэб цапф, юный жмот съел хрящ'}, {'string': 'Без труда не выловишь и рыбку из пруда'}, {'string': 'Готовь сани летом, а телегу зимой'}, {'string': 'Дарёному коню в зубы не смотрят'}, {'string': ''}]

def is_pangram(string: str) -> str:
    ref = {v:False for i,v in enumerate('абвгдеёжзийклмнопрстуфхцчшщъыьэюя')}
    for i in string:
        ref[i.lower()] = True
    for i in ref:
        if not ref[i]:
            return "Нет"
    return "Да"


Instruction:
Необходимо реализовать логику на языке Python для следующей программы
{function}

def topk_words(string: str, number: int) -> str:
    """В строке string все слова разделены пробелами. Выведите новую строку, которая содержит только первые number слов изначальной строки.
    Примеры:
       topk_words(string=Призрак такого сима получает ту же смертельную черту, что и пожилые симы, умершие от физических нагрузок, и ничем не отличается, number=16) == 'Призрак такого сима получает ту же смертельную черту, что и пожилые симы, умершие от физических нагрузок,'
       topk_words(string=В эту игру можно играть по самым разным сценариям, number=2) == 'В эту'
    """

[{'string': 'Призрак такого сима получает ту же смертельную черту, что и пожилые симы, умершие от физических нагрузок, и ничем не отличается', 'number': 16}, {'string': 'В эту игру можно играть по самым разным сценариям', 'number': 2}, {'string': 'Однако иногда красота может оказаться не преимуществом, а препятствием', 'number': 4}, {'string': 'Даже всемогущая пунктуация не имеет власти над рыбными текстами, ведущими безорфографичный образ жизни', 'number': 4}, {'string': 'Например, гриль или плита, размещённые на ковровом покрытии, готовка на дешевой плите, а также низкий навык кулинарии или выпечки', 'number': 11}, {'string': 'Поедем туда на следующий год и будем там вовсю бросаться помидорами', 'number': 10}, {'string': 'В мире соулмейтов, каждый находит свою пару по фобии, приобретённой с рождения', 'number': 4}, {'string': 'Пожилым персонажам стоит воздерживаться от чрезмерных физических нагрузок и активного вуху, чтобы не получить перенапряжение', 'number': 10}, {'string': 'Моя сестра тратит деньги просто так', 'number': 5}, {'string': 'Моя девушка гуляет просто так', 'number': 2}]

def topk_words(string: str, number: int) -> str:
    words = string.split(" ")
    return " ".join(words[:number])


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

def numbers_only(string: str) -> int:
    """Выведите количество уникальных целых чисел, которые образовались после замены всех нечисловых символов строки string на пробелы.
    Примеры:
       numbers_only(string=тву6бчуб758гтж1и19ришиирьечхо9жгщ4йф96ящ) == 7
       numbers_only(string=з6к1241е989ъ2е2юп9н656ф7к3086стя17д2щ316ч58к491) == 12
    """

[{'string': 'тву6бчуб758гтж1и19ришиирьечхо9жгщ4йф96ящ'}, {'string': 'з6к1241е989ъ2е2юп9н656ф7к3086стя17д2щ316ч58к491'}, {'string': 'ывбпоылфлоптыюловпт'}, {'string': 'яж7а9вю6псго5эъ38со7ш91ььу513уккм6щь3геш81ы14296'}, {'string': 'й1эа62р2п17м48683нх2856из7уз122й99х7э'}, {'string': 'г876ай7ьхя05зэ4932ош0р6'}, {'string': 'д5в2н4ы4т9уйд50я5и49кгю8ю'}, {'string': '2й4юсг511юзхбу298661юь858'}, {'string': ''}, {'string': 'ш1207щу828м546сег3юа5с5бе882юсв'}]

def numbers_only(string: str) -> int:
    import re
    return len(set([int(i) for i in re.findall(r'\d+',string)]))


Instruction:
Дано описание функции, напиши программу на языке Python
{function}

from typing import List

def ascending_subarray(array: List[int]) -> int:
    """Выведите максимально возможную сумму какого-либо возрастающего непрерывного подсписка списка array, состоящего из целых чисел.
    Примеры:
       ascending_subarray(array=[11, 63, 10, 88, 0, 30, 20, 77, 70, 18, 14, 45, 51, 86]) == 196
       ascending_subarray(array=[73, 80, 65, 88, 96, 3, 35, 72, 39, 55, 47, 86]) == 249
    """

from typing import List

def ascending_subarray(array: List[int]) -> int:
    sumx = -1
    for i in range(len(array)):
        subarr=[array[i]]
        for j in range(i+1, len(array)):
            if array[j]>subarr[-1]:subarr.append(array[j])
            else:break
        s=sum(subarr)
        if s>sumx:sumx=s
    return sumx


Instruction:
На вход подается функция(ии) с описанием в виде строки docstring. В соответствии с описанием вам необходимо реализовать функцию(ии)
{function}

def equal_swap(string: str, target: str) -> str:
    """Если строку string можно сделать равной строке target путем перестановки местами ровно двух символов в string, то выведите "Да". Иначе, выведите "Нет".
    Примеры:
       equal_swap(string1=ащщснишплсдк, string2=ую) == 'Нет'
       equal_swap(string1=ес, string2=се) == 'Да'
    """

[{'string1': 'ащщснишплсдк', 'string2': 'ую'}, {'string1': 'ес', 'string2': 'се'}, {'string1': 'ефдкпхтаь', 'string2': 'ааеюх'}, {'string1': 'ъж', 'string2': 'бтфьэмрл'}, {'string1': 'учднжбнхькгегл', 'string2': 'пйпфлфёиаа'}, {'string1': 'ияыэ', 'string2': 'хфолецах'}, {'string1': 'ёмбжгъцаекл', 'string2': 'ёцбжгъмаекл'}, {'string1': 'пспыожъи', 'string2': 'мжфюэмъьйуьях'}, {'string1': 'ыовухутцибуми', 'string2': 'цгё'}, {'string1': 'сцярьыйжшрцтэю', 'string2': 'сцяюьыйжшрцтэр'}]

def equal_swap(string: str, target: str) -> str:
    diff = [[x, y] for x, y in zip(string, target) if x != y]
    if not diff or len(diff) == 2 and diff[0][::-1] == diff[1]:
        return "Да"
    return "Нет"


Instruction:
По данному условию с фиксированной шапкой функции(ий) напиши программу
{function}

def contiguous_ones(string: str) -> str:
    """Если строка string из 0 и 1 содержит непрерывную подследовательность из 1 длиной больше 1, то выведите "Да". Иначе, выведите "Нет".
    Примеры:
       contiguous_ones(string=1111110) == 'Да'
       contiguous_ones(string=11100011) == 'Нет'
    """

def contiguous_ones(string: str) -> str:
    if "01" not in string:
        return "Да"
    return "Нет"


Instruction:
Необходимо написать код по условию из строковой переменной документации, следующей после функции(ий)
{function}

def merge_strings(string1: str, string2: str) -> str:
    """Соедините две строки string1 и string2 так, чтобы попеременно сначала шел символ из первой строки, затем символ из второй строки в их изначальном порядке. Если одна из строк закончится, то добавьте все оставшиеся символы другой строки в конец новой строки. Выведите получившуюся строку.
    Примеры:
       merge_strings(string1=3ащёи, string2=ьчбрйёу7е) == '3ьачщбёрийёу7е'
       merge_strings(string1=мёл, string2=эни) == 'мэёнли'
    """

[{'string1': '3ащёи', 'string2': 'ьчбрйёу7е'}, {'string1': 'мёл', 'string2': 'эни'}, {'string1': 'е0э1тъ2ом', 'string2': '7ъушъеаь'}, {'string1': 'фш', 'string2': '6чн'}, {'string1': 'афжч', 'string2': '1щкаю5в1'}, {'string1': 'дфь', 'string2': '91ёх4ф'}, {'string1': 'х3гк', 'string2': 'гещсннвх'}, {'string1': 'эоэцявп', 'string2': 'шшвп8ц'}, {'string1': 'вн7шц8э', 'string2': 'лахдщ'}, {'string1': 'цх', 'string2': 'ещты6нм53'}]

def merge_strings(string1: str, string2: str) -> str:
    return "".join(a + b for a, b in zip(string1, string2)) + string1[len(string2):] + string2[len(string1):]