Analyse de résultats
Exercices corrigés

import time import statistics def mesure_performance(algo, donnees): """Mesure le temps d'exécution d'un algorithme.""" debut = time.time() resultat = algo(donnees) fin = time.time() return fin - debut # Collecte des mesures donnees_tailles = [100, 500, 1000, 2000, 5000] temps_execution = [] for taille in donnees_tailles: donnees = list(range(taille, 0, -1)) # Données inversées temps = mesure_performance(tri_insertion, donnees) temps_execution.append(temps) # Analyse statistique moyenne_temps = statistics.mean(temps_execution) ecart_type = statistics.stdev(temps_execution) minimum = min(temps_execution) maximum = max(temps_execution) print(f"Moyenne: {moyenne_temps:.6f}s") print(f"Écart-type: {ecart_type:.6f}s") print(f"Min: {minimum:.6f}s, Max: {maximum:.6f}s")

def recherche_lineaire(tableau, cible): """Recherche linéaire avec comptage d'opérations.""" operations = 0 for i, element in enumerate(tableau): operations += 1 if element == cible: return i, operations # Retourne l'index et le nombre d'opérations return -1, operations # Analyse des résultats donnees = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] resultats = [] for cible in [5, 9, 7]: # 7 n'est pas dans le tableau index, ops = recherche_lineaire(donnees, cible) resultats.append({ 'cible': cible, 'trouve': index != -1, 'position': index, 'operations': ops }) # Interprétation for res in resultats: if res['trouve']: print(f"Cible {res['cible']} trouvée à l'index {res['position']} " f"après {res['operations']} opérations") else: print(f"Cible {res['cible']} non trouvée " f"après {res['operations']} opérations")

import matplotlib.pyplot as plt import time import random def tri_bulle(tableau): n = len(tableau) operations = 0 for i in range(n): for j in range(0, n-i-1): operations += 1 if tableau[j] > tableau[j+1]: tableau[j], tableau[j+1] = tableau[j+1], tableau[j] return operations def tri_rapide(tableau): operations = 0 def partition(low, high): nonlocal operations pivot = tableau[high] i = low - 1 for j in range(low, high): operations += 1 if tableau[j] <= pivot: i += 1 tableau[i], tableau[j] = tableau[j], tableau[i] tableau[i+1], tableau[high] = tableau[high], tableau[i+1] return i + 1 def tri_recursif(low, high): if low < high: pi = partition(low, high) tri_recursif(low, pi-1) tri_recursif(pi+1, high) tri_recursif(0, len(tableau)-1) return operations # Comparaison tailles = [100, 200, 500, 1000] bulle_ops = [] rapide_ops = [] for taille in tailles: # Tri à bulle donnees_bulle = list(range(taille, 0, -1)) # Pire cas ops_bulle = tri_bulle(donnees_bulle.copy()) bulle_ops.append(ops_bulle) # Tri rapide donnees_rapide = list(range(taille, 0, -1)) # Pire cas ops_rapide = tri_rapide(donnees_rapide.copy()) rapide_ops.append(ops_rapide) # Interprétation des résultats for i, taille in enumerate(tailles): print(f"Taille: {taille}") print(f" Tri à bulle: {bulle_ops[i]} opérations") print(f" Tri rapide: {rapide_ops[i]} opérations") print(f" Ratio: {bulle_ops[i]/rapide_ops[i]:.2f}")

import matplotlib.pyplot as plt import numpy as np # Données à visualiser tailles = [100, 200, 500, 1000, 2000] temps_tri_bulle = [0.001, 0.004, 0.025, 0.100, 0.400] temps_tri_rapide = [0.0005, 0.001, 0.003, 0.007, 0.015] # Création du graphique plt.figure(figsize=(10, 6)) plt.plot(tailles, temps_tri_bulle, label='Tri à bulle', marker='o') plt.plot(tailles, temps_tri_rapide, label='Tri rapide', marker='s') plt.xlabel('Taille des données') plt.ylabel('Temps d\'exécution (secondes)') plt.title('Comparaison des performances des algorithmes de tri') plt.legend() plt.grid(True) plt.tight_layout() # Sauvegarde du graphique plt.savefig('comparaison_tri.png') plt.show() # Interprétation visuelle print("Observations:") print("- Le tri à bulle montre une croissance quadratique") print("- Le tri rapide montre une croissance quasi-linéaire") print("- La différence de performance augmente avec la taille")

def validateur_simulation(resultats): """Valide les résultats d'une simulation.""" erreurs = [] # Vérifier que les résultats sont dans des plages valides for resultat in resultats: if not isinstance(resultat, (int, float)): erreurs.append(f"Type invalide: {type(resultat)}") if resultat < 0: erreurs.append(f"Valeur négative: {resultat}") # Vérifier la cohérence statistique if len(resultats) > 1: moyenne = sum(resultats) / len(resultats) if moyenne < 0 or moyenne > 100: # Plage attendue erreurs.append(f"Moyenne hors plage: {moyenne}") # Vérifier la taille des résultats if len(resultats) == 0: erreurs.append("Aucun résultat obtenu") return len(erreurs) == 0, erreurs def simulateur_systeme(parametres): """Simule un système avec validation.""" # Simulation simplifiée resultats = [] for _ in range(10): # Simulation avec des calculs basés sur les paramètres resultat = parametres['facteur'] * parametres['valeur'] + random.uniform(-0.1, 0.1) resultats.append(resultat) return resultats # Validation des résultats parametres = {'facteur': 2.5, 'valeur': 20} resultats = simulateur_systeme(parametres) valide, erreurs = validateur_simulation(resultats) if valide: print("Résultats valides:") print(f"Moyenne: {sum(resultats)/len(resultats):.2f}") print(f"Écart-type: {statistics.stdev(resultats):.2f}") else: print("Erreurs détectées:") for erreur in erreurs: print(f"- {erreur}")