# Сумма элементов массива
def sum_array(array):
    # Что должна возвращать функция?
    sum = 0

    # Проводим вычисления
    for a in array:
        sum = sum + a

    # Вернуть значение
    return sum


# Из суммы элементов с четным индексом вычесть элементы с нечетным индексом (0 - четный)
def sum_diff_array(array):
    # Что должна возвращать функция?
    result = 0

    # Проводим вычисления
    for e in range(len(array)):
        if e % 2 == 0:
            result = result + array[e]
        else:
            result = result - array[e]

    # Вернуть значение
    return result


# Максимальное число из массива помножить на минимальное число из массива
def max_mul_min_array(array):
    sum = 0


# Развернуть строку (например "Abc" -> "cbA")
def invert_string(string):
    return string[::-1]


# Все буквы сделать заглавными (например "aBc" -> "ABC")
def to_upper_string(string):
    # Что должна возвращать функция?
    str1 = ""

    # Проводим вычисления
    for c in string:
        # Проверить, какая буква
        if 97 <= ord(c) <= 122:
            # Если маленькая - то превращаем в большую и добавляем в итоговую строку
            str1 += chr(ord(c) - 32)
        else:
            # Если уже большая - то перенимаем букву в итоговую строку
            # А если вообще не буква?! - Также перенимаем без изменений
            str1 += c

    # Вернуть значение
    return str1


# Все буквы сделать прописными (например "aBc" -> "abc")
def to_lower_string(string):
    str1 = ""

    for x in string:
        if 65 <= ord(x) <= 90:
            str1 += chr(ord(x) + 32)
        else:
            str1 += x

    return str1


# Проверить, является ли строка палиндромом (независимо от больших/маленьких букв)
def check_palindrome(string):
    new_string = to_upper_string(string)
    return new_string == invert_string(new_string)


# Проверить, является ли строка палиндромом (независимо от больших/маленьких букв и знаков пунктуации/пробелов)
def check_palindrome_escaped(string):
    pass


# "Ручной" аналог функции split()
def split_string(string, separator):
    pass


# "Ручной" аналог функции join()
def join_array(array, separator):
    pass


#################################################
def verifier(test_name, actual, expected):
    print(test_name)
    if actual != expected:
        print("=======> FAILED! <=======")
        print(f"Got value <{actual}>")
        print(f"Expected value is <{expected}>")
    else:
        print("PASSED")
    print()


test_array1 = [6, 4, 7, -3, 6, -1, 5, 8, 4, -6, 8, 3, 6, 4, -7, 21, 6, 4, -1, 1]
test_array2 = [987, 342, -876, 182, -6534, 998, -11, 334, 0, 6654, -9901, 333, 111, 664]
test_array3 = [10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]

test_string1 = "The World is not enough"
test_string2 = "Testing is key"

test_palindrome1 = "Sir, I demand, I am a maid named Iris"
test_palindrome2 = "Satire: Veritas"
test_palindrome3 = "Saippuakivikauppias"

test_split1 = "1, 2, 3, 4, 5, 6, 7, 8, 9"
test_split2 = "1 2 3 4 5 6 7 8 9"
test_split3 = "bagahajemanbdneorijahdhrea4"

test_array4 = test_split1.split(',')
test_array5 = test_split2.split(' ')
test_array6 = test_split3.split('a')

sum_array_tests = [test_array1, test_array2, test_array3, [], [0]]
string_tests = [test_string1, test_string2, test_palindrome1, test_palindrome2, test_palindrome3, '']
palindrome_tests = [test_string1, test_string2, test_palindrome1, test_palindrome2, test_palindrome3, '']
split_string_tests = [test_split1, test_split2, test_split3, test_string1, test_string2, '']
join_array_tests = [test_array4, test_array5, test_array6, [], ['']]

for i in range(len(sum_array_tests)):
    verifier(f"SUM_ARRAY TEST {i+1}", sum_array(sum_array_tests[i]), sum(sum_array_tests[i]))

for i in range(len(sum_array_tests)):
    verifier(f"SUM_DIFF_ARRAY TEST {i+1}", sum_diff_array(sum_array_tests[i]), sum(sum_array_tests[i][0::2]) - sum(sum_array_tests[i][1::2]))

for i in range(len(sum_array_tests)):
    if len(sum_array_tests[i]) == 0:
        verifier(f"MAX_MUL_MIN_ARRAY TEST {i + 1}", max_mul_min_array(sum_array_tests[i]), 0)
    else:
        verifier(f"MAX_MUL_MIN_ARRAY TEST {i+1}", max_mul_min_array(sum_array_tests[i]), max(sum_array_tests[i]) * min(sum_array_tests[i]))

for i in range(len(string_tests)):
    verifier(f"INVERT_STRING TEST {i+1}", invert_string(string_tests[i]), string_tests[i][::-1])

for i in range(len(string_tests)):
    verifier(f"TO_UPPER_STRING TEST {i+1}", to_upper_string(string_tests[i]), string_tests[i].upper())

for i in range(len(string_tests)):
    verifier(f"TO_LOWER_STRING TEST {i+1}", to_lower_string(string_tests[i]), string_tests[i].lower())

for i in range(len(palindrome_tests)):
    verifier(f"CHECK_PALINDROME TEST {i+1}",
            check_palindrome(palindrome_tests[i]),
            (palindrome_tests[i].lower() == palindrome_tests[i].lower()[::-1]))

for i in range(len(palindrome_tests)):
    val = "".join(e for e in palindrome_tests[i] if e.isalpha())
    verifier(f"CHECK_PALINDROME_ESCAPED TEST {i+1}",
             check_palindrome_escaped(palindrome_tests[i]),
             (val.lower() == val.lower()[::-1]))

for i in range(len(split_string_tests)):
    separator = ','
    verifier(f"SPLIT_STRING (SEPARATOR='{separator}') TEST {i+1}",
             split_string(split_string_tests[i], separator),
             split_string_tests[i].split(separator))

for i in range(len(split_string_tests)):
    separator = ' '
    verifier(f"SPLIT_STRING (SEPARATOR='{separator}') TEST {i+1}",
             split_string(split_string_tests[i], separator),
             split_string_tests[i].split(separator))

for i in range(len(join_array_tests)):
    separator = '#'
    verifier(f"JOIN_ARRAY (SEPARATOR='{separator}') TEST {i+1}", join_array(join_array_tests[i], separator), separator.join(join_array_tests[i]))

for i in range(len(join_array_tests)):
    separator = ''
    verifier(f"JOIN_ARRAY (SEPARATOR='{separator}') TEST {i+1}", join_array(join_array_tests[i], separator), separator.join(join_array_tests[i]))