def rebours(n):
    if n == 0:
        print()
        return
    print(n, end=" ")
    rebours(n-1)

rebours(12)

def compte(t, n=1):
    print(n, end=" ")
    if n < t:
        compte(t, n+1)
    else:
        print()

compte(5)


def sommeDesCarres(n):
    if n == 1:
        return 1
    return n**2 + sommeDesCarres(n-1)

def produit(liste):
    if len(liste) == 1:
        return liste[0]
    return liste[0] * produit(liste[1:])

def sommeDesPositifs(liste):
    if len(liste) == 0:
        return 0
    value = liste[0] if liste[0] > 0 else 0
    return value + sommeDesPositifs(liste[1:])

def estPalindrome(x):
    if len(x) == 2:
        return x[0] == x[1]
    elif len(x) == 1:
        return True
    return x[0] == x[-1] and estPalindrome(x[1:-1])

def renvoitLongueur(liste: list) -> int:
    """
    Fonction récursive qui renvoie la longueur de la
    liste donné en paramètres sans utiliser la fonction `len`.
    """
    if not liste: # Si la liste est vide
        return 0 # On renvoie 0
    return 1 + renvoitLongueur(liste[1:]) # On renvoie 1 plus la longueur de la liste sans le premier element

def inverse_lordre(liste: list) -> list:
    """
    Fonction récursive qui renvoie l'inverse de la liste
    donnée en paramètres sans utiliser la fonction `reverse`.
    """
    if not liste: # Si la liste est vide
        return [] # On renvoie une liste vide
    
    # On renvoit la concatenation d'une liste contenant le dernier element
    # de `liste` avec l'inverse de la `liste` sans le dernier element
    return [liste[-1]] + inverse_lordre(liste[:-1])

def premier_chiffre(entier: int) -> int:
    """
    Fonction qui renvoie le premier chiffre de l'entier donné en paramètres.
    """
    if entier < 10: # Si l'entier est inférieur à 10 (donc que c'est le premier chiffre)
        return entier # On renvoie le chiffre
    return premier_chiffre(entier // 10) # Sinon on divise `entier` par 10 et on revérifie avec `premier_chiffre`

def bhaut(n: int):
    """
    Affiche un triangle de points dont la hauteur et la largeur est de n points en ASCII art.
    Cette fonction est récursive.
    """
    if n == 0: return # Si n est égal a 0 on ne fait rien
    print("*" * n) # On affiche n points
    bhaut(n-1) # On fait appel à la fonction avec n-1 points pour afficher la ligne suivante

def bbas(n: int):
    """
    Affiche un triangle de points dont la hauteur et la largeur est de n points en ASCII art.
    Cette fonction est récursive.
    """
    if n == 0: return # Si n est égal a 0 on ne fait rien
    bbas(n-1) # On fait appel à la fonction avec n-1 points pour afficher la ligne suivante
    print("*" * n) # On affiche n points

def pair(n: int) -> bool:
    """
    Fonction récursive qui renvoie True si n est pair et False sinon.
    """
    if n == 0: # Si n est égal a 0 alors
        return True # On renvoie True pour dire que c'est pair
    return impair(n-1) # Sinon on fait appel à la fonction impair avec n-1
    
def impair(n: int) -> bool:
    """
    Fonction récursive qui renvoie True si n est impair et False sinon.
    """
    if n == 0: # Si n est égal a 0 alors
        return False # On renvoie False pour dire que cc n'est pas impair
    return pair(n-1) # Sinon on fait appel à la fonction pair avec n-1

def myst(a, b, q=0):
    """
    Fonction qui renvoie le quotient et le reste de la division de a par b.
    """
    if a < b: return q,a # Si a est plus petit que b on ne peut plus diviser donc on retourne le quotien et le reste
    return myst(a-b, b, q+1) # Sinon on enlève b a a et on retourne le quotien et le reste de a par b

import turtle
def triangle(i, s=200):
    turtle.left(120)
    for j in range(3):
        turtle.forward(s / 2)
        if i != 0:
            triangle(i-1, s / 2)
        turtle.forward(s / 2)
        if j != 2: turtle.right(120)
    turtle.left(120)

turtle.up()
turtle.goto(-200, -200)
turtle.down()
turtle.forward(200)
triangle(2, 200)
turtle.forward(200)
for i in range(2):
    turtle.left(120)
    turtle.forward(400)
turtle.done()

def expo_rapide(x, n):
    if n == 1:
        return x
    if n == 0:
        return 1
    r = expo_rapide(x, n//2)
    return r * expo_rapide(x, n//2 + (n % 2))

print(expo_rapide(2, 10000))

def hanoi(k, source, aide, but):
    if k == 0: return # Si il n'y a plus rien a déplacer on retourne
    hanoi(k-1, source, but, aide) # On déplace la pile source vers l'aide sauf le plus grand
    print(k, ":", source, "->", but) # On affiche l'action réalisé
    but.append(source.pop()) # On déplace le plus grand vers la pile but
    hanoi(k-1, aide, source, but) # On répète l'opération avec aide qui devient la nouvelle source

hanoi(4, [4, 3, 2, 1], [], [])

def better_hanoi(k, source, aide, but, aff=None):
    if aff is None: # Si il n'y a pas encore d'affichage pour l'état des piles
        aff = (source, aide, but) # On l'initialise
        print(aff[0], aff[1], aff[2]) # On l'affiche
    if k == 0: return # Si il n'y a plus rien a déplacer on retourne
    better_hanoi(k-1, source, but, aide, aff) # On déplace la pile source vers l'aide sauf le plus grand
    print(aff[0], aff[1], aff[2]) # On affiche l'état de nos piles
    but.append(source.pop()) # On déplace le plus grand vers la pile but
    better_hanoi(k-1, aide, source, but, aff) # On répète l'opération avec aide qui devient la nouvelle source


better_hanoi(4, [4, 3, 2, 1], [], [])

# Il faut faire du code simple sans utiliser goto, setjmp ou longjmp et ne pas utiliser de récursion directe ou indirecte.
# Cela est utile car cela permet d'avoir un code plus clair et plus facilement analysable pour détécter des erreurs.