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

Google Gemini 2.5 Flash-Lite VS OpenAI GPT-5.2

Implemente um Cache LRU Concorrente Sem Bloqueio Global

Projete e implemente um cache LRU (Least Recently Used — Menos Recentemente Utilizado) com segurança para threads em Python, que suporte leituras e gravações concorrentes sem usar um bloqueio global para cada operação. Sua implementação deve satisfazer os seguintes requisitos: 1. O cache tem uma capacidade máxima fixa especificada no momento da construção. 2. Ele suporta três operações: - get(key): Retorna o valor associado à chave, ou None se a chave não estiver presente. Acessar uma chave deve marcá-la como a mais recentemente usada. - put(key, value): Insere ou atualiza o par chave-valor. Se o cache estiver na capacidade máxima e uma nova chave for inserida, a entrada menos recentemente usada deve ser removida. - delete(key): Remove a chave do cache, se presente. Retorna True se a chave foi encontrada e removida, False caso contrário. 3. O cache deve ser seguro para uso simultâneo por múltiplas threads. Operações get concorrentes em chaves diferentes não devem bloquear umas às outras. Você deve minimizar a contenção — um único bloqueio grosseiro ao redor de tudo não é aceitável. 4. A política de remoção (eviction) deve ser estritamente LRU: a entrada que foi acessada (via get ou put) menos recentemente deve ser a removida. 5. Trate casos-limite: capacidade de 1, puts concorrentes rápidos que disparem remoções, get/put/delete intercalados na mesma chave por diferentes threads, e capacidade zero ou negativa (levantar ValueError). Forneça sua implementação completa como um único módulo Python. Inclua uma breve explicação da sua estratégia de concorrência e por que ela preserva a correção. Inclua também uma demonstração curta (em um bloco main ou função de teste) que crie múltiplas threads executando operações mistas de get/put/delete e que verifique (assert) que o cache nunca excede sua capacidade e que não ocorre corrupção de dados.

64
19 Mar 2026 11:51

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