Respuesta A: Anthropic Claude Opus 4.6
class InMemoryDB: def __init__(self): self._main_store = {} self._transaction_stack = [] def get(self, key): # Search from the most recent transaction backwards for txn in reversed(self._transaction_stack): if key in txn: return txn[key] return self._main_store.get(key, None) def set(self, key, value): if self._transaction_stack: self._transaction_stack[-1][key] = value else: self._main_store[key] = value def begin(self): self._transaction_stack.append({}) def commit(self):...
Mostrar respuesta completa ▼
class InMemoryDB: def __init__(self): self._main_store = {} self._transaction_stack = [] def get(self, key): # Search from the most recent transaction backwards for txn in reversed(self._transaction_stack): if key in txn: return txn[key] return self._main_store.get(key, None) def set(self, key, value): if self._transaction_stack: self._transaction_stack[-1][key] = value else: self._main_store[key] = value def begin(self): self._transaction_stack.append({}) def commit(self): if not self._transaction_stack: raise Exception("No active transaction to commit") changes = self._transaction_stack.pop() if self._transaction_stack: # Merge into parent transaction self._transaction_stack[-1].update(changes) else: # Merge into main store self._main_store.update(changes) def rollback(self): if not self._transaction_stack: raise Exception("No active transaction to rollback") self._transaction_stack.pop() # Example usage if __name__ == "__main__": db = InMemoryDB() # No transaction print(db.get("a")) # Expected: None db.set("a", 10) print(db.get("a")) # Expected: 10 # Transaction db.begin() db.set("a", 20) print(db.get("a")) # Expected: 20 # Nested transaction db.begin() db.set("a", 30) print(db.get("a")) # Expected: 30 # Rollback nested db.rollback() print(db.get("a")) # Expected: 20 # Commit outer db.commit() print(db.get("a")) # Expected: 20 # Error cases try: db.commit() # No transaction active except Exception as e: print(f"Error: {e}")
Resultado
Votos ganadores
0 / 3
Puntuacion media
Puntuacion total
Comentario general
La respuesta A es una implementación correcta y bien estructurada de la clase InMemoryDB. Utiliza un enfoque basado en pilas con nombres de variables claros (_main_store, _transaction_stack). La lógica para get, set, begin, commit y rollback es correcta y maneja adecuadamente las transacciones anidadas. Lanza una excepción genérica para los casos de error, lo cual es funcional pero menos preciso semánticamente que usar RuntimeError o ValueError. Se incluye el uso de ejemplo y coincide con la salida esperada. En general, una solución sólida con pequeños defectos estilísticos.
Ver detalle de evaluacion ▼
Correccion
Peso 35%La respuesta A implementa correctamente todos los métodos. El método get busca en la pila de transacciones en orden inverso antes de recurrir al almacén principal. El método set escribe en la transacción actual o en el almacén principal según corresponda. Commit fusiona los cambios hacia arriba correctamente. Rollback descarta la transacción actual. Todos los escenarios de transacciones anidadas se manejan correctamente.
Integridad
Peso 20%La respuesta A implementa los cinco métodos requeridos (get, set, begin, commit, rollback) e incluye el uso completo del ejemplo de la consigna. Se manejan los casos de error. No hay funcionalidad faltante.
Calidad del codigo
Peso 20%La respuesta A utiliza nombres de variables claros y una estructura lógica. Sin embargo, lanza una excepción genérica para los casos de error en lugar de un tipo de excepción más específico como RuntimeError o ValueError, lo cual es un problema menor de calidad de código. El código es por lo demás limpio y legible.
Valor practico
Peso 15%La respuesta A es prácticamente útil como implementación de referencia. El uso del ejemplo demuestra todos los escenarios clave. La excepción genérica es una preocupación práctica menor, ya que los llamadores pueden querer capturar tipos de excepción específicos.
Seguimiento de instrucciones
Peso 10%La respuesta A sigue todas las instrucciones: implementa la clase requerida y los cinco métodos, maneja transacciones anidadas, lanza errores para commit/rollback sin transacciones activas e incluye el uso del ejemplo de la consigna.
Puntuacion total
Comentario general
Implementa la API requerida con una pila de transacciones clara y un comportamiento correcto de anidamiento de begin/commit/rollback para semántica simple de set/get. La lógica de resolución de claves desde la transacción más reciente hasta la tienda principal es sólida. Los problemas menores se centran principalmente en la robustez y el pulido: genera un tipo de excepción genérico y no hay orientación explícita ni manejo para la semántica de eliminación (no requerida) o para distinguir un None explícitamente establecido de uno faltante (no requerido pero a veces relevante).
Ver detalle de evaluacion ▼
Correccion
Peso 35%Soporta correctamente begin/commit/rollback anidados a través de una pila de diccionarios; get busca de interior a exterior; commit se fusiona en el padre o en la tienda principal; rollback descarta los cambios actuales. No hay errores funcionales para las operaciones especificadas.
Integridad
Peso 20%Implementa todos los métodos requeridos e incluye un uso de ejemplo que demuestra transacciones anidadas y casos de error. No aborda comportamientos opcionales como eliminaciones (no solicitado).
Calidad del codigo
Peso 20%Legible y directo, con nombres de miembros claros; un pequeño inconveniente es el uso genérico de Exception y una ligera verbosidad adicional (valor predeterminado explícito de None en get).
Valor practico
Peso 15%Práctico para uso básico de KV transaccional; carece de extras como tipos de excepción personalizados, marcadores de eliminación o introspección de transacciones, pero eso está más allá de la indicación.
Seguimiento de instrucciones
Peso 10%Sigue la interfaz y el comportamiento solicitados, incluidas las transacciones anidadas y la generación de un error al confirmar/revertir sin una transacción activa.
Puntuacion total
Comentario general
La respuesta A proporciona una implementación completa y funcional de la base de datos en memoria. La lógica para manejar transacciones anidadas es sólida y el código es limpio y legible, con nombres de variables particularmente descriptivos como `_transaction_stack`. Su principal debilidad es el uso de la `Exception` genérica para el manejo de errores, lo cual generalmente se desaconseja en favor de tipos de excepción más específicos.
Ver detalle de evaluacion ▼
Correccion
Peso 35%La implementación es completamente correcta. La lógica para `get`, `set`, `commit` y `rollback` maneja correctamente las transacciones anidadas buscando a través de la pila de transacciones en el orden correcto y fusionando/descartando los cambios apropiadamente.
Integridad
Peso 20%La respuesta está completa, implementando los cinco métodos requeridos: `get`, `set`, `begin`, `commit` y `rollback`.
Calidad del codigo
Peso 20%El código es limpio y legible. Los nombres de las variables, especialmente `_transaction_stack`, son muy descriptivos. El único inconveniente menor es el uso de la clase genérica `Exception` para el manejo de errores.
Valor practico
Peso 15%La solución proporciona una implementación buena y clara de un patrón común de estructura de datos. Es un valioso ejemplo educativo, aunque carece de características como control de concurrencia para uso en producción.
Seguimiento de instrucciones
Peso 10%La respuesta sigue perfectamente todas las instrucciones. Implementa la clase y los métodos especificados, maneja la lógica como se describe e incluye el bloque de ejemplo de uso.