ENSIASD L.

KARBIL
1ére année MGSI
TD1 : solution

Exercice 1 :
# Entrée : Liste et taille de segment
lst = [1, 2, 3, 4, 5, 6, 7, 8, 9]
segment_size = 3
# Liste résultat pour stocker l'inversion par segments
result = []
# Parcours de la liste par segments de taille donnée
for i in range(0, len(lst), segment_size):
# Prendre le segment courant et l'inverser
segment = lst[i:i+segment_size]
result.extend(segment[::-1]) # Inverser et ajouter au résultat
Exercice 2 :
lst = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
max_sum = lst[0]
current_sum = lst[0]
start = 0
end = 0
temp_start = 0
for i in range(1, len(lst)):
# Si lst[i] est plus grand que current_sum + lst[i], on commence une nouvelle
sous-liste
if lst[i] > current_sum + lst[i]:
current_sum = lst[i]
temp_start = i # Mise à jour du début temporaire de la sous-liste
ENSIASD L.KARBIL
1ére année MGSI
else:
current_sum += lst[i]
# Mise à jour de max_sum et des indices de la sous-liste si current_sum est
supérieur
if current_sum > max_sum:
max_sum = current_sum
start = temp_start # Début réel de la sous-liste
end = i # Fin réelle de la sous-liste
# Affichage des résultats
print("La somme maximale est :", max_sum)
print("La sous-liste correspondante est :", lst[start:end+1])
Exercice 3 :
# Liste d'entrée
lst = [1, 2, 3]
# Si la liste est vide, retourner une liste vide
if len(lst) == 0:
result = []
# Si la liste contient un seul élément, retourner cette liste
elif len(lst) == 1:
result = [lst]
else:
# Liste pour stocker les permutations
result = []
# Parcours de la liste et génération des permutations
for i in range(len(lst)):
# Prendre l'élément lst[i]
ENSIASD L.KARBIL
1ére année MGSI
Exercice 4 :
# Liste d'entrée
lst = [1, 2, 3, 4]
# Liste pour stocker les produits des paires
products = []
# Parcours de la liste pour trouver toutes les paires distinctes
for i in range(len(lst)):
for j in range(i + 1, len(lst)): # j commence à i + 1 pour éviter les doublons
product = lst[i] * lst[j] # Calcul du produit
products.append(product) # Ajout du produit à la liste
# Affichage des résultats
print("Le produit de toutes les paires dans", lst, "est :", products)
Exercice 5
# Liste d'entrée
lst = [1, [2, [3, 4], 5], 6]
# Liste pour stocker les éléments aplatis
flat_list = []
# Utilisation d'une pile pour gérer les éléments à traiter
stack = [lst] # On commence avec la liste d'entrée
# Tant qu'il y a des éléments à traiter dans la pile
while stack:
current = stack.pop() # On récupère l'élément du dessus de la pile
# Si l'élément est une liste, on l'ajoute à la pile pour traitement
if isinstance(current, list):
stack.extend(current) # Ajouter les éléments de la sous-liste à la pile
else:
ENSIASD L.KARBIL
1ére année MGSI
flat_list.append(current) # Si c'est un élément, on l'ajoute à la liste aplatie
# Affichage des résultats
print("Liste aplatie :", flat_list)
Exercice 6
# Liste d'entrée
lst = [5, [3, 1, 2], 8, [7, 6], 9]

# Parcours de la liste pour identifier les sous-listes

for i in range(len(lst)):
# Vérifier si l'élément est une sous-liste
if isinstance(lst[i], list):
# Trier la sous-liste en place
lst[i].sort()

# Affichage des résultats

print("Liste avec sous-listes triées :", lst)
Exercice 7
# Listes d'entrée
l1 = [1, 2, 3]
l2 = [2, 3, 4]

# Liste pour stocker les éléments uniques

unique_elements = []

# Parcours de la première liste

for item in l1:
ENSIASD L.KARBIL
1ére année MGSI
if item not in l2: # Si l'élément n'est pas dans l2, on l'ajoute
unique_elements.append(item)

# Parcours de la deuxième liste

for item in l2:
if item not in l1: # Si l'élément n'est pas dans l1, on l'ajoute
unique_elements.append(item)

# Affichage du résultat
print("Éléments uniques dans l1 ou l2, mais pas dans les deux :",
unique_elements)

Exercice 8
# Listes d'entrée
l1 = [1, 2, 3]
l2 = ['a', 'b', 'c']
# Liste pour stocker les tuples
paired_list = []
# Parcours des deux listes en utilisant les indices
for i in range(len(l1)):
paired_list.append((l1[i], l2[i])) # Créer un tuple avec l'élément de l1 et
l'élément de l2
# Affichage du résultat
print("Liste de tuples associés :", paired_list)
Exercice 9
# Liste d'entrée
lst = [1, 2, 3]
ENSIASD L.KARBIL
1ére année MGSI
# Liste pour stocker les rotations circulaires
rotations = []
# Générer toutes les rotations circulaires
for i in range(len(lst)):
# Effectuer la rotation en décalant les éléments
rotation = lst[i:] + lst[:i]
# Ajouter la rotation à la liste des rotations
rotations.append(rotation)
# Affichage du résultat
print("Toutes les rotations circulaires :", rotations)
Exercice 10
# Données d'entrée
lst = [1, 2, 3, 4]
k=2
# Liste pour stocker les combinaisons
resultat = []
# Boucle pour générer les combinaisons de k éléments
n = len(lst)
for i in range(n):
# Si k est 2, on utilise deux boucles pour choisir deux éléments distincts
if k == 2:
for j in range(i + 1, n):
combinaison = [lst[i], lst[j]]
resultat.append(combinaison)
# Si k est 3, on utilise trois boucles pour choisir trois éléments distincts
elif k == 3:
ENSIASD L.KARBIL
1ére année MGSI
for j in range(i + 1, n):
for m in range(j + 1, n):
combinaison = [lst[i], lst[j], lst[m]]
resultat.append(combinaison)
# Étendre le code de cette manière pour des valeurs de k supérieures
# Affichage des combinaisons
print("Toutes les combinaisons possibles de", k, "éléments :", resultat)
Exercice 11
# Liste d'entrée et valeur de n
lst = [1, 2, 2, 3, 4, 4, 4]
n=2
# Initialisation d'une liste pour stocker les résultats
resultat = []
# Parcourir la liste pour compter les occurrences de chaque élément
for i in lst:
# Compter les occurrences de l'élément i
compteur = 0
for j in lst:
if i == j:
compteur += 1
# Si l'élément apparaît exactement n fois et n'est pas déjà dans le résultat,
on l'ajoute
if compteur == n and i not in resultat:
resultat.append(i)
# Affichage de la liste résultat
print("Éléments apparaissant exactement", n, "fois :", resultat)
ENSIASD L.KARBIL
1ére année MGSI
Exercice 12
# Liste d'entrée
lst = [2, 4, 6, 8]
# Vérification de la suite arithmétique
is_arithmetic = True
# Calcul de la différence entre les deux premiers éléments
if len(lst) > 1:
difference = lst[1] - lst[0]
# Parcourir la liste pour vérifier si chaque paire a la même différence
for i in range(1, len(lst) - 1):
if lst[i + 1] - lst[i] != difference:
is_arithmetic = False
break
else:
# Une liste vide ou avec un seul élément est considérée comme arithmétique
is_arithmetic = True
# Affichage du résultat
print("La liste est une suite arithmétique :", is_arithmetic)
Exercice 13
# Liste d'indices et de valeurs correspondantes
indices = [0, 2, 5]
valeurs = [10, 20, 50]
# Calcul de la longueur de la liste finale (basée sur l'indice maximum)
taille_liste = max(indices) + 1
# Initialisation de la liste avec des zéros
resultat = [0] * taille_liste
ENSIASD L.KARBIL
1ére année MGSI
# Remplissage des valeurs aux indices spécifiés
for i in range(len(indices)):
resultat[indices[i]] = valeurs[i]
# Affichage de la liste résultat
print("Liste remplie :", resultat)
Exercice 14
# Liste d'entrée
lst = [1, 2, 3, 6]
# Calcul des sommes des deux moitiés
n = len(lst)
moitie1 = sum(lst[:n//2])
moitie2 = sum(lst[n//2:])
# Vérification pour modifier un élément de la première moitié
for i in range(n//2):
# Calcul de la nouvelle valeur nécessaire pour équilibrer
nouvelle_valeur = moitie2 - (moitie1 - lst[i])
# Remplacer l'élément par la nouvelle valeur
lst_modifiee = lst[:]
lst_modifiee[i] = nouvelle_valeur
# Vérification des sommes
if sum(lst_modifiee[:n//2]) == sum(lst_modifiee[n//2:]):
# Affichage de la liste modifiée
print("Liste modifiée :", lst_modifiee)
break
else:
# Vérification pour modifier un élément de la deuxième moitié
ENSIASD L.KARBIL
1ére année MGSI
for i in range(n//2, n):
# Calcul de la nouvelle valeur nécessaire pour équilibrer
nouvelle_valeur = moitie1 - (moitie2 - lst[i])
# Remplacer l'élément par la nouvelle valeur
lst_modifiee = lst[:]
lst_modifiee[i] = nouvelle_valeur
# Vérification des sommes
if sum(lst_modifiee[:n//2]) == sum(lst_modifiee[n//2:]):
# Affichage de la liste modifiée
print("Liste modifiée :", lst_modifiee)
break

Exercice 15
# Liste d'entrée
lst = [1, 2, 3, 4, 3, 2, 1]
# Fonction pour déterminer le nombre minimal d'éléments à supprimer
def min_deletions_to_palindrome(lst):
n = len(lst)
# Créer une matrice pour stocker les résultats des sous-problèmes
# dp[i][j] sera la longueur de la plus longue sous-séquence palindromique
dp = [[0] * n for _ in range(n)]
# Les sous-séquences de longueur 1 sont des palindromes
for i in range(n):
dp[i][i] = 1
# Remplissage de la matrice dp
for length in range(2, n + 1): # longueur des sous-séquences
ENSIASD L.KARBIL
1ére année MGSI
for i in range(n - length + 1):
j = i + length - 1 # j est la fin de la sous-séquence
if lst[i] == lst[j]:
dp[i][j] = dp[i + 1][j - 1] + 2
else:
dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])
# La longueur de la plus longue sous-séquence palindromique
longest_palindrome_subseq = dp[0][n - 1]
# Le nombre d'éléments à supprimer est la différence entre la longueur de la
liste
# et la longueur de la plus longue sous-séquence palindromique
return n - longest_palindrome_subseq
# Appel de la fonction et affichage du résultat
resultat = min_deletions_to_palindrome(lst)
print("Nombre minimal d'éléments à supprimer :", resultat)