#Exercice 1

# Mystère 1
def moyenne(note_1, note_2, note_3, note_4):
    resultat = (note_1 + note_2 + note_3 + note_4) / 4
    return resultat

# Mystère 2
def est_pair(nombre):
    if nombre%2 == 0:
        return True
    else:
        return False

# Mystère 3
def max2(nombre_1, nombre_2):
    if nombre_1 >= nombre_2:
        return nombre_1
    else:
        return nombre_2

# Mystère 4
def multiplication(nombre_1, nombre_2):
    produit = 0
    for _ in range(nombre_2):
        produit = produit + nombre_1
    return produit

# Mystère 5

def division_euclidienne(dividende, diviseur):
    quotient = dividende // diviseur
    reste = dividende % diviseur
    return (quotient, reste)
    
# Mystère 6

def reciproque_de_Pythagore(cote_1, cote_2, cote_3):
    cote_1 = cote_1**2
    cote_2 = cote_2**2
    cote_3 = cote_3**2
    est_rectangle = cote_1 == (cote_2 + cote_3)
    est_rectangle = est_rectangle or cote_2 == (cote_1 + cote_3)
    est_rectangle = est_rectangle or cote_3 == (cote_1 + cote_2)
    return est_rectangle
    
# Mystère 7
def echange(liste, indice_1, indice_2):
    temporaire = liste[indice_1]
    liste[indice_1] = liste[indice_2]
    liste[indice_2] = temporaire
    
# Mystère 8
def conversion_binaire(nombre):
    liste_bits = []
    while nombre > 0:
        if nombre%2 == 0:
            liste_bits.insert(0, 0)
            nombre = nombre // 2
        else:
            liste_bits.insert(0, 1)
            nombre = (nombre - 1) // 2
    return liste_bits
    
# Exercice 2

# Typage 1
#def gagnant(score1:float, score2:float) -> str:
def gagnant(score1:int, score2:int) -> str:
    if score1 > score2:
        return "Joueur 1"
    elif score1 < score2:
        return "Joueur 2"
    else:
        return "ex æquo"

# Typage 2
from math import sqrt

#def distance(A:list, B:list) -> float :
def distance(A:tuple, B:tuple) -> float :
    xA = A[0]
    yA = A[1]
    xB = B[0]
    yB = B[1]
    return sqrt((xB - xA)**2 + (yB - yA)**2)

# Typage 3

# def puissance(valeur:float, exposant:int) -> list:
def puissance(valeur:int, exposant:int) -> list:
    l = []
    for i in range(1, exposant + 1):
        l.append(valeur**i)
return l

# Exercice 3

# Typage 1
#def gagnant(score1:float, score2:float) -> str:
def gagnant(score1:int, score2:int) -> str:
    """ Prend en paramètre les scores des deux joueurs et retourne si le joueur 1 ou 2 est gagnant 
        ou s'il y a un ex æquo.
    """
    if score1 > score2:
        return "Joueur 1"
    elif score1 < score2:
        return "Joueur 2"
    else:
        return "ex æquo"

# Typage 2
from math import sqrt

#def distance(A:list, B:list) -> float :
def distance(A:tuple, B:tuple) -> float :
    """ Prend en paramètre 2 tuples de deux valeurs contenant les coordonnées (x, y) des points A et B
        et retourne la distance euclidienne entre ceux deux points
    """
    xA = A[0]
    yA = A[1]
    xB = B[0]
    yB = B[1]
    return sqrt((xB - xA)**2 + (yB - yA)**2)

# Typage 3

# def puissance(valeur:float, exposant:int) -> list:
def puissance(valeur:int, exposant:int) -> list:
    """ Retourne une liste contenant toutes les puissances de valeurs avec des exposants de 1 à exposant inclu.
    """
    l = []
    for i in range(1, exposant + 1):
        l.append(valeur**i)
return l

# Exercice 4

"""
Pour gagnant, on veut tester les 3 cas possible :
    - Quand le joueur 1 gagne
    - Quand le joueur 2 gagne
    - ex æquo
"""
gagnant(1, 0) # Joueur 1
gagnant(0, 1) # Joueur 2
gagnant(1, 1) # ex æquo

"""
Pour distance, plein de possibilité :
    - Deux points différents
    - Deux points différents aux memes abscisses
    - Deux points différents aux memes ordonnées
    - Même point
    - valeurs négatives
    - etc
"""

distance((0,0), (1,1)) # racine de 2
distance((0,4), (0,6)) # 2
distance((6,0), (4,0)) # 2

"""
Pour puissance, elle renvoie une liste de puissance de 1 à exposant:
    Si on passe 0 en exposant, la liste est vide
    SI on passe 1, on a un element
    Si on passe n, on a n element
"""
puissance(0, 0) # []
puissance(0, 3) # [0, 0, 0]
puissance(2, 2) # [2, 4]
puissance(-2, 2) # [-2, 4]

# Exercice 5

#def gagnant(score1:float, score2:float) -> str:
def gagnant(score1:int, score2:int) -> str:
    """ Prend en paramètre les scores des deux joueurs et retourne si le joueur 1 ou 2 est gagnant 
        ou s'il y a un ex æquo.
    """
    
    # assert type(score1) == float, "Les score doivent être des nombres décimaux."
    # assert type(score2) == float, "Les score doivent être des nombres décimaux."
    assert type(score1) == int, "Les score doivent être des nombres entiers."
    assert type(score2) == int, "Les score doivent être des nombres entiers."
    
    if score1 > score2:
        return "Joueur 1"
    elif score1 < score2:
        return "Joueur 2"
    else:
        return "ex æquo"

assert gagnant(1, 0) == "Joueur 1"
assert gagnant(0, 1) == "Joueur 2"
assert gagnant(1, 1) == "ex æquo"


from math import sqrt

#def distance(A:list, B:list) -> float :
def distance(A:tuple, B:tuple) -> float :
    """ Prend en paramètre 2 tuples de deux valeurs contenant les coordonnées (x, y) des points A et B
        et retourne la distance euclidienne entre ceux deux points
    """
    
    # assert type(A) == list, "Les coordonnées doivent être des listes."
    # assert type(B) == list, "Les coordonnées doivent être des listes."
    assert type(A) == tuple, "Les coordonnées doivent être des tuples."
    assert type(B) == tuple, "Les coordonnées doivent être des tuples."

    xA = A[0]
    yA = A[1]
    xB = B[0]
    yB = B[1]
    return sqrt((xB - xA)**2 + (yB - yA)**2)

assert distance((0,0), (1,1)) == sqrt(2)
assert distance((0,4), (0,6)) == 2
assert distance((6,0), (4,0)) == 2



# def puissance(valeur:float, exposant:int) -> list:
def puissance(valeur:int, exposant:int) -> list:
    """ Retourne une liste contenant toutes les puissances de valeurs avec des exposants de 1 à exposant inclu.
    """
    
    #assert type(valeur) == float, "La valeur doit être un nombre décimal."
    assert type(valeur) == int, "La valeur doit être entière."
    assert type(exposant) == int, "L'exposant doit être entier."

    l = []
    for i in range(1, exposant + 1):
        l.append(valeur**i)
    return l

assert puissance(0, 0) == []
assert puissance(0, 3) == [0, 0, 0]
assert puissance(2, 2) == [2, 4]
assert puissance(-2, 2) == [-2, 4]

# Exercice 6

#def gagnant(score1:float, score2:float) -> str:
def gagnant(score1:int, score2:int) -> str:
    """ Prend en paramètre les scores des deux joueurs et retourne si le joueur 1 ou 2 est gagnant 
        ou s'il y a un ex æquo.
        
        >>> gagnant(1, 0)
        'Joueur 1'
        >>> gagnant(0, 1)
        'Joueur 2'
        >>> gagnant(1, 1)
        'ex æquo'
    """
    
    # assert type(score1) == float, "Les score doivent être des nombres décimaux."
    # assert type(score2) == float, "Les score doivent être des nombres décimaux."
    assert type(score1) == int, "Les score doivent être des nombres entiers."
    assert type(score2) == int, "Les score doivent être des nombres entiers."
    
    if score1 > score2:
        return "Joueur 1"
    elif score1 < score2:
        return "Joueur 2"
    else:
        return "ex æquo"

from math import sqrt

#def distance(A:list, B:list) -> float :
def distance(A:tuple, B:tuple) -> float :
    """ Prend en paramètre 2 tuples de deux valeurs contenant les coordonnées (x, y) des points A et B
        et retourne la distance euclidienne entre ceux deux points
        
        >>> distance((0,0), (1,1))
        1.4142135623730951
        >>> distance((0,4), (0,6))
        2.0
        >>> distance((6,0), (4,0))
        2.0
    """
    
    # assert type(A) == list, "Les coordonnées doivent être des listes."
    # assert type(B) == list, "Les coordonnées doivent être des listes."
    assert type(A) == tuple, "Les coordonnées doivent être des tuples."
    assert type(B) == tuple, "Les coordonnées doivent être des tuples."

    xA = A[0]
    yA = A[1]
    xB = B[0]
    yB = B[1]
    return sqrt((xB - xA)**2 + (yB - yA)**2)


# def puissance(valeur:float, exposant:int) -> list:
def puissance(valeur:int, exposant:int) -> list:
    """ Retourne une liste contenant toutes les puissances de valeurs avec des exposants de 1 à exposant inclu.
        
        >>> puissance(0, 0)
        []
        >>> puissance(0, 3)
        [0, 0, 0]
        >>> puissance(2, 2)
        [2, 4]
        >>> puissance(-2, 2)
        [-2, 4]
    """
    
    #assert type(valeur) == float, "La valeur doit être un nombre décimal."
    assert type(valeur) == int, "La valeur doit être entière."
    assert type(exposant) == int, "L'exposant doit être entier."

    l = []
    for i in range(1, exposant + 1):
        l.append(valeur**i)
    return l


# Exercice 7

# A faire tourner sur https://mypy-play.net/

#def gagnant(score1:float, score2:float) -> str:
def gagnant(score1:int, score2:int) -> str:
    if score1 > score2:
        return "Joueur 1"
    elif score1 < score2:
        return "Joueur 2"
    else:
        return "ex æquo"

gagnant(1, 2)
gagnant(1.5, 2)

from math import sqrt

#def distance(A:list, B:list) -> float :
def distance(A:tuple, B:tuple) -> float :
    xA = A[0]
    yA = A[1]
    xB = B[0]
    yB = B[1]
    return sqrt((xB - xA)**2 + (yB - yA)**2)

distance((0,0), (1,1))
distance([0,0], [1,1])

# def puissance(valeur:float, exposant:int) -> list:
def puissance(valeur:int, exposant:int) -> list:
    l = []
    for i in range(1, exposant + 1):
        l.append(valeur**i)
    return l

puissance(1, 3)
puissance(1.5, 3)

# Exercice 8
# Pour le OU des types, on utilise le caractère |
# A faire tourner sur https://mypy-play.net/

def gagnant(score1:int|float, score2:int|float) -> str:
    if score1 > score2:
        return "Joueur 1"
    elif score1 < score2:
        return "Joueur 2"
    else:
        return "ex æquo"

gagnant(1, 2)
gagnant(1.5, 2)

from math import sqrt

def distance(A:tuple|list, B:tuple|list) -> float :
    xA = A[0]
    yA = A[1]
    xB = B[0]
    yB = B[1]
    return sqrt((xB - xA)**2 + (yB - yA)**2)

distance((0,0), (1,1))
distance([0,0], [1,1])

def puissance(valeur:int|float, exposant:int) -> list:
    l = []
    for i in range(1, exposant + 1):
        l.append(valeur**i)
    return l

puissance(1, 3)
puissance(1.5, 3)