######################################################################
# PARTIE 1 - DÉFINITION DE FONCTIONS : PYTHAGORE
######################################################################

from math import *

def hypo(x, y):
    return sqrt(x**2 + y**2)

print("Calcul de la longueur de l'hypoténuse")
a = float(input("1er petit côté ? "))
b = float(input("2e petit côté ? "))

print("L'hypoténuse mesure", hypo(a, b))


######################################################################
# PARTIE 1 - INSTRUCTIONS CONDITIONNELLES : NATURE D'UN TRIANGLE
######################################################################

a, b, c = 5, 7, 7

if a==b==c :
    nature = "équilatéral"
elif a==b or b==c or a==c:
    nature = "isocèle"
else:
    nature = "scalène"

print(f"Le triangle est {nature}.")


######################################################################
# PARTIE 1 - BOUCLE WHILE : PARTIE ENTIÈRE DE RACINE DE X
######################################################################

x = 150

k = 0

while k**2 < x:
    k += 1

print(f"{k} est le plus petit entier dont le carré est inférieur à {x}")


######################################################################
# PARTIE 1 - BOUCLE WHILE : JEU PASSIONNANT (VERSION 1, AVEC CONDITION DANS LE WHILE)
######################################################################

import random as rd

n = rd.randint(1, 100)
k = -1

while(k != n):
    k = int(input(("Quel est ton choix ? ")))
    if k<n:
        print("-> Plus grand...")
    elif k>n:
        print("-> Plus petit...")

print("BRAVO !")


######################################################################
# PARTIE 1 - BOUCLE WHILE : JEU PASSIONNANT (VERSION 2, AVEC WHILE TRUE ET BREAK)
######################################################################

import random as rd

n = rd.randint(1, 100)


while True :
    k = int(input(("Quel est ton choix ? ")))
    if k<n :
        print("-> Plus grand...")
    elif k>n :
        print("-> Plus petit...")
    else:
        break

print("BRAVO !")


######################################################################
# PARTIE 1 - BOUCLE FOR : DIVISEURS D'UN ENTIER N
######################################################################

def diviseurs(n):

    D = []

    for k in range(1, n+1):
        if(n%k==0):
            D.append(k)

    return D

print(diviseurs(24))


######################################################################
# PARTIE 1 - CONVERSION DÉCIMAL-BINAIRE
######################################################################

d = 326     # décimal

m = 0       # nb de chiffres binaires
while(2**(m+1) <= d):
    m += 1

b = ""      # chiffres binaires  (chaine de caractères)

for k in range(m, -1, -1):
    if(d >= 2**k):
        b += "1"
        d = d - 2**k
    else:
        b += "0"

print(b)


######################################################################
# PARTIE 1 - ALGORITHME DE KAPREKAR
######################################################################

def kaprekar(n):
    s = str(n).zfill(4)          # Chaine de 4 caractères
    T = [s[0], s[1], s[2], s[3]]
    T.sort()
    c = int(T[0]+T[1]+T[2]+T[3])   # concaténation puis
    d = int(T[3]+T[2]+T[1]+T[0])   # passage en integer
    return d-c

n = 7231

for i in range(8):
    print(i, n)
    n = kaprekar(n)


######################################################################
# PARTIE 2 - RÉCURSIVITÉ : FACTORIELLE
######################################################################

def factorielle(n):
    if(n==0):
        return 1
    else:
        return n*factorielle(n-1)

print(factorielle(5))   # 120


######################################################################
# PARTIE 2 - RÉCURSIVITÉ : EXPONENTIATION RAPIDE
######################################################################

def e(a, n):
    if(n==1):
        return a
    elif(n%2==0):
        return e(a, n/2)**2
    else:
        return a*e(a, n-1)

print(e(3, 10))


######################################################################
# PARTIE 2 - RÉCURSIVITÉ : FONCTION POW (EXPONENTIATION MODULAIRE)
######################################################################

# 1re possibilité (lente)
2440212**(523238) % 7

# 2e possibilité (très rapide)
pow(2440212, 523238, 7)


######################################################################
# PARTIE 2 - RÉCURSIVITÉ : TOUR DE HANOÏ
######################################################################

def hanoi(n, source="A", cible="C", intermediaire="B"):
    if n == 0:
        return None
    hanoi(n-1, source, intermediaire, cible)
    print(f"Déplacer le disque {n} de {source} vers {cible}")
    hanoi(n-1, intermediaire, cible, source)

hanoi(3)


######################################################################
# SOLUTIONS - KAPREKAR POUR LES NOMBRES À 3 CHIFFRES
######################################################################

def kaprekar(n):
    s = str(n).zfill(3)
    T = [s[0], s[1], s[2]]
    T.sort()
    c = int(T[0]+T[1]+T[2])
    d = int(T[2]+T[1]+T[0])
    return d-c

for m in range(100, 1000):
    k = m
    for i in range(7):
        k = kaprekar(k)
    if(k!=495):
        print(m)


######################################################################
# SOLUTIONS - CONVERTISSEUR BINAIRE VERS DÉCIMAL
######################################################################

b = "101000110"     # binaire
m = len(b)          # nb de chiffres binaires

d = 0               # décimal

for k in range(0, m):
    d = d + int(b[k])*2**(m-k-1)

print(d)


######################################################################
# SOLUTIONS - TEST DE PRIMALITÉ (EST_PREMIER)
######################################################################

def est_premier(n):
    if (n%2==0 or n%3==0):
        return False

    k = 5
    while (k*k <= n):
        if (n%k==0 or n%(k+2)==0):
            return False
        k = k + 6
    return True