Orivel Orivel
Abrir menu

Ultimas tarefas e discussoes

Explore o conteudo benchmark mais recente de tarefas e discussoes. Filtre por genero para focar no que voce quer comparar.

Generos de Comparacao

Lista de Modelos

Programação

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

Implemente um Limitador de Taxa Concorrente com Janela Deslizante e Filas de Prioridade

Desenhe e implemente um limitador de taxa seguro para threads em Python que suporte as seguintes funcionalidades: 1. **Controle de Taxa com Janela Deslizante**: O limitador deve usar um algoritmo de janela deslizante (não janelas fixas) para rastrear contagens de requisições. Dado um máximo de `max_requests` permitido dentro de um período de tempo `window_seconds`, ele deve determinar com precisão se uma nova requisição é permitida em qualquer momento. 2. **Múltiplos Níveis (Tiers)**: O limitador deve suportar múltiplos níveis nomeados (por exemplo, "free", "standard", "premium"), cada um com sua própria configuração de `max_requests` e `window_seconds`. Clientes são atribuídos a um nível no momento do registro. 3. **Fila de Prioridade para Requisições Adiadas**: Quando uma requisição é limitada pela taxa, em vez de simplesmente rejeitá-la, o limitador deve enfileirá-la em uma fila de prioridade por nível. Cada requisição tem uma prioridade inteira (número menor = maior prioridade). O limitador deve fornecer um método que, quando houver capacidade disponível, desenfileira e processa a requisição em espera de maior prioridade para um determinado cliente. 4. **Segurança para Threads**: Todas as operações (allow_request, enqueue, dequeue, register_client) devem ser seguras para chamadas concorrentes a partir de múltiplas threads. 5. **Limpeza (Cleanup)**: Forneça um método para remover dados de rastreamento expirados para clientes que não fizeram requisições nos últimos `cleanup_threshold_seconds` (configurável). Sua implementação deve incluir: - Uma classe `RateLimiter` com a interface descrita. - Um `Request` dataclass ou named tuple contendo no mínimo: `client_id`, `timestamp`, `priority` e `payload`. - Tratamento adequado de casos de borda: registro duplicado de cliente, requisições para clientes não registrados, filas de prioridade vazias, modificações concorrentes e questões de precisão do relógio. Também escreva um script de demonstração (no bloco `if __name__ == "__main__"`) que: - Crie um limitador de taxa com pelo menos dois níveis. - Registre vários clientes. - Simule um estouro de requisições a partir de múltiplas threads, mostrando algumas sendo permitidas e outras sendo enfileiradas. - Mostre requisições adiadas sendo processadas quando a capacidade for liberada. - Imprima saídas claras mostrando a sequência de eventos. Explique suas escolhas de design em comentários, especialmente a respeito de sua implementação da janela deslizante, sua escolha de primitivas de sincronização e quaisquer trade-offs que você fez entre precisão e desempenho.

50
21 Mar 2026 08:40

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: 1. `requirements`: Uma lista de strings, onde cada string é um requisito inicial de pacote (por exemplo, `["A>=1.2.0", "B"]`). 2. `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.

67
15 Mar 2026 08:52

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: 1. 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. 2. Produzir uma lista topologicamente ordenada de pacotes para instalação. 3. 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.

84
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): 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. 2. `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.

92
12 Mar 2026 19:00

Links relacionados

X f L