problem_id stringlengths 5 31 | dataset_source stringclasses 3
values | problem_name stringlengths 3 23 | description stringlengths 294 1.49k | sample stringlengths 21 701 | struct_model_info stringlengths 56 2.78k | model stringlengths 160 4.31k | code stringlengths 476 9.66k ⌀ | solver_solution stringlengths 71 469 |
|---|---|---|---|---|---|---|---|---|
aircraft_assignment | ComplexOR | aircraft_assignment | The Aircraft Assignment Problem aims to assign aircraft to routes in order to minimize the total cost while satisfying demand constraints with available aircraft. The problem involves a set of aircraft and a set of routes. Given the costs of assigning an aircraft to a route. The objective is to minimize the total cost ... | {"availability": [2, 3, 1], "demand": [100, 150], "capabilities": [[50, 70], [60, 80], [70, 90]], "costs": [[100, 200], [150, 250], [200, 300]]} | {"sets": [{"name": "Aircraft", "description": "Aircraft: Set of aircraft"}, {"name": "Route", "description": "Route: Set of routes"}], "parameters": [{"name": "Demand", "description": "demand for route `r` \\forall r \\in Route."}, {"name": "Capabilities", "description": "capabilities of aircraft `a` for route `r` \\fo... | the total cost of the assignment min: \sum_{a \in Aircraft,r \in Route} Costs_{a,r} * Allocation_{a,r}
\sum_{r \in Route} Allocation_{a,r} <= Availability_{a}, \forall a \in Aircraft.
\sum_{a \in Aircraft} Allocation_{a,r} * Capabilities_{a,r} = Demand_{r}, \forall r \in Route. | def aircraft_assignment(availability, demand, capabilities, costs):
"""
Args:
availability: list, availability of each aircraft
demand: list, demand for each route
capabilities: 2D list, capabilities of each aircraft for each route
costs: 2D list, costs of assigning each aircraft... | {"status": "OPTIMAL", "objective_value": 700.0, "decision_variables": null} |
aircraft_landing | ComplexOR | aircraft_landing | The Aircraft Landing Problem (ALP) is the problem of deciding a landing time on an appropriate runway for each aircraft in a given set of aircraft such that each aircraft lands within a predetermined time window; and separation criteria between the landing of an aircraft, and the landing of all successive aircraft, are... | {"EarliestLanding": [1, 3, 5], "LatestLanding": [10, 12, 15], "TargetLanding": [4, 8, 14], "PenaltyAfterTarget": [10, 20, 30], "PenaltyBeforeTarget": [5, 10, 15], "SeparationTime": [[0, 2, 3], [2, 0, 4], [3, 4, 0]]} | {"sets": [{"name": "Aircrafts", "description": "Aircrafts: Set of aircrafts"}], "parameters": [{"name": "EarliestLanding", "description": "Earliest landing time for aircraft `i` \\forall i \\in Aircrafts."}, {"name": "LatestLanding", "description": "Latest landing time for aircraft `i` \\forall i \\in Aircrafts."}, {"n... | total cost of landing min: \sum_{i \in Aircrafts} PenaltyBeforeTarget_{i} * Early_{i} + PenaltyAfterTarget_{i} * Late_{i}
AircraftsOrder_{i, j} + AircraftsOrder_{j, i} = 1, \forall i \in Aircrafts, j \in Aircrafts.
Landing_{j} >= Landing_{i} + SeparationTime_{i, j} * AircraftsOrder_{i, j} - (LatestLanding_{i} - Earlies... | from gurobipy import Model, GRB
def aircraft_landing(EarliestLanding, LatestLanding, TargetLanding, PenaltyAfterTarget, PenaltyBeforeTarget, SeparationTime):
"""
Args:
EarliestLanding: list of integers, earliest landing times for each aircraft.
LatestLanding: list of integers, latest landing ti... | {"status": "OPTIMAL", "objective_value": null, "decision_variables": null} |
blend_problem | ComplexOR | blend_problem | The problem aims to determine the optimal amounts of alloys to purchase in order to achieve a desired blend of required elements at the minimum cost. We are given a set of alloys available on the market and a set of required elements for the blend, the percentage composition data of each required element in each alloy,... | {"alloys_on_market": [0, 1], "required_elements": ["A", "B"], "composition_data": [[0.5, 0.5], [0.1, 0.9]], "desired_blend_percentage": [0.5, 0.5], "alloy_price": [10.0, 20.0]} | {"sets": [{"name": "AlloysOnMarket", "description": "AlloysOnMarket: Set of alloys available on the market"}, {"name": "RequiredElements", "description": "RequiredElements: Set of required elements"}], "parameters": [], "decision_variables": []} | Total cost of the alloy blend min: \sum_{a \in AlloysOnMarket} AlloyPrice_{a} * AlloyPurchased_{a}
\sum_{a \in AlloysOnMarket} CompositionDataPercentage_{e,a} * AlloyPurchased_{a} = DesiredBlendPercentage_{e}, \forall e \in RequiredElements.
\sum_{a \in AlloysOnMarket} AlloyPurchased_{a} = 1, \forall . | def blend_problem(alloys_on_market, required_elements, composition_data, desired_blend_percentage, alloy_price):
"""
Args:
alloys_on_market: list of integers, IDs of available alloys on the market
required_elements: list of strings, IDs of required elements
composition_data: 2D list of f... | {"status": "OPTIMAL", "objective_value": 15.0, "decision_variables": null} |
car_selection | ComplexOR | car_selection | The Car Selection Problem is a mixed integer programming model that aims to assign participants to cars in a way that maximizes the total number of assignments. The problem involves a set of participants and a set of cars, where each participant is interested in a subset of cars. The objective is to find the optimal as... | {"participants": ["P1", "P2", "P3"], "cars": ["C1", "C2", "C3"], "possible_assignments": [[1, 0, 1], [0, 1, 0], [1, 1, 1]]} | {"sets": [], "parameters": [], "decision_variables": []} | The total number of assignments max: \sum_{p \in Participants, c \in Cars} Assignments_{p,c}
Assignments_{p,c} <= PossibleAssignments_{p,c}, \forall p \in Participants, c \in Cars.
\sum_{c \in Cars} Assignments_{p,c} <= 1, \forall p \in Participants.
\sum_{p \in Participants} Assignments_{p,c} <= 1, \forall c \in Cars. | def car_selection(participants, cars, possible_assignments):
"""
Args:
participants: list, the set of all participants.
cars: list, the set of all cars.
possible_assignments: 2D list, PossibleAssignments[i][j] indicates whether participant i is interested in car j.
Returns:
... | {"status": "OPTIMAL", "objective_value": 3, "decision_variables": null} |
cell_tower | ComplexOR | cell_tower | A telecom company needs to build a set of cell towers to provide signal coverage for the inhabitants of a given city. A number of potential locations where the towers could be built have been identified. The towers have a fixed range, and due to budget constraints only a limited number of them can be built. Given these... | {"delta": [[1, 0, 1], [0, 1, 0]], "cost": [3, 4], "population": [100, 200, 150], "budget": 4} | {"sets": [{"name": "Tower", "description": "Tower: Set of potential sites to build a tower"}, {"name": "Region", "description": "Region: Set of regions"}], "parameters": [], "decision_variables": []} | maximize the total population covered by the towers max: \sum_{j \in Region} Population_{j} * Covered_{j}
\sum_{i \in Tower} Delta_{i,j} * Build_{i} >= Covered_{j}, \forall j \in Region.
\sum_{i \in Tower} Cost_{i} * Build_{i} <= Budget, \forall i \in Tower. | def cell_tower(delta, cost, population, budget):
"""
Args:
delta: A matrix (list of lists) where delta[i][j] is 1 if site `i` covers region `j`, otherwise 0
cost: A list where cost[i] is the cost of building the tower at site `i`
population: A list where population[j] is the population o... | {"status": "OPTIMAL", "objective_value": 250, "decision_variables": null} |
cutting_stock | ComplexOR | cutting_stock | This is a cutting stock problem. Given a roll of width `RollWidth` and a set of widths `Width` to be cut. Each width `i` has a certain number of Orders `Orders_{i}`. There are `NumPatterns` patterns and each pattern `j` has a certain number of rolls of each width `i` `NumRollsWidth_{i, j}`. The problem aims to minimize... | {"roll_width": 10, "widths": [2, 3, 5], "orders": [4, 2, 2], "num_patterns": 2, "num_rolls_width": [[1, 2, 0], [0, 0, 1]]} | {"sets": [], "parameters": [], "decision_variables": []} | the total number of raw rolls cut minimize: \sum_{j \in Patterns} Cut_{j}
\sum_{j \in Patterns} NumRollsWidth_{i,j} * Cut_{j} >= Orders_{i}, \forall i \in Width.
\sum_{i \in Width} i * NumRollsWidth_{i,j} <= RollWidth, \forall j \in Patterns. | def cutting_stock(roll_width, widths, orders, num_patterns, num_rolls_width):
"""
Solves the Cutting Stock Problem to minimize the total number of raw rolls cut.
Args:
roll_width: An integer, the width of the raw rolls.
widths: A list of integers, the set of widths to be cut.
orders... | {"status": "ERROR", "objective_value": null, "decision_variables": null} |
diet_problem | ComplexOR | diet_problem | Consider a diet problem. Given a set of nutrients `Nutrients` and a set of foods `Foods`. Each food `j` has a cost `Cost_{j}` and a range of amount that can be bought `[MinAmount_{j}, MaxAmount_{j}]`. Each nutrient `i` has a range of amount that should be included in the diet `[MinNutrient_{i}, MaxNutrient_{i}]`. The a... | {"food_set": ["Apple", "Banana"], "nutrient_set": ["VitaminC", "Fiber"], "food_cost": [2.0, 1.5], "min_food_amount": [0, 0], "max_food_amount": [10, 10], "min_nutrient_amount": [50, 30], "max_nutrient_amount": [100, 60], "nutrient_amount": [[10, 5], [5, 10]]} | {"sets": [], "parameters": [], "decision_variables": []} | the total cost of buying foods min: \sum_{j \in Foods} Cost_{j} * Buy_{j}
MinNutrient_{i} <= \sum_{j \in Foods} NutrientAmount_{i,j} * Buy_{j} <= MaxNutrient_{i}, \forall i \in Nutrients. | def diet_problem(food_set, nutrient_set, food_cost, min_food_amount, max_food_amount, min_nutrient_amount, max_nutrient_amount, nutrient_amount):
"""
Args:
food_set: List of strings, each representing a type of food.
nutrient_set: List of strings, each representing a type of nutrient.
fo... | {"status": "OPTIMAL", "objective_value": 10.333333333333334, "decision_variables": null} |
dietu_problem | ComplexOR | dietu_problem | Consider a diet problem. Given a set of foods `Foods` and a set of nutrients `Nutrients` which is the union of nutrients with minimum requirements `MinRequirements` and nutrients with maximum requirements `MaxRequirements`. Each food `j` has a cost `Cost_{j}` and the amount of each nutrient `i` it contains is `Nutrient... | {"cost": [2, 3, 1.5], "f_min": [0, 0, 0], "f_max": [100, 100, 100], "n_min": [50, 60], "n_max": [200, 250], "amt": [[2, 1, 3], [3, 4, 2]]} | {"sets": [], "parameters": [], "decision_variables": []} | the total cost of buying foods min: \sum_{j \in Foods} Cost_{j} * Buy_{j}
\sum_{j \in Foods} NutrientAmount_{i,j} * Buy_{j} >= MinRequirement_{i}, \forall i \in MinRequirements.
\sum_{j \in Foods} NutrientAmount_{i,j} * Buy_{j} <= MaxRequirement_{i}, \forall i \in MaxRequirements. | def dietu_problem(cost, f_min, f_max, n_min, n_max, amt):
"""
Args:
cost: list of costs for each food item, length is the number of foods
f_min: list of minimum amounts to buy for each food item, length is the number of foods
f_max: list of maximum amounts to buy for each food item, leng... | {"status": "OPTIMAL", "objective_value": 41.0, "decision_variables": null} |
flowshop_scheduling | ComplexOR | flowshop_scheduling | A set of jobs `Jobs` need to be processed on a set of machines `Machines` in series. All jobs have the same processing order through all the machines from machine 1 to machine M. Each machine can work in parallel. The workflow is the following: the first job of the sequence goes to the first machine to be processed; me... | {"jobs": [1, 2, 3], "schedules": [1, 2, 3], "machines": [1, 2], "proces_time": [[1, 3], [2, 2], [3, 1]]} | {"sets": [{"name": "Jobs", "description": "Jobs: Set of all Jobs"}, {"name": "Schedules", "description": "Schedules: Set of all schedules"}, {"name": "Machines", "description": "Machines: Set of all machines"}], "parameters": [], "decision_variables": []} | Minimize the total time to process all jobs on all machines min: StartTime_{S,M} + \sum_{j \in Jobs} ProcesTime_{j,M} * JobSchedule_{j,S}
\sum_{j \in Jobs} JobSchedule_{j,s} = 1, \forall s \in Schedules.
\sum_{s \in Schedules} JobSchedule_{j,s} = 1, \forall j \in Jobs.
StartTime_{s,m + 1} >= StartTime_{s,m} + \sum_{j ... | def flowshop_scheduling(jobs, schedules, machines, proces_time):
"""
Args:
jobs: list of ints, represents a set of all Jobs
schedules: list of ints, represents a set of all schedules, range [1, S]
machines: list of ints, represents a set of all machines, range [1, M]
proces_time:... | {"status": "OPTIMAL", "objective_value": null, "decision_variables": null} |
knapsack_optimization | ComplexOR | knapsack_optimization | The Knapsack Problem is a classic optimization problem in operations research and computer science. The problem is to determine the most valuable combination of items to include in a knapsack, given a set of items with different values and weights, and a maximum weight capacity of the knapsack. The goal is to maximize ... | {"item_values": [60, 100, 120], "item_weights": [10, 20, 30], "max_weight_knapsack": 50} | {"sets": [{"name": "Items", "description": "Items: Set of items"}], "parameters": [], "decision_variables": []} | maximize total value of the items in the knapsack max: \sum_{i \in Items} KnapsackItems_{i} * ItemValue_{i}
\sum_{i \in Items} KnapsackItems_{i} * ItemWeight_{i} <= MaxWeightKnapsack | def knapsack_optimization(item_values, item_weights, max_weight_knapsack):
"""
Args:
item_values: a list of integers, indicating the value of each item
item_weights: a list of integers, indicating the weight of each item
max_weight_knapsack: an integer, denotes the maximum weight capacit... | {"status": "OPTIMAL", "objective_value": 220.0, "decision_variables": null} |
media_selection | ComplexOR | media_selection | The main media selection problem is a problem of allocating advertising budgets between possible advertising outlets. Given a set of media options, it aims to determine which media should be selected so that all audiences are reached with minimum campaign cost. It does not matter if an audience is covered more than onc... | {"target_audiences": [0, 1, 2], "advertising_media": [0, 1, 2], "incidence_matrix": [[1, 0, 1], [1, 1, 0], [0, 1, 1]], "media_costs": [10, 15, 20]} | {"sets": [{"name": "TargetAudiences", "description": "TargetAudiences: Set of target audiences"}, {"name": "AdvertisingMedia", "description": "AdvertisingMedia: Set of advertising media"}], "parameters": [], "decision_variables": []} | Total cost of selected media min: \sum_{m \in AdvertisingMedia} CostOfMedia_{m} * IsSelectedMIP_{m}
\sum_{m \in AdvertisingMedia} Incidence_{t,m} * IsSelectedMIP_{m} >=1, \forall t \in TargetAudiences. | def media_selection(target_audiences, advertising_media, incidence_matrix, media_costs):
"""
Args:
target_audiences: List of target audiences (typically a list of integers)
advertising_media: List of advertising media (typically a list of integers)
incidence_matrix: 2D list where inciden... | {"status": "OPTIMAL", "objective_value": 25.0, "decision_variables": null} |
multi | ComplexOR | multi | This is a multi-commodity transportation problem. Given a set of origins `Origins`, a set of destinations `Destinations`, and a set of products `Products`. Each origin `i` has a certain supply of each product `p` `Supply_{i,p}` and each destination `j` has a certain demand for each product `p` `Demand_{j,p}`. The cost ... | {"supply": [[20, 30], [40, 10]], "demand": [[30, 30], [30, 10]], "limit": [[40, 25], [25, 30]], "cost": [[[2, 3], [4, 1]], [[3, 2], [2, 4]]]} | {"sets": [], "parameters": [], "decision_variables": []} | the total cost of shipping all products from the origins to the destinations min: \sum_{i \in Origins, j \in Destinations, p \in Products} ShippingCost_{i,j,p} * Transport_{i,j,p}
\sum_{j \in Destinations} Transport_{i,j,p} = Supply_{i,p}, \forall i \in Origins, p \in Products.
\sum_{i \in Origins} Transport_{i,j,p} = ... | def multi(supply, demand, limit, cost):
"""
Args:
supply: a 2D list, supply[i][p] indicates the amount of product p available at origin i
demand: a 2D list, demand[p][j] indicates the amount of product p required at destination j
limit: a 2D list, limit[i][j] indicates the maximum total ... | {"status": "OPTIMAL", "objective_value": 220.0, "decision_variables": null} |
netasgn | ComplexOR | netasgn | Consider a project assignment problem. Given a set of people `People` and a set of projects `Projects`. Each person `i` has a certain number of available hours `Supply_{i}` and each project `j` requires a certain number of hours `Demand_{j}`. The cost per hour of work for person `i` on project `j` is `Cost_{i, j}`. Eac... | {"supply": [8, 7], "demand": [5, 10], "cost": [[10, 20], [15, 25]], "limit": [[5, 6], [4, 7]]} | {"sets": [], "parameters": [], "decision_variables": []} | the total cost of assigning people to projects min: \sum_{i \in People, j \in Projects} Cost_{i,j} * Assign_{i,j}
\sum_{i \in People, j \in Projects} Assign_{i,j} = Supply_{i}, \forall i \in People.
\sum_{i \in People, j \in Projects} Assign_{i,j} = Demand_{j}, \forall j \in Projects.
Assign_{i,j} <= Limit_{i,j}, \fora... | def netasgn(supply, demand, cost, limit):
"""
Args:
supply: list, hours each person is available, length is number of people
demand: list, hours each project requires, length is number of projects
cost: 2D list, cost per hour of work for each person on each project, dimensions are number... | {"status": "OPTIMAL", "objective_value": 285.0, "decision_variables": null} |
netmcol | ComplexOR | netmcol | Consider a transportation problem with multiple products. Given a set of cities `Cities` and a set of links `Links` between the cities. Each city `i` has a certain supply of each product `p` `Supply_{i,p}` and a certain demand for each product `p` `Demand_{i,p}`. The cost of shipping one package of product `p` from cit... | {"Cities": ["A", "B"], "Links": [["A", "B"]], "Products": ["Product1"], "Supply": [[10], [0]], "Demand": [[0], [10]], "ShipmentCost": [[[1]]], "Capacity": [[[10]]], "JointCapacity": [[10]]} | {"sets": [], "parameters": [], "decision_variables": []} | the total cost of shipping products from the cities to the cities min: \sum_{i \in Links, j \in Links, p \in Products} ShipmentCost_{i, j, p} * Ship_{i, j, p}
Supply_{k, p} + \sum_{i \in Links, k \in Links} Ship_{i, k, p} = Demand_{k, p} + \sum_{k \in Links, j \in Links} Ship_{k, j, p}, \forall k \in Cities, p \in Prod... | def netmcol(Cities, Links, Products, Supply, Demand, ShipmentCost, Capacity, JointCapacity):
"""
Args:
Cities: list, a list of cities
Links: list, a list of links between the cities
Products: list, a list of products
Supply: list of lists, the supply of each product at each city
... | {"status": "ERROR", "objective_value": null, "decision_variables": null} |
nltrans | ComplexOR | nltrans | Consider a transportation problem. Given a set of origins `Origins` and a set of destinations `Destinations`. Each origin `i` has a certain supply of goods `Supply_{i}` and each destination `j` has a certain demand for goods `Demand_{j}`. The cost of shipping one unit of goods from origin `i` to destination `j` is `Rat... | {"supply": [20, 30], "demand": [30, 20], "rate": [[8, 6], [5, 10]], "limit": [[15, 25], [25, 20]]} | {"sets": [], "parameters": [], "decision_variables": []} | the total cost of shipping goods from the origins to the destinations min: \sum_{i \in Origins, j \in Destinations} Rate_{i,j} * Shipping_{i,j}
\sum_{j \in Destinations} Shipping_{i,j} = Supply_{i}, \forall i \in Origins.
\sum_{i \in Origins} Shipping_{i,j} = Demand_{j}, \forall j \in Destinations.
Shipping_{i,j} <= Li... | def nltrans(supply, demand, rate, limit):
"""
Args:
supply: a list of integers, each indicates the amount of goods available at an origin
demand: a list of integers, each indicates the amount of goods required at a destination
rate: a 2D list of integers, the shipment costs per unit from... | {"status": "OPTIMAL", "objective_value": 305, "decision_variables": null} |
revenue_maximization | ComplexOR | revenue_maximization | We have a set of flight legs (one-way non-stop flight) with a limited passenger capacity. According to market research, we defined a set of flight itineraries to sell as a package with a given price. For each package, we have an estimated demand. How many units of each package should we sell to maximize the revenue? We... | {"available_seats": [50, 60, 70], "demand": [30, 40], "revenue": [100, 150], "delta": [[1, 1, 0], [0, 1, 1]]} | {"sets": [{"name": "FlightLegs", "description": "FlightLegs: Set of flight legs (one-way non-stop flight)"}, {"name": "Packages", "description": "Packages: Set of packages"}], "parameters": [{"name": "AvailableSeats", "description": "Number of available seats for flight `r` \\forall r \\in FlightLegs."}, {"name": "Reve... | Maximize the revenue max: \sum_{p \in Packages} Revenue_{p} * Sell_{p}
Sell_{p} <= Demand_{p}, \forall p \in Packages.
\sum_{p \in Packages} Delta_{p,r} * Sell_{p} <= AvailableSeats_{r}, \forall r \in FlightLegs. | def revenue_maximization(available_seats, demand, revenue, delta):
"""
Args:
available_seats: List of integers, available seats for each flight leg
demand: List of integers, estimated demand for each package
revenue: List of integers, revenue gained for selling a unit of each package
... | {"status": "OPTIMAL", "objective_value": 8000, "decision_variables": null} |
steel4 | ComplexOR | steel4 | Consider a production problem. Given a set of products `Products` and a set of stages `Stages`. Each product `p` has a certain production rate `Rate_{p, s}` in each stage `s` and a certain profit `Profit_{p}` per ton. Each stage `s` has a certain number of hours `Available_{s}` available per week. There are also lower ... | {"products": ["P1", "P2"], "stages": ["S1", "S2"], "rate": [[2, 3], [3, 2]], "profit": [10, 20], "commit": [1, 2], "market": [5, 4], "avail": [10, 8]} | {"sets": [], "parameters": [], "decision_variables": [{"name": "Production", "description": "tons to be produced for product `p` \\forall p \\in Products.", "type": "continuous"}]} | the total profit from all products max: \sum_{p \in Products} Profit_{p} * Production_{p}
\sum_{p \in Products} (1/Rate_{p,s}) * Production_{p} <= Available_{s}, \forall s \in Stages.
Commit_{p} <= Production_{p}, \forall p \in Products.
Production_{p} <= Market_{p}, \forall p \in Products. | def steel4(products, stages, rate, profit, commit, market, avail):
"""
Args:
products: list of products
stages: list of stages
rate: 2D list indicating the production rate of each product at each stage
profit: list indicating profit per ton for each product
commit: list i... | {"status": "OPTIMAL", "objective_value": 130.0, "decision_variables": null} |
prob_0 | LPWP | prob_0 | A fishery wants to transport their catch. They can either use local sled dogs or trucks. Local sled dogs and trucks can take different amount of fish per trip. Also, the cost per trip for sled dogs and truck is also differs. You should note that the budget has an upper limit and the number of sled dog trips must be les... | {"DogCapability": 100, "TruckCapability": 300, "DogCost": 50, "TruckCost": 100, "MaxBudget": 1000} | {"sets": [], "parameters": [{"name": "DogCapability", "description": "Number of fish transported per sled dog trip", "type": "scalar"}, {"name": "TruckCapability", "description": "Number of fish transported per truck trip", "type": "scalar"}, {"name": "DogCost", "description": "Cost per sled dog trip", "type": "scalar"... | {"objective": "Maximize total fish transported: DogCapability * x_dog + TruckCapability * x_truck", "constraints": ["Budget constraint: DogCost * x_dog + TruckCost * x_truck \u2264 MaxBudget", "Trip comparison constraint: x_dog \u2264 x_truck", "Non-negativity: x_dog \u2265 0, x_truck \u2265 0"]} | null | {"status": "NOT_EXECUTED", "objective_value": null, "decision_variables": null} |
prob_1 | LPWP | prob_1 | An office supply company makes two types of printers: color printers and black and white printers. Different sections of the factory with different teams produce each printer. The color printer team can produce at most 20 color printers per day while the black and white printer team can produce at most 30 black and whi... | {"color_printers": 20, "bw_printers": 15} | {"sets": [], "parameters": [{"name": "max_color", "description": "Maximum daily production capacity for color printers", "type": "scalar"}, {"name": "max_bw", "description": "Maximum daily production capacity for black and white printers", "type": "scalar"}, {"name": "max_total", "description": "Maximum daily capacity ... | {"objective": "Maximize total daily profit from printer production", "constraints": ["x_color \u2264 max_color", "x_bw \u2264 max_bw", "x_color + x_bw \u2264 max_total", "x_color \u2265 0", "x_bw \u2265 0"]} | from gurobipy import Model, GRB
def prob_1(color_printers, bw_printers):
"""
Linear Programming problem for printer production optimization.
Parameters:
color_printers (float): Profit per color printer
bw_printers (float): Profit per black and white printer
Returns:
list: [optimal... | {"status": "OPTIMAL", "objective_value": 625.0, "decision_variables": null} |
prob_10 | LPWP | prob_10 | A farmer wants to manufacture a special plant nutrition using fertilizers A and B. Each kg of fertilizer A contains 13 units of nitrogen, 5 units of phosphoric acid, 6 units of vitamin A and 5 units of vitamin D. Each kg of fertilizer B contains 8 units of nitrogen, 14 units of phosphoric acid, 6 units of vitamin A and... | {"A": 12, "B": 6, "constraint1": 219, "constraint2": 159, "constraint3": 117} | {"sets": [], "parameters": [{"name": "N_A", "description": "Nitrogen units per kg of fertilizer A", "type": "scalar"}, {"name": "P_A", "description": "Phosphoric acid units per kg of fertilizer A", "type": "scalar"}, {"name": "VA_A", "description": "Vitamin A units per kg of fertilizer A", "type": "scalar"}, {"name": "... | {"objective": "Minimize total vitamin D content: VD_A * x_A + VD_B * x_B", "constraints": ["Nitrogen requirement: N_A * x_A + N_B * x_B \u2265 MIN_NITROGEN", "Phosphoric acid requirement: P_A * x_A + P_B * x_B \u2265 MIN_PHOSPHORIC", "Vitamin A limit: VA_A * x_A + VA_B * x_B \u2264 MAX_VITAMIN_A", "Non-negativity: x_A ... | from gurobipy import Model, GRB
def solve_problem():
# Input data
A_cost = 12
B_cost = 6
nitrogen_min = 219
phosphoric_min = 159
vitamin_a_max = 117
try:
model = Model("plant_nutrition")
# Decision variables: kg of fertilizer A and B
x = model.addVar(vt... | {"status": "OPTIMAL", "objective_value": 192.60000000000002, "decision_variables": null} |
prob_100 | LPWP | prob_100 | A patient in the hospital can take two pills, Pill 1 and Pill 2. Per pill, pill 1 provides 0.2 units of pain medication and 0.3 units of anxiety medication. Per pill, pill 2 provides 0.6 units of pain medication and 0.2 units of anxiety medication. In addition, pill 1 causes 0.3 units of discharge while pill 2 causes 0... | {"Pill_1": 10, "Pill_2": 0} | {"sets": [], "parameters": [{"name": "pain_per_pill1", "description": "Units of pain medication per Pill 1", "type": "scalar"}, {"name": "pain_per_pill2", "description": "Units of pain medication per Pill 2", "type": "scalar"}, {"name": "anxiety_per_pill1", "description": "Units of anxiety medication per Pill 1", "type... | {"objective": "Minimize total discharge: 0.3*x1 + 0.1*x2", "constraints": ["Pain medication constraint: 0.2*x1 + 0.6*x2 \u2264 6", "Anxiety medication constraint: 0.3*x1 + 0.2*x2 \u2265 3", "Non-negativity: x1 \u2265 0, x2 \u2265 0"]} | import gurobipy as gp
from gurobipy import GRB
def prob_100(Pill_1, Pill_2):
"""
LP problem: Minimize discharge while meeting medication requirements
Args:
Pill_1: Maximum available pills of type 1
Pill_2: Maximum available pills of type 2
Returns:
List containing mini... | {"status": "OPTIMAL", "objective_value": null, "decision_variables": null} |
prob_101 | LPWP | prob_101 | A man on a strict diet only drinks meal replacement drinks from two brands, alpha and omega. The alpha brand drink contains 30 grams of protein, 20 grams of sugar, and 350 calories per bottle. The omega brand drink contains 20 grams of protein, 15 grams of sugar, and 300 calories per bottle. The man wants to get at lea... | {"alpha": 4, "omega": 2} | {"sets": [], "parameters": [{"name": "PROTEIN_ALPHA", "description": "Protein per bottle of alpha brand (grams)", "type": "scalar"}, {"name": "PROTEIN_OMEGA", "description": "Protein per bottle of omega brand (grams)", "type": "scalar"}, {"name": "SUGAR_ALPHA", "description": "Sugar per bottle of alpha brand (grams)", ... | {"objective": "Minimize total sugar intake: SUGAR_ALPHA * x_alpha + SUGAR_OMEGA * x_omega", "constraints": ["Protein requirement: PROTEIN_ALPHA * x_alpha + PROTEIN_OMEGA * x_omega \u2265 MIN_PROTEIN", "Calories requirement: CALORIES_ALPHA * x_alpha + CALORIES_OMEGA * x_omega \u2265 MIN_CALORIES", "Omega percentage limi... | from gurobipy import Model, GRB
def prob_101(input_data):
"""
Linear Programming problem: prob_101
Diet optimization with alpha and omega drinks
Args:
input_data: dict with 'alpha' and 'omega' costs per bottle
Returns:
list: [optimal objective value]
"""
try:
... | {"status": "OPTIMAL", "objective_value": null, "decision_variables": null} |
prob_102 | LPWP | prob_102 | A summer camps does science experiments in two pre filled beakers, beaker 1 and beaker 2. Beaker 1 uses 4 units of flour and 6 units of special liquid to make 5 units of slime. Beaker 2 uses 6 units of flour and 3 units of special liquid to make 3 units of slime. However, beaker 1 creates 4 units of waste while beaker... | {"beaker_1": 4, "beaker_2": 6, "constraint1": 5, "constraint2": 6, "constraint3": 3, "constraint4": 3, "constraint5": 4, "constraint6": 2} | {"sets": [], "parameters": [{"name": "flour_per_beaker1", "description": "Units of flour required per beaker 1", "type": "scalar"}, {"name": "liquid_per_beaker1", "description": "Units of special liquid required per beaker 1", "type": "scalar"}, {"name": "slime_per_beaker1", "description": "Units of slime produced per ... | {"objective": "Maximize total slime production: slime_per_beaker1*x1 + slime_per_beaker2*x2", "constraints": ["Flour constraint: flour_per_beaker1*x1 + flour_per_beaker2*x2 \u2264 flour_available", "Liquid constraint: liquid_per_beaker1*x1 + liquid_per_beaker2*x2 \u2264 liquid_available", "Waste constraint: waste_per_b... | import gurobipy as gp
from gurobipy import GRB
def prob_102():
try:
# Create a new model
model = gp.Model("slime_production")
# Decision variables: number of each beaker type
x1 = model.addVar(vtype=GRB.CONTINUOUS, name="beaker_1", lb=0)
x2 = model.addVar(vtype=GRB.... | {"status": "OPTIMAL", "objective_value": 45.0, "decision_variables": null} |
prob_103 | LPWP | prob_103 | An dog hospital has 2000 units of tooth medication to make both small and large bones. A small bone requires 10 units of tooth medication and 12 units of meat. A large bone requires 15 units of tooth medication and 15 units of meat. Since most dogs prefer the small bones, at least 50% of the bones made must be small. I... | {"small_bone": 30, "large_bone": 30, "medication_constraint": 2000, "small_bone_percentage_constraint": 50, "minimum_large_bone_constraint": 30} | {"sets": [], "parameters": [{"name": "TOTAL_MEDICATION", "description": "Total units of tooth medication available", "type": "scalar"}, {"name": "MED_PER_SMALL", "description": "Units of medication required per small bone", "type": "scalar"}, {"name": "MED_PER_LARGE", "description": "Units of medication required per la... | {"objective": "Minimize total meat usage: MEAT_PER_SMALL * x_small + MEAT_PER_LARGE * x_large", "constraints": ["Medication constraint: MED_PER_SMALL * x_small + MED_PER_LARGE * x_large \u2264 TOTAL_MEDICATION", "Percentage constraint: x_small \u2265 MIN_PERCENT_SMALL/100 * (x_small + x_large)", "Minimum large bones: x... | import gurobipy as gp
from gurobipy import GRB
def prob_103(small_bone, large_bone, medication_constraint, small_bone_percentage_constraint, minimum_large_bone_constraint):
try:
model = gp.Model("bone_production")
# Decision variables
x = model.addVar(vtype=GRB.CONTINUOUS, name="sm... | {"status": "OPTIMAL", "objective_value": 810.0, "decision_variables": null} |
prob_104 | LPWP | prob_104 | A scientist in the arctic needs to get enough vitamin D and vitamin C in his diet by drinking orange and apple juice. Each box of orange juice contains 10 units of vitamin D and 8 units of vitamin C. Each box of apple juice contains 12 units of vitamin D and 6 units of vitamin C. Since the scientist prefers apple juice... | {"orange_juice": 3.0, "apple_juice": 46.0} | {"sets": [], "parameters": [{"name": "vitamin_D_orange", "description": "Units of vitamin D per box of orange juice", "type": "scalar"}, {"name": "vitamin_C_orange", "description": "Units of vitamin C per box of orange juice", "type": "scalar"}, {"name": "vitamin_D_apple", "description": "Units of vitamin D per box of ... | {"objective": "Maximize total vitamin D intake: vitamin_D_orange * x_orange + vitamin_D_apple * x_apple", "constraints": ["x_orange \u2265 min_orange", "x_apple \u2265 3 * x_orange", "vitamin_C_orange * x_orange + vitamin_C_apple * x_apple \u2264 max_vitamin_C", "x_orange \u2265 0", "x_apple \u2265 0"]} | import gurobipy as gp
from gurobipy import GRB
def prob_104(orange_juice, apple_juice):
"""
Linear Programming problem for minimizing cost of juice consumption
while meeting vitamin requirements.
Parameters:
orange_juice: cost per box of orange juice
apple_juice: cost per box of apple juic... | {"status": "OPTIMAL", "objective_value": 423.0, "decision_variables": null} |
prob_105 | LPWP | prob_105 | A cleaning company uses a cleansing chemical and odor-removing chemical to clean a house. Each unit of the cleansing chemical takes 4 units to be effective while each unit of the odor-removing chemical takes 6 minutes to be effective. The company must use at least 100 units of the cleansing chemical. In total, at least... | {"cleansing_chemical": 200, "odor_removing_chemical": 100} | {"sets": [], "parameters": [{"name": "min_cleansing", "description": "Minimum units of cleansing chemical required", "type": "scalar"}, {"name": "min_total_chemicals", "description": "Minimum total units of chemicals required", "type": "scalar"}, {"name": "cleansing_time_per_unit", "description": "Time per unit of clea... | {"objective": "Minimize total cleaning time: 4x + 6y", "constraints": ["x \u2265 100 (minimum cleansing chemical requirement)", "x + y \u2265 300 (minimum total chemicals requirement)", "x \u2264 2y (cleansing chemical at most twice odor-removing chemical)", "x \u2265 0, y \u2265 0 (non-negativity)"]} | import gurobipy as gp
from gurobipy import GRB
def prob_105(cleansing_chemical, odor_removing_chemical):
"""
LP problem: Cleaning company chemicals optimization
Variables:
- x: units of cleansing chemical
- y: units of odor-removing chemical
Constraints:
- x >= 100 (at least 100 u... | {"status": "OPTIMAL", "objective_value": 1400.0, "decision_variables": null} |
prob_106 | LPWP | prob_106 | A drug company is making allergy pills and fever reducing pills in two factories, factory 1 and factory 2. Factory 1 produces 20 allergy pills and 15 fever reducing pills per hour. Factory 2 produces 10 allergy pills and 30 fever reducing pills per hour. Factory 1 is much more efficient and only requires 20 units of a... | {"factory_1": 32.0, "factory_2": 4.0} | {"sets": [{"name": "FACTORIES", "description": "Set of factories (factory 1 and factory 2)"}], "parameters": [{"name": "allergy_rate_1", "description": "Allergy pills produced per hour at factory 1", "type": "scalar"}, {"name": "fever_rate_1", "description": "Fever reducing pills produced per hour at factory 1", "type"... | {"objective": "Minimize total hours: hours_1 + hours_2", "constraints": ["Compound constraint: compound_usage_1 * hours_1 + compound_usage_2 * hours_2 \u2264 total_compound", "Allergy pills requirement: allergy_rate_1 * hours_1 + allergy_rate_2 * hours_2 \u2265 min_allergy", "Fever pills requirement: fever_rate_1 * hou... | import gurobipy as gp
from gurobipy import GRB
def solve_problem():
try:
# Create model
model = gp.Model("prob_106")
# Decision variables: hours each factory operates
factory_1 = model.addVar(vtype=GRB.CONTINUOUS, name="factory_1", lb=0)
factory_2 = model.addVar(vty... | {"status": "OPTIMAL", "objective_value": 1750.0, "decision_variables": null} |
prob_107 | LPWP | prob_107 | A doctor recommends her patient eat more fish and chicken to increase her protein and iron intake. Each fish meal contains 10 units of protein and 12 units of iron. Each chicken meal contains 15 units of protein and 8 units of iron. The patient needs to consume at least 130 units of protein and 120 units of iron. Since... | {"fish": 8, "chicken": 4} | {"sets": [], "parameters": [{"name": "protein_fish", "description": "Protein units per fish meal", "type": "scalar"}, {"name": "protein_chicken", "description": "Protein units per chicken meal", "type": "scalar"}, {"name": "iron_fish", "description": "Iron units per fish meal", "type": "scalar"}, {"name": "iron_chicken... | {"objective": "Minimize total fat intake: minimize fat_fish * x_fish + fat_chicken * x_chicken", "constraints": ["Protein requirement: protein_fish * x_fish + protein_chicken * x_chicken \u2265 min_protein", "Iron requirement: iron_fish * x_fish + iron_chicken * x_chicken \u2265 min_iron", "Preference constraint: x_chi... | from gurobipy import Model, GRB
def prob_107(fish=8, chicken=4):
"""
Linear Programming problem: prob_107
Minimize cost of fish and chicken meals while meeting nutritional requirements.
Args:
fish: Cost per fish meal (default 8)
chicken: Cost per chicken meal (default 4)
R... | {"status": "OPTIMAL", "objective_value": 60.0, "decision_variables": null} |
prob_108 | LPWP | prob_108 | A pharmaceutical company makes skin cream in batches, a regular batch and premium batch, to sell to hospitals. The regular batch requires 50 units of medicinal ingredients and 40 units of rehydration product. A premium batch requires 40 units of medicinal ingredients and 60 units of rehydration product. The company has... | {"regular_batch": 0, "premium_batch": 0} | {"sets": [], "parameters": [{"name": "med_ingredient_regular", "description": "Medicinal ingredients required per regular batch", "type": "scalar"}, {"name": "rehyd_regular", "description": "Rehydration product required per regular batch", "type": "scalar"}, {"name": "med_ingredient_premium", "description": "Medicinal ... | {"objective": "Maximize total number of people treated: maximize 50*x_regular + 30*x_premium", "constraints": ["Medicinal ingredients constraint: 50*x_regular + 40*x_premium \u2264 3000", "Rehydration product constraint: 40*x_regular + 60*x_premium \u2264 3500", "Regular batches less than premium batches: x_regular \u2... | from gurobipy import Model, GRB
def prob_108(regular_batch, premium_batch):
try:
model = Model("pharmaceutical_production")
# Decision variables
x = model.addVar(vtype=GRB.CONTINUOUS, name="regular_batch")
y = model.addVar(vtype=GRB.CONTINUOUS, name="premium_batch")
... | {"status": "OPTIMAL", "objective_value": 67.85714285714286, "decision_variables": null} |
prob_109 | LPWP | prob_109 | A clinic takes patient blood pressure either using an automatic machine or a manual machine. The automatic machine takes 10 minutes per patient while the manual machine takes 15 minutes per patient. Since the automatic machine frequently breaks, at least twice as many patients must have their blood pressure taken by th... | {"automatic_machine": 0, "manual_machine": 0} | {"sets": [], "parameters": [{"name": "time_auto", "description": "Time per patient on automatic machine (minutes)", "type": "scalar"}, {"name": "time_manual", "description": "Time per patient on manual machine (minutes)", "type": "scalar"}, {"name": "min_auto", "description": "Minimum patients on automatic machine", "t... | {"objective": "Maximize total number of patients processed", "constraints": ["Time constraint: 10*x_auto + 15*x_manual \u2264 20000", "Manual machine requirement: x_manual \u2265 2*x_auto", "Minimum automatic machine usage: x_auto \u2265 20", "Non-negativity: x_auto \u2265 0, x_manual \u2265 0"]} | import gurobipy as gp
from gurobipy import GRB
def prob_109(automatic_machine, manual_machine):
"""
LP problem: Maximize patient throughput with automatic and manual blood pressure machines
Variables:
x = number of patients processed by automatic machine
y = number of patients processe... | {"status": "OPTIMAL", "objective_value": 1500.0, "decision_variables": null} |
prob_11 | LPWP | prob_11 | Mrs. Watson wants to invest in the real-estate market and has a total budget of at most $760000. She has two choices which include condos and detached houses. Each dollar invested in condos yields a $0.50 profit and each dollar invested in detached houses yields a $1 profit. A minimum of 20% of all money invested must ... | {"condos": 152000.0, "detached_houses": 608000.0} | {"sets": [], "parameters": [{"name": "BUDGET", "description": "Maximum total investment budget ($760,000)", "type": "scalar"}, {"name": "CONDO_MIN_PERCENT", "description": "Minimum percentage of total investment that must be in condos (20%)", "type": "scalar"}, {"name": "DETACHED_MIN", "description": "Minimum amount th... | {"objective": "Maximize total profit = 0.5*x_c + 1.0*x_d", "constraints": ["x_c + x_d \u2264 760000 (total budget constraint)", "x_c \u2265 0.2*(x_c + x_d) (minimum 20% investment in condos)", "x_d \u2265 20000 (minimum investment in detached houses)", "x_c \u2265 0, x_d \u2265 0 (non-negativity)"]} | from gurobipy import GRB, Model
def solve_prob_11():
model = None
try:
model = Model("prob_11")
# Variables: condos (x) and detached houses (y)
x = model.addVar(lb=0, vtype=GRB.CONTINUOUS, name="condos")
y = model.addVar(lb=20000, vtype=GRB.CONTINUOUS, name="detached_ho... | {"status": "OPTIMAL", "objective_value": 684000.0, "decision_variables": null} |
prob_110 | LPWP | prob_110 | A patient with a sore throat can drink two syrups, syrup 1 and syrup 2 for treatment. Per serving, syrup 1 delivers 0.5 units of medicine to the throat and 0.4 units of medicine to the lungs. Per serving, syrup 2 delivers 0.2 units of medicine to the throat and 0.5 units of medicine to the lungs. Furthermore, syrup 1 c... | {"syrup_1": 0.0, "syrup_2": 10.0} | {"sets": [], "parameters": [{"name": "throat_med_syrup1", "description": "Medicine delivered to throat per serving of syrup 1", "type": "scalar"}, {"name": "lung_med_syrup1", "description": "Medicine delivered to lungs per serving of syrup 1", "type": "scalar"}, {"name": "throat_med_syrup2", "description": "Medicine de... | {"objective": "Minimize total sugar intake: sugar_syrup1*x1 + sugar_syrup2*x2", "constraints": ["Throat medicine constraint: throat_med_syrup1*x1 + throat_med_syrup2*x2 \u2264 max_throat_medicine", "Lung medicine constraint: lung_med_syrup1*x1 + lung_med_syrup2*x2 \u2265 min_lung_medicine", "Non-negativity: x1 \u2265 0... | import gurobipy as gp
from gurobipy import GRB
def solve_problem(input_data):
"""
Linear Programming problem: prob_110
Minimize sugar while meeting medicine requirements for throat and lungs.
Constraints:
- Throat medicine <= 5 units
- Lung medicine >= 4 units
- Sugar <= 4 units (... | {"status": "OPTIMAL", "objective_value": 2.4, "decision_variables": null} |
prob_111 | LPWP | prob_111 | A sailor can eat either a crab cakes or a lobster roll for his meals. He needs to ensure he gets at least 80 units of vitamin A and 100 units of vitamin C. Each crab cake contains 5 units of vitamin A and 7 units of vitamin C. Each lobster roll contains 8 units of vitamin A and 4 units of vitamin C. In addition, since ... | {"crab_cakes": 16, "lobster_roll": 0, "constraint1": 5, "constraint2": 7, "constraint3": 8, "constraint4": 4, "constraint5": 4, "constraint6": 6} | {"sets": [], "parameters": [{"name": "vitamin_A_min", "description": "Minimum required units of vitamin A", "type": "scalar"}, {"name": "vitamin_C_min", "description": "Minimum required units of vitamin C", "type": "scalar"}, {"name": "vitamin_A_crab", "description": "Units of vitamin A per crab cake", "type": "scalar"... | {"objective": "Minimize total unsaturated fat intake: 4x + 6y", "constraints": ["Vitamin A requirement: 5x + 8y \u2265 80", "Vitamin C requirement: 7x + 4y \u2265 100", "Lobster proportion constraint: y \u2264 0.4(x + y)", "Non-negativity: x \u2265 0, y \u2265 0"]} | import gurobipy as gp
from gurobipy import GRB
def solve():
try:
model = gp.Model("prob_111")
x = model.addVar(vtype=GRB.INTEGER, name="crab_cakes", lb=0)
y = model.addVar(vtype=GRB.INTEGER, name="lobster_roll", lb=0)
model.setObjective(4*x + 6*y, GRB.MINIMIZE)
model.addCons... | {"status": "OPTIMAL", "objective_value": 64.0, "decision_variables": null} |
prob_112 | LPWP | prob_112 | A science show preforms two different demonstrations, demonstration 1 and demonstration 2. In demonstration 1, 10 units of mint and 20 units of the active ingredient is used to make 25 units of minty foam. In demonstration 2, 12 units of mint and 15 units of the active ingredient is used to make 18 units of minty foam.... | {"demonstration_1": 5.0, "demonstration_2": 0.0, "_10": 10, "_20": 20, "_25": 25, "_12": 12, "_15": 15, "_18": 18, "_5": 5, "_3": 3, "_120": 120, "_100": 100, "_50": 50} | {"sets": [], "parameters": [{"name": "mint_per_demo1", "description": "Units of mint required for demonstration 1", "type": "scalar"}, {"name": "active_per_demo1", "description": "Units of active ingredient required for demonstration 1", "type": "scalar"}, {"name": "foam_per_demo1", "description": "Units of minty foam ... | {"objective": "Maximize total minty foam production: foam_per_demo1*x1 + foam_per_demo2*x2", "constraints": ["Mint availability: mint_per_demo1*x1 + mint_per_demo2*x2 \u2264 mint_available", "Active ingredient availability: active_per_demo1*x1 + active_per_demo2*x2 \u2264 active_available", "Black tar limit: tar_per_de... | from gurobipy import Model, GRB
def solve_problem():
try:
model = Model("prob_112")
# Variables: number of demonstrations
demo1 = model.addVar(vtype=GRB.CONTINUOUS, name="demonstration_1", lb=0)
demo2 = model.addVar(vtype=GRB.CONTINUOUS, name="demonstration_2", lb=0)
... | {"status": "OPTIMAL", "objective_value": 125.0, "decision_variables": null} |
prob_113 | LPWP | prob_113 | A lab has 20000 mg of mRNA anti-viral available to make children's and adult vaccines. Each children's vaccine contains 50 mg of mRNA and 50 mg of fever suppressant. Each adult vaccine contains 75 mg of mRNA and 75 mg of fever suppressant. Since adult vaccines are more essential, at least 70% of vaccines should be adul... | {"children_vaccines": 50, "adult_vaccines": 0} | {"sets": [], "parameters": [{"name": "TOTAL_MRNA", "description": "Total available mRNA in mg", "type": "scalar"}, {"name": "MRNA_PER_CHILD", "description": "mRNA per children's vaccine in mg", "type": "scalar"}, {"name": "MRNA_PER_ADULT", "description": "mRNA per adult vaccine in mg", "type": "scalar"}, {"name": "FEVE... | {"objective": "Minimize total fever suppressant used: FEVER_PER_CHILD * x_c + FEVER_PER_ADULT * x_a", "constraints": ["mRNA availability: MRNA_PER_CHILD * x_c + MRNA_PER_ADULT * x_a \u2264 TOTAL_MRNA", "Adult vaccine percentage: x_a \u2265 ADULT_PERCENTAGE * (x_c + x_a)", "Minimum children's vaccines: x_c \u2265 MIN_CH... | from gurobipy import Model, GRB
def solve_problem():
try:
model = Model("vaccine_production")
# Decision variables
# C = number of children's vaccines
# A = number of adult vaccines
C = model.addVar(vtype=GRB.INTEGER, lb=0, name="children_vaccines")
A = mode... | {"status": "OPTIMAL", "objective_value": 11275.0, "decision_variables": null} |
prob_114 | LPWP | prob_114 | A parent feeds their baby two flavors of baby food, apple and carrot, in order to meet the babies fat and folate requirements. Each serving of apple flavored baby food contains 2 units of fat and 5 units of folate. Each serving of carrot flavored baby food contains 4 units of fat and 3 units of folate. The baby does no... | {"apple_flavored_baby": 45, "carrot_flavored_baby": 2} | {"sets": [], "parameters": [{"name": "fat_per_apple", "description": "Fat units per serving of apple baby food", "type": "scalar"}, {"name": "folate_per_apple", "description": "Folate units per serving of apple baby food", "type": "scalar"}, {"name": "fat_per_carrot", "description": "Fat units per serving of carrot bab... | {"objective": "Maximize total fat intake: maximize 2A + 4C", "constraints": ["A = 3C (baby must eat three times as many apple servings as carrot servings)", "C \u2265 2 (minimum carrot servings requirement)", "5A + 3C \u2264 100 (folate consumption limit)", "A \u2265 0, C \u2265 0 (non-negativity)"]} | import gurobipy as gp
from gurobipy import GRB
def prob_114(apple_flavored_baby, carrot_flavored_baby):
"""
Calculate total fat content for baby food servings.
Each serving of apple flavored baby food contains 2 units of fat.
Each serving of carrot flavored baby food contains 4 units of fat.
... | {"status": "OPTIMAL", "objective_value": 98.0, "decision_variables": null} |
prob_115 | LPWP | prob_115 | Both fertilizer and seeds need to be added to a lawn. One unit of fertilizer takes 0.5 minutes to be effective while one unit of seeds takes 1.5 minutes to be effective. There can be at most 300 units of fertilizer and seeds combined added to the lawn. In addition at least 50 units of fertilizer need to be added. Since... | {"fertilizer": 50.0, "seeds": 25.0} | {"sets": [], "parameters": [{"name": "MAX_TOTAL_UNITS", "description": "Maximum combined units of fertilizer and seeds", "type": "scalar"}, {"name": "MIN_FERTILIZER", "description": "Minimum units of fertilizer required", "type": "scalar"}, {"name": "FERTILIZER_TIME_PER_UNIT", "description": "Time per unit of fertilize... | {"objective": "Minimize total time = 0.5*x_f + 1.5*x_s", "constraints": ["x_f + x_s \u2264 300", "x_f \u2265 50", "x_f \u2264 2*x_s", "x_f \u2265 0", "x_s \u2265 0"]} | import gurobipy as gp
from gurobipy import GRB
def prob_115():
try:
# Create a new model
model = gp.Model("prob_115")
# Create variables
# Fertilizer: at least 50 units
fertilizer = model.addVar(vtype=GRB.CONTINUOUS, name="fertilizer", lb=50.0)
# Seeds: no e... | {"status": "OPTIMAL", "objective_value": 62.5, "decision_variables": null} |
prob_116 | LPWP | prob_116 | A pharmacy has two factories, factory 1 and factory 2, where they make acne cream and anti-bacterial cream. Factory 1 produces 12 units of acne cream and 15 units of anti-bacterial cream per hour. Factory 2 produces 20 units of acne cream and 10 units of anti-bacterial cream per hour. Factory 1 requires 30 units of bas... | {"factory_1": 12, "factory_2": 20, "base_gel": 45} | {"sets": [{"name": "FACTORIES", "description": "Set of factories (factory 1 and factory 2)"}], "parameters": [{"name": "acne_per_hour_f1", "description": "Units of acne cream produced per hour at factory 1", "type": "scalar"}, {"name": "acne_per_hour_f2", "description": "Units of acne cream produced per hour at factory... | {"objective": "Minimize total hours: hours_f1 + hours_f2", "constraints": ["Base gel constraint: base_gel_per_hour_f1 * hours_f1 + base_gel_per_hour_f2 * hours_f2 \u2264 total_base_gel", "Acne cream requirement: acne_per_hour_f1 * hours_f1 + acne_per_hour_f2 * hours_f2 \u2265 min_acne", "Anti-bacterial cream requiremen... | import gurobipy as gp
from gurobipy import GRB
def prob_116(factory_1, factory_2, base_gel):
"""
LP problem: Pharmacy factory optimization
Variables:
- x1: hours factory 1 operates
- x2: hours factory 2 operates
Constraints:
- Base gel: 30*x1 + 45*x2 <= 5000
- Acne cream: 12*x... | {"status": "OPTIMAL", "objective_value": 40.0, "decision_variables": null} |
prob_117 | LPWP | prob_117 | A doctor recommends that a man eat burgers and pizza in order to put on weight. Each burger contains 10 units of fat and 300 calories. Each slice of pizza contains 8 units of fat and 250 calories. The man must get at least 130 units of fat and 3000 calories. Further, each burger contains 12 units of cholesterol while e... | {"burgers": 5, "pizza": 10} | {"sets": [], "parameters": [{"name": "fat_per_burger", "description": "Units of fat per burger", "type": "scalar"}, {"name": "calories_per_burger", "description": "Calories per burger", "type": "scalar"}, {"name": "chol_per_burger", "description": "Units of cholesterol per burger", "type": "scalar"}, {"name": "fat_per_... | {"objective": "Minimize total cholesterol intake: 12*x_b + 10*x_p", "constraints": ["Fat requirement: 10*x_b + 8*x_p \u2265 130", "Calorie requirement: 300*x_b + 250*x_p \u2265 3000", "Pizza-to-burger ratio: x_p \u2265 2*x_b", "Non-negativity: x_b \u2265 0, x_p \u2265 0"]} | from gurobipy import Model, GRB
def solve_problem():
try:
model = Model("Diet_Problem")
# Decision variables
burgers = model.addVar(vtype=GRB.CONTINUOUS, name="burgers", lb=0)
pizza = model.addVar(vtype=GRB.CONTINUOUS, name="pizza", lb=0)
# Objective: Minim... | {"status": "OPTIMAL", "objective_value": 15.0, "decision_variables": null} |
prob_118 | LPWP | prob_118 | A clinic makes batches of vitamin shots and pills. Each batch of vitamin shots requires 30 units of vitamin C and 40 units of vitamin D. Each batch of vitamin pills requires 50 units of vitamin C and 30 units of vitamin D. Since pills are more popular, the number of batches of vitamin pills must be larger than the numb... | {"vitamin_shots": 10, "pills": 7, "var1": 30, "var2": 40, "var3": 50, "var4": 30, "var5": 10, "var6": 7} | {"sets": [], "parameters": [{"name": "vitamin_c_per_shot", "description": "Units of vitamin C required per batch of vitamin shots", "type": "scalar"}, {"name": "vitamin_d_per_shot", "description": "Units of vitamin D required per batch of vitamin shots", "type": "scalar"}, {"name": "vitamin_c_per_pill", "description": ... | {"objective": "Maximize total number of people supplied: maximize 10*x_s + 7*x_p", "constraints": ["Vitamin C availability: 30*x_s + 50*x_p \u2264 1200", "Vitamin D availability: 40*x_s + 30*x_p \u2264 1500", "Popularity constraint: x_p \u2265 x_s", "Maximum shots production: x_s \u2264 10", "Non-negativity: x_s \u2265... | import gurobipy as gp
from gurobipy import GRB
def prob_118(vitamin_shots, pills, var1, var2, var3, var4, var5, var6):
"""
Args:
vitamin_shots: max batches of vitamin shots (10)
pills: parameter related to pills (7)
var1: vitamin C per shot batch (30)
var2: vitamin D per shot ba... | {"status": "OPTIMAL", "objective_value": 226.0, "decision_variables": null} |
prob_119 | LPWP | prob_119 | A doctor's office takes the temperature of patients one by one either by using an electronic or regular thermometer. The electronic thermometer takes 3 minutes to make a reading while the regular thermometer takes 2 minutes to make a reading. Since the electronic thermometer is more accurate, at least twice as many pa... | {"electronic_thermometer": 3750, "regular_thermometer": 1875, "electronic_constraint": 3750, "regular_constraint": 50, "time_constraint": 15000} | {"sets": [], "parameters": [{"name": "time_electronic", "description": "Time required per patient using electronic thermometer (minutes)", "type": "scalar"}, {"name": "time_regular", "description": "Time required per patient using regular thermometer (minutes)", "type": "scalar"}, {"name": "min_ratio_electronic", "desc... | {"objective": "Maximize total number of patients: x_e + x_r", "constraints": ["Time constraint: time_electronic * x_e + time_regular * x_r \u2264 total_time", "Ratio constraint: x_e \u2265 min_ratio_electronic * x_r", "Minimum regular patients: x_r \u2265 min_regular_patients", "Non-negativity: x_e \u2265 0, x_r \u2265... | from gurobipy import Model, GRB
def solve_problem():
try:
model = Model("prob_119")
# Decision variables
# x: number of patients using electronic thermometer
# y: number of patients using regular thermometer
x = model.addVar(vtype=GRB.CONTINUOUS, name="electronic")
... | {"status": "OPTIMAL", "objective_value": 17578125.0, "decision_variables": null} |
prob_12 | LPWP | prob_12 | A breakfast joint makes two different sandwiches: a regular and a special. Both need eggs and bacon. Each regular sandwich requires 2 eggs and 3 slices of bacon. Each special sandwich requires 3 eggs and 5 slices of bacon. The joint has a total of 40 eggs and 70 slices of bacon. It makes a profit of $3 per regular sand... | {"regular": 20, "special": 0, "constraint1": 40, "constraint2": 60} | {"sets": [], "parameters": [{"name": "EGGS_PER_REGULAR", "description": "Eggs required per regular sandwich", "type": "scalar"}, {"name": "BACON_PER_REGULAR", "description": "Bacon slices required per regular sandwich", "type": "scalar"}, {"name": "EGGS_PER_SPECIAL", "description": "Eggs required per special sandwich",... | {"objective": "Maximize total profit from sandwich sales", "constraints": ["Egg constraint: EGGS_PER_REGULAR * x_reg + EGGS_PER_SPECIAL * x_spec \u2264 TOTAL_EGGS", "Bacon constraint: BACON_PER_REGULAR * x_reg + BACON_PER_SPECIAL * x_spec \u2264 TOTAL_BACON", "Non-negativity: x_reg \u2265 0, x_spec \u2265 0"]} | import gurobipy as gp
from gurobipy import GRB
def solve_problem():
try:
model = gp.Model("prob_12")
x = model.addVar(vtype=GRB.INTEGER, name="regular")
y = model.addVar(vtype=GRB.INTEGER, name="special")
model.setObjective(3*x + 4*y, GRB.MAXIMIZE)
model.ad... | {"status": "OPTIMAL", "objective_value": 60.0, "decision_variables": null} |
prob_120 | LPWP | prob_120 | A patient can be hooked up to two machines to have medicine delivered, machine 1 and machine 2. Machine 1 delivers 0.5 units of medicine to the heart per minute and 0.8 units of medicine per minute to the brain. Machine 2 delivers 0.3 units of medicine per minute to the heart and 1 unit of medicine per minute to the br... | {"machine_1": 5.0, "machine_2": 0.0} | {"sets": [], "parameters": [{"name": "heart_limit", "description": "Maximum units of medicine the heart can receive", "type": "scalar"}, {"name": "brain_min", "description": "Minimum units of medicine the brain should receive", "type": "scalar"}, {"name": "m1_heart_rate", "description": "Medicine delivery rate to heart... | {"objective": "Minimize total waste produced: 0.3x1 + 0.5x2", "constraints": ["Heart medicine constraint: 0.5x1 + 0.3x2 \u2264 8", "Brain medicine constraint: 0.8x1 + 1.0x2 \u2265 4", "Non-negativity: x1 \u2265 0, x2 \u2265 0"]} | import gurobipy as gp
from gurobipy import GRB
def prob_120(machine_1, machine_2):
"""
LP problem: Minimize waste from machines given time constraints.
Machine 1 creates 0.3 units waste per minute
Machine 2 creates 0.5 units waste per minute
Args:
machine_1: Maximum time machine 1... | {"status": "OPTIMAL", "objective_value": null, "decision_variables": null} |
prob_121 | LPWP | prob_121 | A travelling salesman only eats ramen and fries. Each pack of ramen contains 400 calories, 20 grams of protein, and 100 mg of sodium. Each pack of fries contains 300 calories, 10 grams of protein, and 75 mg of sodium. Since fries are easier to eat while driving, at most 30% of his meals can be ramen. The salesman wants... | {"ramen": 0.0, "fries": 10.0} | {"sets": [], "parameters": [{"name": "ramen_calories", "description": "Calories per pack of ramen", "type": "scalar"}, {"name": "ramen_protein", "description": "Protein per pack of ramen (grams)", "type": "scalar"}, {"name": "ramen_sodium", "description": "Sodium per pack of ramen (mg)", "type": "scalar"}, {"name": "fr... | {"objective": "Minimize total sodium intake: ramen_sodium * x_ramen + fries_sodium * x_fries", "constraints": ["Calorie requirement: ramen_calories * x_ramen + fries_calories * x_fries \u2265 min_calories", "Protein requirement: ramen_protein * x_ramen + fries_protein * x_fries \u2265 min_protein", "Ramen proportion co... | import gurobipy as gp
from gurobipy import GRB
def prob_121(ramen, fries):
"""
Args:
ramen: initial value (not used in optimization)
fries: initial value (not used in optimization)
Returns:
list: [minimum_sodium_intake]
"""
try:
# Create a new model
mode... | {"status": "OPTIMAL", "objective_value": 750.0, "decision_variables": null} |
prob_122 | LPWP | prob_122 | A science store makes two boxes, a cheap and expensive box. The cheap box contains 3 units of metal and 5 units of acid which can be mixed to create 8 units of foam. The expensive box contains 5 units of metal and 8 units of acid which can be mixed to create 10 units of foam. The cheap box however gives off 2 units of ... | {"cheap_box": 25, "expensive_box": 0, "constraint1": [3, 5, 200], "constraint2": [5, 8, 300], "constraint3": [2, 3, 50]} | {"sets": [], "parameters": [{"name": "metal_cheap", "description": "Units of metal per cheap box", "type": "scalar"}, {"name": "metal_expensive", "description": "Units of metal per expensive box", "type": "scalar"}, {"name": "acid_cheap", "description": "Units of acid per cheap box", "type": "scalar"}, {"name": "acid_e... | {"objective": "Maximize total foam production: 8*x1 + 10*x2", "constraints": ["Metal constraint: 3*x1 + 5*x2 \u2264 200", "Acid constraint: 5*x1 + 8*x2 \u2264 300", "Heat constraint: 2*x1 + 3*x2 \u2264 50", "Non-negativity: x1 \u2265 0, x2 \u2265 0"]} | import gurobipy as gp
from gurobipy import GRB
def prob_122():
try:
# Create model
model = gp.Model("prob_122")
# Decision variables
# x = number of cheap boxes
# y = number of expensive boxes
x = model.addVar(vtype=GRB.CONTINUOUS, name="cheap_box", lb=0)
... | {"status": "OPTIMAL", "objective_value": 200.0, "decision_variables": null} |
prob_123 | LPWP | prob_123 | A pharmacy has 3000 mg of morphine to make painkillers and sleeping pills. Each painkiller pill requires 10 mg of morphine and 3 units of digestive medicine. Each sleeping pill requires 6 mg of morphine and 5 units of digestive medicine. The pharmacy needs to make at least 50 painkiller pills. Since sleeping pills are ... | {"painkillers": 50.0, "sleeping_pills": 117.0} | {"sets": [{"name": "PILL_TYPES", "description": "Set of pill types: painkillers and sleeping pills"}], "parameters": [{"name": "MORPHINE_AVAILABLE", "description": "Total morphine available in mg", "type": "scalar"}, {"name": "MORPHINE_PER_PAINKILLER", "description": "Morphine required per painkiller pill in mg", "type... | {"objective": "Minimize total digestive medicine needed: 3x_p + 5x_s", "constraints": ["Morphine constraint: 10x_p + 6x_s \u2264 3000", "Minimum painkillers: x_p \u2265 50", "Sleeping pill ratio: x_s \u2265 0.7(x_p + x_s)", "Non-negativity: x_p \u2265 0, x_s \u2265 0"]} | import gurobipy as gp
from gurobipy import GRB
def prob_123(input_data):
try:
# Create a new model
model = gp.Model("pharmacy_production")
# Extract input values
painkillers_min = input_data["painkillers"]
# Note: The input also provides a value for sleeping_pills, ... | {"status": "OPTIMAL", "objective_value": null, "decision_variables": null} |
prob_124 | LPWP | prob_124 | A boy needs to get enough magnesium and zinc in his diet by eating chewable gummies and taking pills. Each gummy contains 3 units of magnesium and 4 units of zinc. Each pill contains 2 units of magnesium and 5 units of zinc. The boy must take at least 10 pills. Since he prefers gummies more, he must eat at least 3 time... | {"gummies": 40, "pills": 40, "constraint1": 3, "constraint2": 4, "constraint3": 2, "constraint4": 5, "constraint5": 3} | {"sets": [], "parameters": [{"name": "mg_per_gummy", "description": "Magnesium units per gummy", "type": "scalar"}, {"name": "zn_per_gummy", "description": "Zinc units per gummy", "type": "scalar"}, {"name": "mg_per_pill", "description": "Magnesium units per pill", "type": "scalar"}, {"name": "zn_per_pill", "descriptio... | {"objective": "Maximize total zinc intake: zn_per_gummy * x_g + zn_per_pill * x_p", "constraints": ["x_p \u2265 min_pills (minimum pills requirement)", "x_g \u2265 gummy_pill_ratio * x_p (gummies must be at least 3 times pills)", "mg_per_gummy * x_g + mg_per_pill * x_p \u2264 max_magnesium (magnesium limit)", "x_g \u22... | import gurobipy as gp
from gurobipy import GRB
def prob_124(gummies, pills, constraint1, constraint2, constraint3, constraint4, constraint5):
"""
Linear Programming problem to maximize zinc intake.
Variables:
g = number of gummies
p = number of pills
Objective: Maximize zinc =... | {"status": "OPTIMAL", "objective_value": 225.0, "decision_variables": null} |
prob_125 | LPWP | prob_125 | A patient takes anxiety medication and anti-depressants one after the other. Each unit of anxiety medication takes 3 minutes to be effective while each unit of anti-depressant takes 5 minutes to be effective. The patient must take at least 100 units of medication and at least 30 should be anxiety medication. Since the ... | {"anxiety_medication": 66, "anti_depressants": 34} | {"sets": [], "parameters": [{"name": "time_per_anxiety_unit", "description": "Time per unit of anxiety medication (minutes)", "type": "scalar"}, {"name": "time_per_anti_depressant_unit", "description": "Time per unit of anti-depressant (minutes)", "type": "scalar"}, {"name": "min_total_medication", "description": "Mini... | {"objective": "Minimize total time for medication to be effective: 3x + 5y", "constraints": ["Total medication requirement: x + y \u2265 100", "Minimum anxiety medication: x \u2265 30", "Maximum anxiety to anti-depressant ratio: x \u2264 2y", "Non-negativity: x \u2265 0, y \u2265 0"]} | import gurobipy as gp
from gurobipy import GRB
def solve_problem():
try:
# Create model
model = gp.Model("medication_optimization")
# Decision variables
# x = units of anxiety medication
# y = units of anti-depressants
x = model.addVar(vtype=GRB.CONTINUOUS, ... | {"status": "OPTIMAL", "objective_value": 366.6666666666667, "decision_variables": null} |
prob_126 | LPWP | prob_126 | A pharmacy makes eye cream and foot cream using two different machines, machine 1 and machine 2. Machine 1 can make 30 ml of eye cream and 60 ml of foot cream per hour. Machine 2 can make 45 ml of eye cream and 30 ml of foot cream per hour. Furthermore, machine 1 requires 20 ml of distilled water per hour while machin... | {"machine_1": 15, "machine_2": 18, "constraint1": 570, "constraint2": 1260, "constraint3": 1440} | {"sets": [{"name": "MACHINES", "description": "Set of machines (machine 1 and machine 2)"}], "parameters": [{"name": "eye_cream_rate_m1", "description": "Eye cream production rate for machine 1 (ml/hour)", "type": "scalar"}, {"name": "foot_cream_rate_m1", "description": "Foot cream production rate for machine 1 (ml/hou... | {"objective": "Minimize total time: x1 + x2", "constraints": ["Water constraint: water_usage_m1*x1 + water_usage_m2*x2 \u2264 total_water_available", "Eye cream requirement: eye_cream_rate_m1*x1 + eye_cream_rate_m2*x2 \u2265 min_eye_cream", "Foot cream requirement: foot_cream_rate_m1*x1 + foot_cream_rate_m2*x2 \u2265 m... | from gurobipy import Model, GRB
def prob_126(machine_1, machine_2, constraint1, constraint2, constraint3):
"""
LP problem for cream production optimization
Args:
machine_1: hours available for machine 1
machine_2: hours available for machine 2
constraint1: water constraint (ml)... | {"status": "OPTIMAL", "objective_value": 33.0, "decision_variables": null} |
prob_127 | LPWP | prob_127 | A woman eats cashews and almonds to get her calorie and protein intake. A serving of almonds contains 200 calories and 20 grams of protein. A serving of cashews contains 300 calories and 25 grams of protein. The woman decides to eat at least twice as many servings of almonds as cashews. Furthermore, a serving of almond... | {"cashews": 14.0, "almonds": 29.0, "_200": 200, "_20": 20, "_300": 300, "_25": 25, "twice": 2, "_15": 15, "_12": 12, "_10000": 10000, "_800": 800} | {"sets": [], "parameters": [{"name": "calories_almonds", "description": "Calories per serving of almonds", "type": "scalar"}, {"name": "protein_almonds", "description": "Protein (grams) per serving of almonds", "type": "scalar"}, {"name": "calories_cashews", "description": "Calories per serving of cashews", "type": "sc... | {"objective": "Minimize total fat intake: fat_almonds * x_a + fat_cashews * x_c", "constraints": ["Calorie requirement: calories_almonds * x_a + calories_cashews * x_c \u2265 min_calories", "Protein requirement: protein_almonds * x_a + protein_cashews * x_c \u2265 min_protein", "Almonds to cashews ratio: x_a \u2265 2 *... | from gurobipy import Model, GRB
def prob_127():
try:
model = Model("prob_127")
# Decision variables
almonds = model.addVar(vtype=GRB.CONTINUOUS, name="almonds", lb=0)
cashews = model.addVar(vtype=GRB.CONTINUOUS, name="cashews", lb=0)
# Objective: Minimize f... | {"status": "OPTIMAL", "objective_value": 600.0, "decision_variables": null} |
prob_128 | LPWP | prob_128 | A company make both liquid and foam hand sanitizer. Liquid hand sanitizer requires 40 units of water and 50 units of alcohol. Foam hand sanitizer requires 60 units of water and 40 units of alcohol. The company has available 2000 units of water and 2100 units of alcohol. The number of foam hand sanitizers made must exce... | {"liquid_hand_sanitizer": 20.0, "foam_hand_sanitizer": 20.0, "water": 40, "alcohol": 50, "available_water": 2000, "available_alcohol": 2100, "liquid_constraint": 30, "foam_constraint": 20} | {"sets": [], "parameters": [{"name": "water_per_liquid", "description": "Water units required per liquid hand sanitizer", "type": "scalar"}, {"name": "alcohol_per_liquid", "description": "Alcohol units required per liquid hand sanitizer", "type": "scalar"}, {"name": "water_per_foam", "description": "Water units require... | {"objective": "Maximize total number of hands cleaned: hands_per_liquid * x_liquid + hands_per_foam * x_foam", "constraints": ["Water constraint: water_per_liquid * x_liquid + water_per_foam * x_foam \u2264 available_water", "Alcohol constraint: alcohol_per_liquid * x_liquid + alcohol_per_foam * x_foam \u2264 available... | from gurobipy import Model, GRB
def prob_128():
try:
model = Model("prob_128")
# Decision variables
liquid = model.addVar(vtype=GRB.CONTINUOUS, name="liquid")
foam = model.addVar(vtype=GRB.CONTINUOUS, name="foam")
# Objective: maximize hands cleaned
... | {"status": "OPTIMAL", "objective_value": 1000.0, "decision_variables": null} |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 1