Exemple de Réécriture de Code

Cet exemple montre comment analyser et optimiser du code en utilisant DeepSeek, y compris la gestion des erreurs, les commentaires et les améliorations de performance.

Tâche

Analysez et optimisez le code suivant qui est inefficace et manque de gestion des cas limites :

def fib(n):
    if n <= 2:
        return n
    return fib(n-1) + fib(n-2)

Prompt

Le code ci-dessus est inefficace et ne gère pas les cas limites. Veuillez expliquer les problèmes et les solutions, et optimiser le code.

Réponse

Analyse du Problème

Cette implémentation de la fonction Fibonacci fib(n) utilise la récursion. Le code est simple mais présente les problèmes suivants :

Calculs Redondants : Les appels récursifs entraînent de nombreux calculs répétés. Par exemple, lors du calcul de fib(5), les valeurs de fib(3) et fib(2) sont calculées plusieurs fois, réduisant l'efficacité.
Gestion Insuffisante des Cas Limites : Bien que le cas n <= 2 soit géré, le cas n < 0 n'est pas pris en compte. La fonction renvoie des résultats incorrects pour les entrées négatives.
Limite de Profondeur Récursive : Pour les grandes valeurs de n, la profondeur de récursion peut dépasser la limite standard de Python et provoquer une RecursionError.

Solutions

Utiliser la Mémoïsation : Stocker les nombres de Fibonacci calculés en cache pour éviter les calculs redondants et améliorer l'efficacité.
Gestion des Cas Limites : Ajouter une vérification pour n < 0 et renvoyer un message d'erreur approprié ou une valeur par défaut.
Itération plutôt que Récursion : La récursion est élégante mais inefficace pour les grands ensembles de données. Utiliser une boucle pour calculer les nombres de Fibonacci et éviter la limite de profondeur récursive.

Code Optimisé

Méthode 1 : Récursion avec Mémoïsation

def fib(n, memo={}):
    if n < 0:
        raise ValueError("L'entrée doit être un entier non négatif")
    if n <= 2:
        return 1
    if n in memo:
        return memo[n]
    memo[n] = fib(n-1, memo) + fib(n-2, memo)
    return memo[n]

Méthode 2 : Itération

def fib(n):
    if n < 0:
        raise ValueError("L'entrée doit être un entier non négatif")
    if n <= 2:
        return 1
    
    a, b = 1, 1
    for _ in range(3, n+1):
        a, b = b, a + b
    return b

Explication

Récursion avec Mémoïsation :
- Utilise un dictionnaire memo pour stocker les nombres de Fibonacci calculés
- Vérifie memo avant chaque appel récursif et renvoie directement le résultat s'il est disponible
- Lève une ValueError pour les entrées négatives
Itération :
- Utilise les variables a et b pour stocker les deux derniers nombres de Fibonacci
- Calcule les nombres de Fibonacci dans une boucle de 3 à n
- Lève également une ValueError pour les entrées négatives

Résumé

Le code optimisé améliore l'efficacité et gère correctement les cas limites. La mémoïsation et la méthode itérative sont toutes deux des techniques d'optimisation efficaces, et le choix entre elles dépend des exigences spécifiques et des scénarios.

Code pour Générer la Réponse

from openai import OpenAI

client = OpenAI(
    base_url="https://api.deepseek.com/",
    api_key="<YOUR_API_KEY>"
)

completion = client.chat.completions.create(
    model="deepseek-chat",
    messages=[
        {
            "role": "user",
            "content": "Le code ci-dessus est inefficace et ne gère pas les cas limites. Veuillez expliquer les problèmes et les solutions, et optimiser le code."
        }
    ]
)

print(completion.choices[0].message.content)