"""
Exercice 1:

1. La fonction se nomme test
2. Les paramètres formels de la fonction sont x et y
3. On appelle la fonction avec les paramètres réels 5 et 4
4. A la fin de l'xecution z aura pour valeur 20

Exercice 2:

1.
"""

def calcul_capital(capital_depart: float , n: int):
    capital = capital_depart
    for i in range(n):
        capital = capital * 1.05
    return capital

exemple = calcul_capital(120, 8)
print (exemple)

#2

def depasse_500(capital_depart: float):
    nombre_annees = 0
    while capital_depart < 500:
        capital_depart = capital_depart * 1.05
        nombre_annees = nombre_annees + 1
    return nombre_annees

exemple2 = depasse_500(120)
print (exemple2)

"""
Exercice 3:

1. On remarque que pour ajouter un nouvel étage à son chateau Robert doit ajouter le nombre de cartes précédement ajoutées plus 3.
On a donc:
-Pour 1 étage il a besoin de 2 cartes
-Pour 2 étages il a besoin de 7 cartes ( 2(déjà présentent)+2+3 = 7 )
-Pour 6 étages il a besoin de 57 cartes ( 2+5+8+11+14+17 = 7 )

2. La valeur de retour de cette fonction est un entier (integer)

3. X

4.
"""

def nombre_de_cartes(n: int):
    somme = 0
    for i in range (1,n+1):
        somme = somme + i*3 -1
    return somme

test = nombre_de_cartes(2)
print (test)

"""
5. En sachant que pour faire 6 étages Robert a besoin de 57 cartes, nous pouvons déduire que si il dispose de 52 cartes il pourra faire 5 étages au maximum

6. Fonction : nombre_etages_max
Paramètres : nombre_de_cartes_max
Résultat : Le nombre d'étages maximum qu'il est possible de construire avec un nombre max de cartes donné


8.
"""

def nombre_etages_max(nombre_de_cartes_max):
    nombre_etages = 0
    nombre_cartes = 0
    while nombre_cartes < nombre_de_cartes_max:
        nombre_etages = nombre_etages + 1
        nombre_cartes = nombre_de_cartes(nombre_etages)
    return nombre_etages - 1

#7. test
def test_nombre_etages_max():
    assert nombre_etages_max(11) == 2, "le test a echoue"
    assert nombre_etages_max(23) == 3, "le test a echoue"


"""
Exercice 4:

Partie 1

1.a. Pour cela nous devons calculer le nombre de personnes qui ont pu etre invités du 1er au 8 mai.
1er mai: 5 personnes présentes à l'origine
2 mai: 15 personnes ont été invitées
3 mai: 45 personnes ont été invitées 
4 mai: 135 personnes ont été invitées
5 mai: 405 personnes ont été invitées
6 mai: 1215 personnes ont été invitées
7 mai: 3645 personnes ont été invitées
8 mai: 10935 personnes ont été invitées
Total: 5 + 15 + 45 + 135 + 405 + 1215 + 3645 + 10935 = 16400

b.Tout est proportionnel on a donc :
3 * 16400 / 5 = 9840

2.Fonction : nombre_glacieres
Paramètres : nombre_amis 
Résultat : Le nombre de glacières à partir du nombre d'amis à l'origine de l'évènement
"""

def nombre_glacieres(nombre_amis):
    nombre_invitations = nombre_amis
    nombre = nombre_amis
    for jour in range(7):
        nombre_invitations = nombre_invitations * 3
        nombre = nombre + nombre_invitations
    return nombre

#test
def test_nombre_glacieres():
    assert nombre_glacieres(5) == 16400, "le test a echoue"


"""
Partie 2

1. L'instruction qui permet de savoir ca est
>>> nombre_glacieres(15,16)

2.
"""

def nombre_glacieres2(nombre_amis, nombre_jours):
    nombre_invitations = nombre_amis
    nombre = nombre_amis
    n = nombre_jours 
    for jour in range(n):
        nombre_invitations = nombre_invitations * 3
        nombre = nombre + nombre_invitations
    return nombre

"""
Partie 3
"""

def nombre_jours(nombre_amis):
    date = 1
    amis_precedent = nombre_amis
    nombre_total = nombre_amis
    while nombre_total < 1000000:
        amis_precedent = amis_precedent * 3
        nombre_total = amis_precedent + nombre_total 
        date = date + 1
        print (date,nombre_total)
    return date, nombre_total
        





