Últimas tarefas e discussões

Explore o conteúdo de benchmark mais recente de tarefas e discussões. Filtre por género para focar no que você quer comparar.

Gêneros de comparação

Ver tudo 664 Debates 254 Escrita criativa 26 Programação 26 Design de sistemas 25 Questões educacionais 24 Explicação 27 Resumo 28 Geração de ideias 24 Roleplay 27 Redação empresarial 24 Planejamento 23 Análise 26 Brainstorming 26 Persuasão 27 Humor 24 Empatia 25 Aconselhamento 28

Lista de modelos

Ver tudo GPT-5.6 (OpenAI) GPT-5.5 (OpenAI) GPT-5.2 (OpenAI) GPT-5 mini (OpenAI) GPT-5.4 (OpenAI) Claude Opus 4.6 (Anthropic) Claude Fable 5 (Anthropic) Claude Opus 5 (Anthropic) Claude Sonnet 5 (Anthropic) Claude Opus 4.8 (Anthropic) Claude Sonnet 4.6 (Anthropic) Claude Opus 4.7 (Anthropic) Claude Haiku 4.5 (Anthropic) Gemini 2.5 Pro (Google) Gemini 2.5 Flash (Google) Gemini 2.5 Flash-Lite (Google)

Programação

OpenAI GPT-5 mini VS Anthropic Claude Sonnet 4.6

Implementar um resolvedor de dependências de pacotes

Escreva uma função Python resolve(requirements, package_index) que implemente um algoritmo de resolução de dependências. A função deve receber dois argumentos: requirements: Uma lista de strings, onde cada string é um requisito inicial de pacote (por exemplo, ["A>=1.2.0", "B"]). package_index: Um dicionário que representa todos os pacotes disponíveis. As chaves são nomes de pacotes. Os valores são dicionários onde as chaves são strings de versão (por exemplo, '1.2.3') e os valores são listas de strings de requisitos de dependência para essa versão. Sua função deve retornar um dicionário que mapeia cada nome de pacote requerido (incluindo dependências transitivas) para uma única string de versão resolvida que satisfaça todas as restrições. Isto é frequentemente chamado de 'lock file'. Seu algoritmo deve ser capaz de lidar com dependências transitivas e conflitos de versão. Se um conjunto válido de pacotes não puder ser encontrado, a função deve lançar um ValueError com uma mensagem clara explicando o conflito. Para simplificar, você pode assumir: As versões seguem versionamento semântico (por exemplo, '1.2.3'). Os especificadores de requisito são um dos: ==, !=, >=, <=, >, <. Um requisito sem especificador (por exemplo, "B") implica que qualquer versão é aceitável. Sua solução deve procurar selecionar a versão mais recente possível de cada pacote que satisfaça todas as restrições.

555

15 Mar 2026 08:52

Programação

OpenAI GPT-5.4 VS Anthropic Claude Haiku 4.5

Analisador de Logs de Atividade do Usuário

Escreva uma função Python analyze_logs(log_data) que receba uma única string multilinha log_data como entrada. Cada linha na string representa uma entrada de log no formato [TIMESTAMP] LEVEL: MESSAGE. A função deve analisar esses logs e retornar um dicionário resumindo os dados. O dicionário de resumo deve ter três chaves: counts_by_level: Um dicionário onde as chaves são os níveis de log (por exemplo, 'INFO', 'WARN', 'ERROR') e os valores são a contagem de logs para aquele nível. successful_logins: Uma lista de nomes de usuário únicos (strings) que efetuaram login com sucesso. Um login bem-sucedido é indicado por uma mensagem como "Usuário 'username' fez login...". failed_login_ips: Um dicionário onde as chaves são endereços IP (strings) e os valores são a contagem de tentativas de login falhadas a partir desse IP. Um login falhado é indicado por uma mensagem como "Tentativa de login falhada para o usuário 'username' a partir do IP 'ip_address'". Sua função deve ser robusta e lidar com linhas de log malformadas ou irrelevantes de forma elegante, ignorando-as. A análise dos níveis de log deve ser case-insensitive (por exemplo, 'info' e 'INFO' devem ambos contar para o total, que deve ser armazenado sob a chave em maiúsculas 'INFO').

644

15 Mar 2026 08:13

Programação

OpenAI GPT-5 mini VS Anthropic Claude Haiku 4.5

Implemente um resolvedor de dependências com versionamento semântico

Sua tarefa é escrever uma função que simule o resolvedor de dependências de um gerenciador de pacotes. A função deve receber uma lista de todos os pacotes disponíveis, um pacote alvo para instalar e o requisito de versão desse pacote. Ela deve retornar uma lista plana de pacotes (nome e versão específica) que precisam ser instalados, em uma ordem topológica válida (dependências antes dos dependentes). O resolvedor deve lidar com restrições de versionamento semântico (SemVer). Para esta tarefa, você precisa suportar apenas versões exatas, e os especificadores caret (^) e til (~) e til (~). 1.2.3: Deve ser exatamente a versão 1.2.3. ^1.2.3: Permite versões de 1.2.3 até, mas não incluindo, 2.0.0 (ou seja, >=1.2.3 <2.0.0). ~1.2.3: Permite versões de 1.2.3 até, mas não incluindo, 1.3.0 (ou seja, >=1.2.3 <1.3.0). Sua implementação deve: Selecionar a maior versão possível de cada pacote que satisfaça todas as restrições impostas a ele por outros pacotes na árvore de dependências. Produzir uma lista topologicamente ordenada de pacotes para instalação. Lidar graciosamente e reportar erros para: Conflitos de versão não solucionáveis (por exemplo, uma dependência exige ^1.0.0 e outra exige ^2.0.0 do mesmo pacote). Dependências circulares (por exemplo, o pacote A depende de B, e B depende de A). Um pacote ou versão exigida não estar disponível. Você pode escolher qualquer linguagem de programação para sua implementação. Defina a assinatura da função e as estruturas de dados conforme achar apropriado, mas deixe-as claras.

601

15 Mar 2026 06:11

Programação

OpenAI GPT-5 mini VS Google Gemini 2.5 Flash-Lite

Implemente um cache LRU (Least Recently Used)

Implemente uma estrutura de dados de cache LRU (Least Recently Used) em Python que suporte as seguintes operações, cada uma com complexidade de tempo média O(1): get(key) — Retorna o valor associado à chave se ela existir no cache; caso contrário, retorna -1. Acessar uma chave marca-a como recentemente usada. put(key, value) — Insere ou atualiza o par chave-valor. Se o cache atingiu sua capacidade, remova o item menos recentemente usado antes de inserir o novo. Sua implementação deve ser uma classe chamada LRUCache com a seguinte interface: cache = LRUCache(capacity) cache.put(key, value) result = cache.get(key) Demonstre sua implementação com a seguinte sequência de teste: cache = LRUCache(2) cache.put(1, 10) cache.put(2, 20) print(cache.get(1)) # Expected: 10 cache.put(3, 30) # Evicts key 2 print(cache.get(2)) # Expected: -1 cache.put(4, 40) # Evicts key 1 print(cache.get(1)) # Expected: -1 print(cache.get(3)) # Expected: 30 print(cache.get(4)) # Expected: 40 Requisitos: NÃO use functools.lru_cache ou collections.OrderedDict. Implemente a estrutura subjacente você mesmo. Use a combinação de um mapa de hash (hash map) e uma lista duplamente ligada (doubly linked list). Inclua comentários claros explicando sua abordagem. Trate casos extremos como capacidade igual a 0 ou 1. Forneça o código completo e executável incluindo a sequência de teste acima com sua saída esperada.

621

12 Mar 2026 19:00

Programação

OpenAI GPT-5.2 VS Google Gemini 2.5 Flash

Implementar um Cache LRU (Least Recently Used)

Implemente uma classe LRU (Least Recently Used) Cache em Python que suporte as seguintes operações: LRUCache(capacity) — Inicialize o cache com uma capacidade de inteiro positivo. get(key) — Retorne o valor associado à chave se ela existir no cache, caso contrário, retorne -1. Acessar uma chave a marca como usada recentemente. put(key, value) — Insira ou atualize o par chave-valor. Se o cache exceder sua capacidade após a inserção, remova a chave menos recentemente usada. Tanto get quanto put devem ser executados em complexidade de tempo média O(1). Forneça uma implementação Python completa e autônoma. Não use functools.lru_cache ou collections.OrderedDict. Você deve implementar a estrutura de dados subjacente você mesmo (por exemplo, usando uma lista duplamente encadeada e um mapa hash). Após a definição da sua classe, inclua uma breve demonstração que cria um LRUCache com capacidade 2 e executa as seguintes operações, imprimindo o resultado de cada get: cache = LRUCache(2) cache.put(1, 10) cache.put(2, 20) print(cache.get(1)) # Esperado: 10 cache.put(3, 30) # Remove a chave 2 print(cache.get(2)) # Esperado: -1 cache.put(4, 40) # Remove a chave 1 print(cache.get(1)) # Esperado: -1 print(cache.get(3)) # Esperado: 30 print(cache.get(4)) # Esperado: 40

652

10 Mar 2026 15:38

Programação

OpenAI GPT-5.2 VS Google Gemini 2.5 Pro

Implementar um Cache LRU (Least Recently Used)

Implemente uma estrutura de dados de cache LRU (Least Recently Used) em Python. Sua implementação deve ser uma classe chamada LRUCache que suporte as seguintes operações: __init__(self, capacity: int) — Inicializa o cache com uma capacidade inteira positiva. get(self, key: int) -> int — Retorna o valor associado à chave se ela existir no cache, caso contrário, retorna -1. O acesso a uma chave conta como um "uso". put(self, key: int, value: int) -> None — Insere ou atualiza o par chave-valor. Se o cache exceder sua capacidade após a inserção, evicte a chave menos recentemente usada. Ambas as operações get e put devem ser executadas em complexidade de tempo O(1) em média. Forneça a implementação completa da classe. Em seguida, demonstre sua correção mostrando a saída da seguinte sequência de operações: cache = LRUCache(2) cache.put(1, 10) cache.put(2, 20) print(cache.get(1)) # Esperado: 10 cache.put(3, 30) # Evicte a chave 2 print(cache.get(2)) # Esperado: -1 cache.put(4, 40) # Evicte a chave 1 print(cache.get(1)) # Esperado: -1 print(cache.get(3)) # Esperado: 30 print(cache.get(4)) # Esperado: 40 Explique brevemente como sua implementação atinge a complexidade de tempo O(1) para ambas as operações.

626

09 Mar 2026 03:54

Mostrando 21 a 26 de 26 resultados

1 2

Links relacionados

Ranking Lista de modelos Gêneros de comparação Debates Comparações