Problem with backpack problem

Est is simpler than it seems: What you lack is a price / weight ratio because what you do is that the function process_value returns only one data from the equation Where do you leave the weight? if what you want is the maximum number of packages, prioritizing the highest value you have to divide the price by the value so that the sorted returns a related key. I do not know if I explain myself but what you have to do is this:

def proceso_valor(item):
    nombre, peso, valor = item
    return float(valor)/ float(peso)

and voila, that way the sorted will give you your 4 elements where the room will be that relationship you are looking for. If you try it with proceso_peso.peso_maximo = 500, it gives you a load equal to 493 and not 451 as you say with the two missing packages.

The problem of the backpack is an NP problem, that is, you will not find an algorithm that always obtains the optimal solution. However, what you can do is discard the worst cases to stay with the best possible solutions.

That said, your algorithm should have two objectives:

In your approach it is not clear if prioritizing by value is to put the most expensive packages first or that the total sum is the highest. I suppose that is the latter case. Although the problem can also be posed the other way around: wanting to carry the most expensive load, without exceeding the load limit of the truck.

Well, your algorithm starts by sorting by value and then staying with those that fit in the maximum load. Umm! It is just the opposite of what you should try. To start, all the expensive packages are subtracting from the maximum load. For example, try two packages:

proceso_peso.peso_maximo = 750

PAQUETES = (
    ("Paquete 1", 9, 150), ("Paquete 2", 1000, 10000)
    )

carga_lista = list(takewhile(proceso_peso, reversed(sorted(PAQUETES, key=proceso_valor))))

The Package 2 has a lot of value and a lot of weight. When checking with proceso_peso you subtract your weight from proceso_peso.peso_maximo , which is negative, and takewhile ends up returning an empty list.

Once the failure is seen, my advice is that you do not use function attributes and, more importantly, do not change the problem conditions in an iteration (and if you do, make it clear ). For the former, use object-oriented programming; for the latter, use functional programming. For both, use python.

The problem of the backpack is well studied. Surely you find several algorithms that try to find the solution in a more or less fast way. In case it's a clue, I'll tell you how it would be done by "brute force" , although it takes a lot of time in some cases:

from operator import itemgetter

#Paquetes: "Nombre del paquete", Kilos, Precio
PAQUETES = (
    ("Paquete 1", 9, 150), ("Paquete 2", 9, 160), ("Paquete 3", 153, 200), ("Paquete 4", 50, 160),
    ("Paquete 5", 15, 60), ("Paquete 6", 66, 45), ("Paquete 7", 27, 60), ("Paquete 8", 39, 40),
    ("Paquete 9", 230, 591), ("Paquete 10", 520, 10), ("Paquete 11", 110, 70), ("Paquete 12", 32, 30))

#carga máxima del camión
PESOMAXIMO = 230

# Útiles para acceso al peso y valores (irían mejor definiendo una clase)
get_peso = itemgetter(1)
get_valor = itemgetter(2)

def total_peso(paquetes):
    return sum(get_peso(x) for x in paquetes)

def total_valor(paquetes):
    return sum(get_valor(x) for x in paquetes)

# Obtención de todas las combinaciones posibles
# Función recursiva
def combinaciones(paquetes, peso_maximo):
    paqs = [ p for p in paquetes if get_peso(p) <= peso_maximo ]
    resultado = []
    for p in paqs:
        res = combinaciones([x for x in paqs if x!=p], peso_maximo - get_peso(p))
        if len(res) == 0:
            resultado.append([p])
        else:
            resultado.extend([[p]+x for x in res])
    return resultado

# solución
max(combinaciones(PAQUETES, PESOMAXIMO), key=total_valor)