Resposta A: Anthropic Claude Sonnet 5
import re
from collections import Counter
from datetime import datetime
def analyze_logs(log_data):
result = {
"total_requests": 0,
"error_rate": 0.0,
"top_3_ips": [],
"busiest_hour": None
}
if not log_data or not log_data.strip():
return result
log_pattern = re.compile(
r'^\['(?P<timestamp>[^\]]+)\]\s+'
r'(?P<level>\w+)\s+'
r'(?P<ip>\d{1,3}(?:\.\d{1,3}){3})\s+'
r'"(?P<method>[A-Z]+)\s+(?P<path>\S+)"\s+'
r'(?P<status>\d{3})\s+'
r'(?P<bytes>\d+)\s*$'
)
total_requests = 0
error_count = 0
ip_c...
Mostrar resposta completa ▼
import re
from collections import Counter
from datetime import datetime
def analyze_logs(log_data):
result = {
"total_requests": 0,
"error_rate": 0.0,
"top_3_ips": [],
"busiest_hour": None
}
if not log_data or not log_data.strip():
return result
log_pattern = re.compile(
r'^\['(?P<timestamp>[^\]]+)\]\s+'
r'(?P<level>\w+)\s+'
r'(?P<ip>\d{1,3}(?:\.\d{1,3}){3})\s+'
r'"(?P<method>[A-Z]+)\s+(?P<path>\S+)"\s+'
r'(?P<status>\d{3})\s+'
r'(?P<bytes>\d+)\s*$'
)
total_requests = 0
error_count = 0
ip_counter = Counter()
hour_counter = Counter()
for line in log_data.splitlines():
line = line.strip()
if not line:
continue
match = log_pattern.match(line)
if not match:
continue
data = match.groupdict()
timestamp_str = data["timestamp"]
try:
ts_clean = timestamp_str.replace("Z", "+00:00")
dt = datetime.fromisoformat(ts_clean)
except ValueError:
continue
level = data["level"].upper()
ip = data["ip"]
total_requests += 1
ip_counter[ip] += 1
hour_counter[dt.hour] += 1
if level == "ERROR":
error_count += 1
if total_requests == 0:
return result
error_rate = round((error_count / total_requests) * 100, 2)
top_3_ips = ip_counter.most_common(3)
busiest_hour = None
if hour_counter:
busiest_hour = max(hour_counter.items(), key=lambda x: x[1])[0]
result["total_requests"] = total_requests
result["error_rate"] = error_rate
result["top_3_ips"] = top_3_ips
result["busiest_hour"] = busiest_hour
return result
if name == "main":
sample_log_data = '''[2023-10-27T10:00:00Z] INFO 192.168.1.1 "GET /index.html" 200 1543
[2023-10-27T10:00:05Z] INFO 192.168.1.2 "GET /styles.css" 200 5421
[2023-10-27T10:00:06Z] ERROR 192.168.1.1 "POST /api/login" 500 120
This is a malformed line and should be ignored.
[2023-10-27T10:01:10Z] INFO 203.0.113.45 "GET /about" 200 2345
[2023-10-27T10:01:15Z] WARN 192.168.1.1 "GET /favicon.ico" 404 150
[2023-10-27T11:05:20Z] INFO 198.51.100.8 "GET /" 200 1600
[2023-10-27T11:05:22Z] ERROR 198.51.100.8 "POST /data" 503 100
[2023-10-27T11:15:00Z] INFO 192.168.1.2 "GET /images/logo.png" 200 8765'''
analysis_result = analyze_logs(sample_log_data)
print(analysis_result)
# Expected output for this sample:
# {
# 'total_requests': 8,
# 'error_rate': 25.0,
# 'top_3_ips': [('192.168.1.1', 3), ('192.168.1.2', 2), ('203.0.113.45', 1)],
# 'busiest_hour': 10
# }
print(analyze_logs(""))
# {'total_requests': 0, 'error_rate': 0.0, 'top_3_ips': [], 'busiest_hour': None}
Resultado
Votos de vitória
1 / 3
Pontuação média
Pontuação total
Comentário geral
A Resposta A entrega uma solução de passagem única totalmente correta que corresponde a todas as métricas esperadas nos dados de exemplo, lida graciosamente com entrada vazia e linhas malformadas e, importante, inclui uma demonstração executável com o log de exemplo exato do contexto da tarefa, além da saída esperada documentada. O código é limpo e idiomático com grupos de regex nomeados e Counter, embora falte uma docstring, permita octetos IPv4 numericamente inválidos na regex e o padrão de mutação do dicionário de resultados seja um pouco verboso.
Ver detalhes da avaliação ▼
Correção
Peso 35%Produz exatamente os resultados esperados na entrada de exemplo (total_requests 8, error_rate 25.0, ordenação correta do top 3 de IPs, busiest_hour 10). A regex filtra corretamente linhas malformadas, a entrada vazia retorna valores zerados e os timestamps são analisados com a conversão adequada de Z para offset. Ponto fraco menor: a regex de IP aceita octetos numericamente inválidos como 999.999.999.999, embora isso não afete os dados fornecidos.
Completude
Peso 20%Cobre todas as quatro métricas, todos os casos extremos listados (entrada vazia, menos de 3 IPs via most_common, tratamento de empates) e, adicionalmente, inclui uma demonstração executável usando o log de exemplo exato do contexto da tarefa com a saída esperada documentada, além de uma verificação de string vazia.
Qualidade do código
Peso 20%Código limpo e legível com grupos de regex nomeados, uso de Counter e um loop de passagem única. Ligeiramente verboso em alguns pontos: o dicionário de resultados é inicializado e depois mutado no final, não há docstring e o cálculo da hora de pico via max em itens é um pouco indireto em comparação com os idiomas do Counter. No geral, um estilo PEP 8 sólido.
Valor prático
Peso 15%Imediatamente executável e autoverificável graças ao bloco __main__ com os dados de exemplo exatos e a saída esperada documentada, o que o torna muito prático para adoção e teste. A eficiência é boa: passagem única, regex compilada.
Seguimento de instruções
Peso 10%Segue todas as instruções: assinatura de função exata, todas as métricas, tratamento gracioso de linhas malformadas, casos extremos e usa explicitamente a entrada de exemplo fornecida do contexto da tarefa, conforme solicitado. A estrutura de retorno corresponde exatamente à especificação.
Pontuação total
Comentário geral
A Resposta A fornece uma implementação sólida que lida corretamente com a entrada de exemplo, ignora muitas linhas malformadas, calcula todas as métricas necessárias e usa estruturas apropriadas como Counter. Sua principal fraqueza é que sua validação é um tanto frouxa: aceita octetos de IP inválidos, caminhos que não começam com '/', códigos de resposta arbitrários de três dígitos e alguns timestamps não UTC ou mal formatados como válidos. O código de demonstração incluído é inofensivo, mas não é necessário para a função solicitada.
Ver detalhes da avaliação ▼
Correção
Peso 35%A Resposta A retorna os resultados corretos para o exemplo e calcula corretamente as requisições totais, a taxa de erro, os IPs principais e a hora de pico para entradas normais. No entanto, pode tratar incorretamente linhas malformadas como válidas porque não valida intervalos de octetos de IP, requer apenas qualquer timestamp entre colchetes analisável por fromisoformat, aceita caminhos que não começam com ' ' e permite qualquer código de resposta de três dígitos.
Completude
Peso 20%A Resposta A implementa todas as chaves de saída necessárias e lida com entrada vazia, menos de três IPs únicos, linhas malformadas e zero requisições válidas. É completa para a tarefa principal, embora sua detecção de linhas malformadas seja menos abrangente do que o ideal.
Qualidade do código
Peso 20%A Resposta A é legível, usa Counter apropriadamente e tem nomes de variáveis claros. A regex e o fluxo de controle são compreensíveis. A validação é menos disciplinada e o código de exemplo/teste incorporado torna a resposta um pouco menos focada como uma função submetida.
Valor prático
Peso 15%A Resposta A funcionaria bem para muitos logs comuns e é eficiente com uma única passagem de análise. No uso prático, no entanto, a validação frouxa de IP e requisição poderia inflar as contagens ao aceitar linhas que deveriam ser ignoradas.
Seguimento de instruções
Peso 10%A Resposta A segue a assinatura da função solicitada e retorna o dicionário necessário. Inclui código de exemplo extra no bloco principal, o que não é proibido, mas é mais do que o código solicitado. Sua interpretação de linhas válidas é ligeiramente mais permissiva do que o formato do prompt.
Pontuação total
Comentário geral
A Resposta A fornece uma solução correta e eficiente que atende a todos os requisitos da solicitação. Ela usa corretamente collections.Counter para agregação e processa os logs em uma única passagem. No entanto, sua análise é um tanto frágil; por exemplo, a regex para endereços IP aceitaria valores inválidos (por exemplo, 999.0.0.1). A qualidade do código é boa, mas poderia ser melhorada definindo o padrão regex fora da função como uma constante.
Ver detalhes da avaliação ▼
Correção
Peso 35%A função produz a saída correta para os dados de amostra fornecidos e lida com os casos de borda especificados. A lógica é sólida e resolve diretamente o problema.
Completude
Peso 20%A solução está totalmente completa, implementando todas as quatro métricas exigidas (`total_requests`, `error_rate`, `top_3_ips`, `busiest_hour`) e lidando com todos os casos de borda especificados.
Qualidade do código
Peso 20%O código é limpo e legível, usando estruturas de dados apropriadas como `Counter`. No entanto, a expressão regular é recompilada a cada chamada de função, o que é ineficiente. Também falta uma docstring.
Valor prático
Peso 15%A solução é funcional, mas tem valor prático limitado devido à sua análise frágil. A regex de endereço IP não é rigorosa o suficiente e aceitaria IPs inválidos como `300.1.1.1`, tornando-a não confiável com dados do mundo real.
Seguimento de instruções
Peso 10%A resposta segue perfeitamente todas as instruções, retornando os dados no formato de dicionário especificado e lidando com todos os requisitos.