from random import randint

"""Oficiálně máte na vypracování písemky 100 minut čistého času, začít
programovat smíte hned při obdržení tohoto zadání.

Dohromady vás čeká 5 úloh po 20 bodech (každá úloha - ať už lehká, či
těžká - je za stejný počet bodů). Můžete používat své předchozí zdrojové
kódy i slidy z přednášek, avšak nesmíte s nikým komunikovat.

Pokud jste nepsali náhradní první polosemestrálku, vypracujte i úplně poslední
úkol, máte na něj ještě 20 minut navíc a můžete za něj získat až 20 bodů.

Toto zadání najdete jako polosemestralka_2 v učebních materiálech seminární
skupiny, vypracování odevzdávejte klasicky do odevzdávárny.
Chování vzorového řešení si můžete zkusit zde:
/home/xrucka/ib111_polosemestralka_2 """


### 1. ÚKOL: Recaman again
"""Vypište n členů posloupnosti, pro kterou platí:
nultým členem je 0, každý další člen je buď a_n = a_(n-1) – n, pokud
takové číslo vyjde kladné a ještě se v posloupnosti nevyskytlo (nerovná
se žádnému z předchozích členů), v opačném případě a_n = a_(n-1) + n.
V tomto NEpoužívejte rekurzi."""
def recamans_sequence(n):
    sequence = [0]
    for i in range(n):
        print(sequence[i], end=" ")
        num = sequence[i] - i - 1
        if (num <= 0 or num in sequence):
            num = sequence[i] + i + 1
        sequence.append(num)

recamans_sequence(15) # 0 1 3 6 2 7 13 20 12 21 11 22 10 23 9
print()
print()


### 2. ÚKOL: rekurze na řetězci
"""Napište fuknci, která rekurzivně spočítá a vrátí součet ordinálních hodnot
všech znaků zadaného řetězce.
(Ordinální hodnota =  číselná reprezentace znaku:
https://docs.python.org/3/library/functions.html?highlight=ord#ord )"""
def string_hash(word):
    if len(word) == 0:
        return 0
    return ord(word[0]) + string_hash(word[1:])

print(string_hash("cucoriedka")) #1050
print(string_hash("boruvka")) #762
print(string_hash(""))#0
print()


### 3. ÚKOL: ruleta
"""V hazardní hře ruleta padají v jednom kole čísla 0-36. Tentokrát
hrají proti sobě dva hráči - první vždy sází na lichá čísla, druhý sází
na Manque(čísla v horní polovině), tedy že padne kterékoli číslo
od 1 do 18 včetně. Nasimulujte 50 kol hry a vypište, který hráč
vyhrál, popřípadě zda došlo k remíze.
Řešení tohoto úkolu rozdělte do dvou funkcí."""
def print_winner(player1_score, player2_score):
    print("The winner is:", end=" ")
    if (player1_score > player2_score):
        print("player 1 - the one betting on odd numbers.")
    elif (player1_score < player2_score):
        print("player 2 - the one betting on Manque (1-18).")
    else:
        print("noone, it's a tie.")
    
def roulette():
    odd_num_count = 0
    manque_count = 0
    
    for _ in range(50):
        round_result = randint(0, 36)
        
        if (round_result % 2 == 1):
            odd_num_count += 1
        if (0 < round_result <= 18):
            manque_count += 1
            
    print_winner(odd_num_count, manque_count)

roulette()
print()


### 4. ÚKOL: Facebook
"""Kdo má nejlajkovanější příspěvky na Facebooku?
Na vstupu dostanete řetězec ve formátu "Name:Int,Name:Int,..."
- ten uvádí, jaký uživatel přidal příspěvek a kolik liků jeho
příspěvek má (jména uživatelů se mohou opakovat).
Vypište žebříček oblíbenosti uživatelů, který bude sestupně seřazený
(od největšího po nejmenší) podle počtu lajků na příspěvcích uživatelů."""
def fb_popularity(likes):
    popularity = {}
    fb_posts = likes.split(",")
    
    for i in range(len(fb_posts)):
        fb_posts[i] = fb_posts[i].split(":")
        popularity[fb_posts[i][0]] = popularity.get(fb_posts[i][0], 0) + int(fb_posts[i][1])

    tmp = [(popularity[person], person) for person in popularity]
    tmp.sort(reverse=True)
    for like_count, person in tmp:
        print(person, "\t", like_count)

likes = "Amy:62,Carl:3,Bob:12,John:40,Amy:23,Eve:1,Sonia:34,Amy:10,Bob:20,John:32"
fb_popularity(likes)
#Amy     95
#John    72
#Sonia   34
#Bob     32
#Carl    3
#Eve     1
print()


### 5. ÚKOL: knihy a spisovatelé
"""Před vámi jsou dvě třídy reprezentující objekt kniha a spisovatel.
V kódu se nachází pár chyb, opravte je. Dále napište funkci same_author,
která vrátí seznam knih, které mají stejného autora jako zadaná kniha."""
class Book:
    def __init__(self, title, author, isbn):
        self.title = title
        self.author = author
        self.isbn = isbn

    def __str__(self):
        """Textová reprezentace objektu - voláním print() nad knihou
    se vypíše její název."""
        return str(self.title)

    def get_author(self):
        """Getter - vrací atribut author tohoto objektu."""
        return self.author  #Zamerna chyba - jen author


class Writer:
    def __init__(self, name, birth_year, year_of_death):
        self.name = name
        self.born = birth_year
        self.died = year_of_death

    def could_meet(self, other_writer):
        """Metoda vracející True, pokud se tento spisovatel mohl za dobu svého
    života potkat s určitým jiným spisovatelem, tedy zda byli současníky."""
        #Druha zamerna chyba: or
        return self.born <= other_writer.died and other_writer.born <= self.died

def same_author(book, other_books):
    """Funkce dostane instanci třídy kniha a seznam dalších instancí téže
    třídy; vrací seznam knih, které mají stejného autora jako zadaná kniha."""
    book_list = []
    for piece in other_books:
        if (piece.get_author() == book.get_author()):
            book_list.append(piece)
    return book_list

#vzorová volání:
adams = Writer("Douglas Adams", 1952,  2001)
tolkien = Writer("John Ronald Reuel Tolkien", 1892, 1973)
shakespeare = Writer("William Shakespeare", 1564, 1616)
hitchhiker = Book("The Hitchhiker's Guide to the Galaxy", adams, 42)
lotr = Book("The Lord of the Rings", tolkien, 2954)
silmarillion = Book("The Silmarillion", tolkien, 77)
hobbit = Book("The Hobbit", tolkien, 2137)
macbeth = Book("Macbeth", shakespeare, 8)

print(adams.could_meet(tolkien)) #True
print(tolkien.could_meet(shakespeare)) #False
print([str(book) for book in same_author(lotr, [hitchhiker, hobbit, macbeth, silmarillion])]) #['The Hobbit', 'The Silmarillion']
print(same_author(macbeth, [hitchhiker, hobbit, lotr, silmarillion])) #[]
print()


### Úkol navíc pro ty, kdo nepsali náhradní první polosemestrálku:
"""Funkce dostane seznam kladných celých čísel a má vrátit číslo
reprezentující nejmenší společný násobek všech čísel seznamu.
(Hint: nejmenší společný násobek dvou čísel se dá spočítat jako
podíl součinu těchto dvou čísel a jejich největšího společného dělitele,
tedy jako a * b / NSD(a, b).)"""
def gcd_euclid(a, b):
    if b == 0:
        return a
    return gcd_euclid(b, a % b)

def least_common_multiple(alist):
    if not alist:
        return 0
    
    result = alist[0]
    for num in alist:
        result = (result // gcd_euclid(result, num)) * num
        
    return result

print(least_common_multiple([3, 4, 10, 5, 2])) #60
print(least_common_multiple([7, 5, 3, 2])) #210