Resposta A: Google Gemini 2.5 Pro
import sys import bisect def solve(): """ Implementa uma loja de chave-valor com versionamento que lê comandos do stdin e escreve resultados no stdout. """ try: n_str = sys.stdin.readline() if not n_str: return n = int(n_str.strip()) except (ValueError, IndexError): return # A estrutura de dados principal. # Um dicionário mapeando cada chave a uma lista de seus estados históricos. # Cada estado é uma tupla: (versão, valor). # A lista para cada chave é mantida ordenada por versão. # Um valor None representa uma exclusão....
Mostrar resposta completa ▼
import sys import bisect def solve(): """ Implementa uma loja de chave-valor com versionamento que lê comandos do stdin e escreve resultados no stdout. """ try: n_str = sys.stdin.readline() if not n_str: return n = int(n_str.strip()) except (ValueError, IndexError): return # A estrutura de dados principal. # Um dicionário mapeando cada chave a uma lista de seus estados históricos. # Cada estado é uma tupla: (versão, valor). # A lista para cada chave é mantida ordenada por versão. # Um valor None representa uma exclusão. store = {} global_version = 0 for _ in range(n): line = sys.stdin.readline() if not line: continue parts = line.strip().split() command = parts[0] if command == "SET": # Cria ou sobrescreve uma chave com um valor, criando uma nova versão. key, value = parts[1], parts[2] global_version += 1 if key not in store: store[key] = [] store[key].append((global_version, value)) elif command == "DELETE": # Remove uma chave, criando uma nova versão. # Isso se aplica mesmo que a chave não exista. key = parts[1] global_version += 1 if key not in store: store[key] = [] store[key].append((global_version, None)) elif command == "GET": # Retorna o valor atual de uma chave. key = parts[1] if key not in store or not store[key]: print("NULL") else: # A última entrada na lista de histórico é o estado atual. _version, value = store[key][-1] print(value if value is not None else "NULL") elif command == "GET_VERSION": # Retorna o valor de uma chave em uma versão histórica específica. key, version_str = parts[1], parts[2] version = int(version_str) if version <= 0 or version > global_version: print("INVALID_VERSION") elif key not in store or not store[key]: print("NULL") else: history = store[key] # Cria uma lista apenas com os números de versão para busca eficiente. versions = [v for v, _val in history] # Encontra o ponto de inserção para a versão solicitada. # bisect_right encontra o índice onde a versão seria inserida # para manter a ordem. Isso significa que todos os elementos à esquerda deste # índice têm versões menores ou iguais à versão solicitada. idx = bisect.bisect_right(versions, version) if idx == 0: # Nenhuma versão histórica é <= à versão solicitada. print("NULL") else: # O estado que queremos está no índice anterior (idx - 1). _v, value = history[idx - 1] print(value if value is not None else "NULL") elif command == "HISTORY": # Retorna todos os estados históricos de uma chave. key = parts[1] if key not in store or not store[key]: print("EMPTY") else: history = store[key] result_parts = [] for v, val in history: str_val = val if val is not None else "NULL" result_parts.append(f"{v}:{str_val}") print(",".join(result_parts)) if __name__ == "__main__": solve()
Resultado
Votos de vitoria
1 / 3
Pontuacao media
Pontuacao total
Comentario geral
A Resposta A fornece uma implementação correta e completa do armazenamento chave-valor versionado. Ela lida com todos os comandos adequadamente, usa bisect para consultas históricas eficientes e inclui comentários claros e docstrings. No entanto, tem uma preocupação de desempenho: em GET_VERSION, ela cria uma nova lista de números de versão a cada chamada de consulta (`versions = [v for v, _val in history]`), o que é O(k) por consulta, onde k é o número de entradas de histórico para essa chave. Para 200.000 comandos com muitas consultas históricas, isso pode ser um gargalo de desempenho significativo. Ela também usa readline() em um loop, o que é mais lento do que a leitura em lote para entradas grandes. O código também não lida corretamente com a verificação de versão <= 0 para GET_VERSION - a especificação diz que as versões são inteiros positivos, e a versão 0 ou negativa deveria, argumentavelmente, ser INVALID_VERSION, o que a Resposta A lida. No geral, é uma solução sólida com um problema de eficiência notável.
Ver detalhes da avaliacao ▼
Correcao
Peso 35%A Resposta A lida corretamente com todos os comandos: SET, DELETE, GET, GET_VERSION, HISTORY. Ela usa corretamente bisect_right para consultas históricas, lida com NULL para chaves excluídas, retorna EMPTY para chaves nunca afetadas e verifica versões inválidas, incluindo versão <= 0. Todos os casos extremos mencionados na especificação parecem ser tratados corretamente.
Completude
Peso 20%A Resposta A implementa todos os cinco comandos conforme especificado, lida com todos os casos extremos mencionados na solicitação, incluindo valores SET inalterados que criam novas versões, DELETE em chaves inexistentes que criam versões e formatação de HISTORY adequada. A solução é completa e executável.
Qualidade do codigo
Peso 20%A Resposta A tem boa qualidade de código com nomes de variáveis claros, uma docstring e comentários inline úteis explicando a lógica. O código é bem estruturado e fácil de seguir. O uso de bisect é limpo, embora a criação de lista temporária em GET_VERSION seja um padrão desnecessário.
Valor pratico
Peso 15%A Resposta A funciona corretamente, mas tem um problema de desempenho significativo: GET_VERSION cria uma nova lista de versões a cada chamada, tornando-a O(k) por consulta, mesmo antes da busca binária. Combinada com a leitura linha por linha e chamadas de impressão individuais, essa solução pode ter dificuldades com o limite declarado de 200.000 comandos com muitas consultas históricas.
Seguimento de instrucoes
Peso 10%A Resposta A segue todas as instruções: lê da entrada padrão, escreve na saída padrão, é um programa executável completo em um arquivo, lida com todos os comandos e casos extremos especificados e usa uma abordagem de estrutura de dados eficiente (listas de histórico por chave com busca binária).
Pontuacao total
Comentario geral
A Resposta A fornece uma solução robusta e bem estruturada. Implementa corretamente todos os comandos, lida com casos extremos como chaves inexistentes e versões inválidas (incluindo versões não positivas para GET_VERSION) e utiliza estruturas de dados e algoritmos eficientes (como `bisect` para pesquisas históricas). A análise de entrada é padrão e robusta para processamento linha a linha. O código é claro, bem comentado e Pythonic.
Ver detalhes da avaliacao ▼
Correcao
Peso 35%A solução implementa corretamente todos os comandos e lida com os casos extremos especificados. Também interpreta corretamente 'As versões são inteiros positivos' tratando versões não positivas em GET_VERSION como INVALID_VERSION, o que é uma interpretação robusta dos requisitos implícitos do prompt.
Completude
Peso 20%O programa está totalmente completo, executável e cobre todas as funcionalidades e formatos de entrada/saída exigidos. A leitura de entrada é robusta para processamento linha a linha.
Qualidade do codigo
Peso 20%O código é bem estruturado, usa nomes de variáveis claros e inclui comentários úteis. Ele aproveita o módulo `bisect` para pesquisa binária eficiente e Pythonic, contribuindo para um código mais limpo e de fácil manutenção.
Valor pratico
Peso 15%A solução usa estruturas de dados eficientes (dicionário de listas de tuplas) e algoritmos (pesquisa binária) para consultas históricas, tornando-a escalável. Seu tratamento robusto de entrada e verificações abrangentes de erros aprimoram sua utilidade prática.
Seguimento de instrucoes
Peso 10%A solução segue meticulosamente todas as instruções explícitas, incluindo regras de versionamento, formatos de saída e considerações de eficiência. Também interpreta corretamente os requisitos implícitos, como o tratamento de versões não positivas como inválidas.
Pontuacao total
Comentario geral
A Resposta A é um programa executável completo e captura o modelo principal de histórico versionado para SET, DELETE, GET, GET_VERSION e HISTORY. Sua semântica está em grande parte alinhada com o prompt, incluindo versionamento global e registro de exclusões. No entanto, sua implementação GET_VERSION reconstrói uma lista de números de versão a cada consulta, o que adiciona sobrecarga desnecessária e prejudica a escalabilidade para a configuração de entrada grande declarada. Ele também trata versões não positivas como inválidas, o que é razoável, mas não explicitamente exigido além de as versões serem inteiros positivos. No geral, está correto em casos típicos, mas menos eficiente do que o esperado para consultas históricas intensivas.
Ver detalhes da avaliacao ▼
Correcao
Peso 35%A lógica para SET, DELETE, GET, GET_VERSION e HISTORY está em grande parte correta, incluindo versões globais e marcadores de exclusão. As consultas históricas retornam o estado mais recente em ou antes da versão solicitada, e versões futuras inválidas são tratadas. A principal ressalva de correção não é funcional em casos normais, mas está ligada a suposições de tratamento de borda e estilo de implementação de consulta.
Completude
Peso 20%A resposta fornece um programa completo e funcional de arquivo único, lê a entrada padrão, escreve na saída padrão e cobre todos os comandos e saídas necessários. Ele também inclui o comportamento histórico necessário e o histórico de afetação direta apenas. Está completo para a tarefa, com apenas uma ambiguidade menor de caso de borda em torno de versões não positivas inválidas.
Qualidade do codigo
Peso 20%O código é legível e razoavelmente organizado, com comentários claros e fluxo de controle direto. No entanto, a construção de uma lista de versões nova dentro de cada chamada GET_VERSION é uma fraqueza de design evitável, e a impressão linha por linha é menos otimizada para saída intensiva. A qualidade é sólida, mas não especialmente forte para um benchmark sensível ao desempenho.
Valor pratico
Peso 15%O programa funcionará para muitas entradas comuns, mas chamadas repetidas de GET_VERSION em históricos grandes incorrerão em sobrecarga extra pela reconstrução de arrays de versão a cada vez. Isso o torna menos adequado para a carga de trabalho de alto volume descrita no prompt. É prático como uma linha de base, mas não ideal para as restrições do benchmark.
Seguimento de instrucoes
Peso 10%A resposta segue a instrução de fornecer código executável completo e adere estritamente à semântica de comando e formato de saída especificados. Respeita o versionamento global e a criação de versão apenas por mutação. O tratamento de borda menor em torno de versões inválidas não prejudica materialmente a conformidade.