Orivel Orivel
Abrir menú

Programación

Compara la corrección, la calidad y la utilidad práctica del código generado.

Instantánea 2026-W42 Resultados a 2026-10-16

6 modelos respondieron las mismas 16 tareas. Los mismos jueces (Claude Opus 5.5 / GPT-6.1 Sol / Gemini 3.8 Flash) puntuaron cada respuesta sobre 10, y la puntuación mostrada es la media de los 3 jueces.

Este género tiene una sola tarea, así que el orden de abajo es el resultado de esta tarea, no una clasificación de los modelos en este género. La clasificación general usa las 16 tareas.

De un vistazo

Resultados de esta tarea

Asignación de stock FEFO con pedidos de todo o nada

Puesto Modelo Media (sobre 10)
1 GPT-6.1 Sol 9.74
2 Claude Sonnet 5.5 9.73
3 GPT-6 Luna 9.66
4 Claude Opus 5.5 9.60
5 Gemini 3.8 Flash 9.12
6 Gemini 3.5 Flash-Lite 8.89
Colores de la nota ≥ 9 8–9 7–8 6–7 5–6 < 5

Diferencia entre la media más alta y la más baja: 0.85 puntos.

La tarea

Asignación de stock FEFO con pedidos de todo o nada

Instrucciones

Escribe una función de Python 3 allocate(lots, orders) para un pequeño almacén de alimentos que siempre despacha primero el stock con vencimiento más próximo.

Entradas:

  • lots: una lista de diccionarios {"id": str, "qty": int, "expires": int}. expires es el último número de día en el que el lote todavía puede despacharse.
  • orders: una lista de diccionarios {"id": str, "day": int, "qty": int} con una clave opcional "all_or_nothing": bool (por defecto False). La lista no está necesariamente ordenada por día.

Requisitos:

  1. Procesa los pedidos en orden ascendente de day; los pedidos con el mismo día se procesan en el orden en que aparecen en la lista de entrada.
  2. Para un pedido del día d, un lote solo es utilizable si expires >= d y todavía tiene stock. Toma stock de los lotes utilizables en orden ascendente de expires, desempatando por id de lote ascendente (comparación de cadenas simple), hasta que el pedido se complete o se agote el stock utilizable.
  3. Un pedido normal puede completarse parcialmente. Un pedido all_or_nothing cuya cantidad supere el stock utilizable total en su día no recibe nada, y ese stock sigue disponible para pedidos posteriores.
  4. Devuelve un diccionario con exactamente tres claves: "fills" asigna cada id de pedido a una lista de tuplas (lot_id, qty) en el orden en que se tomó el stock (una lista vacía si no se asignó nada); "short" asigna solo los ids de pedido cuya cantidad no cubierta es mayor que 0 a esa cantidad; "remaining" asigna cada id de lote a su stock final.
  5. Lanza ValueError antes de asignar nada si algún lote o pedido tiene un qty negativo, o si algún id de lote o id de pedido aparece más de una vez.
  6. Usa solo la biblioteca estándar. Mantén el código en 150 líneas o menos y acompáñalo de una explicación de como máximo 200 palabras que indique la complejidad temporal.
Cómo se indicó a los jueces que puntuaran
Lista de verificación de requisitos: (1) pedidos ordenados por día con un ordenamiento estable (se mantiene el orden de entrada para días iguales): corrección; (2) "utilizable" significa expires >= day y stock > 0, tomado en orden (expires, id): corrección; (3) llenados parciales para pedidos normales, y all_or_nothing comparado solo con el stock utilizable de ese día; un pedido all_or_nothing omitido no consume nada: corrección; (4) la forma de retorno es exactamente fills/short/remaining según lo especificado: completitud; (5) validación ValueError antes de cualquier asignación: completitud; (6) biblioteca estándar, código <= 150 líneas, explicación <= 200 palabras con una afirmación de complejidad: cumplimiento de instrucciones; código de más de 165 líneas: cumplimiento de instrucciones -2 o más. Clave de respuestas (precalculada; comparar, no ejecutar). T1 lotes L1(5, exp 10), L2(5, exp 3); pedido O1 día 1 cant 7 -> fills {O1: [(L2,5),(L1,2)]}, short {}, remaining {L1:3, L2:0}. Se decide ordenando los lotes por vencimiento. T2 lotes A(4, exp 5), B(4, exp 8); pedidos listados X(día 6, cant 4) luego Y(día 5, cant 5) -> fills {Y: [(A,4),(B,1)], X: [(B,3)]}, short {X:1}, remaining {A:0, B:0}. Falla si los pedidos se procesan en orden de entrada (da X [(B,4)], Y [(A,4)], short Y 1) o si el vencimiento se trata como exclusivo (expires > day). T3 lotes P(6, exp 2), Q(4, exp 9); pedidos M(día 3, cant 5, all_or_nothing) luego N(día 3, cant 3) -> fills {M: [], N: [(Q,3)]}, short {M:5}, remaining {P:6, Q:1}. Falla si la comprobación de all_or_nothing usa el stock total (10) en lugar del stock utilizable (4). T4 lotes b(2, exp 4), a(2, exp 4), c(1, exp 1); pedidos Z(día 1, cant 0), W(día 2, cant 5) -> fills {Z: [], W: [(a,2),(b,2)]}, short {W:1}, remaining {b:0, a:0, c:1}. Prueba el desempate por id y un pedido de cantidad cero (presente en fills, ausente en short). T5 lotes K(3, exp 5), J(3, exp 6); pedidos R(día 4, cant 2) luego S(día 4, cant 4, all_or_nothing) -> fills {R: [(K,2)], S: [(K,1),(J,3)]}, short {}, remaining {K:0, J:0}. Falla si los pedidos all_or_nothing se reordenan. T6 id de lote duplicado, o un pedido con cant -2 -> ValueError, sin estado parcial devuelto. Solo se puede obtener 9+ si el código pasa T1-T6 leyéndolo, es limpio (sin pasadas innecesarias sobre todos los lotes por unidad de cantidad) y la afirmación de complejidad es correcta (aprox. O(L log L + O log O + O x L) o mejor). Límites: procesa pedidos en orden de entrada o usa vencimiento exclusivo -> corrección <= 5; all_or_nothing comparado con el stock total -> corrección <= 6; código que no se ejecutaría tal cual (error de sintaxis, nombre no definido) -> corrección <= 3; forma de retorno incorrecta -> completitud <= 6.

Cada juez puntúa cada criterio de 0 a 10; la puntuación es la media ponderada de los criterios.

Respuestas, de mayor a menor media

Los jueces leen el original en inglés. Las traducciones son solo para leer.

1 GPT-6.1 Sol

Media (sobre 10) 9.74

Idioma de destino: es

from heapq import heapify, heappop


def allocate(lots, orders):
    # Validate every input before allocating stock.
    remaining = {}
    for lot in lots:
        if lot["qty"] < 0:
            raise ValueError("Negative lot quantity")
        if lot["id"] in remaining:
            raise ValueError("Duplicate lot id")
        remaining[lot["id"]] = lot["qty"]

    seen_orders = set()
    for order in orders:
        if order["qty"] < 0:
            raise ValueError("Negative order quantity")
        if order["id"] in seen_orders:
            raise ValueError("Duplicate order id"...
Mostrar respuesta completa ▼

Idioma de destino: es

from heapq import heapify, heappop


def allocate(lots, orders):
    # Validate every input before allocating stock.
    remaining = {}
    for lot in lots:
        if lot["qty"] < 0:
            raise ValueError("Negative lot quantity")
        if lot["id"] in remaining:
            raise ValueError("Duplicate lot id")
        remaining[lot["id"]] = lot["qty"]

    seen_orders = set()
    for order in orders:
        if order["qty"] < 0:
            raise ValueError("Negative order quantity")
        if order["id"] in seen_orders:
            raise ValueError("Duplicate order id")
        seen_orders.add(order["id"])

    heap = [(lot["expires"], lot["id"])
            for lot in lots if lot["qty"] > 0]
    heapify(heap)
    usable_total = sum(remaining.values())
    fills = {}
    short = {}

    # Python's stable sort preserves input order for equal days.
    for order in sorted(orders, key=lambda order: order["day"]):
        day = order["day"]
        order_id = order["id"]
        need = order["qty"]
        fills[order_id] = []

        # Expired stock stays in remaining but cannot be allocated.
        while heap and heap[0][0] < day:
            _, lot_id = heappop(heap)
            usable_total -= remaining[lot_id]

        if order.get("all_or_nothing", False) and need > usable_total:
            short[order_id] = need
            continue

        while need > 0 and heap:
            _, lot_id = heap[0]
            taken = min(need, remaining[lot_id])
            fills[order_id].append((lot_id, taken))
            remaining[lot_id] -= taken
            usable_total -= taken
            need -= taken
            if remaining[lot_id] == 0:
                heappop(heap)

        if need > 0:
            short[order_id] = need

    return {"fills": fills, "short": short, "remaining": remaining}

Validación completa antes de cualquier asignación. La ordenación estable por día conserva el orden original de los pedidos del mismo día. El montículo ordena los lotes con existencias positivas por fecha de caducidad y, después, por ID de lote. Como los pedidos se procesan cronológicamente, los lotes caducados pueden eliminarse permanentemente del montículo sin cambiar sus existencias finales.

usable_total registra todas las existencias que actualmente son elegibles para envío, lo que permite rechazar un pedido de tipo todo o nada sin consumir nada. Los pedidos normales consumen las existencias situadas al frente del montículo hasta que se completan o se agotan. Los pedidos con cantidad cero reciben fills vacíos y no tienen faltante.

Sea L el número de lotes, M el número de pedidos y K el número de tuplas de asignación devueltas. Cada lote se elimina del montículo como máximo una vez. La complejidad temporal es O(L log(L + 1) + M log(M + 1) + K); la complejidad espacial, incluyendo la salida, es O(L + M + K).

Claude Opus 5.5 9.22

Un asignador FEFO correcto y eficiente basado en un montículo (heap). Al revisar de T1 a T6, siempre se obtiene el resultado esperado: ordenación estable por día, caducidad inclusiva, ordenación del montículo por (expires, id), all_or_nothing comprobado únicamente contra el stock utilizable, y una validación que termina antes de cualquier asignación. La forma del valor devuelto es exacta, el código tiene 58 líneas y la explicación de 129 palabras ofrece una cota de complejidad correcta. Los defectos son menores.

Puntuación por criterio

Corrección

95

Supera T1 a T6 al revisarlo. La ordenación estable mantiene los pedidos del mismo día en el orden de entrada. La comprobación de caducidad extrae lotes solo mientras expires < day, por lo que la expiración es inclusiva. El heap ordena los lotes por (expires, id). usable_total resta el stock caducado antes de la comprobación all_or_nothing (T3 da M [] y N [(Q,3)]). Los pedidos de cantidad cero obtienen un relleno vacío y no tienen entrada en short. Un pedido all_or_nothing omitido no consume nada. No se encontraron errores lógicos.

Integridad

92

Devuelve exactamente fills, short y remaining. Cada id de pedido aparece en fills, short contiene solo faltantes positivos y remaining cubre todos los lotes, incluidos los lotes caducados. Las cantidades negativas y los ids duplicados tanto de lotes como de pedidos generan ValueError antes de la asignación. Las entradas malformadas, como las claves ausentes, no se gestionan, pero la tarea no lo exigía.

Calidad del código

90

Limpio e idiomático. El heap junto con un usable_total acumulado evita volver a recorrer los lotes y evita cualquier bucle por unidad, y los comentarios son concisos. Una peculiaridad menor es que el diccionario de stock se llama remaining y también sirve como mapa devuelto, lo que funciona pero acopla ambos roles.

Valor práctico

88

Eficiente y listo para uso real. Su coste temporal es O(L log L + M log M + K), y la explicación cubre con claridad las decisiones de diseño y casos límite como los pedidos de cantidad cero y los lotes caducados. Sería directamente utilizable en una herramienta pequeña de almacén.

Seguimiento de instrucciones

93

Usa solo la biblioteca estándar (heapq). El código tiene 58 líneas, muy por debajo de 150, y la explicación tiene 129 palabras, por debajo de 200. La afirmación de complejidad O(L log L + M log M + K) es correcta y mejor que la cota de referencia.

GPT-6.1 Sol 10.00

La solución cumple todos los requisitos y supera T1–T6 por inspección. Combina correctamente el procesamiento estable de pedidos en orden cronológico, la asignación FEFO basada en un heap y un total preciso de existencias utilizables para las decisiones de todo o nada. La validación, la estructura de la salida, el análisis de complejidad y los límites de longitud indicados están todos tratados correctamente.

Puntuación por criterio

Corrección

100

Supera T1–T6 por inspección. El ordenamiento estable conserva el orden del mismo día; el orden del montículo implementa la prioridad por caducidad y por ID de cadena; la caducidad es inclusiva. El total de stock utilizable excluye el stock caducado antes de cada asignación, y los pedidos de todo o nada rechazados no consumen nada. Las asignaciones parciales y los pedidos con cantidad cero se comportan correctamente.

Integridad

100

Devuelve exactamente fills, short y remaining, con cada pedido representado en fills, solo se registran faltantes positivos y cada lote se conserva en remaining. Las cantidades negativas y los ID duplicados se validan en ambas entradas antes de realizar cualquier asignación.

Calidad del código

100

La implementación es legible, autocontenida y eficiente. Los nombres de variables claros y los comentarios concisos explican el montículo y el invariante de stock utilizable. Cada lote se extrae del montículo como máximo una vez, sin recorridos repetidos innecesarios ni procesamiento unidad por unidad.

Valor práctico

100

Lista para usarse con las entradas especificadas sin modificar los diccionarios propiedad del llamador. Gestiona entradas vacías, stock agotado, stock caducado, cantidades cero y pedidos de todo o nada omitidos, manteniendo un inventario final preciso. La explicación indica límites de tiempo y espacio correctos y sensibles a la salida.

Seguimiento de instrucciones

100

Proporciona la función de Python 3 solicitada usando solo la biblioteca estándar. Las 58 líneas de código y las 129 palabras de explicación medidas están dentro de ambos límites, y la explicación indica explícitamente la complejidad temporal correcta.

Gemini 3.8 Flash 10.00

La solución está excepcionalmente bien elaborada, es correcta y eficiente. Utiliza un min-heap junto con un total acumulado del inventario utilizable para lograr una complejidad temporal óptima, gestiona con precisión el desempate y la ordenación estable de los pedidos del mismo día, y cumple estrictamente todas las restricciones y especificaciones de formato.

Puntuación por criterio

Corrección

100

Todos los casos de prueba (T1-T6) pasan sin problemas. El stock utilizable se identifica correctamente (caduca >= day), el desempate por ID de lote se respeta mediante el orden del heap, y la comprobación de todo o nada verifica con precisión el stock utilizable actual en ese día.

Integridad

100

La función valida todas las cantidades negativas y los IDs duplicados antes de realizar cualquier asignación, devuelve correctamente la estructura exacta de diccionario requerida y omite adecuadamente los pedidos completamente satisfechos del mapeo 'short'.

Calidad del código

100

El código es idiomático, limpio, legible y muy eficiente. Mantener `usable_total` de forma dinámica junto con la expulsión del heap evita recorridos redundantes sobre los lotes.

Valor práctico

100

La implementación gestiona de forma fluida casos prácticos de almacén (pedidos con cantidad cero, lotes que caducan entre pedidos, umbral de todo o nada) y está lista para producción.

Seguimiento de instrucciones

100

Cumple estrictamente todos los límites de número de líneas (58 líneas <= 150), el límite de palabras de la explicación (129 palabras <= 200), las restricciones de la biblioteca estándar, e incluye un análisis claro de la complejidad temporal.

2 Claude Sonnet 5.5

Media (sobre 10) 9.73
def allocate(lots, orders):
    # ---- validación (no se asigna nada si esto falla) ----
    seen_lots = set()
    for lot in lots:
        if lot["qty"] < 0:
            raise ValueError("negative lot qty: %r" % (lot["id"],))
        if lot["id"] in seen_lots:
            raise ValueError("duplicate lot id: %r" % (lot["id"],))
        seen_lots.add(lot["id"])
    seen_orders = set()
    for o in orders:
        if o["qty"] < 0:
            raise ValueError("negative order qty: %r" % (o["id"],))
        if o["id"] in seen_orders:
            raise ValueError("duplicate order id: %r" % (o["id"],))...
Mostrar respuesta completa ▼
def allocate(lots, orders):
    # ---- validación (no se asigna nada si esto falla) ----
    seen_lots = set()
    for lot in lots:
        if lot["qty"] < 0:
            raise ValueError("negative lot qty: %r" % (lot["id"],))
        if lot["id"] in seen_lots:
            raise ValueError("duplicate lot id: %r" % (lot["id"],))
        seen_lots.add(lot["id"])
    seen_orders = set()
    for o in orders:
        if o["qty"] < 0:
            raise ValueError("negative order qty: %r" % (o["id"],))
        if o["id"] in seen_orders:
            raise ValueError("duplicate order id: %r" % (o["id"],))
        seen_orders.add(o["id"])

    # ---- configuración ----
    # Lotes en orden FEFO: primero la caducidad más temprana, empates por id.
    ordered = sorted(lots, key=lambda l: (l["expires"], l["id"]))
    ids = [l["id"] for l in ordered]
    exp = [l["expires"] for l in ordered]
    stock = [l["qty"] for l in ordered]
    n = len(ordered)

    fills = {o["id"]: [] for o in orders}
    short = {}

    # sorted() es estable, así que los pedidos del mismo día mantienen su orden de entrada.
    queue = sorted(orders, key=lambda o: o["day"])

    ptr = 0                 # primer lote que no está caducado ni agotado
    usable = sum(stock)     # stock en lotes no caducados para el día actual

    for o in queue:
        d = o["day"]
        need = o["qty"]

        # Los días no decrecen, así que un lote caducado sigue caducado.
        while ptr < n and exp[ptr] < d:
            usable -= stock[ptr]
            ptr += 1

        if o.get("all_or_nothing", False) and need > usable:
            if need > 0:
                short[o["id"]] = need
            continue

        i = ptr
        while need > 0 and i < n:
            take = min(stock[i], need)
            if take > 0:
                fills[o["id"]].append((ids[i], take))
                stock[i] -= take
                usable -= take
                need -= take
            i += 1

        # Los lotes agotados forman un prefijo de los lotes no caducados; se omiten.
        while ptr < n and stock[ptr] == 0:
            ptr += 1

        if need > 0:
            short[o["id"]] = need

    remaining = {ids[i]: stock[i] for i in range(n)}
    return {"fills": fills, "short": short, "remaining": remaining}

Explicación

Las entradas se validan primero, de modo que se lanza un ValueError antes de cualquier asignación. Los lotes se ordenan una sola vez por (expires, id). Los pedidos se ordenan por day. El ordenamiento de Python es estable, así que los pedidos del mismo día mantienen su orden de entrada.

Un puntero ptr marca el primer lote que no está caducado ni vacío. Como los días nunca disminuyen, un lote que ha caducado sigue caducado. Como el stock siempre se toma del lote utilizable más temprano, los lotes vaciados forman un prefijo de los lotes utilizables. Por tanto, ptr solo avanza hacia delante.

Un contador acumulado usable guarda el stock en los lotes que no han caducado. Permite comprobar un pedido de todo o nada en O(1). Si el pedido es demasiado grande, no se toca nada y el stock sigue disponible.

Complejidad temporal: O(n log n + m log m + n + m + F), donde n es el número de lotes, m es el número de pedidos y F es el número de entradas de asignación devueltas. F es como máximo m + n, ya que cada pedido vacía lotes y deja como máximo uno parcialmente usado. El total es, por tanto, O(n log n + m log m). El espacio adicional es O(n + m).

Claude Opus 5.5 9.18

Una solución correcta y eficiente. Al contrastarla con T1–T6, produce los rellenos, los valores faltantes y los restantes esperados, incluidos el orden estable dentro del mismo día, la caducidad inclusiva, los desempates por (expires, id) y los pedidos de todo o nada comprobados únicamente contra el stock utilizable. El puntero amortizado y el contador de stock utilizable en ejecución son correctos, y la complejidad indicada es correcta y mejor que el límite de referencia. El código tiene 67 líneas y la explicación tiene 185 palabras. Solo quedan pequeños detalles menores.

Puntuación por criterio

Corrección

94

Supera T1–T6 al leerlo. Los pedidos usan un orden estable por día, y la caducidad es inclusiva (exp < d caduca). Los lotes se ordenan por (expires, id). El contador de utilizables sigue correctamente el stock en lotes no caducados, así que los pedidos de todo o nada se comparan con el stock utilizable y no consumen nada cuando se omiten. Los pedidos de cantidad cero se excluyen de short. Los invariantes de ptr se mantienen incluso con lotes de cantidad cero en medio de la lista.

Integridad

92

Devuelve exactamente fills, short y remaining. Fills contiene tuplas (lot_id, qty) e incluye todos los ids de pedido. Short solo lista faltantes positivos, y remaining cubre todos los lotes. Las cantidades negativas y los ids duplicados se validan antes de construir cualquier estado.

Calidad del código

90

Limpio y bien comentado. Usa un puntero hacia adelante amortizado y un contador de utilizables O(1), sin reescaneos por unidad. Las listas paralelas mantienen simple el bucle crítico. Una pequeña objeción: los arrays paralelos son algo menos legibles que una lista de registros mutables.

Valor práctico

88

Eficiente y lista para uso en producción en el escenario indicado, con mensajes de error claros. No comprueba los tipos de entrada ni las claves ausentes, pero eso no era obligatorio.

Seguimiento de instrucciones

93

Usa solo la biblioteca estándar. El código tiene 67 líneas, muy por debajo de 150, y la explicación tiene 185 palabras, por debajo de 200. Incluye una afirmación de complejidad correcta, O(n log n + m log m), con justificación.

GPT-6.1 Sol 10.00

La implementación cumple todos los requisitos y pasa T1–T6 por inspección. Mantiene correctamente el stock utilizable a medida que avanzan los días, conserva el stock caducado en remaining y omite los pedidos de todo o nada que no se pueden satisfacer sin consumir stock. La validación, la estructura de la salida y la complejidad indicada son correctas.

Puntuación por criterio

Corrección

100

Implementa correctamente el orden estable por día, la caducidad inclusiva, FEFO con desempate por id como cadena, los llenados parciales y las comprobaciones de todo o nada frente al stock utilizable actual. El contador de stock utilizable en curso y el puntero que solo avanza se mantienen consistentes durante toda la asignación.

Integridad

100

Devuelve exactamente fills, short y remaining, incluyendo fills vacíos y el stock caducado sin cambios cuando corresponde. Todas las cantidades negativas y los ids duplicados se validan antes de comenzar la asignación.

Calidad del código

100

Código limpio y autocontenido, con fases claras de validación y asignación, comentarios útiles sobre invariantes, y sin mutar la entrada. El puntero y el total de stock en curso evitan repetir análisis completos del stock.

Valor práctico

100

Lista para usarse con las entradas especificadas, con errores de validación informativos, asignación determinista y un manejo eficiente independiente de la magnitud de las cantidades. La explicación describe con precisión tanto el algoritmo como sus costos de recursos.

Seguimiento de instrucciones

100

Usa solo la funcionalidad estándar de Python, proporciona la función solicitada en 67 líneas de código y la acompaña con una explicación de 185 palabras que incluye una afirmación correcta sobre la complejidad temporal.

Gemini 3.8 Flash 10.00

La solución es completamente correcta, elegante y óptima. Cumple estrictamente todos los requisitos y casos límite: ordenación estable de los pedidos por día, ordenación FEFO de los lotes con desempate por id, validación exacta que lanza ValueError antes del procesamiento, comprobación de todo o nada en O(1) mediante una suma acumulada del inventario utilizable, y un recorrido preciso con dos punteros que logra una complejidad temporal de O(n log n + m log m). Las restricciones sobre el número de líneas y el número de palabras también se cumplieron por completo.

Puntuación por criterio

Corrección

100

Supera todos los casos de prueba de T1 a T6. Gestiona correctamente la ordenación FEFO con desempate por id de lote, la cola de pedidos estable por día, el filtrado de stock utilizable (expires >= day) y la conservación del stock todo-o-nada sin asignar.

Integridad

100

Se gestionan todos los requisitos y casos límite. Lanza ValueError antes de la asignación ante cantidades negativas o ids duplicados. Devuelve exactamente el esquema de diccionario requerido (asignaciones para todos los pedidos, short solo para los pedidos no atendidos y remaining para todos los lotes).

Calidad del código

100

Código Python excepcionalmente limpio, legible e idiomático. El recorrido lineal amortizado que avanza punteros y usa un saldo acumulado de inventario utilizable es a la vez elegante y eficiente.

Valor práctico

100

Implementación de asignación de almacén muy práctica que evita recorridos redundantes de lotes, lo que la hace eficiente y adecuada para entornos de producción reales.

Seguimiento de instrucciones

100

Sigue todas las instrucciones con precisión: usa únicamente la biblioteca estándar, mantiene el código muy por debajo de 150 líneas (67 líneas) y ofrece una explicación dentro del límite de 200 palabras (185 palabras) con un análisis preciso de la complejidad temporal.

3 GPT-6 Luna

Media (sobre 10) 9.66

Código de Python:

def allocate(lots, orders):
    # Validate everything before creating or changing allocation state.
    lot_ids = set()
    for lot in lots:
        if lot["qty"] < 0:
            raise ValueError("lot quantity cannot be negative")
        if lot["id"] in lot_ids:
            raise ValueError("duplicate lot id")
        lot_ids.add(lot["id"])

    order_ids = set()
    for order in orders:
        if order["qty"] < 0:
            raise ValueError("order quantity cannot be negative")
        if order["id"] in order_ids:
            raise ValueError("duplicate order id")
        order_i...
Mostrar respuesta completa ▼

Código de Python:

def allocate(lots, orders):
    # Validate everything before creating or changing allocation state.
    lot_ids = set()
    for lot in lots:
        if lot["qty"] < 0:
            raise ValueError("lot quantity cannot be negative")
        if lot["id"] in lot_ids:
            raise ValueError("duplicate lot id")
        lot_ids.add(lot["id"])

    order_ids = set()
    for order in orders:
        if order["qty"] < 0:
            raise ValueError("order quantity cannot be negative")
        if order["id"] in order_ids:
            raise ValueError("duplicate order id")
        order_ids.add(order["id"])

    remaining = {lot["id"]: lot["qty"] for lot in lots}
    sorted_lots = sorted(lots, key=lambda lot: (lot["expires"], lot["id"]))
    fills = {order["id"]: [] for order in orders}
    short = {}

    for order in sorted(orders, key=lambda order: order["day"]):
        order_id = order["id"]
        qty = order["qty"]
        usable = [
            lot for lot in sorted_lots
            if lot["expires"] >= order["day"] and remaining[lot["id"]] > 0
        ]
        available = sum(remaining[lot["id"]] for lot in usable)

        if order.get("all_or_nothing", False) and qty > available:
            short[order_id] = qty
            continue

        needed = qty
        for lot in usable:
            taken = min(needed, remaining[lot["id"]])
            if taken:
                fills[order_id].append((lot["id"], taken))
                remaining[lot["id"]] -= taken
                needed -= taken
            if needed == 0:
                break

        if needed > 0:
            short[order_id] = needed

    return {"fills": fills, "short": short, "remaining": remaining}

Los pedidos se procesan en orden ascendente estable por día, y los lotes se consideran por fecha de caducidad y luego por ID. Un pedido de todo o nada que no puede abastecerse por completo deja el inventario sin cambios. Las entradas se validan antes de crear el estado de asignación, y las listas y diccionarios de entrada no se modifican.

Para L lotes y O pedidos, la complejidad temporal es O(L log L + O log O + OL): la ordenación de lotes y pedidos, más el recorrido de los lotes utilizables para cada pedido. La complejidad espacial es O(L + O), excluyendo las asignaciones devueltas.

Claude Opus 5.5 8.99

Una solución correcta y limpia. Al contrastarla con la clave de respuestas, supera de T1 a T6: usa una ordenación estable por día, caducidad inclusiva, ordenación de los lotes por (expires, id), una comprobación de todo o nada que solo tiene en cuenta el stock utilizable, y mantiene fuera de short los pedidos de cantidad cero. La validación se ejecuta antes de construir ningún estado, la forma del valor devuelto es exacta y la declaración de complejidad es precisa. El código tiene 50 líneas y la explicación 82 palabras, ambos muy por debajo de los límites. Los únicos puntos débiles son menores: no hay comprobaciones de tipo ni de claves ausentes, y los lotes utilizables se reconstruyen para cada pedido.

Puntuación por criterio

Corrección

93

Supera los seis casos de la clave de respuestas al revisarla. El sorted de Python es estable, así que los pedidos del mismo día mantienen el orden de entrada. La expiración es inclusiva (>=), los lotes se ordenan por (expires, id) y la verificación de todo o nada compara con el stock utilizable de ese día, sin consumir nada cuando el pedido se omite. Un pedido de cantidad cero produce un relleno vacío y ninguna entrada en short.

Integridad

90

Devuelve exactamente las claves fills, short y remaining. Cada id de pedido aparece en fills, short solo incluye faltantes positivos y remaining cubre todos los lotes. Se lanza ValueError para cantidades negativas y para ids de lote o de pedido duplicados antes de que exista cualquier estado de asignación. No se validan tipos ni claves faltantes, pero la tarea no lo exigía.

Calidad del código

87

Legible y conciso, con nombres claros, lotes preordenados y sin bucles por unidad. Las entradas no se modifican. La lista de lotes utilizables y su suma se reconstruyen con un recorrido completo para cada pedido, lo cual es aceptable en la complejidad O x L indicada. La guarda 'if taken' es algo redundante.

Valor práctico

85

Directamente utilizable para el escenario de almacén. Es suficientemente eficiente para conjuntos de datos pequeños, y el valor por defecto de all_or_nothing se gestiona con dict.get. Los mensajes de ValueError son claros, pero no indican el id infractor, y hay poca gestión defensiva más allá de lo especificado.

Seguimiento de instrucciones

92

Usa solo la biblioteca estándar. El código tiene 50 líneas (límite 150) y la explicación 82 palabras (límite 200). La explicación indica la complejidad temporal correcta, O(L log L + O log O + OL), y también da la complejidad espacial. Se respetan todas las restricciones indicadas.

GPT-6.1 Sol 10.00

La implementación cumple todos los requisitos y supera T1–T6 por inspección. Maneja correctamente el procesamiento estable de pedidos, la caducidad inclusiva, el desempate FEFO, los rellenos parciales y los fallos de todo o nada sin consumo. La validación se realiza antes de la asignación, las entradas se conservan y la explicación concisa indica la complejidad correcta.

Puntuación por criterio

Corrección

100

Pasa T1–T6 por inspección. La ordenación estable por días, las comprobaciones de caducidad inclusiva, el orden de lotes por caducidad/ID, los pedidos de cantidad cero y las comprobaciones todo o nada solo con stock utilizable son correctos.

Integridad

100

Devuelve exactamente fills, short y remaining con las entradas requeridas y las asignaciones en forma de tupla. Ambas colecciones de entrada se comprueban por completo en busca de cantidades negativas e IDs duplicados antes de que se produzca cualquier asignación.

Calidad del código

100

Código claro y autocontenido, con nombres descriptivos, validación sencilla y lógica de asignación directa. Evita mutar las entradas y no realiza trabajo por cada unidad de cantidad.

Valor práctico

100

Listo para usar con las entradas especificadas, con manejo correcto del stock caducado, las faltas de stock, las asignaciones vacías y los pedidos omitidos por la regla todo o nada. La explicación describe con precisión el comportamiento y los costes de recursos.

Seguimiento de instrucciones

100

Usa únicamente funciones integradas de Python, se mantiene dentro del límite de 150 líneas de código y del límite de 200 palabras de la explicación, y sigue el código con las afirmaciones correctas sobre la complejidad temporal y de espacio auxiliar.

Gemini 3.8 Flash 10.00

La solución cumple perfectamente todas las especificaciones y restricciones. Maneja correctamente la ordenación estable de los pedidos por día, la priorización de lotes por caducidad e ID, los pedidos de cantidad cero, las comprobaciones de todo o nada frente al stock utilizable disponible, la validación de la entrada previa a la asignación y los formatos exactos de los diccionarios de salida. La explicación que la acompaña es concisa e indica con precisión la complejidad temporal y espacial.

Puntuación por criterio

Corrección

100

La implementación pasa todos los casos de prueba (T1-T6). Usa la ordenación estable de Python para las fechas de los pedidos, evalúa correctamente la usabilidad de los lotes con caducidad inclusiva (`expires >= day`), evalúa con precisión los pedidos de todo o nada frente al stock utilizable actual y resuelve limpiamente los empates entre lotes.

Integridad

100

Todos los casos límite y requisitos de validación están cubiertos a fondo. Tanto las cantidades negativas como los ID duplicados de lotes y pedidos generan `ValueError` antes de modificar cualquier estado de asignación, y la estructura de retorno coincide exactamente con la especificación de diccionario requerida.

Calidad del código

100

El código es idiomático, limpio, legible y está bien estructurado, sin dependencias innecesarias ni lógica excesivamente compleja.

Valor práctico

100

La función no modifica las colecciones de entrada, controla correctamente el inventario restante y es utilizable de inmediato en un escenario real de asignación de stock en almacén.

Seguimiento de instrucciones

100

Se ajustó estrictamente a todas las instrucciones: usa solo la biblioteca estándar, está muy por debajo del límite de 150 líneas de código (50 líneas), está muy por debajo del límite de 200 palabras de la explicación (82 palabras) y detalla explícitamente la complejidad temporal.

4 Claude Opus 5.5

Media (sobre 10) 9.60
def allocate(lots, orders):
    """Allocate stock FEFO (first-expiring, first-out) to orders.

    Returns {"fills": ..., "short": ..., "remaining": ...}.
    Raises ValueError for negative quantities or duplicate ids.
    """
    # ---- Validation (before any allocation) ----
    seen_lots = set()
    for lot in lots:
        if lot["qty"] < 0:
            raise ValueError(f"lot {lot['id']!r} has negative qty")
        if lot["id"] in seen_lots:
            raise ValueError(f"duplicate lot id {lot['id']!r}")
        seen_lots.add(lot["id"])

    seen_orders = set()
    for order in orders:
        if o...
Mostrar respuesta completa ▼
def allocate(lots, orders):
    """Allocate stock FEFO (first-expiring, first-out) to orders.

    Returns {"fills": ..., "short": ..., "remaining": ...}.
    Raises ValueError for negative quantities or duplicate ids.
    """
    # ---- Validation (before any allocation) ----
    seen_lots = set()
    for lot in lots:
        if lot["qty"] < 0:
            raise ValueError(f"lot {lot['id']!r} has negative qty")
        if lot["id"] in seen_lots:
            raise ValueError(f"duplicate lot id {lot['id']!r}")
        seen_lots.add(lot["id"])

    seen_orders = set()
    for order in orders:
        if order["qty"] < 0:
            raise ValueError(f"order {order['id']!r} has negative qty")
        if order["id"] in seen_orders:
            raise ValueError(f"duplicate order id {order['id']!r}")
        seen_orders.add(order["id"])

    # ---- Setup (input dicts are never mutated) ----
    stock = {lot["id"]: lot["qty"] for lot in lots}
    # FEFO order: earliest expiry first, ties by lot id (string comparison).
    fefo = sorted(lots, key=lambda l: (l["expires"], l["id"]))
    fills = {order["id"]: [] for order in orders}
    short = {}

    # sorted() is stable, so orders on the same day keep their input order.
    for order in sorted(orders, key=lambda o: o["day"]):
        oid, day, need = order["id"], order["day"], order["qty"]

        usable = [l["id"] for l in fefo
                  if l["expires"] >= day and stock[l["id"]] > 0]

        if order.get("all_or_nothing", False):
            available = sum(stock[lid] for lid in usable)
            if need > available:
                # Allocate nothing; stock stays for later orders.
                if need > 0:
                    short[oid] = need
                continue

        for lid in usable:
            if need == 0:
                break
            take = min(need, stock[lid])
            stock[lid] -= take
            need -= take
            fills[oid].append((lid, take))

        if need > 0:
            short[oid] = need

    return {"fills": fills, "short": short, "remaining": stock}

Cómo funciona

La función comprueba primero todos los lotes y pedidos. Lanza ValueError ante cualquier qty negativa o id repetido, de modo que no se asigna nada cuando la entrada no es válida. Ordena los lotes una sola vez por (expires, id). También ordena los pedidos por day. La ordenación de Python es estable, así que los pedidos del mismo día mantienen su orden de entrada. Para cada pedido, lista los lotes que aún se pueden usar: expires >= day y existencias mayores que 0. Si un pedido de todo o nada necesita más que el total de existencias utilizables, no recibe nada y su cantidad completa pasa a short. En caso contrario, toma existencias de los lotes utilizables en orden FEFO y registra una tupla (lot_id, qty) por cada lote que usa. Cualquier cantidad que quede sin cubrir pasa a short. Los pedidos con cantidad 0 obtienen una lista de asignaciones vacía y no aparecen en short. La función trabaja sobre copias de los niveles de existencias y nunca modifica los diccionarios de entrada.

Complejidad temporal: O(L log L + O log O + O·L), donde L es el número de lotes y O es el número de pedidos. Los dos términos con logaritmos provienen de ordenar los lotes y los pedidos. El término O·L proviene de recorrer los lotes una vez por cada pedido. El uso de espacio es O(L + O + F), donde F es el número total de tuplas de asignación.

Claude Opus 5.5 9.11

La solución es correcta y, según la lectura del código, pasa las seis pruebas de la clave de respuestas. Usa una ordenación estable para los pedidos, caducidad inclusiva, ordenación de lotes por (expires, id) y comprueba los pedidos all_or_nothing solo con el stock utilizable. La validación se realiza antes de la asignación y la forma de lo que devuelve es exacta. El código es breve y limpio, y la indicación de la complejidad es precisa. El principal defecto es que la explicación tiene 220 palabras, por encima del límite de 200.

Puntuación por criterio

Corrección

95

Las seis pruebas pasan. T1 se deriva del ordenamiento FEFO. T2 requiere el ordenamiento estable por día y expires >= day inclusivo, y ambos están presentes. T3 comprueba el pedido all_or_nothing contra el stock utilizable (4), no contra el stock total. T4 aplica el desempate por id y maneja el pedido de cantidad cero. T5 conserva el orden de entrada para los pedidos del mismo día. T6: la validación se ejecuta primero. Un pedido all_or_nothing omitido no consume nada. No encontré errores lógicos.

Integridad

93

El diccionario devuelto tiene exactamente fills, short y remaining. Fills incluye todos los ids de pedido, con listas vacías cuando no se asignó nada. Short contiene solo faltantes positivos. Remaining cubre todos los lotes. La cantidad negativa y los ids duplicados tanto de lotes como de pedidos generan ValueError antes de cualquier asignación.

Calidad del código

90

El código es limpio y legible. Los lotes se ordenan una sola vez, cada pedido recorre los lotes en una sola pasada, los diccionarios de entrada no se modifican y los comentarios son útiles. Una ineficiencia menor es reconstruir la lista de lotes utilizables para cada pedido, pero esto es aceptable a esta escala.

Valor práctico

88

Es directamente utilizable, con mensajes de error informativos y sin modificar las entradas. La explicación es clara y expresa correctamente la complejidad como O(L log L + O log O + O·L) más el uso de espacio.

Seguimiento de instrucciones

80

Usa solo la biblioteca estándar, el código tiene 57 líneas (muy por debajo de 150) y la complejidad temporal está indicada. Sin embargo, la explicación tiene 220 palabras frente a un límite de 200, un exceso del 10 %, por lo que se descuentan puntos.

GPT-6.1 Sol 9.90

La implementación maneja correctamente la asignación FEFO, el procesamiento estable de los pedidos, los pedidos de todo o nada, la validación y la estructura de retorno requerida. Pasa T1–T6 por inspección, preserva las entradas e indica la complejidad correcta. El único defecto es que la explicación supera el límite de 200 palabras.

Puntuación por criterio

Corrección

100

Pasa T1–T6 por inspección. Usa ordenación estable por día, expiración inclusiva y orden de lotes (expires, id). La disponibilidad para todo o nada incluye solo el stock utilizable, y los pedidos omitidos no consumen nada.

Integridad

100

Devuelve exactamente fills, short y remaining con el contenido requerido. Valida las cantidades negativas y los IDs duplicados en ambas entradas antes de comenzar la asignación.

Calidad del código

100

Código claro y autocontenido, con lógica de validación y asignación directa. Evita la mutación de las entradas y la iteración por unidad, y sus afirmaciones sobre complejidad temporal y espacial son precisas.

Valor práctico

100

Listo para usar con las entradas especificadas, con errores de validación informativos y manejo correcto de asignaciones vacías, cantidades cero, stock caducado y cumplimientos parciales.

Seguimiento de instrucciones

90

Usa únicamente Python estándar, se mantiene dentro del límite de 57 líneas de código e incluye la afirmación de complejidad requerida. Se descontó 1 punto porque la explicación medida tiene 220 palabras, lo que supera el límite de 200 palabras.

Gemini 3.8 Flash 9.80

La implementación cumple correctamente todos los requisitos funcionales y supera los casos de prueba T1 a T6. El formato de retorno y la lógica de validación coinciden con precisión con la especificación. El único defecto es que se supera el límite de 200 palabras en la explicación (se midieron 220 palabras).

Puntuación por criterio

Corrección

100

Todos los casos límite (T1–T6) se resuelven correctamente. El ordenamiento es estable según los días de los pedidos, los lotes se ordenan por (expires, id), las comprobaciones de stock todo-o-nada calculan correctamente el stock utilizable solo en ese día y las asignaciones de stock sin mutación funcionan como se espera.

Integridad

100

La función devuelve exactamente las claves solicitadas, con tipos y valores adecuados. La validación previa a la asignación cubre estrictamente las cantidades negativas y los IDs duplicados tanto para los lotes como para los pedidos.

Calidad del código

100

Código Python limpio e idiomático, con comentarios claros, estructuras de datos apropiadas y nombres de variables razonables.

Valor práctico

100

Implementación directamente utilizable y autocontenida, con entradas puras y sin mutación.

Seguimiento de instrucciones

80

La longitud del código está muy por debajo del límite de 150 líneas (57 líneas), solo se usa la biblioteca estándar y se indica la complejidad. Sin embargo, el recuento de palabras medido de la explicación fuera de los bloques de código es de 220 palabras, lo que supera el límite explícito de como máximo 200 palabras (un 10 % por encima, -2 puntos).

5 Gemini 3.8 Flash

Media (sobre 10) 9.12
def allocate(lots, orders):
    # 1. Validation
    seen_lot_ids = set()
    for lot in lots:
        if lot["qty"] < 0:
            raise ValueError(f"Negative lot quantity: {lot['qty']}")
        if lot["id"] in seen_lot_ids:
            raise ValueError(f"Duplicate lot ID: {lot['id']}")
        seen_lot_ids.add(lot["id"])

    seen_order_ids = set()
    for order in orders:
        if order["qty"] < 0:
            raise ValueError(f"Negative order quantity: {order['qty']}")
        if order["id"] in seen_order_ids:
            raise ValueError(f"Duplicate order ID: {order['id']}")
        seen_order_...
Mostrar respuesta completa ▼
def allocate(lots, orders):
    # 1. Validation
    seen_lot_ids = set()
    for lot in lots:
        if lot["qty"] < 0:
            raise ValueError(f"Negative lot quantity: {lot['qty']}")
        if lot["id"] in seen_lot_ids:
            raise ValueError(f"Duplicate lot ID: {lot['id']}")
        seen_lot_ids.add(lot["id"])

    seen_order_ids = set()
    for order in orders:
        if order["qty"] < 0:
            raise ValueError(f"Negative order quantity: {order['qty']}")
        if order["id"] in seen_order_ids:
            raise ValueError(f"Duplicate order ID: {order['id']}")
        seen_order_ids.add(order["id"])

    # Internal lot inventory
    remaining = {lot["id"]: lot["qty"] for lot in lots}
    lots_meta = {lot["id"]: lot["expires"] for lot in lots}

    fills = {order["id"]: [] for order in orders}
    short = {}

    # Sort orders by day (Python's Timsort is stable, preserving input order on ties)
    sorted_orders = sorted(orders, key=lambda o: o["day"])

    for order in sorted_orders:
        oid = order["id"]
        req_qty = order["qty"]
        day = order["day"]
        aon = order.get("all_or_nothing", False)

        # Identify and sort usable lots
        usable_lots = [
            lid for lid, exp in lots_meta.items()
            if exp >= day and remaining[lid] > 0
        ]
        usable_lots.sort(key=lambda lid: (lots_meta[lid], lid))

        total_usable = sum(remaining[lid] for lid in usable_lots)

        # Handle all-or-nothing check
        if aon and req_qty > total_usable:
            if req_qty > 0:
                short[oid] = req_qty
            continue

        # Allocate stock according to FEFO
        unfilled = req_qty
        for lid in usable_lots:
            if unfilled == 0:
                break
            take = min(remaining[lid], unfilled)
            if take > 0:
                remaining[lid] -= take
                unfilled -= take
                fills[oid].append((lid, take))

        if unfilled > 0:
            short[oid] = unfilled

    return {
        "fills": fills,
        "short": short,
        "remaining": remaining,
    }
Complejidad y explicación
  • Complejidad temporal: Sea $L$ el número de lotes y $O$ el número de pedidos. La validación de las entradas requiere $O(L + O)$. Ordenar los pedidos requiere $O(O \log O)$. Para cada pedido, filtrar y ordenar los lotes utilizables requiere $O(L \log L)$, y la deducción de existencias requiere $O(L)$. Por lo tanto, procesar todos los pedidos requiere $O(O \cdot L \log L)$. La complejidad temporal total es $\mathcal{O}(O \log O + O \cdot L \log L)$.
  • Complejidad espacial: $\mathcal{O}(L + O \cdot \min(L, \text{divisiones de llenado promedio}))$, ya que el seguimiento de lotes, metadatos de pedidos e historiales de llenado requiere espacio auxiliar lineal respecto a las entradas.
Claude Opus 5.5 8.74

Comparada con la clave de respuestas, la función supera las seis pruebas: de T1 a T5 para la asignación y T6 para la validación. Los pedidos se ordenan de forma estable por día y la caducidad es inclusiva. La comprobación de todo o nada usa solo el stock utilizable en ese día, y un pedido omitido no consume nada. La validación termina antes de cualquier asignación, y la forma del valor devuelto es correcta. El principal punto débil es la eficiencia: los lotes utilizables se reconstruyen y se vuelven a ordenar para cada pedido, lo que da O(O·L log L) en lugar de ordenar los lotes una sola vez. El código respeta los límites de longitud y la explicación indica correctamente su complejidad.

Puntuación por criterio

Corrección

90

Supera T1 a T6 mediante revisión del código. La ordenación por día es estable, la comprobación expires >= day es inclusiva y los lotes se ordenan por (expires, id). Los llenados parciales funcionan para pedidos normales. El criterio de todo o nada se compara con el stock utilizable ese día y un pedido omitido no asigna nada. Un pedido de cantidad cero obtiene un llenado vacío y ninguna entrada en short. No se encontraron errores lógicos.

Integridad

90

Devuelve exactamente fills, short y remaining. Todos los ids de pedido aparecen en fills, short solo incluye faltantes positivos y remaining cubre todos los lotes. Las cantidades negativas y los ids duplicados tanto de lotes como de pedidos generan ValueError antes de cualquier cambio de estado. Están presentes todas las partes requeridas.

Calidad del código

82

El código es limpio y legible, con nombres de variables claros y comentarios útiles. Nunca itera por unidad de cantidad. Sin embargo, filtra y reordena todos los lotes para cada pedido, lo que da O(O·L log L), cuando ordenar los lotes una vez al inicio sería más limpio. La protección `if take > 0` es algo redundante.

Valor práctico

83

Es directamente utilizable para almacenes pequeños, y la reordenación por pedido no será un problema a escala moderada. Los mensajes de error son informativos. Es algo menos eficiente de lo posible para un número grande de lotes.

Seguimiento de instrucciones

90

Usa solo la biblioteca estándar. El código tiene 68 líneas, muy por debajo de 150, y la explicación tiene 93 palabras, por debajo de 200. La afirmación de complejidad, O(O log O + O·L log L), es correcta para el código tal como está escrito. La explicación trata sobre todo de la complejidad y dice poco sobre el enfoque, pero se cumplen todos los elementos requeridos.

GPT-6.1 Sol 8.62

La función maneja correctamente los seis casos de prueba, valida las entradas antes de asignar y devuelve la estructura requerida sin modificar las entradas. La principal debilidad es que vuelve a ordenar los lotes utilizables para cada pedido en lugar de ordenarlos una sola vez. La afirmación sobre la complejidad temporal refleja esa implementación, pero la afirmación sobre la complejidad espacial omite el almacenamiento inevitable por pedido cuando los fills están vacíos.

Puntuación por criterio

Corrección

89

Supera T1–T6 por inspección: el procesamiento cronológico estable, la caducidad inclusiva, el desempate por ID de cadena, los envíos parciales y el rechazo sin consumo en los pedidos de todo o nada son correctos. Ordenar repetidamente por pedido ofrece una cota asintótica peor que la condición de eficiencia 9+ declarada en la política.

Integridad

89

Devuelve exactamente fills, short y remaining, incluidos los envíos vacíos y el stock caducado no utilizado. Ambas comprobaciones de ID duplicados y todas las comprobaciones de cantidades negativas se realizan antes de la asignación. Están presentes todos los componentes funcionales requeridos; la condición compartida de 9+ no se cumple por completo.

Calidad del código

80

Código legible y autocontenido, con fases claras de validación y asignación, nombres descriptivos y sin mutación de las entradas. Ordenar los lotes utilizables por separado para cada pedido es innecesario; ordenar los lotes una sola vez simplificaría el procesamiento y mejoraría el tiempo de ejecución en el peor caso. Además, el stock utilizable se suma también para los pedidos normales, aunque solo los pedidos de todo o nada necesitan esa comprobación.

Valor práctico

83

Directamente utilizable para el pequeño almacén indicado y maneja correctamente los casos límite importantes. La ordenación repetida limita la escalabilidad, y la explicación de la complejidad espacial subestima el almacenamiento cuando muchos pedidos no reciben stock.

Seguimiento de instrucciones

88

Usa únicamente funciones integradas de Python, se mantiene dentro de las 68 líneas de código y las 93 palabras de explicación medidas, e incluye una afirmación correcta de complejidad temporal para su implementación. La cota espacial adicional es inexacta: el almacenamiento es O(L + O + F), donde F es el número total de tuplas de asignación, incluido un término O(O) aunque ningún pedido reciba stock.

Gemini 3.8 Flash 10.00

La solución implementa de forma completa y precisa el algoritmo de asignación de existencias FEFO con restricciones de todo o nada. Maneja los casos límite sin fallos (incluidos los pedidos de cantidad cero, el desempate estable por días de pedido e ID de lote, y la validación estricta previa a la asignación de cantidades negativas y duplicados). El código es conciso, idiomático y cumple estrictamente todas las restricciones de número de líneas y límite de palabras, a la vez que ofrece un análisis de complejidad preciso.

Puntuación por criterio

Corrección

100

Todas las pruebas T1–T6 pasan al revisarlas. El ordenamiento estable conserva la secuencia de pedidos en días iguales, la comparación de caducidad usa '>=' correctamente, los empates en la caducidad de los lotes se desempatan por ID de cadena, las comprobaciones de todo o nada se hacen contra el stock utilizable de ese día, y el stock se deduce en fragmentos de cantidad mínima en lugar de unidad por unidad.

Integridad

100

Se atiende cada requisito. Todas las validaciones de lotes y pedidos se realizan antes de cualquier asignación, lanzando ValueError ante cantidades negativas o IDs duplicados. El diccionario de retorno coincide con la estructura exacta requerida y con la semántica de 'fills', 'short' y 'remaining'.

Calidad del código

100

El código es legible, modular y está bien comentado, y evita una complejidad innecesaria. Las asignaciones se realizan con min(remaining, unfilled), lo que hace que la deducción del stock sea eficiente.

Valor práctico

100

La implementación es directamente utilizable en entornos similares a producción o en sistemas de gestión de almacenes, con comprobaciones defensivas adecuadas y asignaciones claras.

Seguimiento de instrucciones

100

Cumplimiento estricto de las restricciones: usa únicamente la biblioteca estándar de Python, se mantiene muy por debajo del límite de 150 líneas (68 líneas), y la explicación está muy por debajo del límite de 200 palabras (93 palabras), indicando con precisión la complejidad temporal y espacial.

6 Gemini 3.5 Flash-Lite

Media (sobre 10) 8.89

Función de asignación FEFO

def allocate(lots, orders):
    if any(l["qty"] < 0 for l in lots) or any(o["qty"] < 0 for o in orders):
        raise ValueError("Negative quantity found")
    
    lot_ids = [l["id"] for l in lots]
    if len(lot_ids) != len(set(lot_ids)):
        raise ValueError("Duplicate lot ID")
    
    order_ids = [o["id"] for o in orders]
    if len(order_ids) != len(set(order_ids)):
        raise ValueError("Duplicate order ID")
    
    remaining = {l["id"]: l["qty"] for l in lots}
    lot_data = {l["id"]: {"expires": l["expires"], "id": l["id"]} for l in lots}
    
    sorted_o...
Mostrar respuesta completa ▼

Función de asignación FEFO

def allocate(lots, orders):
    if any(l["qty"] < 0 for l in lots) or any(o["qty"] < 0 for o in orders):
        raise ValueError("Negative quantity found")
    
    lot_ids = [l["id"] for l in lots]
    if len(lot_ids) != len(set(lot_ids)):
        raise ValueError("Duplicate lot ID")
    
    order_ids = [o["id"] for o in orders]
    if len(order_ids) != len(set(order_ids)):
        raise ValueError("Duplicate order ID")
    
    remaining = {l["id"]: l["qty"] for l in lots}
    lot_data = {l["id"]: {"expires": l["expires"], "id": l["id"]} for l in lots}
    
    sorted_orders = sorted(enumerate(orders), key=lambda x: (x[1]["day"], x[0]))
    
    fills = {o["id"]: [] for o in orders}
    short = {}
    
    for _, order in sorted_orders:
        oid = order["id"]
        oday = order["day"]
        oqty = order["qty"]
        aon = order.get("all_or_nothing", False)
        
        usable_lots = [
            lid for lid, qty in remaining.items()
            if qty > 0 and lot_data[lid]["expires"] >= oday
        ]
        usable_lots.sort(key=lambda lid: (lot_data[lid]["expires"], lot_data[lid]["id"]))
        
        total_usable = sum(remaining[lid] for lid in usable_lots)
        
        if aon and oqty > total_usable:
            short[oid] = oqty
            continue
            
        allocated_for_order = []
        needed = oqty
        
        # Comprobar si podemos atender el pedido parcial o totalmente
        temp_allocation = []
        for lid in usable_lots:
            if needed <= 0:
                break
            take = min(remaining[lid], needed)
            temp_allocation.append((lid, take))
            needed -= take
            
        if aon and needed > 0:
            short[oid] = oqty
            continue
            
        # Aplicar la asignación
        for lid, take in temp_allocation:
            remaining[lid] -= take
            allocated_for_order.append((lid, take))
            
        fills[oid] = allocated_for_order
        if needed > 0:
            short[oid] = needed
            
    return {
        "fills": fills,
        "short": short,
        "remaining": remaining
    }

Explicación y complejidad

La función allocate primero valida las entradas en busca de cantidades negativas e IDs duplicados, lanzando un ValueError si se incumple alguna restricción. Conserva los índices originales de los pedidos para desempatar los del mismo día.

Para cada pedido ordenado por día, la función identifica los lotes utilizables, es decir, aquellos cuya caducidad es como mínimo el día del pedido y cuyo stock es distinto de cero. Ordena estos lotes según las reglas FEFO: expires ascendente, y después id ascendente. Si un pedido all_or_nothing no tiene stock utilizable total suficiente, se omite. En caso contrario, el stock se descuenta de forma voraz hasta completar el pedido o agotar el stock utilizable.

Complejidad temporal

Sea $L$ el número de lotes y $O$ el número de pedidos. Ordenar los pedidos cuesta $O(O \log O)$. Para cada uno de los $O$ pedidos, filtramos y ordenamos los lotes en $O(L \log L)$. Por tanto, la complejidad temporal global es $O(O \log O + O \cdot L \log L)$.

Claude Opus 5.5 8.07

Según la lectura, la función es correcta en los seis casos de la clave de respuestas: usa una ordenación estable por día, caducidad inclusiva, ordenación de lotes por (expires, id), comprueba los pedidos all_or_nothing únicamente con el stock utilizable, gestiona los pedidos de cantidad cero, valida antes de asignar y devuelve exactamente las tres claves. Sus puntos débiles son la ineficiencia y la redundancia. Los lotes utilizables se vuelven a filtrar y a ordenar para cada pedido (O·L log L), hay una segunda comprobación all_or_nothing inútil, y el diccionario lot_data repite innecesariamente el id. Esto la deja fuera de la banda de 9+.

Puntuación por criterio

Corrección

85

Supera T1 a T6 según la lectura. Los pedidos se ordenan por (day, index), expires >= day es inclusivo, los empates se resuelven por id de lote, y all_or_nothing se comprueba solo contra el stock utilizable. Un pedido all_or_nothing omitido no consume nada, y un pedido de cantidad cero aparece en fills pero no en short. No alcanza 9 o más porque volver a ordenar los lotes para cada pedido da O·L log L en lugar del O·L más limpio.

Integridad

87

La forma de devolución es exactamente fills, short y remaining. Cada id de pedido aparece en fills con listas de tuplas, y short contiene solo faltantes positivos. Se lanza ValueError para cantidades negativas y para ids de lote o de pedido duplicados antes de cualquier asignación.

Calidad del código

68

El código es legible pero tiene redundancia. lot_data vuelve a almacenar el id, la segunda comprobación aon tras la asignación temporal nunca puede activarse, y allocated_for_order duplica temp_allocation. Volver a filtrar y ordenar todos los lotes en cada pedido es un desperdicio, cuando bastaría con una única ordenación previa.

Valor práctico

75

Funciona correctamente para el escenario del almacén y la validación es razonable. La ordenación por pedido escalaría mal con muchos lotes y pedidos, pero es aceptable para un almacén pequeño.

Seguimiento de instrucciones

87

Usa solo la biblioteca estándar. El código tiene 68 líneas, dentro del límite de 150. La explicación tiene 148 palabras, dentro del límite de 200, y declara una complejidad temporal que describe con exactitud esta implementación.

GPT-6.1 Sol 8.61

La implementación gestiona correctamente los seis casos de prueba, valida las entradas antes de asignar y devuelve la estructura requerida. Cumple los límites de código y de explicación y describe con precisión su principal coste de ejecución. Su principal debilidad es que vuelve a ordenar los lotes utilizables para cada pedido, lo que da una cota más lenta que ordenar los lotes una sola vez; además, parte de la contabilidad de asignaciones es redundante.

Puntuación por criterio

Corrección

89

Supera T1–T6 por inspección: el procesamiento cronológico conserva el orden del mismo día, la caducidad es inclusiva, los empates de FEFO usan los ID de lote, y los pedidos de todo o nada comprueban solo el stock utilizable y no consumen nada cuando se omiten. Los pedidos con cantidad cero se gestionan correctamente. La ordenación repetida no cumple la cota de eficiencia asociada a la condición 9+ de la política.

Integridad

89

Devuelve exactamente fills, short y remaining, incluyendo cada pedido y lote cuando es necesario. Las cantidades negativas y los ID duplicados se rechazan antes de iniciar la asignación. No falta ninguna funcionalidad requerida; la condición global de eficiencia 9+ no se cumple.

Calidad del código

78

Código legible y autocontenido, con etapas claras de validación y asignación. Sin embargo, ordenar los lotes utilizables para cada pedido es innecesario, lot_data almacena cada ID de forma redundante, y la asignación temporal más una segunda comprobación de todo o nada añaden contabilidad después de que la suficiencia ya se ha establecido.

Valor práctico

84

Listo para usar en un almacén pequeño, con resultados deterministas y sin modificar las entradas proporcionadas. La ordenación repetida por pedido limita la escalabilidad frente a ordenar los lotes una sola vez, pero no compromete su utilidad para el entorno indicado.

Seguimiento de instrucciones

89

Usa solo funcionalidades integradas de Python, proporciona la función solicitada y se mantiene dentro de los límites medidos de 68 líneas de código y 148 palabras de explicación. La explicación incluye una cota de complejidad principal precisa, pero esa cota es más lenta que el objetivo de eficiencia 9+ de la política.

Gemini 3.8 Flash 10.00

La solución cumple perfectamente todos los requisitos y supera todos los casos de prueba (T1–T6) descritos en la política. La validación se realiza desde el principio, la ordenación de los pedidos es estable, el desempate entre lotes y las condiciones de caducidad son estrictamente correctos, la lógica de todo o nada tiene en cuenta correctamente el stock utilizable, y la estructura de retorno es exacta. Se respetan estrictamente el número de líneas y los límites de palabras de la explicación, con un análisis preciso de la complejidad temporal.

Puntuación por criterio

Corrección

100

La implementación aplica correctamente el orden estable de los pedidos por día, la selección estricta FEFO de lotes con desempate por identificador como cadena, el filtrado por caducidad (expires >= day) y la semántica exacta de todo o nada sin fuga de estado.

Integridad

100

Se manejan todos los casos extremos y requisitos: validación previa de cantidades negativas e identificadores duplicados, formato correcto del diccionario de retorno, omisión de pedidos con faltante restante cero en 'short', e inclusión de pedidos con asignaciones cero en 'fills'.

Calidad del código

100

El código es limpio, idiomático, legible y está bien estructurado, evitando recorridos redundantes sobre cada unidad de cantidad.

Valor práctico

100

La solución está lista para producción en problemas estándar de asignación de inventario, es clara en su ruta de ejecución y completamente confiable.

Seguimiento de instrucciones

100

Se siguieron todas las restricciones: solo biblioteca estándar, 68 líneas de código (muy por debajo del límite de 150) y una explicación de 148 palabras (por debajo del límite de 200) que incluye un análisis de complejidad temporal preciso.

Sobre este género

En este género, las capacidades que más se intentan medir son Corrección, Integridad, Calidad del código.

A diferencia de system design, aquí pesa más si el código realmente funciona que las decisiones de arquitectura de alto nivel.

Una puntuación alta aquí no garantiza mejor juicio de producto, mejor arquitectura ni mejores explicaciones para principiantes.

Para qué sirve un modelo fuerte en este género

implementación, depuración, refactorización y apoyo práctico al programar.

Lo que este género por sí solo no alcanza a mostrar

si el modelo es mejor para arquitectura, documentos para stakeholders o ideación abierta.

Qué se evalúa en Programación

Criterios y pesos usados para este ranking por género.

Corrección

35.0%

Este criterio se incluye para comprobar Corrección en la respuesta. Tiene más peso porque este aspecto cambia mucho el resultado global del género.

Integridad

20.0%

Este criterio se incluye para comprobar Integridad en la respuesta. Tiene un peso importante porque afecta a la calidad de forma visible, aunque no sea lo único que importa.

Calidad del código

20.0%

Este criterio se incluye para comprobar Calidad del código en la respuesta. Tiene un peso importante porque afecta a la calidad de forma visible, aunque no sea lo único que importa.

Valor práctico

15.0%

Este criterio se incluye para comprobar Valor práctico en la respuesta. Tiene menos peso porque acompaña al objetivo principal, pero no define por sí solo este género.

Seguimiento de instrucciones

10.0%

Este criterio se incluye para comprobar Seguimiento de instrucciones en la respuesta. Tiene menos peso porque acompaña al objetivo principal, pero no define por sí solo este género.

Enlaces relacionados

X f L