# Dans toutes ces fonctions : la première ligne ("assert") est optionnelle.
# Elle sert à vérifier que le "n" entré est de type entier.

def petit_par_minimum(n) :
    assert type(n) == int , "n n'est pas entier"
    liste = list(str(n))       # Conversion de n en chaine, puis en liste
    k = len(liste)             # Longueur de la liste
    r = ""                     # Initialisation de la variable de retour (chaine)
    while k > 0 :              # Tant que la liste n'est pas vide
        mini = min(liste)      # Trouver le plus petit élément de la liste
        liste.remove(mini)     # L'enlever
        r = r + mini           # Le placer dans la chaine résultat
        k = k - 1              # La taille de la liste décroit
    return int(r)              # On retourne la chaine convertie en entier


# Variante sans calcul de la longueur de la liste
def petit_par_minimum_variante(n) :   # n entier à 3 chiffres
    assert type(n) == int,  "n n'est pas entier"
    N1 = str(n)
    L1 = [N1[0], N1[1], N1[2]]
    L2 = []
    while L1 != [] :
        element = min(L1)
        L1.remove(element)
        L2.append(element)
    return int("".join(L2))

def inversion(n) :
    assert type(n) == int , "n n'est pas entier"
    chaine = str(n)                   # Conversion de n en chaine
    longueur = len(chaine)            # Longueur de la chaine
    r = ""                            # Initialisation de la variable de retour (chaine)
    for k in range(longueur) :        # Reconstruction de la chaine
        r = r + chaine[longueur - 1 - k]  #   en partant du dernier caractère
    return int(r)


# Variante pour seulement 3 chiffres à inverser
def inversion_trois_chiffres(n) :  # n entier à  3 chiffres
    N = str(n)
    L = [N[2], N[1], N[0]]
    return int("".join(L))


def kaprekar(n) :
    assert type(n) == int , "n n'est pas entier"
    u = n
    liste_valeurs = [u]
    while u != 495 :
        u = petit_par_minimum(u)
        u = inversion(u) - u
        liste_valeurs.append(u)
    return liste_valeurs