Aritmetica postfissa limitata
Valuta da uno a 100 token postfissi con interi limitati e gli operatori +, -, * e //.
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]- Progetto
- Verifica la divisione negativa arrotondata verso il basso e rifiuta divisione per zero, pila incompleta o valori intermedi in modulo superiori a 10**18.
- Controlla prima di applicare
- Confronta il comportamento effettivo con il risultato atteso. Se una verifica fallisce, indaga la causa prima di altre modifiche.
- Modelli
- Configura un endpoint compatibile con OpenAI o Anthropic usando URL di base e chiave API, se necessaria. Prova la connessione. Il server locale deve essere in esecuzione; gli strumenti remoti possono trasmettere dati separatamente.
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]Definisci che cosa può fare un'espressione prima di modificarne il parser
La gestione delle espressioni richiede confini chiari anche quando il linguaggio è piccolo. StackSundial è uno spazio di lavoro Windows con IA per discuterli accanto ai file sorgente. Apri il progetto e chiedi al modello collegato di esaminare token ammessi, regole di valutazione e gestione degli errori del chiamante prima di proporre una modifica all'implementazione.
Una possibile attività è rivedere un valutatore postfisso usato da una schermata interna di calcolo. Specifica operatori ammessi, limiti numerici e risposta alle espressioni malformate. Chiedi all'assistente di identificare dove sono applicati questi requisiti e proporre modifiche mirate dove mancano. Così la conversazione riguarda la manutenzione del software anziché la semplice generazione di un altro valutatore.
Rivedi i percorsi di rifiuto con la stessa attenzione dell'aritmetica riuscita. Esegui i controlli del progetto per operandi mancanti, risultati in eccesso, divisione per zero e valori oltre i limiti consentiti. Esamina l'ordine degli operandi nelle operazioni non commutative e conferma che il chiamante riceva l'errore previsto. Non accettare un ciclo di valutazione più breve se indebolisce il contratto circostante.
StackSundial supporta connessioni a endpoint compatibili con OpenAI o Anthropic. Dove disponibile, scegli un modello IA abliterato tenendo presente che restrizioni, limiti di contesto e strumenti dipendono dal servizio selezionato. Il codice proposto resta un punto di partenza per l'esame e la tua verifica, non una prova che l'interprete sia pronto.
Prima di accettare una modifica al valutatore
- Quali regole devo includere nella descrizione dell'attività?
Indica token consentiti, tipi degli operandi, limiti numerici e comportamento degli errori. Includi il chiamante che presenta i fallimenti agli utenti. Senza queste regole, una proposta può calcolare correttamente esempi ordinari accettando però espressioni che l'applicazione dovrebbe rifiutare.
- Perché testare esplicitamente sottrazione e divisione?
I loro risultati dipendono dall'ordine degli operandi, a differenza dell'addizione nei casi ordinari. Usa casi con risultati visibilmente diversi invertendo gli operandi. Verifica la convenzione di divisione richiesta dal progetto e la risposta a un divisore zero.
- Le espressioni malformate devono restituire zero?
Solo se è un requisito applicativo esplicito. Un ripiego numerico plausibile può nascondere input errati. Chiedi all'assistente di preservare un chiaro percorso di rifiuto ed esamina come il chiamante distingue uno zero valido da un errore.
- Un limite ai token basta a limitare la valutazione?
Rivedi tutti i limiti richiesti dal progetto, inclusi valori intermedi e struttura dell'input accettata. Il conteggio dei token copre soltanto una parte del contratto. Verifica i percorsi di rifiuto pertinenti dopo ogni modifica al ciclo di valutazione.
StackSundial · Aggiornato 2026-10-25