"""
5.1.1. Součet, maximum a hledání

Napište funkce nad seznamem čísel, které zjistí:

    součet všech čísel v seznamu,
    nejvyšší číslo v seznamu,
    zda se určitá hodnota vyskytuje v seznamu,

tedy ekvivalenty operací max, sum a in (ale s použitím pouze základních operací nad seznamy).
"""


def my_sum(numbers):
    list_sum = 0
    for x in numbers:
        list_sum += x
    return list_sum


def my_max(numbers):
    if not numbers:
        return None
    maximum = numbers[0]
    for x in numbers:
        if x > maximum:
            maximum = x
    return maximum


def my_in(x, array):
    for element in array:
        if x == element:
            return True
    return False


print(my_max([6, 5, 11, 8]))  # 11
print(my_sum([6, 5, 11, 8]))  # 30
print(my_in(5, [6, 5, 11, 8]))  # True
print(my_in(4, [6, 5, 11, 8]))  # False

"""
5.1.2. Součin nenulových čísel

Napište funkci, která vypočítá součin čísel v seznamu, ale ignoruje přitom případné nuly.
"""


def nonzero_product(numbers):
    product = 1
    for n in numbers:
        if n != 0:
            product *= n
    return product


print(nonzero_product([0, 2, 3, 0, 0, 3]))  # 18
print(nonzero_product([0, 0, 0, 0]))  # 1

"""
5.1.3. Modifikace vs. vytváření nového seznamu

Napište funkci double_all, která dostane na vstupu seznam čísel a každý jeho prvek vynásobí dvěma. Dále napište funkci create_doubled, která dostane na vstupu seznam čísel a vrátí nový seznam získaný ze vstupního tak, že každý prvek vynásobí dvěma. Na rozdíl od předchozí funkce však nemění předaný seznam.
"""


def double_all(numbers):
    for i in range(len(numbers)):
        numbers[i] = 2 * numbers[i]


def create_doubled(numbers):
    doubled_list = []
    for n in numbers:
        doubled_list.append(2 * n)
    return doubled_list


a = [1, 4, 2, 5]
double_all(a)
print(a)  # [2, 8, 4, 10]

a = [1, 4, 2, 5]
b = create_doubled(a)
print(a)  # [1, 4, 2, 5]
print(b)  # [2, 8, 4, 10]

"""
5.2.1. Prokládání textu textem

Napište funkci, která mezi každá dvě písmena daného textu vloží dodaný text.
"""


def dummy(text, rubbish):
    output = ""
    for char in text:
        output += char + rubbish
    return output


print(dummy('pampeliska', 'XX'))

"""
5.2.3. Pozpátku

Napište funkci, která vám vrátí řetězec s písmeny uspořádanými pozpátku.
"""


def reverse(text):
    output = ""
    for i in range(len(text)):
        output += text[len(text) - i - 1]
    return output


print(reverse('ONMEJATEJOLSEH'))
# HESLOJETAJEMNO


"""
5.2.4. Cenzura

Napište funkci, která zcenzuruje dodaný řetězec tak, že každé druhé písmeno nahradí za X.
"""


def censorship(text):
    output = ""
    i = 1
    for char in text:
        if i % 2 == 0:
            output += "X"
        else:
            output += char
        i += 1
    return output


print(censorship("Vinnetou: Jsem krestan."))
# VXnXeXoX:XJXeX XrXsXaX.

"""
5.2.8. Palindrom

Napište funkci, která vrátí, zda je řetězec palindromem. Palindromem je takové slovo či věta, která má při čtení v libovolném směru stejný význam, například nepotopen či jelenovi pivo nelej (mezery můžete ignorovat).
"""


def palindrom(text):
    length = len(text)
    for i in range(int(length / 2)):
        if text[i] != text[length - 1 - i]:
            return False
    return True


print(palindrom("JELENOVIPIVONELEJ"))
# True


"""
5.3.1. Caesarova šifra

Napište funkci, která zašifruje text tak, že posune všechna jeho písmena v abecedě o n dopředu (cyklicky), můžete se inspirovat popisem Caesarovy šifry.
"""


def caesar(text, offset):
    text = text.upper()
    output = ""
    for char in text:
        output += chr(((ord(char) - 65 + offset) % 26) + 65)
    return output


def caesar2(text, offset):
    text = text.upper()
    offset = offset % 26  # Offset of 27 is same as offset of 1
    output = ""
    for char in text:
        newChar = (ord(char) + offset)
        if newChar > ord("Z"):
            newChar -= 26  # Rollover to start of the alphabet
        output += chr(newChar)
    return output


print(caesar('zirafa', 3))
# CLUDID
print(caesar2('ZIRAFA', 29))
# CLUDID


"""
5.3.2. Vigenèrova šifra

Napište funkci, která zašifruje text podle předem daného klíče. Pro posun písmen zdrojového textu se postupně používají písmena z klíče: ‘a’ posouvá o 0, ‘b’ o 1, ... ‘z’ o 25. Pokud je klíč kratší než zdrojový text, jsou použita písmena z klíče opět od začátku. Můžete se inspirovat popisem Vigenèrovy šifry.
"""


def vigenere(text, key):
    text = text.upper()
    key = key.upper()
    output = ""
    i = 0
    for char in text:
        output += chr(
            (
                (
                    ord(char) - 65 + ord(key[i]) - 65
                ) % 26
            ) + 65
        )
        i += 1
        i %= len(key)
    return output


print(vigenere('pampeliska', 'klic'))
# ZLUROWQUUL