Aritmética pós-fixa limitada
Avalie de um a 100 tokens pós-fixos com inteiros limitados e os operadores +, -, * 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]- Projeto
- Teste divisão negativa arredondada para baixo e rejeite divisão por zero, pilha incompleta ou magnitude intermediária acima de 10**18.
- Revise antes de aplicar
- Compare o comportamento real com o resultado esperado. Se uma verificação falhar, investigue a causa antes de fazer outras alterações.
- Modelos
- Configure um endpoint compatível com OpenAI ou Anthropic com a URL base e uma chave API, quando necessária. Teste a conexão. O servidor local precisa estar em execução; ferramentas remotas podem transmitir dados separadamente.
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]Defina o que uma expressão pode fazer antes de alterar seu analisador
O tratamento de expressões precisa de limites claros mesmo quando a linguagem é pequena. O StackSundial é um ambiente de programação com IA para Windows para discutir esses limites ao lado dos arquivos-fonte. Abra o projeto e peça ao modelo conectado que examine os tokens aceitos, as regras de avaliação e o tratamento de erros do chamador antes de propor uma alteração de implementação.
Uma tarefa possível é revisar um avaliador pós-fixo usado em uma tela interna de cálculos. Especifique os operadores permitidos, os limites numéricos e a resposta a expressões malformadas. Peça ao assistente que identifique onde esses requisitos são aplicados e proponha alterações pontuais onde estiverem ausentes. Isso direciona a conversa à manutenção do seu software, em vez de apenas gerar outro avaliador.
Revise os caminhos de rejeição com a mesma atenção dedicada à aritmética bem-sucedida. Execute verificações do projeto para operandos ausentes, resultados extras, divisão por zero e valores além dos limites permitidos. Examine a ordem dos operandos em operações não comutativas e confirme que o chamador recebe o erro pretendido. Evite aceitar um laço de avaliação mais curto se ele enfraquecer o contrato ao redor.
O StackSundial aceita conexões a endpoints compatíveis com OpenAI ou Anthropic. Onde estiver disponível, escolha um modelo de IA abliterado sabendo que restrições, limites de contexto e ferramentas dependem do serviço selecionado. Seu código proposto continua sendo um ponto de partida para inspeção e verificação por você, e não evidência de que o interpretador está pronto.
Antes de aceitar uma alteração no avaliador
- Que regras devo incluir na descrição da tarefa?
Declare os tokens permitidos, os tipos de operandos, os limites numéricos e o comportamento de erro. Inclua o chamador que apresenta falhas aos usuários. Sem essas regras, uma proposta pode calcular exemplos comuns corretamente e ainda aceitar expressões que a aplicação deveria rejeitar.
- Por que testar subtração e divisão explicitamente?
Seus resultados dependem da ordem dos operandos, ao contrário da adição nos casos comuns. Use casos de teste com resultados visivelmente diferentes quando os operandos são invertidos. Confira a convenção de divisão exigida pelo projeto e a resposta a um divisor zero.
- Expressões malformadas devem retornar zero?
Somente se esse for um requisito explícito da aplicação. Um valor numérico alternativo plausível pode esconder uma entrada incorreta. Peça ao assistente que preserve um caminho claro de rejeição e examine como o chamador distingue um resultado zero válido de um erro.
- Um limite de tokens sozinho limita a avaliação?
Revise todos os limites exigidos pelo projeto, incluindo valores intermediários e estrutura de entrada aceita. Uma contagem de tokens responde apenas a uma parte desse contrato. Teste os caminhos de rejeição pertinentes após qualquer alteração no laço de avaliação.
StackSundial · Atualizado 2026-10-25