def reverse_string(s):
    return s[::-1]
s = "hello"
print(f"'{s}' перевёрнутая: '{reverse_string(s)}'")
s = "12345"
print(f"'{s}' перевёрнутая: '{reverse_string(s)}'")
s = "Привет"
print(f"'{s}' перевёрнутая: '{reverse_string(s)}'")
def draw(n):
    s = ""
    for i in range(n//2+1):
        s += (" "*(n//2-i)+"*"*(i*2+1))
        s += "\n"
    for i in range(n//2-1, -1, -1):
        s += (" "*(n//2-i)+"*"*(i*2+1))
        s += "\n"
    return s
n = 7
print(f"Ромбик шириной в {n} звёздочек:\n{draw(n)}")
def gcd(a, b):
    max_possible = min(a, b)
    for i in range(1, max_possible+1):
        #print(i)
        if (a%i==0) and (b%i==0):
            nod = i
    return nod

a = 48
b = 18
print(f"НОД {a} и {b} = {gcd(a, b)}")
a = 100
b = 25
print(f"НОД {a} и {b} = {gcd(a, b)}")
a = 17
b = 13
print(f"НОД {a} и {b} = {gcd(a, b)}")
def convert_to_decimal(number_str, base):
    if (base < 2) or (base > 36):
        raise ValueError
    try:
        return int(number_str, base)
    except:
        raise ValueError

number_str, base = "1010", 2
print(f"Число {number_str} в системе счисления с базой {base} в десятичной будет {convert_to_decimal(number_str, base)}")
number_str, base = "1010", 2
print(f"Число {number_str} в системе счисления с базой {base} в десятичной будет {convert_to_decimal(number_str, base)}")
number_str, base = "1A", 16
print(f"Число {number_str} в системе счисления с базой {base} в десятичной будет {convert_to_decimal(number_str, base)}")
number_str, base = "123", 8
print(f"Число {number_str} в системе счисления с базой {base} в десятичной будет {convert_to_decimal(number_str, base)}")
number_str, base = "Z", 36
print(f"Число {number_str} в системе счисления с базой {base} в десятичной будет {convert_to_decimal(number_str, base)}")
def is_palindrome(s):
    return s == s[::-1]

s = "мадам"
print(f"Строка '{s}' - палиндром? Ответ: {is_palindrome(s)}")
s = "топот"
print(f"Строка '{s}' - палиндром? Ответ: {is_palindrome(s)}")
s = "привет"
print(f"Строка '{s}' - палиндром? Ответ: {is_palindrome(s)}")
def count_greater_than_kth(arr, k):
    sorted_array = sorted(arr)
    elem_on_k = sorted_array[k-1]
    result = 0
    for i in arr:
        if i > elem_on_k:
            result += 1
    return result

arr = [5, 3, 8, 6, 2]
k = 3
result = count_greater_than_kth(arr, k)
print(f"Количество элементов в массиве {arr}, которые больше, чем элемент, находящийся на позиции {k}: {result}")
arr = [5, 3, 8, 6, 2, 5, 5]
k = 3
result = count_greater_than_kth(arr, k)
print(f"Количество элементов в массиве {arr}, которые больше, чем элемент, находящийся на позиции {k}: {result}")
def count_unique_substrings(text, k):
    length = len(text)
    if length < k:
        return 0
    elif length == k:
        return 1
    substrings = set()
    for i in range(length-k+1):
        substrings.add(text[i:k+i:])
    result = len(substrings)
    return result

text = "abcabc"
k = 3
result = count_unique_substrings(text, k)
print(f"Количество уникальных подстрок в строке {text}: {result}")
def minimum(n):
    dels = set()
    for a in range(1, int(n**(1/3)) + 1):
        if n%a == 0:
            for b in range(1, int( (n//a)**(1/2)) + 1):
                if (n//a)%b == 0:
                    c = (n//a)//b
                    #сортируем чтобы не добавлять одни и те же наборы
                    dels.add(tuple(sorted((a, b, c))))
    a, b, c = n, n, n
    for i, j, k in dels:
        if (i + j + k) < (a + b + c):
            a, b, c = i, j, k
    return a, b, c
n = 12
a, b, c = minimum(n)
print(f"Числа дающие минимальную сумму при объёме паралеллепипеда {n} это {a}, {b}, {c}")
n = 27
a, b, c = minimum(n)
print(f"Числа дающие минимальную сумму при объёме паралеллепипеда {n} это {a}, {b}, {c}")
n = 7
a, b, c = minimum(n)
print(f"Числа дающие минимальную сумму при объёме паралеллепипеда {n} это {a}, {b}, {c}")
def determinant(matrix):
    #создание алгебраического дополнения
    def algebraic_addition(matrix, row, col):
        new_matrix = list()
        for i in range(len(matrix)):
            if i == row:
                continue
            else:
                new_matrix.append( matrix[i][:col:] + matrix[i][col+1:len(matrix[i]):] )
        return new_matrix

    #проверка квадратности
    for i in range(len(matrix)):
        if len(matrix) != len(matrix[i]):
            raise ValueError("Wrong matrix size!")
    is_even = lambda n: (n%2*2 - 1)
    if len(matrix) == 1:
        return matrix[0][0]
    result = 0
    for j in range(len(matrix[0])):
        result += is_even(j+1)*matrix[0][j]*determinant(algebraic_addition(matrix, 0, j))
    return result


matrix = [
    [1, 2],
    [3, 4]
]
result = determinant(matrix)
print(f"Определитель матрицы {matrix}: {result}")

matrix = [
    [9, 2, 7],
    [1, 2, 3],
    [16, 15, 11]
]
result = determinant(matrix)
print(f"Определитель матрицы {matrix}: {result}")
def is_valid_sequence(s):
    parenthesis = {
        ")":"(",
        "}":"{",
        "]":"[",
    }
    list_of_closed = list()
    for symbol in s:
        if symbol in parenthesis.values():
            list_of_closed.append(symbol)
            #print(list_of_closed)
        elif symbol in parenthesis.keys():
            if list_of_closed == [] or parenthesis[symbol] != list_of_closed[-1]:
                return False
            list_of_closed.pop()
            #print(list_of_closed)
    return len(list_of_closed) == 0


s = "({[]})"
result = is_valid_sequence(s)
print(f"Является ли скобочная последовательность {s} корректной: {result}")
s = "{()[]}"
result = is_valid_sequence(s)
print(f"Является ли скобочная последовательность {s} корректной: {result}")
s = "{()[)]}"
result = is_valid_sequence(s)
print(f"Является ли скобочная последовательность {s} корректной: {result}")