2023-09-21 13:09:01 +00:00
|
|
|
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)
|
2023-09-21 13:41:09 +00:00
|
|
|
|
|
|
|
|
|
|
|
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
|
2023-09-21 13:52:09 +00:00
|
|
|
return value + sommeDesPositifs(liste[1:])
|
|
|
|
|
|
|
|
def estPalindrome(x):
|
|
|
|
if len(x) == 2:
|
|
|
|
return x[0] == x[1]
|
|
|
|
elif len(x) == 1:
|
|
|
|
return True
|
2023-09-27 08:46:04 +00:00
|
|
|
return x[0] == x[-1] and estPalindrome(x[1:-1])
|
|
|
|
|
|
|
|
def renvoitLongueur(liste: list) -> int:
|
|
|
|
"""
|
|
|
|
Fonction récursive qui renvoie la longueur de la
|
2023-09-27 08:56:46 +00:00
|
|
|
liste donné en paramètres sans utiliser la fonction `len`.
|
2023-09-27 08:46:04 +00:00
|
|
|
"""
|
|
|
|
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
|
|
|
|
|
2023-09-27 08:46:46 +00:00
|
|
|
def inverse_lordre(liste: list) -> list:
|
2023-09-27 08:46:04 +00:00
|
|
|
"""
|
|
|
|
Fonction récursive qui renvoie l'inverse de la liste
|
2023-09-27 08:56:46 +00:00
|
|
|
donnée en paramètres sans utiliser la fonction `reverse`.
|
2023-09-27 08:46:04 +00:00
|
|
|
"""
|
|
|
|
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])
|
2023-09-27 08:56:46 +00:00
|
|
|
|
2023-10-04 08:33:52 +00:00
|
|
|
def premier_chiffre(entier: int) -> int:
|
2023-09-27 08:56:46 +00:00
|
|
|
"""
|
|
|
|
Fonction qui renvoie le premier chiffre de l'entier donné en paramètres.
|
|
|
|
"""
|
2023-10-04 08:35:34 +00:00
|
|
|
if entier < 10: # Si l'entier est inférieur à 10 (donc que c'est le premier chiffre)
|
2023-09-27 09:00:38 +00:00
|
|
|
return entier # On renvoie le chiffre
|
2023-10-04 08:35:34 +00:00
|
|
|
return premier_chiffre(entier // 10) # Sinon on divise `entier` par 10 et on revérifie avec `premier_chiffre`
|
2023-09-27 09:05:46 +00:00
|
|
|
|
|
|
|
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.
|
|
|
|
"""
|
2023-10-04 08:49:09 +00:00
|
|
|
if n == 0: return # Si n est égal a 0 on ne fait rien
|
2023-09-27 09:05:46 +00:00
|
|
|
print("*" * n) # On affiche n points
|
2023-09-27 09:11:47 +00:00
|
|
|
bhaut(n-1) # On fait appel à la fonction avec n-1 points pour afficher la ligne suivante
|
|
|
|
|
2023-10-04 08:39:06 +00:00
|
|
|
def bbas(n: int):
|
2023-10-04 08:40:13 +00:00
|
|
|
"""
|
|
|
|
Affiche un triangle de points dont la hauteur et la largeur est de n points en ASCII art.
|
|
|
|
Cette fonction est récursive.
|
|
|
|
"""
|
2023-10-04 08:49:09 +00:00
|
|
|
if n == 0: return # Si n est égal a 0 on ne fait rien
|
2023-10-04 08:39:06 +00:00
|
|
|
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
|
2023-09-27 09:11:47 +00:00
|
|
|
|
2023-10-04 08:39:06 +00:00
|
|
|
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
|
2023-10-05 12:44:14 +00:00
|
|
|
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
|
2023-10-05 13:03:07 +00:00
|
|
|
|
2023-10-05 13:33:28 +00:00
|
|
|
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)
|
|
|
|
|
2023-10-05 13:40:18 +00:00
|
|
|
turtle.forward(200)
|
2023-10-05 13:33:28 +00:00
|
|
|
triangle(5, 200)
|
2023-10-05 13:40:18 +00:00
|
|
|
turtle.forward(200)
|
|
|
|
for i in range(2):
|
|
|
|
turtle.left(120)
|
|
|
|
turtle.forward(400)
|
2023-10-05 13:33:28 +00:00
|
|
|
turtle.done()
|
|
|
|
|
2023-10-05 13:03:07 +00:00
|
|
|
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))
|
2023-10-05 13:33:28 +00:00
|
|
|
|