Arithmétique postfixée bornée
Évaluez de un à 100 jetons postfixés avec des entiers bornés et les opérateurs +, -, * et //.
def postfix_value(tokens):
tokens = tuple(tokens)
if not 1 <= len(tokens) <= 100:
raise ValueError("tokens.limit")
stack = []
for token in tokens:
if type(token) is int and abs(token) <= 1000000000:
stack.append(token)
continue
if type(token) is not str or token not in ("+", "-", "*", "//") or len(stack) < 2:
raise ValueError("token.invalid")
right, left = stack.pop(), stack.pop()
if token == "//" and right == 0:
raise ValueError("division.zero")
value = (left + right if token == "+" else left - right if token == "-" else left * right if token == "*" else left // right)
if abs(value) > 10**18:
raise ValueError("result.range")
stack.append(value)
if len(stack) != 1:
raise ValueError("stack.remainder")
return stack[0]- Projet
- Vérifiez la division négative arrondie vers le bas et rejetez la division par zéro, une pile incomplète ou une magnitude intermédiaire supérieure à 10**18.
- Vérifiez avant d’appliquer
- Comparez le comportement observé au résultat attendu. Si une vérification échoue, cherchez la cause avant de poursuivre les modifications.
- Modèles
- Configurez un endpoint compatible OpenAI ou Anthropic avec son URL de base et une clé API si nécessaire. Testez la connexion. Un serveur local doit fonctionner ; les outils distants peuvent transmettre des données séparément.
def postfix_value(tokens):
tokens = tuple(tokens)
if not 1 <= len(tokens) <= 100:
raise ValueError("tokens.limit")
stack = []
for token in tokens:
if type(token) is int and abs(token) <= 1000000000:
stack.append(token)
continue
if type(token) is not str or token not in ("+", "-", "*", "//") or len(stack) < 2:
raise ValueError("token.invalid")
right, left = stack.pop(), stack.pop()
if token == "//" and right == 0:
raise ValueError("division.zero")
value = (left + right if token == "+" else left - right if token == "-" else left * right if token == "*" else left // right)
if abs(value) > 10**18:
raise ValueError("result.range")
stack.append(value)
if len(stack) != 1:
raise ValueError("stack.remainder")
return stack[0]Définissez ce qu’une expression peut faire avant de modifier son analyseur
Le traitement d’expressions demande des limites claires, même pour un petit langage. StackSundial est un espace de programmation avec IA sous Windows pour discuter de ces limites à côté des fichiers source. Ouvrez le projet et demandez au modèle connecté d’examiner les jetons acceptés, les règles d’évaluation et la gestion des erreurs par l’appelant avant de proposer une modification.
Une tâche possible est la revue d’un évaluateur postfixé utilisé par un écran de calcul interne. Précisez les opérateurs autorisés, les limites numériques et la réponse aux expressions mal formées. Demandez à l’assistant d’identifier où ces exigences sont appliquées et de proposer des changements ciblés là où elles manquent. La conversation porte ainsi sur la maintenance du logiciel plutôt que sur la simple génération d’un autre évaluateur.
Examinez les chemins de rejet avec autant d’attention que les calculs réussis. Exécutez les vérifications du projet pour les opérandes manquants, les résultats supplémentaires, la division par zéro et les valeurs hors limites. Inspectez l’ordre des opérandes pour les opérations non commutatives et confirmez que l’appelant reçoit l’erreur prévue. N’acceptez pas une boucle d’évaluation plus courte si elle affaiblit le contrat environnant.
StackSundial prend en charge les connexions aux points de terminaison compatibles OpenAI ou Anthropic. Lorsqu’il est disponible, choisissez un modèle d’IA ablité en sachant que les restrictions, les limites de contexte et les outils dépendent du service sélectionné. Le code proposé reste un point de départ pour l’inspection et vos propres vérifications, pas une preuve que l’interpréteur est prêt.
Avant d’accepter un correctif d’évaluateur
- Quelles règles inclure dans la description de la tâche ?
Précisez les jetons autorisés, les types d’opérandes, les bornes numériques et le comportement en cas d’erreur. Incluez l’appelant qui présente les échecs aux utilisateurs. Sans ces règles, une proposition peut calculer correctement des exemples ordinaires tout en acceptant des expressions que l’application doit rejeter.
- Pourquoi tester explicitement la soustraction et la division ?
Leurs résultats dépendent de l’ordre des opérandes, contrairement à l’addition dans les cas ordinaires. Utilisez des tests dont les résultats changent visiblement quand on inverse les opérandes. Vérifiez la convention de division du projet et la réponse à un diviseur nul.
- Les expressions mal formées doivent-elles renvoyer zéro ?
Seulement si c’est une exigence explicite de l’application. Une valeur de repli plausible peut masquer une mauvaise entrée. Demandez à l’assistant de préserver un chemin de rejet clair et examinez comment l’appelant distingue un zéro valide d’une erreur.
- Une limite de jetons suffit-elle à borner l’évaluation ?
Examinez toutes les limites requises par le projet, y compris les valeurs intermédiaires et la structure d’entrée acceptée. Le nombre de jetons ne répond qu’à une partie du contrat. Testez les chemins de rejet pertinents après toute modification de la boucle d’évaluation.
StackSundial · Mis à jour 2026-10-25