Copiez ce prompt dans notre Console pour développeurs pour l’essayer vous-même !
Contenu
SystemVotre tâche consiste à analyser la fonction ou l’algorithme fourni et à calculer sa complexité temporelle en utilisant la notation Big O. Expliquez votre raisonnement étape par étape, en décrivant comment vous êtes arrivé à la complexité temporelle finale. Considérez le pire des cas lors de la détermination de la complexité temporelle. Si la fonction ou l’algorithme contient plusieurs étapes ou des boucles imbriquées, indiquez la complexité temporelle pour chaque étape, puis donnez la complexité temporelle globale pour l’ensemble de la fonction ou de l’algorithme. Supposez que toutes les fonctions ou opérations intégrées utilisées ont une complexité temporelle de O(1), sauf indication contraire.
Userdef example_function(n): for i in range(n): print(i) for j in range(n): for k in range(n): print(j, k)

​
Exemple de sortie

Pour analyser la complexité temporelle de la fonction donnée example_function(n), nous allons la décomposer en étapes et considérer le pire des cas. Étape 1 : Analyse de la première boucle 
for i in range(n):
   print(i)
Cette boucle itère n fois et effectue une opération en temps constant (print(i)) à chaque itération. Par conséquent, la complexité temporelle de cette étape est O(n). Étape 2 : Analyse des boucles imbriquées 
for j in range(n):
    for k in range(n):
        print(j, k)
La boucle externe itère n fois, et pour chaque itération, la boucle interne itère également n fois. À chaque itération de la boucle interne, une opération en temps constant (print(j, k)) est effectuée. Par conséquent, la complexité temporelle des boucles imbriquées est O(n * n) = O(n^2). Étape 3 : Combinaison des complexités temporelles
La fonction example_function(n) se compose de deux étapes : la première boucle et les boucles imbriquées. La complexité temporelle globale est la somme des complexités temporelles de chaque étape. Complexité temporelle de la première boucle : O(n)
Complexité temporelle des boucles imbriquées : O(n^2) Pour déterminer la complexité temporelle globale, nous considérons le terme dominant, qui est le terme avec l’ordre de croissance le plus élevé. Dans ce cas, O(n^2) domine O(n). Par conséquent, la complexité temporelle globale de la fonction example_function(n) est O(n^2). Dans le pire des cas, lorsque n est grand, les boucles imbriquées domineront le temps d’exécution, et la fonction aura une complexité temporelle quadratique.

​
Requête API

import anthropic

client = anthropic.Anthropic(
    # defaults to os.environ.get("ANTHROPIC_API_KEY")
    api_key="my_api_key",
)
message = client.messages.create(
    model="claude-opus-4-20250514",
    max_tokens=1000,
    temperature=0,
    system="Your task is to analyze the provided function or algorithm and calculate its time complexity using Big O notation. Explain your reasoning step by step, describing how you arrived at the final time complexity. Consider the worst-case scenario when determining the time complexity. If the function or algorithm contains multiple steps or nested loops, provide the time complexity for each step and then give the overall time complexity for the entire function or algorithm. Assume any built-in functions or operations used have a time complexity of O(1) unless otherwise specified.",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "def example_function(n):\n    for i in range(n):\n        print(i)\n\n    for j in range(n):\n        for k in range(n):\n            print(j, k)"
                }
            ]
        }
    ]
)
print(message.content)