Respuesta A: OpenAI GPT-5.4
import re from collections import defaultdict def analyze_logs(log_data): """ Analiza una cadena de registro multilínea y devuelve un diccionario resumen con: - counts_by_level: recuentos de entradas de registro por nivel de registro en mayúsculas - successful_logins: nombres de usuario únicos que iniciaron sesión correctamente - failed_login_ips: recuentos de intentos de inicio de sesión fallidos por dirección IP Se ignoran las líneas mal formadas o irrelevantes. """ counts_by_level = defaultdict(int) successful_logins = set() failed_login_ips = defaultdict(int)...
Mostrar respuesta completa ▼
import re from collections import defaultdict def analyze_logs(log_data): """ Analiza una cadena de registro multilínea y devuelve un diccionario resumen con: - counts_by_level: recuentos de entradas de registro por nivel de registro en mayúsculas - successful_logins: nombres de usuario únicos que iniciaron sesión correctamente - failed_login_ips: recuentos de intentos de inicio de sesión fallidos por dirección IP Se ignoran las líneas mal formadas o irrelevantes. """ counts_by_level = defaultdict(int) successful_logins = set() failed_login_ips = defaultdict(int) # Coincide con líneas como: [TIMESTAMP] LEVEL: MESSAGE log_line_pattern = re.compile( r"^\s*\[(?P<timestamp>[^\]]+)\]\s+(?P<level>[A-Za-z]+)\s*:\s*(?P<message>.*)$" ) # Ejemplo de inicio de sesión exitoso: User 'alice' logged in from IP '192.168.1.10' success_pattern = re.compile( r"User\s+'([^']+)'\s+logged\s+in\b", re.IGNORECASE, ) # Ejemplo de inicio de sesión fallido: Failed login attempt for user 'bob' from IP '203.0.113.5' failed_pattern = re.compile( r"Failed\s+login\s+attempt\s+for\s+user\s+'[^']+'\s+from\s+IP\s+'([^']+)'", re.IGNORECASE, ) if not isinstance(log_data, str): return { "counts_by_level": {}, "successful_logins": [], "failed_login_ips": {}, } for line in log_data.splitlines(): line = line.strip() if not line: continue match = log_line_pattern.match(line) if not match: continue level = match.group("level").upper() message = match.group("message") counts_by_level[level] += 1 success_match = success_pattern.search(message) if success_match: successful_logins.add(success_match.group(1)) failed_match = failed_pattern.search(message) if failed_match: failed_login_ips[failed_match.group(1)] += 1 return { "counts_by_level": dict(counts_by_level), "successful_logins": sorted(successful_logins), "failed_login_ips": dict(failed_login_ips), } # Ejemplo de uso: if __name__ == "__main__": sample_logs = """ [2023-10-27T10:00:00Z] INFO: Server starting up. [2023-10-27T10:01:00Z] INFO: User 'alice' logged in from IP '192.168.1.10' [2023-10-27T10:02:30Z] WARN: Failed login attempt for user 'bob' from IP '203.0.113.5' This is not a valid log line and should be ignored. [2023-10-27T10:03:00Z] error: Database connection failed. [2023-10-27T10:05:00Z] INFO: User 'alice' accessed resource '/dashboard' [2023-10-27T10:06:00Z] WARN: Failed login attempt for user 'eve' from IP '203.0.113.5' [2023-10-27T10:07:00Z] INFO: User 'charlie' logged in from IP '198.51.100.2'""" print(analyze_logs(sample_logs))
Resultado
Votos ganadores
3 / 3
Puntuacion media
Puntuacion total
Comentario general
La Respuesta A proporciona una solución muy robusta y bien diseñada. Implementa correctamente toda la lógica de análisis, maneja la insensibilidad a mayúsculas y minúsculas para los niveles de registro y utiliza `re.IGNORECASE` para el análisis de mensajes, lo que la hace resistente a las variaciones. El uso de `defaultdict` y `set` es eficiente y pythónico. También incluye una verificación del tipo de entrada y ordena los inicios de sesión exitosos para una salida coherente, lo que demuestra atención al detalle y las mejores prácticas.
Ver detalle de evaluacion ▼
Correccion
Peso 35%La Respuesta A es completamente correcta, analiza con precisión todos los componentes del registro y agrega datos según sea necesario. Maneja correctamente la insensibilidad a mayúsculas y minúsculas para los niveles de registro y utiliza `re.IGNORECASE` para los patrones de mensajes, lo que garantiza una coincidencia robusta.
Integridad
Peso 20%La Respuesta A implementa completamente todas las características requeridas, incluido el análisis robusto de las líneas de registro, el conteo de niveles sin distinción entre mayúsculas y minúsculas y la extracción precisa de los detalles de inicio de sesión exitosos/fallidos. También incluye una verificación del tipo de entrada para una mayor completitud.
Calidad del codigo
Peso 20%La Respuesta A demuestra una excelente calidad de código. Utiliza `defaultdict` y `set` para una agregación de datos eficiente, `re.compile` para la eficiencia de las expresiones regulares, grupos nombrados para la legibilidad y `re.IGNORECASE` para una coincidencia de patrones robusta. El código está limpio, bien estructurado e incluye una útil cadena de documentación.
Valor practico
Peso 15%La Respuesta A tiene un alto valor práctico debido a su diseño robusto. Puede manejar varios formatos de líneas de registro, incluidas variaciones de mayúsculas y minúsculas en los mensajes, y gestiona con gracia las líneas mal formadas y las entradas no de cadena, lo que la hace adecuada para escenarios de análisis de registros del mundo real.
Seguimiento de instrucciones
Peso 10%La Respuesta A sigue todas las instrucciones al pie de la letra. Maneja correctamente la insensibilidad a mayúsculas y minúsculas para los niveles de registro e ignora de manera robusta las líneas mal formadas. El uso de `re.IGNORECASE` para los patrones de mensajes, aunque no se indica explícitamente para los mensajes, se alinea con el requisito de 'robusto'. También utiliza estructuras de datos apropiadas y ordena la lista final para garantizar la coherencia.
Puntuacion total
Comentario general
Proporciona una implementación robusta y correcta con análisis claro basado en expresiones regulares, normalización de niveles sin distinción entre mayúsculas y minúsculas y omisión elegante de líneas mal formadas. Utiliza estructuras de datos apropiadas (defaultdict, set) y devuelve diccionarios simples. Pequeño detalle: devuelve logins exitosos ordenados (no requerido) e incluye un ejemplo de uso más allá de la función solicitada, pero no perjudica los requisitos principales.
Ver detalle de evaluacion ▼
Correccion
Peso 35%Extrae correctamente los niveles de registro en mayúsculas, los cuenta, encuentra los nombres de usuario únicos de los inicios de sesión exitosos y cuenta las IP de los inicios de sesión fallidos; los patrones se alinean con la indicación y manejan variaciones de mayúsculas y minúsculas en los mensajes.
Integridad
Peso 20%Cubre todas las salidas requeridas e ignora explícitamente las líneas mal formadas; también maneja la entrada no cadena devolviendo un resumen con forma vacía.
Calidad del codigo
Peso 20%Bien estructurado con expresiones regulares con nombre y compiladas y colecciones apropiadas; legible y mantenible. Ligera extralimitación con un bloque principal de ejemplo adicional y ordenación innecesaria de nombres de usuario (aunque inofensivo).
Valor practico
Peso 15%Práctico para registros reales: maneja variantes de mayúsculas y minúsculas, líneas mal formadas y entradas no cadena de forma segura; procesamiento de una sola pasada y estructuras de datos sensatas.
Seguimiento de instrucciones
Peso 10%Implementa la función y el comportamiento solicitados, incluida la interpretación de niveles sin distinción entre mayúsculas y minúsculas y la omisión elegante de líneas mal formadas; devuelve las claves requeridas. Añade un ejemplo de uso pero no entra en conflicto con los requisitos.
Puntuacion total
Comentario general
La respuesta A es una solución bien estructurada, correcta y robusta. Utiliza grupos nombrados en expresiones regulares para mayor legibilidad, defaultdict para un conteo más limpio, compila patrones de expresiones regulares fuera del bucle para mayor eficiencia, incluye validación del tipo de entrada, ordena la lista successful_logins para una salida determinista, convierte defaultdicts a diccionarios regulares para una salida limpia, e incluye una cadena de documentación completa y un ejemplo de uso. El uso de re.IGNORECASE en los patrones de inicio de sesión añade robustez adicional. El código es limpio y está listo para producción.
Ver detalle de evaluacion ▼
Correccion
Peso 35%Produce resultados correctos para la entrada de ejemplo y maneja bien los casos extremos. Los patrones de expresiones regulares están bien elaborados con grupos nombrados y banderas de insensibilidad a mayúsculas y minúsculas. La validación del tipo de entrada añade corrección para entradas inesperadas.
Integridad
Peso 20%Maneja todas las características requeridas: counts_by_level, successful_logins (únicos, ordenados), failed_login_ips. También maneja entradas no de tipo cadena con gracia, líneas vacías y líneas mal formadas. Incluye ejemplo de uso con bloque __main__.
Calidad del codigo
Peso 20%Excelente calidad de código: patrones de expresiones regulares compilados para eficiencia, grupos nombrados para legibilidad, defaultdict para conteo limpio, cadena de documentación completa, salida ordenada para determinismo, conversión adecuada de defaultdicts a diccionarios regulares y separación limpia de responsabilidades.
Valor practico
Peso 15%Altamente práctico: validación de entrada robusta, salida ordenada determinista, expresiones regulares compiladas eficientes y ejemplo de uso lo hacen listo para uso en producción. Las banderas re.IGNORECASE en los patrones de inicio de sesión añaden robustez en el mundo real.
Seguimiento de instrucciones
Peso 10%Sigue todas las instrucciones con precisión: firma de función correcta, formato de salida correcto con las tres claves, niveles de análisis insensibles a mayúsculas y minúsculas almacenados en mayúsculas, nombres de usuario únicos como lista, manejo con gracia de líneas mal formadas y uso de expresiones regulares como se recomendó.