1.
Fonction somme(L)
Cette fonction calcule la somme des éléments d'une liste L sans utiliser la
fonction sum().
python
Copier le code
def somme(L):
total = 0 # Initialisation de la somme
for element in L:
total += element # Ajout de chaque élément au total
return total
Explication :
total commence à 0.
On parcourt chaque élément de la liste L et on l'ajoute à total.
À la fin, total contient la somme de tous les éléments.
2. Fonction minimum(L)
Cette fonction trouve le minimum des éléments d'une liste L sans utiliser min().
python
Copier le code
def minimum(L):
if len(L) == 0:
return None # Cas particulier : si la liste est vide
min_value = L[0] # Initialisation avec le premier élément
for element in L:
if element < min_value: # Si un élément est plus petit que min_value
min_value = element # On met à jour min_value
return min_value
Explication :
min_value est initialisé avec le premier élément de la liste.
On parcourt chaque élément de L et on met à jour min_value si on trouve un élément
plus petit.
À la fin, min_value contient la plus petite valeur de la liste.
3. Fonction somme_1_n(n)
Cette fonction calcule la somme des entiers de 1 à n.
python
Copier le code
def somme_1_n(n):
total = 0 # Initialisation de la somme
for i in range(1, n + 1): # Parcours de 1 à n inclus
total += i # Ajout de chaque entier à total
return total
Explication :
total commence à 0.
On utilise une boucle for pour ajouter chaque entier de 1 à n à total.
À la fin, total contient la somme des entiers de 1 à n.
4. Fonction multiplie_par_n(L, n)
Cette fonction retourne une nouvelle liste où chaque élément de L est multiplié par
n.
python
Copier le code
def multiplie_par_n(L, n):
resultat = [] # Nouvelle liste vide
for element in L:
[Link](element * n) # Ajoute le produit de element par n
return resultat
Explication :
resultat est une nouvelle liste vide.
On parcourt chaque élément de L et on multiplie cet élément par n, puis on l'ajoute
à resultat.
À la fin, resultat contient tous les éléments de L multipliés par n.
5. Fonction n_elements(L, n)
Cette fonction retourne une nouvelle liste contenant les n premiers éléments de L.
python
Copier le code
def n_elements(L, n):
resultat = [] # Nouvelle liste vide
index = 0 # Compteur pour le nombre d'éléments ajoutés
while index < n and index < len(L): # On vérifie qu'on ne dépasse pas len(L)
[Link](L[index]) # Ajout de l'élément à la liste resultat
index += 1 # Incrément du compteur
return resultat
Explication :
resultat est une nouvelle liste vide.
index est utilisé pour parcourir la liste sans utiliser le slicing.
On ajoute les n premiers éléments à resultat, ou moins si n est supérieur à la
longueur de L.
6. Fonction concat(L1, L2)
Cette fonction retourne une nouvelle liste qui est la concaténation de L1 et L2.
python
Copier le code
def concat(L1, L2):
resultat = [] # Nouvelle liste vide
for element in L1:
[Link](element) # Ajout de chaque élément de L1
for element in L2:
[Link](element) # Ajout de chaque élément de L2
return resultat
Explication :
resultat est une nouvelle liste vide.
On parcourt L1 et on ajoute chaque élément à resultat.
Ensuite, on parcourt L2 et on ajoute chaque élément de L2 à resultat.
resultat contient ainsi tous les éléments de L1 puis de L2.
7. Fonction insere_elem(L, i, e)
Cette fonction insère l'élément e dans la liste L à l'indice i.
python
Copier le code
def insere_elem(L, i, e):
resultat = [] # Nouvelle liste vide
index = 0
while index < len(L):
if index == i:
[Link](e) # Insère e à l'indice i
[Link](L[index]) # Ajout de chaque élément de L
index += 1
if i >= len(L): # Si i est à la fin ou après la fin de la liste
[Link](e) # On ajoute e en fin de liste
return resultat
Explication :
resultat est une nouvelle liste vide.
On parcourt L en ajoutant chaque élément à resultat.
Lorsque l'indice index est égal à i, on insère e avant d'ajouter l'élément
L[index].
Si i est plus grand que la longueur de L, on ajoute e à la fin de la liste.
8. Fonction present(L, e)
Cette fonction retourne True si e est présent dans la liste L, et False sinon.
python
Copier le code
def present(L, e):
for element in L:
if element == e: # Si l'élément est trouvé
return True
return False # Si on a parcouru toute la liste sans trouver e
Explication :
On parcourt chaque élément de L.
Si element est égal à e, on retourne True immédiatement.
Si la boucle se termine sans trouver e, on retourne False
