# -*- coding: utf-8 -*-
from math import *

####### EXERCICE 7 ########

def moyenne(a,b,c):
    """ moyenne arithmetique """
    moy = (a + b  + c)/3
    return moy

print("Exercice 6 : ",moyenne(10,11,12))

def racine_car(x):
    """ racine carree d un nombre positif """
    assert x>0 ,"Rentrer un nombre positif!"
    return x**0.5

print("Exercice 6 : ",racine_car(2))
#print("Exercice 6 : ",racine_car(-2))


def norme(u):
    ux,uy= u
    return sqrt(ux**2+uy**2)

def vecteur(A,B):
    xA,yA = A
    xB,yB = B
    return ( (xB-xA), (yB-yA) )

def distance(A,B):
    return norme(vecteur(A,B))

A = (1,1)
B = (0,0)
print("Exercice 6 - distance : ",distance(A,B))


####### EXERCICE 7 ########

#fonction pour vérifier si x est un carré
def est_carre(x):
    if x >=0:           #il faut que x soit supérieur ou égal à 0 pour que ce soit le carré d'un nombre
        return True
    else:
        return False

#fonction pour vérifier si x est un cosinus
def est_cos(x):
    if x > 1 or x <-1:      #il faut que x, le resultat de l'opération cos(x) soit dans le domaine d'arrivée de cos(x) ([-1; 1])
        return False
    else:
        return True

#fonction retournant les racines d'un polynome (réelles ou complexes)
def racine(a,b,c):
    #verifier si a est égal à 0
    assert a != 0

    #calcul du discriminant
    delta=b*b-4*a*c
    #1er cas : Si delta est égal à 0, une seule racine réelle
    if delta == 0:
        x = b/(2*a)
        racines = x
    
    #2eme cas : Si delta est supérieur à 0, deux racines réelles
    elif delta > 0:
        x1=(-b-sqrt(delta))/(2*a)
        x2=(-b+sqrt(delta))/(2*a)
        racines = [x1, x2]
    
    #3eme cas : Si delta est inférieur à 0, deux racines complexes retournées sous la forme d'un tuple.
    else:
        re =-b/(2*a)
        im1 = sqrt(abs(delta))/(2*a)
        im2 = -sqrt(abs(delta))/(2*a)
        racines = [(re, im1), (re, im2)]

    return racines

print("Exercice 7", racine(1,1,2))



####### EXERCICE 8 ########

def factorielle(p):
    assert p>1 and type(p) == type(1)

    f = 1
    for i in range(1,p+1):
        f  = f*i
    return f

####### EXERCICE 9 ########


def depasse(p):
    assert p>1 and type(p) == type(1)

    n = 2
    while factorielle(n) < n**p:
        n = n+1
    return n



    

####### EXERCICE 11 ########

#a
L = [i**2 for i in range(26)]

#b
L = [2*i+1 for i in range(5//2,601//2+1)]
print("Exercice 11 : ",L)

L = [7,3,-9,15]
L.append(42)
L = L.append(42)


def liste_valeurs_u(n):
    u = 1
    L = [u]
    for i in range(1,n):
        u = 1 + u**2
        L.append(u)
    return L


v = [2*i for i in range(7)]
L = v
L[2] = 37
print(v)
print(L)
v = [2*i for i in range(7)]
L = v.copy()
L[2] = 37
print(v)
print(L)

v = [[13,-7] , 5]
L = v.copy()
v[0][0] = 42
print(v)
print(L)




####### EXERCICE 14 ########

#fonction somme d'une liste
def somme(L): 
    n = len(L) #longueur de la liste
    S = 0
    for k in range (n): #boucle allant de 0 au nombre de terme
        S = S + L[k]  #S est la somme et on ajoute à la somme le terme à la place k de L

    return S


#fonction comptant le nombre voyelle d'une chaine de caractère
def nb_voyelles(s):
    tableauS = list(s.lower()) #on converti la chaine de caractère en tableau grâce à la fonction liste (ex : "salut", 's', 'a', 'l', 'u', 't') + mise en minuscule 
    nb_v = 0 #nombre de voyelle
    for k in range (len(tableauS)): #boucle allant de k à la longueur de la liste
        ltr = tableauS[k] #ltr correspond à la lettre à la place k dans la liste
        if ltr == "a" or ltr == "e" or ltr == "i" or ltr == "o" or ltr == "u" or ltr == "y": #verification de si la lettre est une voyelle
            nb_v = nb_v + 1 #si c'est une voyelle : on ajoute 1 au compteur de voyelle
    
    return nb_v


#fonction comptant les valeurs d'un dictionnaire
def somme(dico):
    assert type(dico) == dict #verification si la variable dico est un dictionnaire
    cles=dico.keys() #on récupères toutes les clés du dictionnaire dans une liste 
    nb_val = 0 #somme des valeurs
    for k in range (len(cles)): #boucle allant de k au dernier mot de la liste (derniere clé du dictionnaire)
        nb_val = nb_val + dico[cles[k]] #on ajoute la valeur de la clé à la position k de la liste
    
    return nb_val


# Exercice 15
def transfo_liste(s):
    """ Retourne la liste des caractères
        de la chaine s """
    L = []
    for c in s:
        L.append(c)
    return L

def comptage(s):
    """ Retourne un dictionnaire avec
        pour chaque clé le nombre d'apparition
        du caractère de la chaine s """

    L = transfo_liste(s)

    inventaire = {}
    for i in range(len(L)):
        if L[i] in inventaire.keys():
            inventaire[L[i]] =  inventaire[L[i]] + 1
        else:
            inventaire[L[i]] = 1
    return inventaire

def somme(data):
    """ data est une chaine contenant des nombres
        séparés par des ;
        -> retourne leur somme """
    L = data.split(";") # séparateur ;
    s = 0
    for x in L:
        s = s + float(x)
    return s


# Test
s = 'Parpadelle'

print(transfo_liste(s))
print(comptage(s))


phrase = 'La réponse universelle est 42.'
#Chaque élément est une chaine: + réalisee une
# concaténation
L = phrase.split()
print(L)

data = '12 ; 0.34 ; 5.6 ; -78 '
print(somme(data))