## Exercice 1

def conversion(montant):
    return montant * 1.16


## Exercice 2

def min2(a, b):
    if a < b:
        return a
    else:
        return b

def min3(a, b, c):
    if a < b and a < c:
        return a
    elif b < c:
        return b
    else:
        return c

# ou :

def min3(a, b, c):
    return min2(a, min2(b, c))


## Exercice 3

def factorielle(n):
    fact = 1
    for k in range(2, n+1):
        fact = fact * k
    return fact

# Pour la fonction seuil il vaut mieux utiliser une boucle while plutôt qu'une
# boucle for car on ne sait pas combien d'itérations seront nécessaires.

def seuil(M):
    n = 0
    while factorielle(n) <= M:
        n = n + 1
    return n

# L'inconvénient est qu'on refait plusieurs fois les mêmes calculs. Il vaut mieux
# ne pas utiliser la fonction factorielle et procéder comme suit :

def seuil1(M):
    n = 0
    fact = 1
    while fact <= M:
        n = n + 1
        fact = fact * n
    return n


## Exercice 4

def est_bissextile(annee):
    if annee % 400 == 0:
        return True
    elif annee % 100 == 0:
        return False
    elif annee % 4 == 0:
        return True
    else:
        return False

# ou plus simplement :
    
def est_bissextile(annee):
    if annee % 400 == 0 or (annee % 4 == 0 and annee % 100 != 0):
        return True
    else:
        return False

# ou sans utiliser if :
        
def est_bissextile(annee):
    return annee % 400 == 0 or (annee % 4 == 0 and annee % 100 != 0)


## Exercice 5

def cubes(n):
    for i in range(n+1):
        print(i**3)


## Exercice 6

def equation_second_degre(a, b, c):
    delta = b**2 - 4*a*c
    if delta > 0:
        print('Deux solutions réelles : ', (-b-sqrt(delta))/(2*a), (-b+sqrt(delta))/(2*a))
    elif delta == 0:
        print('Une solution réelle : ', -b/(2*a))
    else:
        print('Pas de solutions réelles')

# >>> equation_second_degre(0.1, 0.6, 0.9)
# Pas de solutions réelles

# Ce n'est pas normal puisque 0.6**2 - 4*0.9*0.1 = 0, il y a donc une solution double.
# C'est un problème de flottants :
# >>> 0.6**2 - 4*0.9*0.1
# -5.551115123125783e-17

# Une solution est de remplacer la comparaison delta == 0 par abs(delta) < 1e-12 par exemple.

def equation_second_degre(a, b, c):
    delta = b**2 - 4*a*c
    if abs(delta) < 1e-12:  # abs = valeur absolue
        print('Une solution réelle : ', -b/(2*a))
    elif delta > 0:
        print('Deux solutions réelles : ', (-b-sqrt(delta))/(2*a), (-b+sqrt(delta))/(2*a))
    else:
        print('Pas de solutions réelles')



## Exercice 7

def jhms(secondes):
    print('Jours :', secondes // 86400)
    print('Heures :', (secondes % 86400) // 3600)
    print('Minutes :', (secondes % 3600) // 60)
    print('Secondes :', secondes % 60)

def secondes(j, h, m, s):
    return j*86400 + h*3600 + m*60 + s


## Exercice 8

# 2)

def syracuse(n):
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = 3*n + 1
        print(n)

# 3)

def nombre_iterations(n):  # on ajoute un compteur à la fonction précédente
    nb = 0
    while n != 1:
        if n % 2 == 0:
            n //= 2
        else:
            n = 3*n + 1
        nb += 1
    return nb

nb_max = 0
for n in range(1, 101):
    nb = nombre_iterations(n)
    if nb > nb_max:
        nb_max = nb
        n_max = n
print(n_max, nb_max)


## Exercice 9

def est_premier(n):
    if n < 2:
        return False
    for k in range(2, n):
        if n % k == 0:
            return False
    return True

i = 2
nb = 0  # nombre de nombres non premiers consécutifs trouvés
while nb < 10:
    if not est_premier(i):
        nb += 1
    else:
        nb = 0
    i += 1
for k in range(10):  # les nombres de i-10 à i-1 sont non premiers
    print(i-10+k)


## Exercice 10

# 1)

def goldbach(n):
    for i in range(4, n+1, 2):
        for p in range(i):
            if est_premier(p) and est_premier(i-p):
                print(i, '=', p, '+', i-p)
                break

# 2) Pour cette question il vaut mieux créer d'abord la liste des nombres premiers
# inférieurs à 10000.

liste_premiers = []
for i in range(10000):
    if est_premier(i):
        liste_premiers.append(i)

for i in range(4, 10001, 2):
    ok = 0
    for p in liste_premiers:
        if i-p in liste_premiers:
            ok = 1
            break
    if ok == 0:  # si ok = 0 alors i ne vérifie pas la conjecture de Goldbach
        print(i)

# Le programme n'affiche rien : cela signifie que tous les entiers naturels pairs
# compris entre 4 et 10000 vérifient la conjecture de Goldbach.


## Exercice 11

for n in range(100):
    if est_premier(n) and est_premier(n+2):
        print(n, n+2)