KP/KP_L_context.csv

task_name,problem_type,instruction,instance,solution,obj,instance_variant,solution_variant,context_index,input_format,input_index_base
KP,KP,"I’m squeezing into a tiny apartment and have only one carload to get there, so it’s down to choosing which boxes to bring. Each box has a little “sentimental value” number and a weight, and the idea is to pick a set of boxes whose sentimental numbers add up to as much as possible while the combined weight stays under the car’s limit. Boxes can’t be split or duplicated — each box is either in the car or left behind — and the exact list of boxes, their weights and sentimental values are shown below.

{
  ""car_load_capacity"": 582,
  ""items"": [
    {
      ""box_id"": 1,
      ""box_weight"": 78,
      ""sentimental_value"": 19
    },
    {
      ""box_id"": 2,
      ""box_weight"": 66,
      ""sentimental_value"": 93
    },
    {
      ""box_id"": 3,
      ""box_weight"": 44,
      ""sentimental_value"": 79
    },
    {
      ""box_id"": 4,
      ""box_weight"": 44,
      ""sentimental_value"": 65
    },
    {
      ""box_id"": 5,
      ""box_weight"": 86,
      ""sentimental_value"": 41
    },
    {
      ""box_id"": 6,
      ""box_weight"": 9,
      ""sentimental_value"": 83
    },
    {
      ""box_id"": 7,
      ""box_weight"": 70,
      ""sentimental_value"": 55
    },
    {
      ""box_id"": 8,
      ""box_weight"": 21,
      ""sentimental_value"": 45
    },
    {
      ""box_id"": 9,
      ""box_weight"": 10,
      ""sentimental_value"": 46
    },
    {
      ""box_id"": 10,
      ""box_weight"": 53,
      ""sentimental_value"": 23
    },
    {
      ""box_id"": 11,
      ""box_weight"": 98,
      ""sentimental_value"": 10
    },
    {
      ""box_id"": 12,
      ""box_weight"": 74,
      ""sentimental_value"": 56
    },
    {
      ""box_id"": 13,
      ""box_weight"": 77,
      ""sentimental_value"": 89
    },
    {
      ""box_id"": 14,
      ""box_weight"": 72,
      ""sentimental_value"": 7
    },
    {
      ""box_id"": 15,
      ""box_weight"": 79,
      ""sentimental_value"": 86
    },
    {
      ""box_id"": 16,
      ""box_weight"": 52,
      ""sentimental_value"": 83
    },
    {
      ""box_id"": 17,
      ""box_weight"": 13,
      ""sentimental_value"": 28
    },
    {
      ""box_id"": 18,
      ""box_weight"": 84,
      ""sentimental_value"": 64
    },
    {
      ""box_id"": 19,
      ""box_weight"": 46,
      ""sentimental_value"": 17
    },
    {
      ""box_id"": 20,
      ""box_weight"": 51,
      ""sentimental_value"": 76
    },
    {
      ""box_id"": 21,
      ""box_weight"": 38,
      ""sentimental_value"": 71
    }
  ]
}

If you want to tell me which boxes to load, just give it in this simple JSON layout so I can parse it easily:

{
  ""solution"": [0, 1, 0, 1, ...]
}

That ""solution"" array is just a checklist in the same order as the boxes listed above: a 1 means pack that box, a 0 means leave it behind. Think of it as a quick form — this block is only a sketch of the shape I expect, not the actual packing list.

Please use the exact identifiers from the problem input when you refer to boxes — don’t rename anything or invent new labels. Valid identifiers look like:
- plain numbers such as ""1"" or ""23""
- single capital letters like ""A"" or ""B""
- a capital letter followed by digits like ""A1"" or ""X7""","{'problem_type': 'KP', 'weights': [78, 66, 44, 44, 86, 9, 70, 21, 10, 53, 98, 74, 77, 72, 79, 52, 13, 84, 46, 51, 38], 'profits': [19, 93, 79, 65, 41, 83, 55, 45, 46, 23, 10, 56, 89, 7, 86, 83, 28, 64, 17, 76, 71], 'capacity': 582, 'solution': [0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1], 'objective': 900, 'solve_time': 0.002792835235595703, 'n_items': 21, 'R': 100, 'alpha': 0.5, 'instance_idx': 0, 'alpha_idx': 0}","[0, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1]",900,"{'problem_type': 'KP', 'capacity': 582, 'n_items': 21, 'items': [{'item_id': 1, 'weight': 78, 'profit': 19}, {'item_id': 2, 'weight': 66, 'profit': 93}, {'item_id': 3, 'weight': 44, 'profit': 79}, {'item_id': 4, 'weight': 44, 'profit': 65}, {'item_id': 5, 'weight': 86, 'profit': 41}, {'item_id': 6, 'weight': 9, 'profit': 83}, {'item_id': 7, 'weight': 70, 'profit': 55}, {'item_id': 8, 'weight': 21, 'profit': 45}, {'item_id': 9, 'weight': 10, 'profit': 46}, {'item_id': 10, 'weight': 53, 'profit': 23}, {'item_id': 11, 'weight': 98, 'profit': 10}, {'item_id': 12, 'weight': 74, 'profit': 56}, {'item_id': 13, 'weight': 77, 'profit': 89}, {'item_id': 14, 'weight': 72, 'profit': 7}, {'item_id': 15, 'weight': 79, 'profit': 86}, {'item_id': 16, 'weight': 52, 'profit': 83}, {'item_id': 17, 'weight': 13, 'profit': 28}, {'item_id': 18, 'weight': 84, 'profit': 64}, {'item_id': 19, 'weight': 46, 'profit': 17}, {'item_id': 20, 'weight': 51, 'profit': 76}, {'item_id': 21, 'weight': 38, 'profit': 71}]}","{'1': 0, '2': 1, '3': 1, '4': 1, '5': 0, '6': 1, '7': 0, '8': 1, '9': 1, '10': 0, '11': 0, '12': 1, '13': 1, '14': 0, '15': 1, '16': 1, '17': 1, '18': 0, '19': 0, '20': 1, '21': 1}",1,json,1
KP,KP,"Someone at the gallery is juggling a stack of prints and a scarce amount of wall, deciding which ones will make the best impression. The selection rule is straightforward in practice: choose a subset of works whose appeal values add up to the biggest number possible, provided their total width stays within the wall that’s available. Every piece can only appear once on the wall, and the concrete list of pieces with their sizes and appeal ratings is listed below.

They have 671 of wall to work with.
Print 1 occupies 7 of wall and scores 8 in visitor appeal.
Print 2 occupies 98 of wall and scores 47 in visitor appeal.
Print 3 occupies 45 of wall and scores 80 in visitor appeal.
Print 4 occupies 90 of wall and scores 19 in visitor appeal.
Print 5 occupies 68 of wall and scores 47 in visitor appeal.
Print 6 occupies 78 of wall and scores 13 in visitor appeal.
Print 7 occupies 76 of wall and scores 69 in visitor appeal.
Print 8 occupies 20 of wall and scores 48 in visitor appeal.
Print 9 occupies 37 of wall and scores 34 in visitor appeal.
Print 10 occupies 47 of wall and scores 23 in visitor appeal.
Print 11 occupies 50 of wall and scores 57 in visitor appeal.
Print 12 occupies 5 of wall and scores 67 in visitor appeal.
Print 13 occupies 55 of wall and scores 95 in visitor appeal.
Print 14 occupies 16 of wall and scores 44 in visitor appeal.
Print 15 occupies 75 of wall and scores 17 in visitor appeal.
Print 16 occupies 69 of wall and scores 84 in visitor appeal.
Print 17 occupies 93 of wall and scores 63 in visitor appeal.
Print 18 occupies 75 of wall and scores 71 in visitor appeal.
Print 19 occupies 37 of wall and scores 10 in visitor appeal.
Print 20 occupies 97 of wall and scores 32 in visitor appeal.
Print 21 occupies 42 of wall and scores 77 in visitor appeal.
Print 22 occupies 33 of wall and scores 84 in visitor appeal.
Print 23 occupies 91 of wall and scores 44 in visitor appeal.
Print 24 occupies 38 of wall and scores 81 in visitor appeal.
They will select the combination that fits within 671 and maximizes total visitor appeal.

If you want to give the final selection in a tidy, machine-friendly way, just drop it into a small JSON snippet like this:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is just a list that matches the order of the pieces above — a 1 means “hang this print” and a 0 means “leave it off the wall.” Think of the JSON as a simple form: the key tells me this is the selection and the array shows which works make the cut. It's just a sketch of the shape I expect, not the actual answer.

Please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.

Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [7, 98, 45, 90, 68, 78, 76, 20, 37, 47, 50, 5, 55, 16, 75, 69, 93, 75, 37, 97, 42, 33, 91, 38], 'profits': [8, 47, 80, 19, 47, 13, 69, 48, 34, 23, 57, 67, 95, 44, 17, 84, 63, 71, 10, 32, 77, 84, 44, 81], 'capacity': 671, 'solution': [1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1], 'objective': 962, 'solve_time': 0.0006222724914550781, 'n_items': 24, 'R': 100, 'alpha': 0.5, 'instance_idx': 1, 'alpha_idx': 0}","[1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1]",962,"{'problem_type': 'KP', 'capacity': 671, 'n_items': 24, 'items': [{'item_id': 1, 'weight': 7, 'profit': 8}, {'item_id': 2, 'weight': 98, 'profit': 47}, {'item_id': 3, 'weight': 45, 'profit': 80}, {'item_id': 4, 'weight': 90, 'profit': 19}, {'item_id': 5, 'weight': 68, 'profit': 47}, {'item_id': 6, 'weight': 78, 'profit': 13}, {'item_id': 7, 'weight': 76, 'profit': 69}, {'item_id': 8, 'weight': 20, 'profit': 48}, {'item_id': 9, 'weight': 37, 'profit': 34}, {'item_id': 10, 'weight': 47, 'profit': 23}, {'item_id': 11, 'weight': 50, 'profit': 57}, {'item_id': 12, 'weight': 5, 'profit': 67}, {'item_id': 13, 'weight': 55, 'profit': 95}, {'item_id': 14, 'weight': 16, 'profit': 44}, {'item_id': 15, 'weight': 75, 'profit': 17}, {'item_id': 16, 'weight': 69, 'profit': 84}, {'item_id': 17, 'weight': 93, 'profit': 63}, {'item_id': 18, 'weight': 75, 'profit': 71}, {'item_id': 19, 'weight': 37, 'profit': 10}, {'item_id': 20, 'weight': 97, 'profit': 32}, {'item_id': 21, 'weight': 42, 'profit': 77}, {'item_id': 22, 'weight': 33, 'profit': 84}, {'item_id': 23, 'weight': 91, 'profit': 44}, {'item_id': 24, 'weight': 38, 'profit': 81}]}","{'1': 1, '2': 0, '3': 1, '4': 0, '5': 0, '6': 0, '7': 1, '8': 1, '9': 1, '10': 0, '11': 1, '12': 1, '13': 1, '14': 1, '15': 0, '16': 1, '17': 1, '18': 1, '19': 0, '20': 0, '21': 1, '22': 1, '23': 0, '24': 1}",2,nl,1
KP,KP,"On this outing the shared rucksack is limited, so as the leader the decision is which gear to include to give everyone the most benefit without exceeding the carrying limit. The way to compare choices is to add the usefulness values of whatever items are selected to get a total usefulness score, and choose the selection with the highest total that doesn’t push the combined weight over the allowance; no item can be picked more than once. The concrete weights and usefulness ratings are shown below.

# rucksack_capacity=711
gear_id,gear_weight,usefulness_score
0,39,66
1,90,48
2,29,86
3,24,57
4,69,8
5,64,77
6,14,58
7,84,64
8,20,57
9,81,56
10,1,10
11,80,56
12,79,80
13,79,31
14,67,61
15,48,4
16,71,35
17,28,44
18,79,99
19,56,22
20,46,28
21,51,41
22,57,100
23,4,86
24,14,4
25,25,24
26,12,83
27,44,6
28,67,86

If you want, just send back the chosen items in a tiny JSON like this — quick and tidy so it’s easy to check and reuse.

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is an array where each entry corresponds to one item from the list above: a 1 means you pack that item, a 0 means you leave it behind. Think of it like ticking boxes on a checklist — that’s all this JSON is showing. It’s just a sketch of the shape I’m expecting, not the actual final choice.

Please use the exact identifiers from the instance input when you refer to items — don’t rename them or introduce new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [39, 90, 29, 24, 69, 64, 14, 84, 20, 81, 1, 80, 79, 79, 67, 48, 71, 28, 79, 56, 46, 51, 57, 4, 14, 25, 12, 44, 67], 'profits': [66, 48, 86, 57, 8, 77, 58, 64, 57, 56, 10, 56, 80, 31, 61, 4, 35, 44, 99, 22, 28, 41, 100, 86, 4, 24, 83, 6, 86], 'capacity': 711, 'solution': [1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1], 'objective': 1143, 'solve_time': 0.0005533695220947266, 'n_items': 29, 'R': 100, 'alpha': 0.5, 'instance_idx': 2, 'alpha_idx': 0}","[1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1]",1143,"{'problem_type': 'KP', 'capacity': 711, 'n_items': 29, 'items': [{'item_id': 0, 'weight': 39, 'profit': 66}, {'item_id': 1, 'weight': 90, 'profit': 48}, {'item_id': 2, 'weight': 29, 'profit': 86}, {'item_id': 3, 'weight': 24, 'profit': 57}, {'item_id': 4, 'weight': 69, 'profit': 8}, {'item_id': 5, 'weight': 64, 'profit': 77}, {'item_id': 6, 'weight': 14, 'profit': 58}, {'item_id': 7, 'weight': 84, 'profit': 64}, {'item_id': 8, 'weight': 20, 'profit': 57}, {'item_id': 9, 'weight': 81, 'profit': 56}, {'item_id': 10, 'weight': 1, 'profit': 10}, {'item_id': 11, 'weight': 80, 'profit': 56}, {'item_id': 12, 'weight': 79, 'profit': 80}, {'item_id': 13, 'weight': 79, 'profit': 31}, {'item_id': 14, 'weight': 67, 'profit': 61}, {'item_id': 15, 'weight': 48, 'profit': 4}, {'item_id': 16, 'weight': 71, 'profit': 35}, {'item_id': 17, 'weight': 28, 'profit': 44}, {'item_id': 18, 'weight': 79, 'profit': 99}, {'item_id': 19, 'weight': 56, 'profit': 22}, {'item_id': 20, 'weight': 46, 'profit': 28}, {'item_id': 21, 'weight': 51, 'profit': 41}, {'item_id': 22, 'weight': 57, 'profit': 100}, {'item_id': 23, 'weight': 4, 'profit': 86}, {'item_id': 24, 'weight': 14, 'profit': 4}, {'item_id': 25, 'weight': 25, 'profit': 24}, {'item_id': 26, 'weight': 12, 'profit': 83}, {'item_id': 27, 'weight': 44, 'profit': 6}, {'item_id': 28, 'weight': 67, 'profit': 86}]}","{'0': 1, '1': 0, '2': 1, '3': 1, '4': 0, '5': 1, '6': 1, '7': 0, '8': 1, '9': 0, '10': 1, '11': 0, '12': 1, '13': 0, '14': 1, '15': 0, '16': 0, '17': 1, '18': 1, '19': 0, '20': 1, '21': 1, '22': 1, '23': 1, '24': 0, '25': 1, '26': 1, '27': 0, '28': 1}",3,csv,0
KP,KP,"I run a little street food stall and today I have to pick which menu items to prep so the stall brings in the most cash. The plan is to choose a group of dishes, add up the expected earnings from each chosen dish to get the total money for the day, and make the combination that gives the highest total. The catch is the fridge is small, so the combined ingredient volume of everything prepared has to fit inside it, and each menu item can only be made once. The exact menu items, their ingredient volumes and their estimated earnings are listed below.

I have 567 total refrigerated ingredient volume for the day.
I'll prep 1 — it uses 92 units of ingredient volume and should earn 47.
I'll prep 2 — it uses 30 units of ingredient volume and should earn 72.
I'll prep 3 — it uses 44 units of ingredient volume and should earn 17.
I'll prep 4 — it uses 67 units of ingredient volume and should earn 91.
I'll prep 5 — it uses 13 units of ingredient volume and should earn 51.
I'll prep 6 — it uses 56 units of ingredient volume and should earn 94.
I'll prep 7 — it uses 51 units of ingredient volume and should earn 16.
I'll prep 8 — it uses 79 units of ingredient volume and should earn 50.
I'll prep 9 — it uses 100 units of ingredient volume and should earn 70.
I'll prep 10 — it uses 67 units of ingredient volume and should earn 50.
I'll prep 11 — it uses 41 units of ingredient volume and should earn 45.
I'll prep 12 — it uses 41 units of ingredient volume and should earn 17.
I'll prep 13 — it uses 42 units of ingredient volume and should earn 39.
I'll prep 14 — it uses 82 units of ingredient volume and should earn 24.
I'll prep 15 — it uses 33 units of ingredient volume and should earn 31.
I'll prep 16 — it uses 17 units of ingredient volume and should earn 69.
I'll prep 17 — it uses 34 units of ingredient volume and should earn 64.
I'll prep 18 — it uses 3 units of ingredient volume and should earn 61.
I'll prep 19 — it uses 11 units of ingredient volume and should earn 37.
I'll prep 20 — it uses 10 units of ingredient volume and should earn 96.
I'll prep 21 — it uses 78 units of ingredient volume and should earn 9.
I'll prep 22 — it uses 73 units of ingredient volume and should earn 35.
I'll prep 23 — it uses 70 units of ingredient volume and should earn 12.
I'll pick the combination that fits within 567 and brings in the most cash.

Oh, and when you reply, could you put the chosen dishes into a tiny JSON snip like this so it's easy to parse?

{
  ""solution"": [0, 1, 0, 1, ...]
}

""solution"" is just a list that lines up with the menu items above — a 1 means make that dish, a 0 means skip it. Think of it like ticking boxes on a prep list; this block is just the shape I want, not the actual final picks.

Please use the exact identifiers from the instance input — don't rename anything or add new labels. For example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [92, 30, 44, 67, 13, 56, 51, 79, 100, 67, 41, 41, 42, 82, 33, 17, 34, 3, 11, 10, 78, 73, 70], 'profits': [47, 72, 17, 91, 51, 94, 16, 50, 70, 50, 45, 17, 39, 24, 31, 69, 64, 61, 37, 96, 9, 35, 12], 'capacity': 567, 'solution': [0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0], 'objective': 887, 'solve_time': 0.0004508495330810547, 'n_items': 23, 'R': 100, 'alpha': 0.5, 'instance_idx': 3, 'alpha_idx': 0}","[0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0]",887,"{'problem_type': 'KP', 'capacity': 567, 'n_items': 23, 'items': [{'item_id': 1, 'weight': 92, 'profit': 47}, {'item_id': 2, 'weight': 30, 'profit': 72}, {'item_id': 3, 'weight': 44, 'profit': 17}, {'item_id': 4, 'weight': 67, 'profit': 91}, {'item_id': 5, 'weight': 13, 'profit': 51}, {'item_id': 6, 'weight': 56, 'profit': 94}, {'item_id': 7, 'weight': 51, 'profit': 16}, {'item_id': 8, 'weight': 79, 'profit': 50}, {'item_id': 9, 'weight': 100, 'profit': 70}, {'item_id': 10, 'weight': 67, 'profit': 50}, {'item_id': 11, 'weight': 41, 'profit': 45}, {'item_id': 12, 'weight': 41, 'profit': 17}, {'item_id': 13, 'weight': 42, 'profit': 39}, {'item_id': 14, 'weight': 82, 'profit': 24}, {'item_id': 15, 'weight': 33, 'profit': 31}, {'item_id': 16, 'weight': 17, 'profit': 69}, {'item_id': 17, 'weight': 34, 'profit': 64}, {'item_id': 18, 'weight': 3, 'profit': 61}, {'item_id': 19, 'weight': 11, 'profit': 37}, {'item_id': 20, 'weight': 10, 'profit': 96}, {'item_id': 21, 'weight': 78, 'profit': 9}, {'item_id': 22, 'weight': 73, 'profit': 35}, {'item_id': 23, 'weight': 70, 'profit': 12}]}","{'1': 0, '2': 1, '3': 0, '4': 1, '5': 1, '6': 1, '7': 0, '8': 0, '9': 1, '10': 1, '11': 1, '12': 1, '13': 1, '14': 0, '15': 1, '16': 1, '17': 1, '18': 1, '19': 1, '20': 1, '21': 0, '22': 0, '23': 0}",4,nl,1
KP,KP,"Someone set up a raised bed and a pile of different vegetable starters; now they need to pick which ones to plant so the projected harvest is as valuable as possible. The plan is to choose a selection of distinct seedlings, compute the garden’s projected haul by adding each chosen seedling’s expected value, and keep the combined soil volume of those seedlings under the bed’s capacity — no duplicates and no half-plants. The concrete data about varieties, volumes, and expected yields follows below.

They have 653 of raised bed soil volume available.
They can plant 0, which requires 97 soil volume and is expected to yield 21.
They can plant 1, which requires 37 soil volume and is expected to yield 73.
They can plant 2, which requires 91 soil volume and is expected to yield 31.
They can plant 3, which requires 50 soil volume and is expected to yield 81.
They can plant 4, which requires 70 soil volume and is expected to yield 58.
They can plant 5, which requires 46 soil volume and is expected to yield 55.
They can plant 6, which requires 27 soil volume and is expected to yield 18.
They can plant 7, which requires 77 soil volume and is expected to yield 47.
They can plant 8, which requires 97 soil volume and is expected to yield 86.
They can plant 9, which requires 27 soil volume and is expected to yield 2.
They can plant 10, which requires 78 soil volume and is expected to yield 76.
They can plant 11, which requires 27 soil volume and is expected to yield 50.
They can plant 12, which requires 72 soil volume and is expected to yield 72.
They can plant 13, which requires 79 soil volume and is expected to yield 67.
They can plant 14, which requires 45 soil volume and is expected to yield 44.
They can plant 15, which requires 74 soil volume and is expected to yield 31.
They can plant 16, which requires 28 soil volume and is expected to yield 63.
They can plant 17, which requires 8 soil volume and is expected to yield 15.
They can plant 18, which requires 10 soil volume and is expected to yield 59.
They can plant 19, which requires 45 soil volume and is expected to yield 10.
They can plant 20, which requires 91 soil volume and is expected to yield 65.
They can plant 21, which requires 13 soil volume and is expected to yield 63.
They can plant 22, which requires 46 soil volume and is expected to yield 9.
They can plant 23, which requires 71 soil volume and is expected to yield 76.
Selections must be whole, distinct seedlings and keep total soil volume within 653.

Oh, and when you reply with which seedlings to plant, please follow this little shape so it's easy to read by both people and machines:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a simple on/off checklist for the varieties listed in the instance: a 1 means ""yes, plant this one,"" a 0 means ""no, skip it."" The positions in the list line up with the order the varieties were given earlier. This JSON is just a sketch of the shape I want — not your final pick.

Please make sure to use the exact identifiers from the instance input when naming varieties — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”. ""","{'problem_type': 'KP', 'weights': [97, 37, 91, 50, 70, 46, 27, 77, 97, 27, 78, 27, 72, 79, 45, 74, 28, 8, 10, 45, 91, 13, 46, 71], 'profits': [21, 73, 31, 81, 58, 55, 18, 47, 86, 2, 76, 50, 72, 67, 44, 31, 63, 15, 59, 10, 65, 63, 9, 76], 'capacity': 653, 'solution': [0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1], 'objective': 871, 'solve_time': 0.00045299530029296875, 'n_items': 24, 'R': 100, 'alpha': 0.5, 'instance_idx': 4, 'alpha_idx': 0}","[0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1]",871,"{'problem_type': 'KP', 'capacity': 653, 'n_items': 24, 'items': [{'item_id': 0, 'weight': 97, 'profit': 21}, {'item_id': 1, 'weight': 37, 'profit': 73}, {'item_id': 2, 'weight': 91, 'profit': 31}, {'item_id': 3, 'weight': 50, 'profit': 81}, {'item_id': 4, 'weight': 70, 'profit': 58}, {'item_id': 5, 'weight': 46, 'profit': 55}, {'item_id': 6, 'weight': 27, 'profit': 18}, {'item_id': 7, 'weight': 77, 'profit': 47}, {'item_id': 8, 'weight': 97, 'profit': 86}, {'item_id': 9, 'weight': 27, 'profit': 2}, {'item_id': 10, 'weight': 78, 'profit': 76}, {'item_id': 11, 'weight': 27, 'profit': 50}, {'item_id': 12, 'weight': 72, 'profit': 72}, {'item_id': 13, 'weight': 79, 'profit': 67}, {'item_id': 14, 'weight': 45, 'profit': 44}, {'item_id': 15, 'weight': 74, 'profit': 31}, {'item_id': 16, 'weight': 28, 'profit': 63}, {'item_id': 17, 'weight': 8, 'profit': 15}, {'item_id': 18, 'weight': 10, 'profit': 59}, {'item_id': 19, 'weight': 45, 'profit': 10}, {'item_id': 20, 'weight': 91, 'profit': 65}, {'item_id': 21, 'weight': 13, 'profit': 63}, {'item_id': 22, 'weight': 46, 'profit': 9}, {'item_id': 23, 'weight': 71, 'profit': 76}]}","{'0': 0, '1': 1, '2': 0, '3': 1, '4': 1, '5': 1, '6': 0, '7': 0, '8': 1, '9': 0, '10': 1, '11': 1, '12': 1, '13': 0, '14': 1, '15': 0, '16': 1, '17': 1, '18': 1, '19': 0, '20': 0, '21': 1, '22': 0, '23': 1}",5,nl,0
KP,KP,"On my commute I sort through what fits in my pockets and what actually helps during the day. The winning mix is the set that gives the biggest total convenience when adding up each chosen item's usefulness, without the total size exceeding the pocket space I’ve got. Nothing can be split or doubled — each item can be picked at most once. The exact items and their size/usefulness numbers are below.

I’ve got 536 total pocket space to work with.
I can take 1: it uses 79 pocket space and provides 96 usefulness on my commute.
I can take 2: it uses 5 pocket space and provides 42 usefulness on my commute.
I can take 3: it uses 18 pocket space and provides 49 usefulness on my commute.
I can take 4: it uses 50 pocket space and provides 47 usefulness on my commute.
I can take 5: it uses 19 pocket space and provides 79 usefulness on my commute.
I can take 6: it uses 33 pocket space and provides 7 usefulness on my commute.
I can take 7: it uses 67 pocket space and provides 9 usefulness on my commute.
I can take 8: it uses 15 pocket space and provides 28 usefulness on my commute.
I can take 9: it uses 68 pocket space and provides 49 usefulness on my commute.
I can take 10: it uses 11 pocket space and provides 68 usefulness on my commute.
I can take 11: it uses 18 pocket space and provides 50 usefulness on my commute.
I can take 12: it uses 59 pocket space and provides 45 usefulness on my commute.
I can take 13: it uses 80 pocket space and provides 94 usefulness on my commute.
I can take 14: it uses 18 pocket space and provides 17 usefulness on my commute.
I can take 15: it uses 30 pocket space and provides 58 usefulness on my commute.
I can take 16: it uses 93 pocket space and provides 55 usefulness on my commute.
I can take 17: it uses 99 pocket space and provides 48 usefulness on my commute.
I can take 18: it uses 59 pocket space and provides 81 usefulness on my commute.
I can take 19: it uses 45 pocket space and provides 27 usefulness on my commute.
I can take 20: it uses 35 pocket space and provides 96 usefulness on my commute.
I can take 21: it uses 62 pocket space and provides 34 usefulness on my commute.
I can take 22: it uses 60 pocket space and provides 55 usefulness on my commute.
I can take 23: it uses 30 pocket space and provides 53 usefulness on my commute.
I can take 24: it uses 3 pocket space and provides 85 usefulness on my commute.
I can take 25: it uses 16 pocket space and provides 44 usefulness on my commute.
I’ll pick the set that fits within 536 and gives me the highest total convenience.

If you want to tell me which items you’d pick from the list, a tiny JSON sketch like this is perfect — simple and tidy:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is just a list where each position matches one of the items I described above: a 1 means you tuck that item into your pocket, a 0 means you leave it out. Think of it like a quick answersheet rather than a full explanation.

This is only the expected shape of the reply, not the final choice — just the format to use.

Also, please make sure you use the exact identifiers from the instance input — don’t rename or invent labels.
- for example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [79, 5, 18, 50, 19, 33, 67, 15, 68, 11, 18, 59, 80, 18, 30, 93, 99, 59, 45, 35, 62, 60, 30, 3, 16], 'profits': [96, 42, 49, 47, 79, 7, 9, 28, 49, 68, 50, 45, 94, 17, 58, 55, 48, 81, 27, 96, 34, 55, 53, 85, 44], 'capacity': 536, 'solution': [1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1], 'objective': 1025, 'solve_time': 0.00046825408935546875, 'n_items': 25, 'R': 100, 'alpha': 0.5, 'instance_idx': 5, 'alpha_idx': 0}","[1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1]",1025,"{'problem_type': 'KP', 'capacity': 536, 'n_items': 25, 'items': [{'item_id': 1, 'weight': 79, 'profit': 96}, {'item_id': 2, 'weight': 5, 'profit': 42}, {'item_id': 3, 'weight': 18, 'profit': 49}, {'item_id': 4, 'weight': 50, 'profit': 47}, {'item_id': 5, 'weight': 19, 'profit': 79}, {'item_id': 6, 'weight': 33, 'profit': 7}, {'item_id': 7, 'weight': 67, 'profit': 9}, {'item_id': 8, 'weight': 15, 'profit': 28}, {'item_id': 9, 'weight': 68, 'profit': 49}, {'item_id': 10, 'weight': 11, 'profit': 68}, {'item_id': 11, 'weight': 18, 'profit': 50}, {'item_id': 12, 'weight': 59, 'profit': 45}, {'item_id': 13, 'weight': 80, 'profit': 94}, {'item_id': 14, 'weight': 18, 'profit': 17}, {'item_id': 15, 'weight': 30, 'profit': 58}, {'item_id': 16, 'weight': 93, 'profit': 55}, {'item_id': 17, 'weight': 99, 'profit': 48}, {'item_id': 18, 'weight': 59, 'profit': 81}, {'item_id': 19, 'weight': 45, 'profit': 27}, {'item_id': 20, 'weight': 35, 'profit': 96}, {'item_id': 21, 'weight': 62, 'profit': 34}, {'item_id': 22, 'weight': 60, 'profit': 55}, {'item_id': 23, 'weight': 30, 'profit': 53}, {'item_id': 24, 'weight': 3, 'profit': 85}, {'item_id': 25, 'weight': 16, 'profit': 44}]}","{'1': 1, '2': 1, '3': 1, '4': 1, '5': 1, '6': 0, '7': 0, '8': 1, '9': 0, '10': 1, '11': 1, '12': 0, '13': 1, '14': 0, '15': 1, '16': 0, '17': 0, '18': 1, '19': 0, '20': 1, '21': 0, '22': 1, '23': 1, '24': 1, '25': 1}",6,nl,1
KP,KP,"At the school library’s front table there’s room for only a few face-out books, so the challenge is choosing which titles will bring in the most readers without overflowing the space. Each book has a space cost and a projected number of readers; judge any selection by adding up those projected readers to get its total appeal. The selection must fit within the table’s space limit and each book can only be used once — nothing partial and no duplicates. The concrete details are included below.

# display_space_capacity=522
book_id,space_cost,projected_readers
0,3,62
1,37,92
2,83,98
3,1,24
4,90,24
5,55,4
6,15,15
7,31,56
8,56,55
9,32,38
10,11,31
11,67,83
12,68,47
13,12,81
14,29,97
15,25,32
16,66,21
17,74,96
18,73,64
19,94,30
20,77,63
21,33,52
22,11,91

If you want to reply with a chosen set of books, slip it into this simple JSON shape so it's easy to read and check:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a checklist that matches the list of books in the instance: a 1 means ""put this book on the front table,"" a 0 means ""leave it off."" That's all the structure I need here — just a sketch of the shape, not the final selection itself.

Please use the exact identifiers from the instance input — don't rename anything or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [3, 37, 83, 1, 90, 55, 15, 31, 56, 32, 11, 67, 68, 12, 29, 25, 66, 74, 73, 94, 77, 33, 11], 'profits': [62, 92, 98, 24, 24, 4, 15, 56, 55, 38, 31, 83, 47, 81, 97, 32, 21, 96, 64, 30, 63, 52, 91], 'capacity': 522, 'solution': [1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1], 'objective': 1003, 'solve_time': 0.00043201446533203125, 'n_items': 23, 'R': 100, 'alpha': 0.5, 'instance_idx': 6, 'alpha_idx': 0}","[1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1]",1003,"{'problem_type': 'KP', 'capacity': 522, 'n_items': 23, 'items': [{'item_id': 0, 'weight': 3, 'profit': 62}, {'item_id': 1, 'weight': 37, 'profit': 92}, {'item_id': 2, 'weight': 83, 'profit': 98}, {'item_id': 3, 'weight': 1, 'profit': 24}, {'item_id': 4, 'weight': 90, 'profit': 24}, {'item_id': 5, 'weight': 55, 'profit': 4}, {'item_id': 6, 'weight': 15, 'profit': 15}, {'item_id': 7, 'weight': 31, 'profit': 56}, {'item_id': 8, 'weight': 56, 'profit': 55}, {'item_id': 9, 'weight': 32, 'profit': 38}, {'item_id': 10, 'weight': 11, 'profit': 31}, {'item_id': 11, 'weight': 67, 'profit': 83}, {'item_id': 12, 'weight': 68, 'profit': 47}, {'item_id': 13, 'weight': 12, 'profit': 81}, {'item_id': 14, 'weight': 29, 'profit': 97}, {'item_id': 15, 'weight': 25, 'profit': 32}, {'item_id': 16, 'weight': 66, 'profit': 21}, {'item_id': 17, 'weight': 74, 'profit': 96}, {'item_id': 18, 'weight': 73, 'profit': 64}, {'item_id': 19, 'weight': 94, 'profit': 30}, {'item_id': 20, 'weight': 77, 'profit': 63}, {'item_id': 21, 'weight': 33, 'profit': 52}, {'item_id': 22, 'weight': 11, 'profit': 91}]}","{'0': 1, '1': 1, '2': 1, '3': 1, '4': 0, '5': 0, '6': 1, '7': 1, '8': 1, '9': 1, '10': 1, '11': 1, '12': 0, '13': 1, '14': 1, '15': 1, '16': 0, '17': 1, '18': 0, '19': 0, '20': 0, '21': 1, '22': 1}",7,csv,0
KP,KP,"Recently a travel photographer faced the usual packing puzzle: which lenses and accessories will cover the most ground without blowing the bag’s weight allowance? Each piece has a usefulness rating and a weight, and the photographer will total the usefulness points for whatever gets packed — the higher that total, the better — provided the total weight of those chosen items stays within the bag’s capacity. No repeats or fractional items are allowed; each one is either packed or left behind. All of the item specifics and the bag’s capacity are shown below.

# bag_weight_capacity=592
gear_id,item_weight,usefulness_score
A,100,78
B,94,34
C,19,67
D,17,42
E,54,38
F,5,89
G,30,10
H,44,74
I,97,75
J,100,38
K,16,27
L,90,1
M,10,94
N,75,95
O,85,25
P,90,4
Q,23,13
R,90,7
S,12,84
T,52,90
U,47,16
V,32,75
W,3,18

If you want the answer in a compact, machine-friendly form, just return a JSON object that looks like this:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is an array where each entry corresponds to one of the pieces in the list above: 1 means you pack that item, 0 means you leave it behind. Think of it as a simple checked/unchecked list — just a sketch of the shape I expect, not the final packing decision itself.

Please use the exact identifiers from the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [100, 94, 19, 17, 54, 5, 30, 44, 97, 100, 16, 90, 10, 75, 85, 90, 23, 90, 12, 52, 47, 32, 3], 'profits': [78, 34, 67, 42, 38, 89, 10, 74, 75, 38, 27, 1, 94, 95, 25, 4, 13, 7, 84, 90, 16, 75, 18], 'capacity': 592, 'solution': [1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1], 'objective': 969, 'solve_time': 0.0004425048828125, 'n_items': 23, 'R': 100, 'alpha': 0.5, 'instance_idx': 7, 'alpha_idx': 0}","[1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1]",969,"{'problem_type': 'KP', 'capacity': 592, 'n_items': 23, 'items': [{'item_id': 'A', 'weight': 100, 'profit': 78}, {'item_id': 'B', 'weight': 94, 'profit': 34}, {'item_id': 'C', 'weight': 19, 'profit': 67}, {'item_id': 'D', 'weight': 17, 'profit': 42}, {'item_id': 'E', 'weight': 54, 'profit': 38}, {'item_id': 'F', 'weight': 5, 'profit': 89}, {'item_id': 'G', 'weight': 30, 'profit': 10}, {'item_id': 'H', 'weight': 44, 'profit': 74}, {'item_id': 'I', 'weight': 97, 'profit': 75}, {'item_id': 'J', 'weight': 100, 'profit': 38}, {'item_id': 'K', 'weight': 16, 'profit': 27}, {'item_id': 'L', 'weight': 90, 'profit': 1}, {'item_id': 'M', 'weight': 10, 'profit': 94}, {'item_id': 'N', 'weight': 75, 'profit': 95}, {'item_id': 'O', 'weight': 85, 'profit': 25}, {'item_id': 'P', 'weight': 90, 'profit': 4}, {'item_id': 'Q', 'weight': 23, 'profit': 13}, {'item_id': 'R', 'weight': 90, 'profit': 7}, {'item_id': 'S', 'weight': 12, 'profit': 84}, {'item_id': 'T', 'weight': 52, 'profit': 90}, {'item_id': 'U', 'weight': 47, 'profit': 16}, {'item_id': 'V', 'weight': 32, 'profit': 75}, {'item_id': 'W', 'weight': 3, 'profit': 18}]}","{'A': 1, 'B': 0, 'C': 1, 'D': 1, 'E': 1, 'F': 1, 'G': 1, 'H': 1, 'I': 1, 'J': 0, 'K': 1, 'L': 0, 'M': 1, 'N': 1, 'O': 0, 'P': 0, 'Q': 1, 'R': 0, 'S': 1, 'T': 1, 'U': 0, 'V': 1, 'W': 1}",8,csv,names
KP,KP,"There’s a tiny team and a two-week sprint ahead, and the question on the table is which prototypes to actually build to bring in the most user interest. Success is measured by adding up each prototype’s projected engagement to get a single expected-impact number, but that has to be balanced against the sum of the development hours those prototypes require, which can’t exceed the sprint’s time budget. No duplicating prototypes and no partial builds — each idea is either included or left out. The concrete choices and numbers follow below.

{
  ""sprint_hours_budget"": 560,
  ""items"": [
    {
      ""prototype_id"": 1,
      ""dev_hours_required"": 60,
      ""projected_engagement_score"": 13
    },
    {
      ""prototype_id"": 2,
      ""dev_hours_required"": 72,
      ""projected_engagement_score"": 30
    },
    {
      ""prototype_id"": 3,
      ""dev_hours_required"": 88,
      ""projected_engagement_score"": 51
    },
    {
      ""prototype_id"": 4,
      ""dev_hours_required"": 5,
      ""projected_engagement_score"": 93
    },
    {
      ""prototype_id"": 5,
      ""dev_hours_required"": 20,
      ""projected_engagement_score"": 70
    },
    {
      ""prototype_id"": 6,
      ""dev_hours_required"": 29,
      ""projected_engagement_score"": 77
    },
    {
      ""prototype_id"": 7,
      ""dev_hours_required"": 32,
      ""projected_engagement_score"": 59
    },
    {
      ""prototype_id"": 8,
      ""dev_hours_required"": 100,
      ""projected_engagement_score"": 42
    },
    {
      ""prototype_id"": 9,
      ""dev_hours_required"": 78,
      ""projected_engagement_score"": 20
    },
    {
      ""prototype_id"": 10,
      ""dev_hours_required"": 33,
      ""projected_engagement_score"": 87
    },
    {
      ""prototype_id"": 11,
      ""dev_hours_required"": 98,
      ""projected_engagement_score"": 81
    },
    {
      ""prototype_id"": 12,
      ""dev_hours_required"": 50,
      ""projected_engagement_score"": 3
    },
    {
      ""prototype_id"": 13,
      ""dev_hours_required"": 51,
      ""projected_engagement_score"": 72
    },
    {
      ""prototype_id"": 14,
      ""dev_hours_required"": 44,
      ""projected_engagement_score"": 9
    },
    {
      ""prototype_id"": 15,
      ""dev_hours_required"": 15,
      ""projected_engagement_score"": 74
    },
    {
      ""prototype_id"": 16,
      ""dev_hours_required"": 94,
      ""projected_engagement_score"": 83
    },
    {
      ""prototype_id"": 17,
      ""dev_hours_required"": 2,
      ""projected_engagement_score"": 14
    },
    {
      ""prototype_id"": 18,
      ""dev_hours_required"": 18,
      ""projected_engagement_score"": 44
    },
    {
      ""prototype_id"": 19,
      ""dev_hours_required"": 23,
      ""projected_engagement_score"": 13
    },
    {
      ""prototype_id"": 20,
      ""dev_hours_required"": 28,
      ""projected_engagement_score"": 57
    },
    {
      ""prototype_id"": 21,
      ""dev_hours_required"": 14,
      ""projected_engagement_score"": 93
    },
    {
      ""prototype_id"": 22,
      ""dev_hours_required"": 2,
      ""projected_engagement_score"": 9
    },
    {
      ""prototype_id"": 23,
      ""dev_hours_required"": 68,
      ""projected_engagement_score"": 40
    },
    {
      ""prototype_id"": 24,
      ""dev_hours_required"": 97,
      ""projected_engagement_score"": 98
    }
  ]
}

Also, when you reply with which prototypes to build, please use this simple JSON layout so I can read it straight away:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Pretty casual: the ""solution"" array just lists a 0 or 1 for each prototype in the same order as the instance — 1 means go ahead and build that prototype this sprint, 0 means skip it. Think of it like ticking boxes on a checklist; replace the ... with the full sequence of choices for every idea.

This JSON is just a sketch of the shape I expect, not the final answer itself. Also, make sure all identifiers in your reply match exactly what's in the instance input — no renaming or inventing new labels. For example:
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7"".""","{'problem_type': 'KP', 'weights': [60, 72, 88, 5, 20, 29, 32, 100, 78, 33, 98, 50, 51, 44, 15, 94, 2, 18, 23, 28, 14, 2, 68, 97], 'profits': [13, 30, 51, 93, 70, 77, 59, 42, 20, 87, 81, 3, 72, 9, 74, 83, 14, 44, 13, 57, 93, 9, 40, 98], 'capacity': 560, 'solution': [0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1], 'objective': 1015, 'solve_time': 0.00044417381286621094, 'n_items': 24, 'R': 100, 'alpha': 0.5, 'instance_idx': 8, 'alpha_idx': 0}","[0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1]",1015,"{'problem_type': 'KP', 'capacity': 560, 'n_items': 24, 'items': [{'item_id': 1, 'weight': 60, 'profit': 13}, {'item_id': 2, 'weight': 72, 'profit': 30}, {'item_id': 3, 'weight': 88, 'profit': 51}, {'item_id': 4, 'weight': 5, 'profit': 93}, {'item_id': 5, 'weight': 20, 'profit': 70}, {'item_id': 6, 'weight': 29, 'profit': 77}, {'item_id': 7, 'weight': 32, 'profit': 59}, {'item_id': 8, 'weight': 100, 'profit': 42}, {'item_id': 9, 'weight': 78, 'profit': 20}, {'item_id': 10, 'weight': 33, 'profit': 87}, {'item_id': 11, 'weight': 98, 'profit': 81}, {'item_id': 12, 'weight': 50, 'profit': 3}, {'item_id': 13, 'weight': 51, 'profit': 72}, {'item_id': 14, 'weight': 44, 'profit': 9}, {'item_id': 15, 'weight': 15, 'profit': 74}, {'item_id': 16, 'weight': 94, 'profit': 83}, {'item_id': 17, 'weight': 2, 'profit': 14}, {'item_id': 18, 'weight': 18, 'profit': 44}, {'item_id': 19, 'weight': 23, 'profit': 13}, {'item_id': 20, 'weight': 28, 'profit': 57}, {'item_id': 21, 'weight': 14, 'profit': 93}, {'item_id': 22, 'weight': 2, 'profit': 9}, {'item_id': 23, 'weight': 68, 'profit': 40}, {'item_id': 24, 'weight': 97, 'profit': 98}]}","{'1': 0, '2': 0, '3': 0, '4': 1, '5': 1, '6': 1, '7': 1, '8': 0, '9': 0, '10': 1, '11': 1, '12': 0, '13': 1, '14': 0, '15': 1, '16': 1, '17': 1, '18': 1, '19': 1, '20': 1, '21': 1, '22': 0, '23': 0, '24': 1}",9,json,1
KP,KP,"Many people face the same little puzzle each morning: pick which notes, textbooks, and tools to carry so class prep is maximized. The measure of a good pick is simple — sum up the usefulness points of the chosen items to see how ready the bag makes someone — while making sure the combined weight doesn’t exceed the backpack limit. Items are indivisible and unique, meaning each one is either taken once or left. The detailed list of materials and their weights and usefulness scores follows below.

- **backpack_capacity**: 614

| material_id | material_weight | usefulness_score |
|---|---|---|
| 0 | 14 | 17 |
| 1 | 49 | 60 |
| 2 | 51 | 19 |
| 3 | 67 | 94 |
| 4 | 32 | 74 |
| 5 | 96 | 81 |
| 6 | 53 | 44 |
| 7 | 29 | 47 |
| 8 | 97 | 64 |
| 9 | 93 | 79 |
| 10 | 50 | 85 |
| 11 | 3 | 2 |
| 12 | 60 | 67 |
| 13 | 56 | 11 |
| 14 | 15 | 29 |
| 15 | 64 | 83 |
| 16 | 85 | 26 |
| 17 | 11 | 80 |
| 18 | 73 | 47 |
| 19 | 15 | 24 |
| 20 | 75 | 34 |
| 21 | 42 | 54 |
| 22 | 1 | 77 |
| 23 | 97 | 61 |

If you want to hand me your pick in a compact, machine-friendly way, just use a tiny JSON like this as a sketch of the shape I expect:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a checklist that lines up with the item list above — each slot in the array corresponds to one item: 1 means you packed it, 0 means you left it. This JSON is just a simple template showing the format, not the actual selection you should submit.

Please make sure any identifiers in your real input are used exactly as given in the instance — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [14, 49, 51, 67, 32, 96, 53, 29, 97, 93, 50, 3, 60, 56, 15, 64, 85, 11, 73, 15, 75, 42, 1, 97], 'profits': [17, 60, 19, 94, 74, 81, 44, 47, 64, 79, 85, 2, 67, 11, 29, 83, 26, 80, 47, 24, 34, 54, 77, 61], 'capacity': 614, 'solution': [1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0], 'objective': 918, 'solve_time': 0.00045418739318847656, 'n_items': 24, 'R': 100, 'alpha': 0.5, 'instance_idx': 9, 'alpha_idx': 0}","[1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0]",918,"{'problem_type': 'KP', 'capacity': 614, 'n_items': 24, 'items': [{'item_id': 0, 'weight': 14, 'profit': 17}, {'item_id': 1, 'weight': 49, 'profit': 60}, {'item_id': 2, 'weight': 51, 'profit': 19}, {'item_id': 3, 'weight': 67, 'profit': 94}, {'item_id': 4, 'weight': 32, 'profit': 74}, {'item_id': 5, 'weight': 96, 'profit': 81}, {'item_id': 6, 'weight': 53, 'profit': 44}, {'item_id': 7, 'weight': 29, 'profit': 47}, {'item_id': 8, 'weight': 97, 'profit': 64}, {'item_id': 9, 'weight': 93, 'profit': 79}, {'item_id': 10, 'weight': 50, 'profit': 85}, {'item_id': 11, 'weight': 3, 'profit': 2}, {'item_id': 12, 'weight': 60, 'profit': 67}, {'item_id': 13, 'weight': 56, 'profit': 11}, {'item_id': 14, 'weight': 15, 'profit': 29}, {'item_id': 15, 'weight': 64, 'profit': 83}, {'item_id': 16, 'weight': 85, 'profit': 26}, {'item_id': 17, 'weight': 11, 'profit': 80}, {'item_id': 18, 'weight': 73, 'profit': 47}, {'item_id': 19, 'weight': 15, 'profit': 24}, {'item_id': 20, 'weight': 75, 'profit': 34}, {'item_id': 21, 'weight': 42, 'profit': 54}, {'item_id': 22, 'weight': 1, 'profit': 77}, {'item_id': 23, 'weight': 97, 'profit': 61}]}","{'0': 1, '1': 1, '2': 0, '3': 1, '4': 1, '5': 1, '6': 1, '7': 1, '8': 0, '9': 0, '10': 1, '11': 1, '12': 1, '13': 0, '14': 1, '15': 1, '16': 0, '17': 1, '18': 0, '19': 1, '20': 0, '21': 1, '22': 1, '23': 0}",10,markdown_table,0
KP,KP,"At the museum, the registrar faces a classic packing puzzle: from a list of loaned pieces, pick those that together produce the highest cultural impact — just add up each chosen item’s impact score to get that total — while ensuring the combined weight stays under the shipping limit, and recognizing that each artifact is unique and can only go into the crate once. The exact list of artifacts, their weights, and impact scores are shown below.

- **shipping_weight_limit_kg**: 818

| artifact_id | artifact_weight_kg | cultural_impact_score |
|---|---|---|
| 1 | 87 | 15 |
| 2 | 76 | 20 |
| 3 | 61 | 83 |
| 4 | 29 | 32 |
| 5 | 42 | 32 |
| 6 | 12 | 93 |
| 7 | 38 | 15 |
| 8 | 93 | 92 |
| 9 | 43 | 93 |
| 10 | 12 | 60 |
| 11 | 66 | 17 |
| 12 | 97 | 16 |
| 13 | 87 | 29 |
| 14 | 28 | 58 |
| 15 | 46 | 16 |
| 16 | 54 | 46 |
| 17 | 25 | 12 |
| 18 | 27 | 55 |
| 19 | 24 | 3 |
| 20 | 100 | 71 |
| 21 | 75 | 6 |
| 22 | 85 | 20 |
| 23 | 82 | 18 |
| 24 | 96 | 84 |
| 25 | 11 | 6 |
| 26 | 89 | 43 |
| 27 | 7 | 60 |
| 28 | 48 | 52 |
| 29 | 60 | 69 |
| 30 | 36 | 81 |

If you want to send back your selection, just use this little JSON shape so I can read which pieces you chose:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a simple checklist that lines up with the artifact list above: each entry is either 1 (put this piece in the crate) or 0 (leave it behind). This JSON is just a sketch of the shape I expect — not the final, definitive pick.

Please make sure any identifiers you use in your reply match the instance exactly — no renaming, no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [87, 76, 61, 29, 42, 12, 38, 93, 43, 12, 66, 97, 87, 28, 46, 54, 25, 27, 24, 100, 75, 85, 82, 96, 11, 89, 7, 48, 60, 36], 'profits': [15, 20, 83, 32, 32, 93, 15, 92, 93, 60, 17, 16, 29, 58, 16, 46, 12, 55, 3, 71, 6, 20, 18, 84, 6, 43, 60, 52, 69, 81], 'capacity': 818, 'solution': [0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1], 'objective': 1088, 'solve_time': 0.0005578994750976562, 'n_items': 30, 'R': 100, 'alpha': 0.5, 'instance_idx': 10, 'alpha_idx': 0}","[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1]",1088,"{'problem_type': 'KP', 'capacity': 818, 'n_items': 30, 'items': [{'item_id': 1, 'weight': 87, 'profit': 15}, {'item_id': 2, 'weight': 76, 'profit': 20}, {'item_id': 3, 'weight': 61, 'profit': 83}, {'item_id': 4, 'weight': 29, 'profit': 32}, {'item_id': 5, 'weight': 42, 'profit': 32}, {'item_id': 6, 'weight': 12, 'profit': 93}, {'item_id': 7, 'weight': 38, 'profit': 15}, {'item_id': 8, 'weight': 93, 'profit': 92}, {'item_id': 9, 'weight': 43, 'profit': 93}, {'item_id': 10, 'weight': 12, 'profit': 60}, {'item_id': 11, 'weight': 66, 'profit': 17}, {'item_id': 12, 'weight': 97, 'profit': 16}, {'item_id': 13, 'weight': 87, 'profit': 29}, {'item_id': 14, 'weight': 28, 'profit': 58}, {'item_id': 15, 'weight': 46, 'profit': 16}, {'item_id': 16, 'weight': 54, 'profit': 46}, {'item_id': 17, 'weight': 25, 'profit': 12}, {'item_id': 18, 'weight': 27, 'profit': 55}, {'item_id': 19, 'weight': 24, 'profit': 3}, {'item_id': 20, 'weight': 100, 'profit': 71}, {'item_id': 21, 'weight': 75, 'profit': 6}, {'item_id': 22, 'weight': 85, 'profit': 20}, {'item_id': 23, 'weight': 82, 'profit': 18}, {'item_id': 24, 'weight': 96, 'profit': 84}, {'item_id': 25, 'weight': 11, 'profit': 6}, {'item_id': 26, 'weight': 89, 'profit': 43}, {'item_id': 27, 'weight': 7, 'profit': 60}, {'item_id': 28, 'weight': 48, 'profit': 52}, {'item_id': 29, 'weight': 60, 'profit': 69}, {'item_id': 30, 'weight': 36, 'profit': 81}]}","{'1': 0, '2': 0, '3': 1, '4': 1, '5': 1, '6': 1, '7': 1, '8': 1, '9': 1, '10': 1, '11': 0, '12': 0, '13': 0, '14': 1, '15': 0, '16': 1, '17': 1, '18': 1, '19': 0, '20': 1, '21': 0, '22': 0, '23': 0, '24': 1, '25': 0, '26': 0, '27': 1, '28': 1, '29': 1, '30': 1}",11,markdown_table,1
KP,KP,"Someone dropped off a bunch of donations and the team needed to sort them into care boxes that help people the most. The job is to pick which items go into a box so the sum of their benefit values is as high as possible. Simple rules apply: the box has a maximum volume it won’t accept beyond, and each donated item is one-of-a-kind in the pile, so it can’t be put in twice. The specific volumes and benefit numbers appear below.

# box_max_volume=608
donation_id,item_volume,benefit_value
1,83,93
2,32,53
3,99,90
4,51,11
5,74,10
6,88,84
7,80,11
8,86,6
9,54,41
10,5,93
11,50,69
12,19,10
13,89,84
14,24,85
15,23,81
16,25,91
17,65,24
18,58,98
19,95,33
20,42,81
21,29,58
22,5,78
23,1,63
24,38,65

If you want to tell me which items to toss in the care box, just send it back in a tiny JSON snippet like this — super simple and easy to read:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here, ""solution"" is just a list that lines up with the items above: a 1 means ""tuck this item into the box"" and a 0 means ""leave it out."" Think of it like checking boxes on a short form.

This JSON is only a sketch of the shape I expect, not the actual answer — just follow that layout when you send your real picks. Also, please use the exact identifiers from the instance input for any item labels — don't rename or invent new ones. 

- for example: Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [83, 32, 99, 51, 74, 88, 80, 86, 54, 5, 50, 19, 89, 24, 23, 25, 65, 58, 95, 42, 29, 5, 1, 38], 'profits': [93, 53, 90, 11, 10, 84, 11, 6, 41, 93, 69, 10, 84, 85, 81, 91, 24, 98, 33, 81, 58, 78, 63, 65], 'capacity': 608, 'solution': [1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1], 'objective': 1182, 'solve_time': 0.00044727325439453125, 'n_items': 24, 'R': 100, 'alpha': 0.5, 'instance_idx': 11, 'alpha_idx': 0}","[1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1]",1182,"{'problem_type': 'KP', 'capacity': 608, 'n_items': 24, 'items': [{'item_id': 1, 'weight': 83, 'profit': 93}, {'item_id': 2, 'weight': 32, 'profit': 53}, {'item_id': 3, 'weight': 99, 'profit': 90}, {'item_id': 4, 'weight': 51, 'profit': 11}, {'item_id': 5, 'weight': 74, 'profit': 10}, {'item_id': 6, 'weight': 88, 'profit': 84}, {'item_id': 7, 'weight': 80, 'profit': 11}, {'item_id': 8, 'weight': 86, 'profit': 6}, {'item_id': 9, 'weight': 54, 'profit': 41}, {'item_id': 10, 'weight': 5, 'profit': 93}, {'item_id': 11, 'weight': 50, 'profit': 69}, {'item_id': 12, 'weight': 19, 'profit': 10}, {'item_id': 13, 'weight': 89, 'profit': 84}, {'item_id': 14, 'weight': 24, 'profit': 85}, {'item_id': 15, 'weight': 23, 'profit': 81}, {'item_id': 16, 'weight': 25, 'profit': 91}, {'item_id': 17, 'weight': 65, 'profit': 24}, {'item_id': 18, 'weight': 58, 'profit': 98}, {'item_id': 19, 'weight': 95, 'profit': 33}, {'item_id': 20, 'weight': 42, 'profit': 81}, {'item_id': 21, 'weight': 29, 'profit': 58}, {'item_id': 22, 'weight': 5, 'profit': 78}, {'item_id': 23, 'weight': 1, 'profit': 63}, {'item_id': 24, 'weight': 38, 'profit': 65}]}","{'1': 1, '2': 1, '3': 1, '4': 0, '5': 0, '6': 1, '7': 0, '8': 0, '9': 0, '10': 1, '11': 1, '12': 0, '13': 0, '14': 1, '15': 1, '16': 1, '17': 0, '18': 1, '19': 0, '20': 1, '21': 1, '22': 1, '23': 1, '24': 1}",12,csv,1
KP,KP,"We’ve planned a picnic and now the job is to pick which homemade sweets and snacks go into the cooler. The point is to make people happiest by selecting goodies whose enjoyment scores add up to the biggest total, while making sure the combined size/weight of the chosen items doesn’t exceed the cooler’s limit. Each recipe is unique, so each item can only be chosen once. The concrete item details and numbers are listed below.

Our cooler can hold 666 units, so below each treat is listed with its size and enjoyment:
We can bring A; it uses 78 capacity and yields 51 enjoyment.
We can bring B; it uses 74 capacity and yields 37 enjoyment.
We can bring C; it uses 14 capacity and yields 74 enjoyment.
We can bring D; it uses 83 capacity and yields 33 enjoyment.
We can bring E; it uses 54 capacity and yields 44 enjoyment.
We can bring F; it uses 33 capacity and yields 38 enjoyment.
We can bring G; it uses 52 capacity and yields 19 enjoyment.
We can bring H; it uses 97 capacity and yields 69 enjoyment.
We can bring I; it uses 86 capacity and yields 24 enjoyment.
We can bring J; it uses 84 capacity and yields 30 enjoyment.
We can bring K; it uses 47 capacity and yields 80 enjoyment.
We can bring L; it uses 79 capacity and yields 95 enjoyment.
We can bring M; it uses 39 capacity and yields 68 enjoyment.
We can bring N; it uses 69 capacity and yields 92 enjoyment.
We can bring O; it uses 64 capacity and yields 86 enjoyment.
We can bring P; it uses 25 capacity and yields 49 enjoyment.
We can bring Q; it uses 27 capacity and yields 78 enjoyment.
We can bring R; it uses 7 capacity and yields 33 enjoyment.
We can bring S; it uses 14 capacity and yields 47 enjoyment.
We can bring T; it uses 44 capacity and yields 54 enjoyment.
We can bring U; it uses 48 capacity and yields 97 enjoyment.
We can bring V; it uses 17 capacity and yields 85 enjoyment.
We can bring W; it uses 42 capacity and yields 49 enjoyment.
We can bring X; it uses 61 capacity and yields 66 enjoyment.
We can bring Y; it uses 24 capacity and yields 21 enjoyment.
We can bring Z; it uses 34 capacity and yields 81 enjoyment.
We can bring AA; it uses 37 capacity and yields 56 enjoyment.
We'll pick treats whose total size stays within 666 to maximize everyone's enjoyment.

Also, when you tell me which treats make the cut, please use this simple JSON layout so it's easy for whoever's packing to read:

{
  ""solution"": [0, 1, 0, 1, ...]
}

The ""solution"" array is just a sequence of zeros and ones that correspond to the items listed above — 1 means put that recipe in the cooler, 0 means leave it behind. Think of it like ticking boxes on a shopping list; this block is only a sketch of the expected shape, not the actual packing decision.

Also a quick note: use the exact identifiers from the instance input when you refer to items — no renaming and don’t invent new labels. 
For example: ""Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".""","{'problem_type': 'KP', 'weights': [78, 74, 14, 83, 54, 33, 52, 97, 86, 84, 47, 79, 39, 69, 64, 25, 27, 7, 14, 44, 48, 17, 42, 61, 24, 34, 37], 'profits': [51, 37, 74, 33, 44, 38, 19, 69, 24, 30, 80, 95, 68, 92, 86, 49, 78, 33, 47, 54, 97, 85, 49, 66, 21, 81, 56], 'capacity': 666, 'solution': [0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1], 'objective': 1183, 'solve_time': 0.0004904270172119141, 'n_items': 27, 'R': 100, 'alpha': 0.5, 'instance_idx': 12, 'alpha_idx': 0}","[0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1]",1183,"{'problem_type': 'KP', 'capacity': 666, 'n_items': 27, 'items': [{'item_id': 'A', 'weight': 78, 'profit': 51}, {'item_id': 'B', 'weight': 74, 'profit': 37}, {'item_id': 'C', 'weight': 14, 'profit': 74}, {'item_id': 'D', 'weight': 83, 'profit': 33}, {'item_id': 'E', 'weight': 54, 'profit': 44}, {'item_id': 'F', 'weight': 33, 'profit': 38}, {'item_id': 'G', 'weight': 52, 'profit': 19}, {'item_id': 'H', 'weight': 97, 'profit': 69}, {'item_id': 'I', 'weight': 86, 'profit': 24}, {'item_id': 'J', 'weight': 84, 'profit': 30}, {'item_id': 'K', 'weight': 47, 'profit': 80}, {'item_id': 'L', 'weight': 79, 'profit': 95}, {'item_id': 'M', 'weight': 39, 'profit': 68}, {'item_id': 'N', 'weight': 69, 'profit': 92}, {'item_id': 'O', 'weight': 64, 'profit': 86}, {'item_id': 'P', 'weight': 25, 'profit': 49}, {'item_id': 'Q', 'weight': 27, 'profit': 78}, {'item_id': 'R', 'weight': 7, 'profit': 33}, {'item_id': 'S', 'weight': 14, 'profit': 47}, {'item_id': 'T', 'weight': 44, 'profit': 54}, {'item_id': 'U', 'weight': 48, 'profit': 97}, {'item_id': 'V', 'weight': 17, 'profit': 85}, {'item_id': 'W', 'weight': 42, 'profit': 49}, {'item_id': 'X', 'weight': 61, 'profit': 66}, {'item_id': 'Y', 'weight': 24, 'profit': 21}, {'item_id': 'Z', 'weight': 34, 'profit': 81}, {'item_id': 'AA', 'weight': 37, 'profit': 56}]}","{'A': 0, 'B': 0, 'C': 1, 'D': 0, 'E': 0, 'F': 1, 'G': 0, 'H': 0, 'I': 0, 'J': 0, 'K': 1, 'L': 1, 'M': 1, 'N': 1, 'O': 1, 'P': 1, 'Q': 1, 'R': 1, 'S': 1, 'T': 1, 'U': 1, 'V': 1, 'W': 1, 'X': 0, 'Y': 1, 'Z': 1, 'AA': 1}",13,nl,names
KP,KP,"There’s a tiny flash player on the table and a pile of songs to pick from — the goal is simple: get the biggest total listening pleasure onto the device without overflowing its storage. To check any selection, just sum up the enjoyment scores of the songs you put on and sum their file sizes to confirm the total stays within the available space. Keep in mind a song is either on the player or not (no duplicates, no half-tracks). The full details for each track are shown below.

{
  ""storage_capacity_mb"": 670,
  ""items"": [
    {
      ""track_id"": 0,
      ""file_size_mb"": 77,
      ""enjoyment_score"": 96
    },
    {
      ""track_id"": 1,
      ""file_size_mb"": 64,
      ""enjoyment_score"": 96
    },
    {
      ""track_id"": 2,
      ""file_size_mb"": 8,
      ""enjoyment_score"": 17
    },
    {
      ""track_id"": 3,
      ""file_size_mb"": 29,
      ""enjoyment_score"": 81
    },
    {
      ""track_id"": 4,
      ""file_size_mb"": 18,
      ""enjoyment_score"": 41
    },
    {
      ""track_id"": 5,
      ""file_size_mb"": 74,
      ""enjoyment_score"": 60
    },
    {
      ""track_id"": 6,
      ""file_size_mb"": 4,
      ""enjoyment_score"": 45
    },
    {
      ""track_id"": 7,
      ""file_size_mb"": 21,
      ""enjoyment_score"": 79
    },
    {
      ""track_id"": 8,
      ""file_size_mb"": 60,
      ""enjoyment_score"": 100
    },
    {
      ""track_id"": 9,
      ""file_size_mb"": 70,
      ""enjoyment_score"": 80
    },
    {
      ""track_id"": 10,
      ""file_size_mb"": 51,
      ""enjoyment_score"": 94
    },
    {
      ""track_id"": 11,
      ""file_size_mb"": 87,
      ""enjoyment_score"": 95
    },
    {
      ""track_id"": 12,
      ""file_size_mb"": 92,
      ""enjoyment_score"": 10
    },
    {
      ""track_id"": 13,
      ""file_size_mb"": 14,
      ""enjoyment_score"": 26
    },
    {
      ""track_id"": 14,
      ""file_size_mb"": 96,
      ""enjoyment_score"": 73
    },
    {
      ""track_id"": 15,
      ""file_size_mb"": 62,
      ""enjoyment_score"": 60
    },
    {
      ""track_id"": 16,
      ""file_size_mb"": 64,
      ""enjoyment_score"": 6
    },
    {
      ""track_id"": 17,
      ""file_size_mb"": 10,
      ""enjoyment_score"": 10
    },
    {
      ""track_id"": 18,
      ""file_size_mb"": 63,
      ""enjoyment_score"": 53
    },
    {
      ""track_id"": 19,
      ""file_size_mb"": 73,
      ""enjoyment_score"": 62
    },
    {
      ""track_id"": 20,
      ""file_size_mb"": 59,
      ""enjoyment_score"": 17
    },
    {
      ""track_id"": 21,
      ""file_size_mb"": 9,
      ""enjoyment_score"": 18
    },
    {
      ""track_id"": 22,
      ""file_size_mb"": 53,
      ""enjoyment_score"": 13
    },
    {
      ""track_id"": 23,
      ""file_size_mb"": 94,
      ""enjoyment_score"": 57
    },
    {
      ""track_id"": 24,
      ""file_size_mb"": 73,
      ""enjoyment_score"": 1
    },
    {
      ""track_id"": 25,
      ""file_size_mb"": 14,
      ""enjoyment_score"": 58
    }
  ]
}

If you want to hand me a final pick, just use this simple JSON layout so it's easy to read and check:

{
  ""solution"": [0, 1, 0, 1, ...]
}

""solution"" is just a list that follows the track listing order: use 1 for a song you put on the player and 0 for one you leave off. Think of the JSON above as a little form showing the shape I expect — replace that example array with your actual selection of zeros and ones.

Please make sure any identifiers you use match the instance input exactly — don't rename tracks or invent new labels.  
- Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [77, 64, 8, 29, 18, 74, 4, 21, 60, 70, 51, 87, 92, 14, 96, 62, 64, 10, 63, 73, 59, 9, 53, 94, 73, 14], 'profits': [96, 96, 17, 81, 41, 60, 45, 79, 100, 80, 94, 95, 10, 26, 73, 60, 6, 10, 53, 62, 17, 18, 13, 57, 1, 58], 'capacity': 670, 'solution': [1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1], 'objective': 1049, 'solve_time': 0.0004649162292480469, 'n_items': 26, 'R': 100, 'alpha': 0.5, 'instance_idx': 13, 'alpha_idx': 0}","[1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1]",1049,"{'problem_type': 'KP', 'capacity': 670, 'n_items': 26, 'items': [{'item_id': 0, 'weight': 77, 'profit': 96}, {'item_id': 1, 'weight': 64, 'profit': 96}, {'item_id': 2, 'weight': 8, 'profit': 17}, {'item_id': 3, 'weight': 29, 'profit': 81}, {'item_id': 4, 'weight': 18, 'profit': 41}, {'item_id': 5, 'weight': 74, 'profit': 60}, {'item_id': 6, 'weight': 4, 'profit': 45}, {'item_id': 7, 'weight': 21, 'profit': 79}, {'item_id': 8, 'weight': 60, 'profit': 100}, {'item_id': 9, 'weight': 70, 'profit': 80}, {'item_id': 10, 'weight': 51, 'profit': 94}, {'item_id': 11, 'weight': 87, 'profit': 95}, {'item_id': 12, 'weight': 92, 'profit': 10}, {'item_id': 13, 'weight': 14, 'profit': 26}, {'item_id': 14, 'weight': 96, 'profit': 73}, {'item_id': 15, 'weight': 62, 'profit': 60}, {'item_id': 16, 'weight': 64, 'profit': 6}, {'item_id': 17, 'weight': 10, 'profit': 10}, {'item_id': 18, 'weight': 63, 'profit': 53}, {'item_id': 19, 'weight': 73, 'profit': 62}, {'item_id': 20, 'weight': 59, 'profit': 17}, {'item_id': 21, 'weight': 9, 'profit': 18}, {'item_id': 22, 'weight': 53, 'profit': 13}, {'item_id': 23, 'weight': 94, 'profit': 57}, {'item_id': 24, 'weight': 73, 'profit': 1}, {'item_id': 25, 'weight': 14, 'profit': 58}]}","{'0': 1, '1': 1, '2': 1, '3': 1, '4': 1, '5': 0, '6': 1, '7': 1, '8': 1, '9': 1, '10': 1, '11': 1, '12': 0, '13': 1, '14': 0, '15': 1, '16': 0, '17': 1, '18': 1, '19': 0, '20': 0, '21': 1, '22': 0, '23': 0, '24': 0, '25': 1}",14,json,0
KP,KP,"In a small group chat everyone was trying to figure out what to buy with a shared budget: the idea is to select a set of gadgets so that when their usefulness points are added together the total beats other selections, but the total spending on those gadgets must stay within the preset limit. Items can’t be split and only one of each is available, so the comparison is made by summing usefulness and summing prices for each possible set and picking the best set that stays inside the budget. The exact item details and numbers are shown below.

The group's spending limit is 728.
Gadget A costs 47 and gives 21 usefulness points.
Gadget B costs 68 and gives 68 usefulness points.
Gadget C costs 53 and gives 74 usefulness points.
Gadget D costs 73 and gives 34 usefulness points.
Gadget E costs 77 and gives 74 usefulness points.
Gadget F costs 93 and gives 90 usefulness points.
Gadget G costs 80 and gives 82 usefulness points.
Gadget H costs 52 and gives 77 usefulness points.
Gadget I costs 50 and gives 64 usefulness points.
Gadget J costs 24 and gives 28 usefulness points.
Gadget K costs 60 and gives 80 usefulness points.
Gadget L costs 14 and gives 37 usefulness points.
Gadget M costs 94 and gives 54 usefulness points.
Gadget N costs 85 and gives 32 usefulness points.
Gadget O costs 12 and gives 32 usefulness points.
Gadget P costs 79 and gives 16 usefulness points.
Gadget Q costs 12 and gives 97 usefulness points.
Gadget R costs 73 and gives 15 usefulness points.
Gadget S costs 9 and gives 9 usefulness points.
Gadget T costs 49 and gives 94 usefulness points.
Gadget U costs 66 and gives 56 usefulness points.
Gadget V costs 73 and gives 44 usefulness points.
Gadget W costs 42 and gives 74 usefulness points.
Gadget X costs 93 and gives 39 usefulness points.
Gadget Y costs 78 and gives 13 usefulness points.
Choose the set with the highest total usefulness that stays within 728.

Oh, and one more thing — when you send back your pick, a little JSON snippet like this is perfect:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is just a list with one entry per gadget in the same order as the instance lists them: 1 means you pick that gadget, 0 means you leave it. Think of it like ticking boxes on a shared shopping list. This JSON is only a sketch of the shape I want, not the actual final answer — just follow the layout.

Please make sure to use the exact identifiers from the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [47, 68, 53, 73, 77, 93, 80, 52, 50, 24, 60, 14, 94, 85, 12, 79, 12, 73, 9, 49, 66, 73, 42, 93, 78], 'profits': [21, 68, 74, 34, 74, 90, 82, 77, 64, 28, 80, 37, 54, 32, 32, 16, 97, 15, 9, 94, 56, 44, 74, 39, 13], 'capacity': 728, 'solution': [0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0], 'objective': 999, 'solve_time': 0.00046515464782714844, 'n_items': 25, 'R': 100, 'alpha': 0.5, 'instance_idx': 14, 'alpha_idx': 0}","[0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0]",999,"{'problem_type': 'KP', 'capacity': 728, 'n_items': 25, 'items': [{'item_id': 'A', 'weight': 47, 'profit': 21}, {'item_id': 'B', 'weight': 68, 'profit': 68}, {'item_id': 'C', 'weight': 53, 'profit': 74}, {'item_id': 'D', 'weight': 73, 'profit': 34}, {'item_id': 'E', 'weight': 77, 'profit': 74}, {'item_id': 'F', 'weight': 93, 'profit': 90}, {'item_id': 'G', 'weight': 80, 'profit': 82}, {'item_id': 'H', 'weight': 52, 'profit': 77}, {'item_id': 'I', 'weight': 50, 'profit': 64}, {'item_id': 'J', 'weight': 24, 'profit': 28}, {'item_id': 'K', 'weight': 60, 'profit': 80}, {'item_id': 'L', 'weight': 14, 'profit': 37}, {'item_id': 'M', 'weight': 94, 'profit': 54}, {'item_id': 'N', 'weight': 85, 'profit': 32}, {'item_id': 'O', 'weight': 12, 'profit': 32}, {'item_id': 'P', 'weight': 79, 'profit': 16}, {'item_id': 'Q', 'weight': 12, 'profit': 97}, {'item_id': 'R', 'weight': 73, 'profit': 15}, {'item_id': 'S', 'weight': 9, 'profit': 9}, {'item_id': 'T', 'weight': 49, 'profit': 94}, {'item_id': 'U', 'weight': 66, 'profit': 56}, {'item_id': 'V', 'weight': 73, 'profit': 44}, {'item_id': 'W', 'weight': 42, 'profit': 74}, {'item_id': 'X', 'weight': 93, 'profit': 39}, {'item_id': 'Y', 'weight': 78, 'profit': 13}]}","{'A': 0, 'B': 1, 'C': 1, 'D': 0, 'E': 1, 'F': 1, 'G': 1, 'H': 1, 'I': 1, 'J': 0, 'K': 1, 'L': 1, 'M': 0, 'N': 0, 'O': 1, 'P': 0, 'Q': 1, 'R': 0, 'S': 0, 'T': 1, 'U': 1, 'V': 0, 'W': 1, 'X': 0, 'Y': 0}",15,nl,names
KP,KP,"Many people slimming down their portfolios treat it like a game: which combination of drawings will make the folder read richest? Each sketch brings a certain amount of visual weight and a certain amount of impression — the folder’s overall impression is just the total of those impression values for whatever is chosen. The sleeve only holds so much paper, and you can’t put the same drawing in twice, so choices are mutually exclusive. The exact sizes and impression values are listed below.

Fit selections so their total thickness does not exceed 744.
Sketch 1 — thickness 18, impression 55.
Sketch 2 — thickness 56, impression 2.
Sketch 3 — thickness 95, impression 10.
Sketch 4 — thickness 94, impression 46.
Sketch 5 — thickness 37, impression 73.
Sketch 6 — thickness 79, impression 83.
Sketch 7 — thickness 62, impression 44.
Sketch 8 — thickness 48, impression 30.
Sketch 9 — thickness 14, impression 97.
Sketch 10 — thickness 38, impression 46.
Sketch 11 — thickness 66, impression 32.
Sketch 12 — thickness 99, impression 45.
Sketch 13 — thickness 1, impression 2.
Sketch 14 — thickness 72, impression 31.
Sketch 15 — thickness 85, impression 52.
Sketch 16 — thickness 96, impression 92.
Sketch 17 — thickness 43, impression 74.
Sketch 18 — thickness 12, impression 79.
Sketch 19 — thickness 28, impression 55.
Sketch 20 — thickness 86, impression 12.
Sketch 21 — thickness 88, impression 40.
Sketch 22 — thickness 64, impression 100.
Sketch 23 — thickness 13, impression 5.
Sketch 24 — thickness 13, impression 88.
Sketch 25 — thickness 48, impression 69.
Sketch 26 — thickness 59, impression 29.
Sketch 27 — thickness 4, impression 78.
Sketch 28 — thickness 69, impression 84.
Aim for the richest overall impression while staying within 744.

Oh, and when you reply with your pick, it helps to use a little JSON snippet like this so everything’s easy to read and parse:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here’s what that means in plain terms: the ""solution"" array is a checklist that lines up with the drawings listed above — a 1 means you tuck that drawing into the sleeve, a 0 means you leave it out. Treat the JSON as just the shape I’m expecting, not the final selection itself.

Please make sure any identifiers you use match the instance input exactly — don’t rename things or invent new labels.  
Valid identifiers look like:
- plain numbers such as ""1"" or ""23""
- single capital letters like ""A"" or ""B""
- a capital letter followed by digits like ""A1"" or ""X7""","{'problem_type': 'KP', 'weights': [18, 56, 95, 94, 37, 79, 62, 48, 14, 38, 66, 99, 1, 72, 85, 96, 43, 12, 28, 86, 88, 64, 13, 13, 48, 59, 4, 69], 'profits': [55, 2, 10, 46, 73, 83, 44, 30, 97, 46, 32, 45, 2, 31, 52, 92, 74, 79, 55, 12, 40, 100, 5, 88, 69, 29, 78, 84], 'capacity': 744, 'solution': [1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1], 'objective': 1181, 'solve_time': 0.0005049705505371094, 'n_items': 28, 'R': 100, 'alpha': 0.5, 'instance_idx': 15, 'alpha_idx': 0}","[1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1]",1181,"{'problem_type': 'KP', 'capacity': 744, 'n_items': 28, 'items': [{'item_id': 1, 'weight': 18, 'profit': 55}, {'item_id': 2, 'weight': 56, 'profit': 2}, {'item_id': 3, 'weight': 95, 'profit': 10}, {'item_id': 4, 'weight': 94, 'profit': 46}, {'item_id': 5, 'weight': 37, 'profit': 73}, {'item_id': 6, 'weight': 79, 'profit': 83}, {'item_id': 7, 'weight': 62, 'profit': 44}, {'item_id': 8, 'weight': 48, 'profit': 30}, {'item_id': 9, 'weight': 14, 'profit': 97}, {'item_id': 10, 'weight': 38, 'profit': 46}, {'item_id': 11, 'weight': 66, 'profit': 32}, {'item_id': 12, 'weight': 99, 'profit': 45}, {'item_id': 13, 'weight': 1, 'profit': 2}, {'item_id': 14, 'weight': 72, 'profit': 31}, {'item_id': 15, 'weight': 85, 'profit': 52}, {'item_id': 16, 'weight': 96, 'profit': 92}, {'item_id': 17, 'weight': 43, 'profit': 74}, {'item_id': 18, 'weight': 12, 'profit': 79}, {'item_id': 19, 'weight': 28, 'profit': 55}, {'item_id': 20, 'weight': 86, 'profit': 12}, {'item_id': 21, 'weight': 88, 'profit': 40}, {'item_id': 22, 'weight': 64, 'profit': 100}, {'item_id': 23, 'weight': 13, 'profit': 5}, {'item_id': 24, 'weight': 13, 'profit': 88}, {'item_id': 25, 'weight': 48, 'profit': 69}, {'item_id': 26, 'weight': 59, 'profit': 29}, {'item_id': 27, 'weight': 4, 'profit': 78}, {'item_id': 28, 'weight': 69, 'profit': 84}]}","{'1': 1, '2': 0, '3': 0, '4': 0, '5': 1, '6': 1, '7': 1, '8': 1, '9': 1, '10': 1, '11': 1, '12': 0, '13': 1, '14': 0, '15': 0, '16': 1, '17': 1, '18': 1, '19': 1, '20': 0, '21': 0, '22': 1, '23': 0, '24': 1, '25': 1, '26': 0, '27': 1, '28': 1}",16,nl,1
KP,KP,"On a tight budget, a solo entrepreneur is picking advertising slots: every slot has a cost and an expected audience size, and the job is to pick the combination that yields the largest combined expected audience. That total is found by adding up the expected reaches of the chosen slots, and the sum of their costs must stay within the spending cap — each slot can only be purchased once and can be skipped. The exact placements, costs, and reach estimates follow below.

- **ad_spend_cap**: 513

| placement_id | placement_cost | expected_reach |
|---|---|---|
| 1 | 11 | 2 |
| 2 | 67 | 92 |
| 3 | 100 | 29 |
| 4 | 3 | 66 |
| 5 | 67 | 91 |
| 6 | 14 | 4 |
| 7 | 66 | 1 |
| 8 | 63 | 1 |
| 9 | 10 | 16 |
| 10 | 69 | 6 |
| 11 | 90 | 82 |
| 12 | 87 | 61 |
| 13 | 3 | 99 |
| 14 | 25 | 81 |
| 15 | 25 | 97 |
| 16 | 46 | 24 |
| 17 | 15 | 29 |
| 18 | 86 | 85 |
| 19 | 78 | 25 |
| 20 | 81 | 6 |
| 21 | 20 | 67 |

If you want to send the pick as a tidy, machine-friendly snippet, just follow this little JSON shape so I know which slots you chose:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Pretty simple: ""solution"" is a list of zeros and ones where each entry lines up with a slot from the list above — 1 means you buy that slot, 0 means you skip it. Think of it like ticking boxes on a form. This JSON is just a sketch of the expected shape, not the actual answer you must submit.

Please make sure any identifiers you use match the instance input exactly — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [11, 67, 100, 3, 67, 14, 66, 63, 10, 69, 90, 87, 3, 25, 25, 46, 15, 86, 78, 81, 20], 'profits': [2, 92, 29, 66, 91, 4, 1, 1, 16, 6, 82, 61, 99, 81, 97, 24, 29, 85, 25, 6, 67], 'capacity': 513, 'solution': [0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1], 'objective': 870, 'solve_time': 0.0004439353942871094, 'n_items': 21, 'R': 100, 'alpha': 0.5, 'instance_idx': 16, 'alpha_idx': 0}","[0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1]",870,"{'problem_type': 'KP', 'capacity': 513, 'n_items': 21, 'items': [{'item_id': 1, 'weight': 11, 'profit': 2}, {'item_id': 2, 'weight': 67, 'profit': 92}, {'item_id': 3, 'weight': 100, 'profit': 29}, {'item_id': 4, 'weight': 3, 'profit': 66}, {'item_id': 5, 'weight': 67, 'profit': 91}, {'item_id': 6, 'weight': 14, 'profit': 4}, {'item_id': 7, 'weight': 66, 'profit': 1}, {'item_id': 8, 'weight': 63, 'profit': 1}, {'item_id': 9, 'weight': 10, 'profit': 16}, {'item_id': 10, 'weight': 69, 'profit': 6}, {'item_id': 11, 'weight': 90, 'profit': 82}, {'item_id': 12, 'weight': 87, 'profit': 61}, {'item_id': 13, 'weight': 3, 'profit': 99}, {'item_id': 14, 'weight': 25, 'profit': 81}, {'item_id': 15, 'weight': 25, 'profit': 97}, {'item_id': 16, 'weight': 46, 'profit': 24}, {'item_id': 17, 'weight': 15, 'profit': 29}, {'item_id': 18, 'weight': 86, 'profit': 85}, {'item_id': 19, 'weight': 78, 'profit': 25}, {'item_id': 20, 'weight': 81, 'profit': 6}, {'item_id': 21, 'weight': 20, 'profit': 67}]}","{'1': 0, '2': 1, '3': 0, '4': 1, '5': 1, '6': 1, '7': 0, '8': 0, '9': 1, '10': 0, '11': 1, '12': 1, '13': 1, '14': 1, '15': 1, '16': 0, '17': 1, '18': 1, '19': 0, '20': 0, '21': 1}",17,markdown_table,1
KP,KP,"Many homeowners want a narrow strip outside their window to pop with color, so the landscaper must choose which shrubs and perennials to put in. The best selection will be the one whose individual seasonal color scores add up to the largest total, giving the most visual impact across the year. That total has to be achieved without overrunning the bed’s area — the sum of the plants’ space requirements must fit — and each plant option can only be used once; nothing can be split or repeated. The detailed plant options and the border’s capacity are shown below.

- **bed_area_capacity**: 726

| plant_id | space_required | seasonal_color_score |
|---|---|---|
| 0 | 97 | 28 |
| 1 | 93 | 10 |
| 2 | 13 | 71 |
| 3 | 78 | 53 |
| 4 | 85 | 99 |
| 5 | 70 | 75 |
| 6 | 82 | 62 |
| 7 | 84 | 51 |
| 8 | 45 | 6 |
| 9 | 5 | 8 |
| 10 | 46 | 62 |
| 11 | 21 | 1 |
| 12 | 12 | 5 |
| 13 | 13 | 22 |
| 14 | 70 | 89 |
| 15 | 51 | 46 |
| 16 | 54 | 71 |
| 17 | 75 | 42 |
| 18 | 55 | 18 |
| 19 | 64 | 38 |
| 20 | 9 | 10 |
| 21 | 86 | 78 |
| 22 | 45 | 19 |
| 23 | 16 | 38 |
| 24 | 82 | 99 |
| 25 | 74 | 60 |
| 26 | 6 | 46 |
| 27 | 20 | 55 |
| 28 | 2 | 79 |

If you want to send back your plant picks in a neat, machine-friendly way, just follow this simple JSON shape so I can read which items you chose:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is a list that lines up with the plant options shown above: each position is one plant in the same order, and a 1 means ""put it in the border"" while a 0 means ""leave it out."" Think of it as a quick yes/no checklist rather than a long paragraph — and remember, this is just the expected shape, not the final selection itself.

Please use the exact identifiers from the instance input — do not rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [97, 93, 13, 78, 85, 70, 82, 84, 45, 5, 46, 21, 12, 13, 70, 51, 54, 75, 55, 64, 9, 86, 45, 16, 82, 74, 6, 20, 2], 'profits': [28, 10, 71, 53, 99, 75, 62, 51, 6, 8, 62, 1, 5, 22, 89, 46, 71, 42, 18, 38, 10, 78, 19, 38, 99, 60, 46, 55, 79], 'capacity': 726, 'solution': [0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1], 'objective': 1015, 'solve_time': 0.0005314350128173828, 'n_items': 29, 'R': 100, 'alpha': 0.5, 'instance_idx': 17, 'alpha_idx': 0}","[0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1]",1015,"{'problem_type': 'KP', 'capacity': 726, 'n_items': 29, 'items': [{'item_id': 0, 'weight': 97, 'profit': 28}, {'item_id': 1, 'weight': 93, 'profit': 10}, {'item_id': 2, 'weight': 13, 'profit': 71}, {'item_id': 3, 'weight': 78, 'profit': 53}, {'item_id': 4, 'weight': 85, 'profit': 99}, {'item_id': 5, 'weight': 70, 'profit': 75}, {'item_id': 6, 'weight': 82, 'profit': 62}, {'item_id': 7, 'weight': 84, 'profit': 51}, {'item_id': 8, 'weight': 45, 'profit': 6}, {'item_id': 9, 'weight': 5, 'profit': 8}, {'item_id': 10, 'weight': 46, 'profit': 62}, {'item_id': 11, 'weight': 21, 'profit': 1}, {'item_id': 12, 'weight': 12, 'profit': 5}, {'item_id': 13, 'weight': 13, 'profit': 22}, {'item_id': 14, 'weight': 70, 'profit': 89}, {'item_id': 15, 'weight': 51, 'profit': 46}, {'item_id': 16, 'weight': 54, 'profit': 71}, {'item_id': 17, 'weight': 75, 'profit': 42}, {'item_id': 18, 'weight': 55, 'profit': 18}, {'item_id': 19, 'weight': 64, 'profit': 38}, {'item_id': 20, 'weight': 9, 'profit': 10}, {'item_id': 21, 'weight': 86, 'profit': 78}, {'item_id': 22, 'weight': 45, 'profit': 19}, {'item_id': 23, 'weight': 16, 'profit': 38}, {'item_id': 24, 'weight': 82, 'profit': 99}, {'item_id': 25, 'weight': 74, 'profit': 60}, {'item_id': 26, 'weight': 6, 'profit': 46}, {'item_id': 27, 'weight': 20, 'profit': 55}, {'item_id': 28, 'weight': 2, 'profit': 79}]}","{'0': 0, '1': 0, '2': 1, '3': 0, '4': 1, '5': 1, '6': 1, '7': 0, '8': 0, '9': 1, '10': 1, '11': 0, '12': 1, '13': 1, '14': 1, '15': 1, '16': 1, '17': 0, '18': 0, '19': 0, '20': 1, '21': 1, '22': 0, '23': 1, '24': 1, '25': 0, '26': 1, '27': 1, '28': 1}",18,markdown_table,0
KP,KP,"Many people who shoot in RAW face the same problem: a lovely set of high-res photos but a strict upload limit. In this case every photo has a file-size and a score for how much the client will value it, and the job is to pick the best mix so the total client value is as high as possible. Decide by summing the value scores of the photos you include, and check that the sum of their file sizes doesn’t exceed the upload allowance. No photo can be picked more than once and you can’t split files. The detailed file sizes and value scores appear below.

- **upload_size_limit**: 586

| photo_id | photo_file_size | client_value_score |
|---|---|---|
| A | 64 | 92 |
| B | 88 | 48 |
| C | 58 | 13 |
| D | 45 | 12 |
| E | 15 | 98 |
| F | 25 | 14 |
| G | 95 | 95 |
| H | 55 | 28 |
| I | 31 | 10 |
| J | 42 | 31 |
| K | 58 | 62 |
| L | 54 | 43 |
| M | 70 | 79 |
| N | 26 | 62 |
| O | 65 | 41 |
| P | 45 | 64 |
| Q | 95 | 98 |
| R | 16 | 42 |
| S | 15 | 16 |
| T | 47 | 41 |
| U | 51 | 85 |
| V | 70 | 22 |
| W | 41 | 95 |

When you send back which photos to upload, just stick to a tiny JSON snippet so it’s easy to parse — something like this:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here the ""solution"" array is one entry per photo: 1 means include that photo, 0 means skip it — like ticking boxes on a form. This block is just a sketch of the shape I expect, not the actual answer — replace the example vector with your chosen ones and zeros.

All identifiers in your reply must match the instance input exactly — no renaming, no new labels.  
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [64, 88, 58, 45, 15, 25, 95, 55, 31, 42, 58, 54, 70, 26, 65, 45, 95, 16, 15, 47, 51, 70, 41], 'profits': [92, 48, 13, 12, 98, 14, 95, 28, 10, 31, 62, 43, 79, 62, 41, 64, 98, 42, 16, 41, 85, 22, 95], 'capacity': 586, 'solution': [1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1], 'objective': 872, 'solve_time': 0.0004487037658691406, 'n_items': 23, 'R': 100, 'alpha': 0.5, 'instance_idx': 18, 'alpha_idx': 0}","[1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1]",872,"{'problem_type': 'KP', 'capacity': 586, 'n_items': 23, 'items': [{'item_id': 'A', 'weight': 64, 'profit': 92}, {'item_id': 'B', 'weight': 88, 'profit': 48}, {'item_id': 'C', 'weight': 58, 'profit': 13}, {'item_id': 'D', 'weight': 45, 'profit': 12}, {'item_id': 'E', 'weight': 15, 'profit': 98}, {'item_id': 'F', 'weight': 25, 'profit': 14}, {'item_id': 'G', 'weight': 95, 'profit': 95}, {'item_id': 'H', 'weight': 55, 'profit': 28}, {'item_id': 'I', 'weight': 31, 'profit': 10}, {'item_id': 'J', 'weight': 42, 'profit': 31}, {'item_id': 'K', 'weight': 58, 'profit': 62}, {'item_id': 'L', 'weight': 54, 'profit': 43}, {'item_id': 'M', 'weight': 70, 'profit': 79}, {'item_id': 'N', 'weight': 26, 'profit': 62}, {'item_id': 'O', 'weight': 65, 'profit': 41}, {'item_id': 'P', 'weight': 45, 'profit': 64}, {'item_id': 'Q', 'weight': 95, 'profit': 98}, {'item_id': 'R', 'weight': 16, 'profit': 42}, {'item_id': 'S', 'weight': 15, 'profit': 16}, {'item_id': 'T', 'weight': 47, 'profit': 41}, {'item_id': 'U', 'weight': 51, 'profit': 85}, {'item_id': 'V', 'weight': 70, 'profit': 22}, {'item_id': 'W', 'weight': 41, 'profit': 95}]}","{'A': 1, 'B': 0, 'C': 0, 'D': 0, 'E': 1, 'F': 0, 'G': 1, 'H': 0, 'I': 0, 'J': 0, 'K': 1, 'L': 0, 'M': 1, 'N': 1, 'O': 0, 'P': 1, 'Q': 1, 'R': 1, 'S': 0, 'T': 0, 'U': 1, 'V': 0, 'W': 1}",19,markdown_table,names
KP,KP,"Recently I’ve been figuring out what to take for a two-day cottage stay: pick pantry staples so the combined usefulness for meals is as high as possible, yet everything must fit into the cooler. For any selection, calculate how good it is by summing the value points of each chosen ingredient; bigger totals mean better meals, but the total space those items occupy can’t be more than the cooler can hold. Ingredients are indivisible — each one can be packed at most once. The full list of items and their sizes/values is shown below.

{
  ""cooler_capacity"": 610,
  ""items"": [
    {
      ""ingredient_id"": ""A"",
      ""ingredient_space"": 61,
      ""ingredient_value"": 20
    },
    {
      ""ingredient_id"": ""B"",
      ""ingredient_space"": 32,
      ""ingredient_value"": 44
    },
    {
      ""ingredient_id"": ""C"",
      ""ingredient_space"": 93,
      ""ingredient_value"": 53
    },
    {
      ""ingredient_id"": ""D"",
      ""ingredient_space"": 4,
      ""ingredient_value"": 63
    },
    {
      ""ingredient_id"": ""E"",
      ""ingredient_space"": 30,
      ""ingredient_value"": 53
    },
    {
      ""ingredient_id"": ""F"",
      ""ingredient_space"": 42,
      ""ingredient_value"": 37
    },
    {
      ""ingredient_id"": ""G"",
      ""ingredient_space"": 48,
      ""ingredient_value"": 97
    },
    {
      ""ingredient_id"": ""H"",
      ""ingredient_space"": 48,
      ""ingredient_value"": 52
    },
    {
      ""ingredient_id"": ""I"",
      ""ingredient_space"": 15,
      ""ingredient_value"": 81
    },
    {
      ""ingredient_id"": ""J"",
      ""ingredient_space"": 23,
      ""ingredient_value"": 74
    },
    {
      ""ingredient_id"": ""K"",
      ""ingredient_space"": 10,
      ""ingredient_value"": 56
    },
    {
      ""ingredient_id"": ""L"",
      ""ingredient_space"": 58,
      ""ingredient_value"": 89
    },
    {
      ""ingredient_id"": ""M"",
      ""ingredient_space"": 36,
      ""ingredient_value"": 13
    },
    {
      ""ingredient_id"": ""N"",
      ""ingredient_space"": 57,
      ""ingredient_value"": 93
    },
    {
      ""ingredient_id"": ""O"",
      ""ingredient_space"": 59,
      ""ingredient_value"": 86
    },
    {
      ""ingredient_id"": ""P"",
      ""ingredient_space"": 71,
      ""ingredient_value"": 51
    },
    {
      ""ingredient_id"": ""Q"",
      ""ingredient_space"": 55,
      ""ingredient_value"": 74
    },
    {
      ""ingredient_id"": ""R"",
      ""ingredient_space"": 65,
      ""ingredient_value"": 53
    },
    {
      ""ingredient_id"": ""S"",
      ""ingredient_space"": 59,
      ""ingredient_value"": 27
    },
    {
      ""ingredient_id"": ""T"",
      ""ingredient_space"": 66,
      ""ingredient_value"": 80
    },
    {
      ""ingredient_id"": ""U"",
      ""ingredient_space"": 62,
      ""ingredient_value"": 25
    },
    {
      ""ingredient_id"": ""V"",
      ""ingredient_space"": 32,
      ""ingredient_value"": 32
    },
    {
      ""ingredient_id"": ""W"",
      ""ingredient_space"": 25,
      ""ingredient_value"": 52
    },
    {
      ""ingredient_id"": ""X"",
      ""ingredient_space"": 79,
      ""ingredient_value"": 84
    },
    {
      ""ingredient_id"": ""Y"",
      ""ingredient_space"": 35,
      ""ingredient_value"": 39
    },
    {
      ""ingredient_id"": ""Z"",
      ""ingredient_space"": 55,
      ""ingredient_value"": 50
    }
  ]
}

If you want to tell me which items you’re actually packing, just send it back in a little JSON snippet like this — nice and simple:

{
  ""solution"": [0, 1, 0, 1, ...]
}

This ""solution"" array is just a checklist that matches the item list above: each position corresponds to the item in the same order, 1 means you’re packing that ingredient, 0 means you’re leaving it behind. Think of it as a tiny form, not the final packing list — it just shows the shape I need to read your choice.

Please use the exact identifiers from the instance input — don’t rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [61, 32, 93, 4, 30, 42, 48, 48, 15, 23, 10, 58, 36, 57, 59, 71, 55, 65, 59, 66, 62, 32, 25, 79, 35, 55], 'profits': [20, 44, 53, 63, 53, 37, 97, 52, 81, 74, 56, 89, 13, 93, 86, 51, 74, 53, 27, 80, 25, 32, 52, 84, 39, 50], 'capacity': 610, 'solution': [0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0], 'objective': 1078, 'solve_time': 0.0004611015319824219, 'n_items': 26, 'R': 100, 'alpha': 0.5, 'instance_idx': 19, 'alpha_idx': 0}","[0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0]",1078,"{'problem_type': 'KP', 'capacity': 610, 'n_items': 26, 'items': [{'item_id': 'A', 'weight': 61, 'profit': 20}, {'item_id': 'B', 'weight': 32, 'profit': 44}, {'item_id': 'C', 'weight': 93, 'profit': 53}, {'item_id': 'D', 'weight': 4, 'profit': 63}, {'item_id': 'E', 'weight': 30, 'profit': 53}, {'item_id': 'F', 'weight': 42, 'profit': 37}, {'item_id': 'G', 'weight': 48, 'profit': 97}, {'item_id': 'H', 'weight': 48, 'profit': 52}, {'item_id': 'I', 'weight': 15, 'profit': 81}, {'item_id': 'J', 'weight': 23, 'profit': 74}, {'item_id': 'K', 'weight': 10, 'profit': 56}, {'item_id': 'L', 'weight': 58, 'profit': 89}, {'item_id': 'M', 'weight': 36, 'profit': 13}, {'item_id': 'N', 'weight': 57, 'profit': 93}, {'item_id': 'O', 'weight': 59, 'profit': 86}, {'item_id': 'P', 'weight': 71, 'profit': 51}, {'item_id': 'Q', 'weight': 55, 'profit': 74}, {'item_id': 'R', 'weight': 65, 'profit': 53}, {'item_id': 'S', 'weight': 59, 'profit': 27}, {'item_id': 'T', 'weight': 66, 'profit': 80}, {'item_id': 'U', 'weight': 62, 'profit': 25}, {'item_id': 'V', 'weight': 32, 'profit': 32}, {'item_id': 'W', 'weight': 25, 'profit': 52}, {'item_id': 'X', 'weight': 79, 'profit': 84}, {'item_id': 'Y', 'weight': 35, 'profit': 39}, {'item_id': 'Z', 'weight': 55, 'profit': 50}]}","{'A': 0, 'B': 1, 'C': 0, 'D': 1, 'E': 1, 'F': 0, 'G': 1, 'H': 1, 'I': 1, 'J': 1, 'K': 1, 'L': 1, 'M': 0, 'N': 1, 'O': 1, 'P': 0, 'Q': 1, 'R': 0, 'S': 0, 'T': 1, 'U': 0, 'V': 0, 'W': 1, 'X': 1, 'Y': 0, 'Z': 0}",20,json,names
KP,KP,"On a rainy afternoon the decision got narrowed down to which vinyl made it into the crate: pick the combination that yields the largest total sentimental value when the chosen records’ values are summed, but keep the total weight of those records beneath the crate’s capacity. Records are indivisible and single-copy — either they go in or they don’t. The concrete item-by-item details are shown below.

{
  ""crate_capacity"": 445,
  ""items"": [
    {
      ""record_id"": 1,
      ""record_weight"": 12,
      ""sentimental_value"": 71
    },
    {
      ""record_id"": 2,
      ""record_weight"": 6,
      ""sentimental_value"": 86
    },
    {
      ""record_id"": 3,
      ""record_weight"": 8,
      ""sentimental_value"": 42
    },
    {
      ""record_id"": 4,
      ""record_weight"": 87,
      ""sentimental_value"": 38
    },
    {
      ""record_id"": 5,
      ""record_weight"": 85,
      ""sentimental_value"": 71
    },
    {
      ""record_id"": 6,
      ""record_weight"": 83,
      ""sentimental_value"": 16
    },
    {
      ""record_id"": 7,
      ""record_weight"": 6,
      ""sentimental_value"": 24
    },
    {
      ""record_id"": 8,
      ""record_weight"": 8,
      ""sentimental_value"": 61
    },
    {
      ""record_id"": 9,
      ""record_weight"": 29,
      ""sentimental_value"": 67
    },
    {
      ""record_id"": 10,
      ""record_weight"": 57,
      ""sentimental_value"": 12
    },
    {
      ""record_id"": 11,
      ""record_weight"": 34,
      ""sentimental_value"": 51
    },
    {
      ""record_id"": 12,
      ""record_weight"": 49,
      ""sentimental_value"": 37
    },
    {
      ""record_id"": 13,
      ""record_weight"": 18,
      ""sentimental_value"": 51
    },
    {
      ""record_id"": 14,
      ""record_weight"": 74,
      ""sentimental_value"": 96
    },
    {
      ""record_id"": 15,
      ""record_weight"": 32,
      ""sentimental_value"": 8
    },
    {
      ""record_id"": 16,
      ""record_weight"": 7,
      ""sentimental_value"": 100
    },
    {
      ""record_id"": 17,
      ""record_weight"": 75,
      ""sentimental_value"": 45
    },
    {
      ""record_id"": 18,
      ""record_weight"": 91,
      ""sentimental_value"": 78
    },
    {
      ""record_id"": 19,
      ""record_weight"": 2,
      ""sentimental_value"": 43
    },
    {
      ""record_id"": 20,
      ""record_weight"": 44,
      ""sentimental_value"": 32
    },
    {
      ""record_id"": 21,
      ""record_weight"": 83,
      ""sentimental_value"": 78
    }
  ]
}

If you want to send the final pick in a compact form, just use this little JSON layout so it's easy to read and process:

{
  ""solution"": [0, 1, 0, 1, ...]
}

The ""solution"" array is a simple on/off list that lines up with the records as they were listed — 1 means that record goes in the crate, 0 means it stays out. The ellipsis just shows the pattern continues until every record in the instance has a corresponding entry. Think of it as a short checklist, not the final answer itself.

Please use the exact identifiers given in the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [12, 6, 8, 87, 85, 83, 6, 8, 29, 57, 34, 49, 18, 74, 32, 7, 75, 91, 2, 44, 83], 'profits': [71, 86, 42, 38, 71, 16, 24, 61, 67, 12, 51, 37, 51, 96, 8, 100, 45, 78, 43, 32, 78], 'capacity': 445, 'solution': [1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1], 'objective': 885, 'solve_time': 0.00039958953857421875, 'n_items': 21, 'R': 100, 'alpha': 0.5, 'instance_idx': 20, 'alpha_idx': 0}","[1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1]",885,"{'problem_type': 'KP', 'capacity': 445, 'n_items': 21, 'items': [{'item_id': 1, 'weight': 12, 'profit': 71}, {'item_id': 2, 'weight': 6, 'profit': 86}, {'item_id': 3, 'weight': 8, 'profit': 42}, {'item_id': 4, 'weight': 87, 'profit': 38}, {'item_id': 5, 'weight': 85, 'profit': 71}, {'item_id': 6, 'weight': 83, 'profit': 16}, {'item_id': 7, 'weight': 6, 'profit': 24}, {'item_id': 8, 'weight': 8, 'profit': 61}, {'item_id': 9, 'weight': 29, 'profit': 67}, {'item_id': 10, 'weight': 57, 'profit': 12}, {'item_id': 11, 'weight': 34, 'profit': 51}, {'item_id': 12, 'weight': 49, 'profit': 37}, {'item_id': 13, 'weight': 18, 'profit': 51}, {'item_id': 14, 'weight': 74, 'profit': 96}, {'item_id': 15, 'weight': 32, 'profit': 8}, {'item_id': 16, 'weight': 7, 'profit': 100}, {'item_id': 17, 'weight': 75, 'profit': 45}, {'item_id': 18, 'weight': 91, 'profit': 78}, {'item_id': 19, 'weight': 2, 'profit': 43}, {'item_id': 20, 'weight': 44, 'profit': 32}, {'item_id': 21, 'weight': 83, 'profit': 78}]}","{'1': 1, '2': 1, '3': 1, '4': 0, '5': 0, '6': 0, '7': 1, '8': 1, '9': 1, '10': 0, '11': 1, '12': 1, '13': 1, '14': 1, '15': 0, '16': 1, '17': 0, '18': 1, '19': 1, '20': 0, '21': 1}",21,json,1
KP,KP,"Many people face the same packing puzzle: a limited baggage allowance but a wish-list of outfits that do different jobs. Each choice has a weight and a versatility rating, so the plan is to pick a combination of outfits and add up their versatility ratings to see how flexible the whole suitcase will be, keeping the combined weight beneath the allowed maximum. Each outfit can only be selected once, and the particular outfits, weights, and versatility values follow below.

# luggage_weight_allowance=794
outfit_id,outfit_weight,versatility_score
A,15,15
B,71,51
C,76,45
D,39,85
E,93,40
F,65,33
G,34,9
H,2,84
I,68,76
J,21,5
K,76,44
L,53,48
M,47,47
N,17,92
O,72,16
P,17,31
Q,42,19
R,84,25
S,93,91
T,99,95
U,96,5
V,56,64
W,21,24
X,84,20
Y,81,30
Z,100,20
AA,66,50

If you want to send me the answer in a neat, machine-friendly way, a simple JSON object like this is perfect—just one key with a list showing which outfits you pick:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a checklist that runs down the outfit list from top to bottom: a 1 means that outfit goes in the suitcase, a 0 means it stays home. This JSON is just a sketch of the shape I expect, not the real answer — you'll fill in the actual 0/1 choices for your instance.

Please use the exact identifiers from the instance input when referring to items — no renaming and no extra labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [15, 71, 76, 39, 93, 65, 34, 2, 68, 21, 76, 53, 47, 17, 72, 17, 42, 84, 93, 99, 96, 56, 21, 84, 81, 100, 66], 'profits': [15, 51, 45, 85, 40, 33, 9, 84, 76, 5, 44, 48, 47, 92, 16, 31, 19, 25, 91, 95, 5, 64, 24, 20, 30, 20, 50], 'capacity': 794, 'solution': [1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1], 'objective': 917, 'solve_time': 0.00047850608825683594, 'n_items': 27, 'R': 100, 'alpha': 0.5, 'instance_idx': 21, 'alpha_idx': 0}","[1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 1]",917,"{'problem_type': 'KP', 'capacity': 794, 'n_items': 27, 'items': [{'item_id': 'A', 'weight': 15, 'profit': 15}, {'item_id': 'B', 'weight': 71, 'profit': 51}, {'item_id': 'C', 'weight': 76, 'profit': 45}, {'item_id': 'D', 'weight': 39, 'profit': 85}, {'item_id': 'E', 'weight': 93, 'profit': 40}, {'item_id': 'F', 'weight': 65, 'profit': 33}, {'item_id': 'G', 'weight': 34, 'profit': 9}, {'item_id': 'H', 'weight': 2, 'profit': 84}, {'item_id': 'I', 'weight': 68, 'profit': 76}, {'item_id': 'J', 'weight': 21, 'profit': 5}, {'item_id': 'K', 'weight': 76, 'profit': 44}, {'item_id': 'L', 'weight': 53, 'profit': 48}, {'item_id': 'M', 'weight': 47, 'profit': 47}, {'item_id': 'N', 'weight': 17, 'profit': 92}, {'item_id': 'O', 'weight': 72, 'profit': 16}, {'item_id': 'P', 'weight': 17, 'profit': 31}, {'item_id': 'Q', 'weight': 42, 'profit': 19}, {'item_id': 'R', 'weight': 84, 'profit': 25}, {'item_id': 'S', 'weight': 93, 'profit': 91}, {'item_id': 'T', 'weight': 99, 'profit': 95}, {'item_id': 'U', 'weight': 96, 'profit': 5}, {'item_id': 'V', 'weight': 56, 'profit': 64}, {'item_id': 'W', 'weight': 21, 'profit': 24}, {'item_id': 'X', 'weight': 84, 'profit': 20}, {'item_id': 'Y', 'weight': 81, 'profit': 30}, {'item_id': 'Z', 'weight': 100, 'profit': 20}, {'item_id': 'AA', 'weight': 66, 'profit': 50}]}","{'A': 1, 'B': 1, 'C': 1, 'D': 1, 'E': 0, 'F': 0, 'G': 0, 'H': 1, 'I': 1, 'J': 0, 'K': 0, 'L': 1, 'M': 1, 'N': 1, 'O': 0, 'P': 1, 'Q': 1, 'R': 0, 'S': 1, 'T': 1, 'U': 0, 'V': 1, 'W': 1, 'X': 0, 'Y': 0, 'Z': 0, 'AA': 1}",22,csv,names
KP,KP,"We’re imagining a busy morning where a contractor needs to decide what power tools to toss into the van before hitting multiple sites. The trick is to pack the combination of tools that gives the most total usefulness on the job — computed by adding up each chosen tool’s usefulness score — while making sure the van’s weight limit isn’t exceeded by the sum of their weights. Each tool exists only once, so a tool can be loaded or left at home, but can’t be taken twice or taken in pieces. The concrete tool names, weights, and usefulness numbers are given below.

- **van_payload_capacity**: 849

| tool_name | tool_weight | usefulness_score |
|---|---|---|
| 1 | 59 | 77 |
| 2 | 73 | 69 |
| 3 | 50 | 86 |
| 4 | 2 | 37 |
| 5 | 9 | 51 |
| 6 | 27 | 44 |
| 7 | 25 | 91 |
| 8 | 85 | 31 |
| 9 | 85 | 59 |
| 10 | 86 | 13 |
| 11 | 64 | 86 |
| 12 | 56 | 39 |
| 13 | 65 | 35 |
| 14 | 41 | 59 |
| 15 | 68 | 50 |
| 16 | 80 | 85 |
| 17 | 77 | 54 |
| 18 | 62 | 52 |
| 19 | 6 | 11 |
| 20 | 73 | 3 |
| 21 | 37 | 40 |
| 22 | 75 | 100 |
| 23 | 54 | 92 |
| 24 | 89 | 63 |
| 25 | 34 | 64 |
| 26 | 94 | 40 |
| 27 | 85 | 18 |
| 28 | 34 | 1 |
| 29 | 49 | 34 |
| 30 | 54 | 32 |

Just so we're on the same page, when you send back which tools to take, please use a simple JSON layout like this:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a checklist: each position in the list matches a tool in the order shown above, with 1 meaning ""yep, load this tool in the van"" and 0 meaning ""leave it behind."" This JSON is just a template to show the shape I expect — it's not your final packed list.

Also: use the exact identifiers from the instance input when referring to tools — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [59, 73, 50, 2, 9, 27, 25, 85, 85, 86, 64, 56, 65, 41, 68, 80, 77, 62, 6, 73, 37, 75, 54, 89, 34, 94, 85, 34, 49, 54], 'profits': [77, 69, 86, 37, 51, 44, 91, 31, 59, 13, 86, 39, 35, 59, 50, 85, 54, 52, 11, 3, 40, 100, 92, 63, 64, 40, 18, 1, 34, 32], 'capacity': 849, 'solution': [1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0], 'objective': 1148, 'solve_time': 0.0005207061767578125, 'n_items': 30, 'R': 100, 'alpha': 0.5, 'instance_idx': 22, 'alpha_idx': 0}","[1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0]",1148,"{'problem_type': 'KP', 'capacity': 849, 'n_items': 30, 'items': [{'item_id': 1, 'weight': 59, 'profit': 77}, {'item_id': 2, 'weight': 73, 'profit': 69}, {'item_id': 3, 'weight': 50, 'profit': 86}, {'item_id': 4, 'weight': 2, 'profit': 37}, {'item_id': 5, 'weight': 9, 'profit': 51}, {'item_id': 6, 'weight': 27, 'profit': 44}, {'item_id': 7, 'weight': 25, 'profit': 91}, {'item_id': 8, 'weight': 85, 'profit': 31}, {'item_id': 9, 'weight': 85, 'profit': 59}, {'item_id': 10, 'weight': 86, 'profit': 13}, {'item_id': 11, 'weight': 64, 'profit': 86}, {'item_id': 12, 'weight': 56, 'profit': 39}, {'item_id': 13, 'weight': 65, 'profit': 35}, {'item_id': 14, 'weight': 41, 'profit': 59}, {'item_id': 15, 'weight': 68, 'profit': 50}, {'item_id': 16, 'weight': 80, 'profit': 85}, {'item_id': 17, 'weight': 77, 'profit': 54}, {'item_id': 18, 'weight': 62, 'profit': 52}, {'item_id': 19, 'weight': 6, 'profit': 11}, {'item_id': 20, 'weight': 73, 'profit': 3}, {'item_id': 21, 'weight': 37, 'profit': 40}, {'item_id': 22, 'weight': 75, 'profit': 100}, {'item_id': 23, 'weight': 54, 'profit': 92}, {'item_id': 24, 'weight': 89, 'profit': 63}, {'item_id': 25, 'weight': 34, 'profit': 64}, {'item_id': 26, 'weight': 94, 'profit': 40}, {'item_id': 27, 'weight': 85, 'profit': 18}, {'item_id': 28, 'weight': 34, 'profit': 1}, {'item_id': 29, 'weight': 49, 'profit': 34}, {'item_id': 30, 'weight': 54, 'profit': 32}]}","{'1': 1, '2': 1, '3': 1, '4': 1, '5': 1, '6': 1, '7': 1, '8': 0, '9': 0, '10': 0, '11': 1, '12': 0, '13': 0, '14': 1, '15': 1, '16': 1, '17': 1, '18': 1, '19': 1, '20': 0, '21': 1, '22': 1, '23': 1, '24': 0, '25': 1, '26': 0, '27': 0, '28': 0, '29': 0, '30': 0}",23,markdown_table,1
KP,KP,"I’m planning a small garden bed and need to decide which plants to pot so the whole plot looks as lovely as possible. Each candidate plant comes with a little “beauty” score and a required amount of planting space, and the way to judge any lineup is simple: add up the beauty numbers of the chosen plants to see how pretty the bed will be, and add up their space needs to make sure everything actually fits in the bed. No plant can be used more than once and it’s not allowed to split a plant into pieces — each choice is either planted or not. The exact list of plants, their beauty ratings, and space requirements are shown below.

# bed_capacity=548
plant_id,space_required,beauty_score
1,26,88
2,3,48
3,61,99
4,93,77
5,70,66
6,45,91
7,43,52
8,31,73
9,15,29
10,60,97
11,57,63
12,1,79
13,42,47
14,28,87
15,18,8
16,71,12
17,53,51
18,64,74
19,72,81
20,99,45
21,81,65
22,63,56

If you want to send me your plant picks, a simple JSON reply like this works fine — nothing fancy, just that one field with a little list of zeros and ones to say which plants to pot:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a quick form: a list of 0s and 1s in the same order as the plant list above. A 1 means ""pot this plant"", a 0 means ""leave it out."" It's just a sketch of the shape I expect, not the actual final selection — I'll need the real instance details to pick the best lineup.

Please make sure any identifiers you use match the instance input exactly — no renaming and no new labels.  
Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'problem_type': 'KP', 'weights': [26, 3, 61, 93, 70, 45, 43, 31, 15, 60, 57, 1, 42, 28, 18, 71, 53, 64, 72, 99, 81, 63], 'profits': [88, 48, 99, 77, 66, 91, 52, 73, 29, 97, 63, 79, 47, 87, 8, 12, 51, 74, 81, 45, 65, 56], 'capacity': 548, 'solution': [1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0], 'objective': 1008, 'solve_time': 0.0004336833953857422, 'n_items': 22, 'R': 100, 'alpha': 0.5, 'instance_idx': 23, 'alpha_idx': 0}","[1, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0]",1008,"{'problem_type': 'KP', 'capacity': 548, 'n_items': 22, 'items': [{'item_id': 1, 'weight': 26, 'profit': 88}, {'item_id': 2, 'weight': 3, 'profit': 48}, {'item_id': 3, 'weight': 61, 'profit': 99}, {'item_id': 4, 'weight': 93, 'profit': 77}, {'item_id': 5, 'weight': 70, 'profit': 66}, {'item_id': 6, 'weight': 45, 'profit': 91}, {'item_id': 7, 'weight': 43, 'profit': 52}, {'item_id': 8, 'weight': 31, 'profit': 73}, {'item_id': 9, 'weight': 15, 'profit': 29}, {'item_id': 10, 'weight': 60, 'profit': 97}, {'item_id': 11, 'weight': 57, 'profit': 63}, {'item_id': 12, 'weight': 1, 'profit': 79}, {'item_id': 13, 'weight': 42, 'profit': 47}, {'item_id': 14, 'weight': 28, 'profit': 87}, {'item_id': 15, 'weight': 18, 'profit': 8}, {'item_id': 16, 'weight': 71, 'profit': 12}, {'item_id': 17, 'weight': 53, 'profit': 51}, {'item_id': 18, 'weight': 64, 'profit': 74}, {'item_id': 19, 'weight': 72, 'profit': 81}, {'item_id': 20, 'weight': 99, 'profit': 45}, {'item_id': 21, 'weight': 81, 'profit': 65}, {'item_id': 22, 'weight': 63, 'profit': 56}]}","{'1': 1, '2': 1, '3': 1, '4': 0, '5': 0, '6': 1, '7': 1, '8': 1, '9': 1, '10': 1, '11': 1, '12': 1, '13': 1, '14': 1, '15': 0, '16': 0, '17': 0, '18': 1, '19': 1, '20': 0, '21': 0, '22': 0}",24,csv,1
KP,KP,"Many people face the same little dilemma before a potluck: which dishes to carry so the guests are happiest and everything still fits into a single tote. Every dish takes up some space and contributes a particular satisfaction value, and the total satisfaction is simply the sum of those values for whatever gets packed. Because the tote has limited room and each dish can only be brought once (no halves or clones allowed), the best pick is the one with the highest combined satisfaction that stays within the tote’s capacity. The specific dish details and their space and satisfaction numbers follow below.

Tote capacity: 820.
1: takes 66 space in the tote and contributes 80 satisfaction.
2: takes 42 space in the tote and contributes 65 satisfaction.
3: takes 97 space in the tote and contributes 9 satisfaction.
4: takes 11 space in the tote and contributes 23 satisfaction.
5: takes 99 space in the tote and contributes 56 satisfaction.
6: takes 16 space in the tote and contributes 55 satisfaction.
7: takes 29 space in the tote and contributes 81 satisfaction.
8: takes 83 space in the tote and contributes 27 satisfaction.
9: takes 74 space in the tote and contributes 93 satisfaction.
10: takes 98 space in the tote and contributes 45 satisfaction.
11: takes 75 space in the tote and contributes 83 satisfaction.
12: takes 64 space in the tote and contributes 24 satisfaction.
13: takes 35 space in the tote and contributes 4 satisfaction.
14: takes 1 space in the tote and contributes 6 satisfaction.
15: takes 13 space in the tote and contributes 38 satisfaction.
16: takes 30 space in the tote and contributes 96 satisfaction.
17: takes 5 space in the tote and contributes 5 satisfaction.
18: takes 51 space in the tote and contributes 37 satisfaction.
19: takes 78 space in the tote and contributes 11 satisfaction.
20: takes 97 space in the tote and contributes 94 satisfaction.
21: takes 49 space in the tote and contributes 68 satisfaction.
22: takes 88 space in the tote and contributes 77 satisfaction.
23: takes 99 space in the tote and contributes 72 satisfaction.
24: takes 86 space in the tote and contributes 66 satisfaction.
25: takes 47 space in the tote and contributes 78 satisfaction.
26: takes 33 space in the tote and contributes 1 satisfaction.
27: takes 98 space in the tote and contributes 87 satisfaction.
28: takes 25 space in the tote and contributes 74 satisfaction.
29: takes 42 space in the tote and contributes 74 satisfaction.
30: takes 8 space in the tote and contributes 40 satisfaction.
Chosen dishes must keep their combined space within the tote capacity 820.

If you'd like the result in a compact, machine-friendly form, I usually return a tiny JSON sketch like this:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is just a list that lines up with the dishes above — a 1 means ""bring this dish"" and a 0 means ""leave it behind."" Think of it as a simple checklist you can read or feed into another tool. This block is only a sketch of the shape I’ll use, not the actual packing decision.

Please make sure to use all identifiers exactly as they appear in the instance input — no renaming and no new labels. Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [66, 42, 97, 11, 99, 16, 29, 83, 74, 98, 75, 64, 35, 1, 13, 30, 5, 51, 78, 97, 49, 88, 99, 86, 47, 33, 98, 25, 42, 8], 'profits': [80, 65, 9, 23, 56, 55, 81, 27, 93, 45, 83, 24, 4, 6, 38, 96, 5, 37, 11, 94, 68, 77, 72, 66, 78, 1, 87, 74, 74, 40], 'capacity': 820, 'solution': [1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1], 'objective': 1217, 'solve_time': 0.0006625652313232422, 'n_items': 30, 'R': 100, 'alpha': 0.5, 'instance_idx': 24, 'alpha_idx': 0}","[1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1]",1217,"{'problem_type': 'KP', 'capacity': 820, 'n_items': 30, 'items': [{'item_id': 1, 'weight': 66, 'profit': 80}, {'item_id': 2, 'weight': 42, 'profit': 65}, {'item_id': 3, 'weight': 97, 'profit': 9}, {'item_id': 4, 'weight': 11, 'profit': 23}, {'item_id': 5, 'weight': 99, 'profit': 56}, {'item_id': 6, 'weight': 16, 'profit': 55}, {'item_id': 7, 'weight': 29, 'profit': 81}, {'item_id': 8, 'weight': 83, 'profit': 27}, {'item_id': 9, 'weight': 74, 'profit': 93}, {'item_id': 10, 'weight': 98, 'profit': 45}, {'item_id': 11, 'weight': 75, 'profit': 83}, {'item_id': 12, 'weight': 64, 'profit': 24}, {'item_id': 13, 'weight': 35, 'profit': 4}, {'item_id': 14, 'weight': 1, 'profit': 6}, {'item_id': 15, 'weight': 13, 'profit': 38}, {'item_id': 16, 'weight': 30, 'profit': 96}, {'item_id': 17, 'weight': 5, 'profit': 5}, {'item_id': 18, 'weight': 51, 'profit': 37}, {'item_id': 19, 'weight': 78, 'profit': 11}, {'item_id': 20, 'weight': 97, 'profit': 94}, {'item_id': 21, 'weight': 49, 'profit': 68}, {'item_id': 22, 'weight': 88, 'profit': 77}, {'item_id': 23, 'weight': 99, 'profit': 72}, {'item_id': 24, 'weight': 86, 'profit': 66}, {'item_id': 25, 'weight': 47, 'profit': 78}, {'item_id': 26, 'weight': 33, 'profit': 1}, {'item_id': 27, 'weight': 98, 'profit': 87}, {'item_id': 28, 'weight': 25, 'profit': 74}, {'item_id': 29, 'weight': 42, 'profit': 74}, {'item_id': 30, 'weight': 8, 'profit': 40}]}","{'1': 1, '2': 1, '3': 0, '4': 1, '5': 0, '6': 1, '7': 1, '8': 0, '9': 1, '10': 0, '11': 1, '12': 0, '13': 0, '14': 1, '15': 1, '16': 1, '17': 1, '18': 0, '19': 0, '20': 1, '21': 1, '22': 1, '23': 0, '24': 0, '25': 1, '26': 0, '27': 1, '28': 1, '29': 1, '30': 1}",25,nl,1
KP,KP,"We’re sorting through a pile of textbooks, figuring out which ones to bring to campus so the bag stays comfortable on long walks. The better choice is the one that gives the highest combined usefulness — just sum the usefulness values of the books picked — while keeping the total weight below the backpack’s comfort threshold; each book can only be brought once. The concrete weights and usefulness ratings are listed below.

- **backpack_comfort_capacity**: 720

| book_id | book_weight | usefulness_score |
|---|---|---|
| 0 | 39 | 86 |
| 1 | 5 | 91 |
| 2 | 91 | 30 |
| 3 | 24 | 71 |
| 4 | 11 | 60 |
| 5 | 63 | 45 |
| 6 | 24 | 40 |
| 7 | 86 | 12 |
| 8 | 45 | 28 |
| 9 | 1 | 55 |
| 10 | 96 | 89 |
| 11 | 52 | 87 |
| 12 | 27 | 19 |
| 13 | 68 | 68 |
| 14 | 54 | 9 |
| 15 | 3 | 68 |
| 16 | 76 | 35 |
| 17 | 41 | 45 |
| 18 | 70 | 72 |
| 19 | 90 | 43 |
| 20 | 62 | 81 |
| 21 | 68 | 54 |
| 22 | 26 | 100 |
| 23 | 24 | 64 |
| 24 | 42 | 30 |
| 25 | 86 | 78 |
| 26 | 53 | 41 |
| 27 | 35 | 54 |
| 28 | 78 | 14 |

If you want to hand me your pick in a machine-friendly way, just drop it in a little JSON sketch like this — nothing fancy, just the shape I expect:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is an array that corresponds to the list of books: a 1 means you decide to bring that book, a 0 means you leave it at home. Think of this as a simple form to fill out, not the final call — just the expected layout.

Please remember to use the exact identifiers from the problem instance when you refer to items — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [39, 5, 91, 24, 11, 63, 24, 86, 45, 1, 96, 52, 27, 68, 54, 3, 76, 41, 70, 90, 62, 68, 26, 24, 42, 86, 53, 35, 78], 'profits': [86, 91, 30, 71, 60, 45, 40, 12, 28, 55, 89, 87, 19, 68, 9, 68, 35, 45, 72, 43, 81, 54, 100, 64, 30, 78, 41, 54, 14], 'capacity': 720, 'solution': [1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0], 'objective': 1250, 'solve_time': 0.0003731250762939453, 'n_items': 29, 'R': 100, 'alpha': 0.5, 'instance_idx': 25, 'alpha_idx': 0}","[1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0]",1250,"{'problem_type': 'KP', 'capacity': 720, 'n_items': 29, 'items': [{'item_id': 0, 'weight': 39, 'profit': 86}, {'item_id': 1, 'weight': 5, 'profit': 91}, {'item_id': 2, 'weight': 91, 'profit': 30}, {'item_id': 3, 'weight': 24, 'profit': 71}, {'item_id': 4, 'weight': 11, 'profit': 60}, {'item_id': 5, 'weight': 63, 'profit': 45}, {'item_id': 6, 'weight': 24, 'profit': 40}, {'item_id': 7, 'weight': 86, 'profit': 12}, {'item_id': 8, 'weight': 45, 'profit': 28}, {'item_id': 9, 'weight': 1, 'profit': 55}, {'item_id': 10, 'weight': 96, 'profit': 89}, {'item_id': 11, 'weight': 52, 'profit': 87}, {'item_id': 12, 'weight': 27, 'profit': 19}, {'item_id': 13, 'weight': 68, 'profit': 68}, {'item_id': 14, 'weight': 54, 'profit': 9}, {'item_id': 15, 'weight': 3, 'profit': 68}, {'item_id': 16, 'weight': 76, 'profit': 35}, {'item_id': 17, 'weight': 41, 'profit': 45}, {'item_id': 18, 'weight': 70, 'profit': 72}, {'item_id': 19, 'weight': 90, 'profit': 43}, {'item_id': 20, 'weight': 62, 'profit': 81}, {'item_id': 21, 'weight': 68, 'profit': 54}, {'item_id': 22, 'weight': 26, 'profit': 100}, {'item_id': 23, 'weight': 24, 'profit': 64}, {'item_id': 24, 'weight': 42, 'profit': 30}, {'item_id': 25, 'weight': 86, 'profit': 78}, {'item_id': 26, 'weight': 53, 'profit': 41}, {'item_id': 27, 'weight': 35, 'profit': 54}, {'item_id': 28, 'weight': 78, 'profit': 14}]}","{'0': 1, '1': 1, '2': 0, '3': 1, '4': 1, '5': 0, '6': 1, '7': 0, '8': 0, '9': 1, '10': 1, '11': 1, '12': 0, '13': 1, '14': 0, '15': 1, '16': 0, '17': 1, '18': 1, '19': 0, '20': 1, '21': 0, '22': 1, '23': 1, '24': 0, '25': 1, '26': 1, '27': 1, '28': 0}",26,markdown_table,0
KP,KP,"Recently a parent was staring at a pile of toys and a cramped storage bin, trying to decide what to bring on a long drive to keep the little ones entertained. The trick is to pick a mix that fits in the bin and gives the kids the most overall amusement — simply sum each toy’s enjoyment value to measure how good a selection is. No repeats of the same toy are allowed, and the total packed volume/weight has to be under the bin’s capacity. The specific toys, their space requirements, and their fun ratings are shown below.

The storage bin holds 478 units of space.
1: occupies 58 units of space and provides 2 enjoyment.
2: occupies 19 units of space and provides 31 enjoyment.
3: occupies 100 units of space and provides 46 enjoyment.
4: occupies 86 units of space and provides 97 enjoyment.
5: occupies 71 units of space and provides 64 enjoyment.
6: occupies 74 units of space and provides 89 enjoyment.
7: occupies 60 units of space and provides 35 enjoyment.
8: occupies 7 units of space and provides 45 enjoyment.
9: occupies 40 units of space and provides 43 enjoyment.
10: occupies 50 units of space and provides 89 enjoyment.
11: occupies 92 units of space and provides 96 enjoyment.
12: occupies 22 units of space and provides 97 enjoyment.
13: occupies 50 units of space and provides 76 enjoyment.
14: occupies 35 units of space and provides 51 enjoyment.
15: occupies 14 units of space and provides 55 enjoyment.
16: occupies 11 units of space and provides 99 enjoyment.
17: occupies 37 units of space and provides 29 enjoyment.
18: occupies 9 units of space and provides 35 enjoyment.
19: occupies 7 units of space and provides 90 enjoyment.
20: occupies 36 units of space and provides 39 enjoyment.
21: occupies 21 units of space and provides 24 enjoyment.
22: occupies 56 units of space and provides 57 enjoyment.
Keep the total packed space within 478 so the parent maximizes the kids' enjoyment on the drive.

If you want the final pick in a simple, machine-friendly form, just hand it back in a tiny JSON object like this:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is a list that lines up with the toys above — each position is one toy, and a 1 means ""toss this toy in the bin"" while a 0 means ""leave it behind."" Think of it as a yes/no checklist that follows the same order the toys were listed. This JSON is just a sketch of the shape I expect, not the actual answer.

Please make sure to use the exact identifiers from the instance input — don’t rename them or invent new labels.  
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [58, 19, 100, 86, 71, 74, 60, 7, 40, 50, 92, 22, 50, 35, 14, 11, 37, 9, 7, 36, 21, 56], 'profits': [2, 31, 46, 97, 64, 89, 35, 45, 43, 89, 96, 97, 76, 51, 55, 99, 29, 35, 90, 39, 24, 57], 'capacity': 478, 'solution': [0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0], 'objective': 950, 'solve_time': 0.0003311634063720703, 'n_items': 22, 'R': 100, 'alpha': 0.5, 'instance_idx': 26, 'alpha_idx': 0}","[0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0]",950,"{'problem_type': 'KP', 'capacity': 478, 'n_items': 22, 'items': [{'item_id': 1, 'weight': 58, 'profit': 2}, {'item_id': 2, 'weight': 19, 'profit': 31}, {'item_id': 3, 'weight': 100, 'profit': 46}, {'item_id': 4, 'weight': 86, 'profit': 97}, {'item_id': 5, 'weight': 71, 'profit': 64}, {'item_id': 6, 'weight': 74, 'profit': 89}, {'item_id': 7, 'weight': 60, 'profit': 35}, {'item_id': 8, 'weight': 7, 'profit': 45}, {'item_id': 9, 'weight': 40, 'profit': 43}, {'item_id': 10, 'weight': 50, 'profit': 89}, {'item_id': 11, 'weight': 92, 'profit': 96}, {'item_id': 12, 'weight': 22, 'profit': 97}, {'item_id': 13, 'weight': 50, 'profit': 76}, {'item_id': 14, 'weight': 35, 'profit': 51}, {'item_id': 15, 'weight': 14, 'profit': 55}, {'item_id': 16, 'weight': 11, 'profit': 99}, {'item_id': 17, 'weight': 37, 'profit': 29}, {'item_id': 18, 'weight': 9, 'profit': 35}, {'item_id': 19, 'weight': 7, 'profit': 90}, {'item_id': 20, 'weight': 36, 'profit': 39}, {'item_id': 21, 'weight': 21, 'profit': 24}, {'item_id': 22, 'weight': 56, 'profit': 57}]}","{'1': 0, '2': 1, '3': 0, '4': 1, '5': 0, '6': 1, '7': 0, '8': 1, '9': 0, '10': 1, '11': 1, '12': 1, '13': 1, '14': 1, '15': 1, '16': 1, '17': 0, '18': 1, '19': 1, '20': 0, '21': 0, '22': 0}",27,nl,1
KP,KP,"A caterer has a list of potential dishes, each with a known serving-table footprint and an anticipated guest-pleasure number, and needs to decide which ones to set out. The smartest selection is the one with the highest combined enjoyment, computed by summing the enjoyment values of the dishes that get included. Every dish is a yes-or-no decision (no duplicates, no halves), and the total space those chosen dishes occupy must not be larger than the available buffet surface. The full breakdown of sizes and enjoyment scores appears below.

- **available_table_area**: 554

| dish_id | dish_footprint_area | anticipated_guest_enjoyment |
|---|---|---|
| 0 | 90 | 26 |
| 1 | 91 | 80 |
| 2 | 31 | 59 |
| 3 | 53 | 79 |
| 4 | 99 | 64 |
| 5 | 75 | 44 |
| 6 | 22 | 87 |
| 7 | 60 | 48 |
| 8 | 62 | 95 |
| 9 | 66 | 100 |
| 10 | 3 | 59 |
| 11 | 30 | 68 |
| 12 | 86 | 26 |
| 13 | 25 | 82 |
| 14 | 30 | 68 |
| 15 | 33 | 91 |
| 16 | 18 | 27 |
| 17 | 16 | 79 |
| 18 | 35 | 48 |
| 19 | 88 | 19 |
| 20 | 1 | 18 |
| 21 | 29 | 57 |
| 22 | 7 | 32 |
| 23 | 57 | 11 |

When you're ready to tell me which dishes to include, just send it back in a tiny JSON package like this:

{
  ""solution"": [0, 1, 0, 1, ...]
}

""solution"" is an ordered list of 0s and 1s that lines up with the dish list above — 1 means ""put it out"", 0 means ""skip it"". Think of this JSON as a simple form template, not the final selection itself.

Also, please use the identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [90, 91, 31, 53, 99, 75, 22, 60, 62, 66, 3, 30, 86, 25, 30, 33, 18, 16, 35, 88, 1, 29, 7, 57], 'profits': [26, 80, 59, 79, 64, 44, 87, 48, 95, 100, 59, 68, 26, 82, 68, 91, 27, 79, 48, 19, 18, 57, 32, 11], 'capacity': 554, 'solution': [0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0], 'objective': 1129, 'solve_time': 0.00037980079650878906, 'n_items': 24, 'R': 100, 'alpha': 0.5, 'instance_idx': 27, 'alpha_idx': 0}","[0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0]",1129,"{'problem_type': 'KP', 'capacity': 554, 'n_items': 24, 'items': [{'item_id': 0, 'weight': 90, 'profit': 26}, {'item_id': 1, 'weight': 91, 'profit': 80}, {'item_id': 2, 'weight': 31, 'profit': 59}, {'item_id': 3, 'weight': 53, 'profit': 79}, {'item_id': 4, 'weight': 99, 'profit': 64}, {'item_id': 5, 'weight': 75, 'profit': 44}, {'item_id': 6, 'weight': 22, 'profit': 87}, {'item_id': 7, 'weight': 60, 'profit': 48}, {'item_id': 8, 'weight': 62, 'profit': 95}, {'item_id': 9, 'weight': 66, 'profit': 100}, {'item_id': 10, 'weight': 3, 'profit': 59}, {'item_id': 11, 'weight': 30, 'profit': 68}, {'item_id': 12, 'weight': 86, 'profit': 26}, {'item_id': 13, 'weight': 25, 'profit': 82}, {'item_id': 14, 'weight': 30, 'profit': 68}, {'item_id': 15, 'weight': 33, 'profit': 91}, {'item_id': 16, 'weight': 18, 'profit': 27}, {'item_id': 17, 'weight': 16, 'profit': 79}, {'item_id': 18, 'weight': 35, 'profit': 48}, {'item_id': 19, 'weight': 88, 'profit': 19}, {'item_id': 20, 'weight': 1, 'profit': 18}, {'item_id': 21, 'weight': 29, 'profit': 57}, {'item_id': 22, 'weight': 7, 'profit': 32}, {'item_id': 23, 'weight': 57, 'profit': 11}]}","{'0': 0, '1': 1, '2': 1, '3': 1, '4': 0, '5': 0, '6': 1, '7': 0, '8': 1, '9': 1, '10': 1, '11': 1, '12': 0, '13': 1, '14': 1, '15': 1, '16': 1, '17': 1, '18': 1, '19': 0, '20': 1, '21': 1, '22': 1, '23': 0}",28,markdown_table,0
KP,KP,"There’s a flash drive with limited space and a big list of potential party tracks; the job is to decide which ones to load. The aim is to maximize the combined crowd energy by summing each chosen song’s energy rating, but at the same time keep the combined file sizes of those chosen songs at or below the drive’s available capacity. Each song can only appear once on the drive, so duplicates aren’t allowed and some tracks will be left off. The concrete details for each track and the drive’s free space are shown below.

- **flash_drive_free_space**: 611

| track_id | file_size_mb | energy_rating |
|---|---|---|
| A | 66 | 5 |
| B | 32 | 6 |
| C | 96 | 86 |
| D | 78 | 12 |
| E | 52 | 64 |
| F | 94 | 39 |
| G | 44 | 78 |
| H | 14 | 7 |
| I | 4 | 90 |
| J | 94 | 70 |
| K | 96 | 45 |
| L | 74 | 21 |
| M | 11 | 98 |
| N | 30 | 31 |
| O | 5 | 50 |
| P | 6 | 40 |
| Q | 25 | 24 |
| R | 58 | 42 |
| S | 7 | 16 |
| T | 99 | 1 |
| U | 46 | 29 |
| V | 27 | 12 |
| W | 52 | 42 |
| X | 80 | 87 |
| Y | 32 | 17 |

If you want to hand me the choices in a tidy, machine-friendly way, just follow this little JSON layout:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" like a checklist that lines up with the track list: each position is one track, 1 means ""put it on the flash drive"" and 0 means ""skip it."" It's just a template showing the shape I expect — not your actual final answer.

Please use the exact identifiers from the instance input — don't rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [66, 32, 96, 78, 52, 94, 44, 14, 4, 94, 96, 74, 11, 30, 5, 6, 25, 58, 7, 99, 46, 27, 52, 80, 32], 'profits': [5, 6, 86, 12, 64, 39, 78, 7, 90, 70, 45, 21, 98, 31, 50, 40, 24, 42, 16, 1, 29, 12, 42, 87, 17], 'capacity': 611, 'solution': [0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0], 'objective': 847, 'solve_time': 0.00034427642822265625, 'n_items': 25, 'R': 100, 'alpha': 0.5, 'instance_idx': 28, 'alpha_idx': 0}","[0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0]",847,"{'problem_type': 'KP', 'capacity': 611, 'n_items': 25, 'items': [{'item_id': 'A', 'weight': 66, 'profit': 5}, {'item_id': 'B', 'weight': 32, 'profit': 6}, {'item_id': 'C', 'weight': 96, 'profit': 86}, {'item_id': 'D', 'weight': 78, 'profit': 12}, {'item_id': 'E', 'weight': 52, 'profit': 64}, {'item_id': 'F', 'weight': 94, 'profit': 39}, {'item_id': 'G', 'weight': 44, 'profit': 78}, {'item_id': 'H', 'weight': 14, 'profit': 7}, {'item_id': 'I', 'weight': 4, 'profit': 90}, {'item_id': 'J', 'weight': 94, 'profit': 70}, {'item_id': 'K', 'weight': 96, 'profit': 45}, {'item_id': 'L', 'weight': 74, 'profit': 21}, {'item_id': 'M', 'weight': 11, 'profit': 98}, {'item_id': 'N', 'weight': 30, 'profit': 31}, {'item_id': 'O', 'weight': 5, 'profit': 50}, {'item_id': 'P', 'weight': 6, 'profit': 40}, {'item_id': 'Q', 'weight': 25, 'profit': 24}, {'item_id': 'R', 'weight': 58, 'profit': 42}, {'item_id': 'S', 'weight': 7, 'profit': 16}, {'item_id': 'T', 'weight': 99, 'profit': 1}, {'item_id': 'U', 'weight': 46, 'profit': 29}, {'item_id': 'V', 'weight': 27, 'profit': 12}, {'item_id': 'W', 'weight': 52, 'profit': 42}, {'item_id': 'X', 'weight': 80, 'profit': 87}, {'item_id': 'Y', 'weight': 32, 'profit': 17}]}","{'A': 0, 'B': 0, 'C': 1, 'D': 0, 'E': 1, 'F': 0, 'G': 1, 'H': 0, 'I': 1, 'J': 1, 'K': 0, 'L': 0, 'M': 1, 'N': 1, 'O': 1, 'P': 1, 'Q': 1, 'R': 1, 'S': 1, 'T': 0, 'U': 1, 'V': 0, 'W': 1, 'X': 1, 'Y': 0}",29,markdown_table,names
KP,KP,"There’s a friend moving into a shoe-box apartment who has to choose which kitchen items to keep on hand. The trick is to pick the mix that gives the highest overall daily convenience — just add up the convenience points for whichever appliances are chosen — but the packed volume can’t exceed the cupboard’s space. Everything must be taken whole (no splitting) and each item only once; the concrete details are shown below.

- **cupboard_volume_capacity**: 489

| appliance_id | appliance_volume | convenience_points |
|---|---|---|
| 0 | 12 | 69 |
| 1 | 51 | 34 |
| 2 | 28 | 23 |
| 3 | 49 | 75 |
| 4 | 3 | 34 |
| 5 | 34 | 25 |
| 6 | 42 | 94 |
| 7 | 44 | 49 |
| 8 | 56 | 5 |
| 9 | 79 | 50 |
| 10 | 47 | 47 |
| 11 | 85 | 87 |
| 12 | 53 | 72 |
| 13 | 27 | 20 |
| 14 | 23 | 16 |
| 15 | 33 | 61 |
| 16 | 60 | 5 |
| 17 | 25 | 32 |
| 18 | 92 | 14 |
| 19 | 48 | 3 |
| 20 | 87 | 92 |

Also, when you send your final pick, just use a tiny JSON like this so it's easy to read and machine-friendly:

{
  ""solution"": [0, 1, 0, 1, ...]
}

""solution"" is a list with one entry per item in the same order they appear in the instance. A 1 means you keep that item in the cupboard, a 0 means you leave it behind. This JSON is only a sketch of the shape I expect — replace the example vector with your actual choices when you're ready.

Please make sure all identifiers in your reply match the instance input exactly — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [12, 51, 28, 49, 3, 34, 42, 44, 56, 79, 47, 85, 53, 27, 23, 33, 60, 25, 92, 48, 87], 'profits': [69, 34, 23, 75, 34, 25, 94, 49, 5, 50, 47, 87, 72, 20, 16, 61, 5, 32, 14, 3, 92], 'capacity': 489, 'solution': [1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1], 'objective': 712, 'solve_time': 0.00030112266540527344, 'n_items': 21, 'R': 100, 'alpha': 0.5, 'instance_idx': 29, 'alpha_idx': 0}","[1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1]",712,"{'problem_type': 'KP', 'capacity': 489, 'n_items': 21, 'items': [{'item_id': 0, 'weight': 12, 'profit': 69}, {'item_id': 1, 'weight': 51, 'profit': 34}, {'item_id': 2, 'weight': 28, 'profit': 23}, {'item_id': 3, 'weight': 49, 'profit': 75}, {'item_id': 4, 'weight': 3, 'profit': 34}, {'item_id': 5, 'weight': 34, 'profit': 25}, {'item_id': 6, 'weight': 42, 'profit': 94}, {'item_id': 7, 'weight': 44, 'profit': 49}, {'item_id': 8, 'weight': 56, 'profit': 5}, {'item_id': 9, 'weight': 79, 'profit': 50}, {'item_id': 10, 'weight': 47, 'profit': 47}, {'item_id': 11, 'weight': 85, 'profit': 87}, {'item_id': 12, 'weight': 53, 'profit': 72}, {'item_id': 13, 'weight': 27, 'profit': 20}, {'item_id': 14, 'weight': 23, 'profit': 16}, {'item_id': 15, 'weight': 33, 'profit': 61}, {'item_id': 16, 'weight': 60, 'profit': 5}, {'item_id': 17, 'weight': 25, 'profit': 32}, {'item_id': 18, 'weight': 92, 'profit': 14}, {'item_id': 19, 'weight': 48, 'profit': 3}, {'item_id': 20, 'weight': 87, 'profit': 92}]}","{'0': 1, '1': 0, '2': 0, '3': 1, '4': 1, '5': 0, '6': 1, '7': 1, '8': 0, '9': 0, '10': 1, '11': 1, '12': 1, '13': 0, '14': 0, '15': 1, '16': 0, '17': 1, '18': 0, '19': 0, '20': 1}",30,markdown_table,0
KP,KP,"We’ve got a crowded supply room and a stack of goodies to choose from—paper reams, coffee, pens—each with how much shelf space it uses and a usefulness score for the office. The task is to decide which of those items to stock so that, if the usefulness scores of the chosen items are added together, that total is as high as it can be without the sum of their shelf space going over the closet’s capacity; nothing can be duplicated or split. The exact items, their space requirements, and the closet capacity are listed below.

Our closet holds 452 shelf-space units.
1 — takes up 1 shelf-space units and gives a usefulness score of 54.
2 — takes up 94 shelf-space units and gives a usefulness score of 62.
3 — takes up 19 shelf-space units and gives a usefulness score of 46.
4 — takes up 82 shelf-space units and gives a usefulness score of 17.
5 — takes up 4 shelf-space units and gives a usefulness score of 90.
6 — takes up 16 shelf-space units and gives a usefulness score of 78.
7 — takes up 12 shelf-space units and gives a usefulness score of 100.
8 — takes up 71 shelf-space units and gives a usefulness score of 86.
9 — takes up 63 shelf-space units and gives a usefulness score of 30.
10 — takes up 48 shelf-space units and gives a usefulness score of 26.
11 — takes up 25 shelf-space units and gives a usefulness score of 25.
12 — takes up 9 shelf-space units and gives a usefulness score of 92.
13 — takes up 57 shelf-space units and gives a usefulness score of 56.
14 — takes up 24 shelf-space units and gives a usefulness score of 46.
15 — takes up 60 shelf-space units and gives a usefulness score of 97.
16 — takes up 69 shelf-space units and gives a usefulness score of 61.
17 — takes up 85 shelf-space units and gives a usefulness score of 91.
18 — takes up 50 shelf-space units and gives a usefulness score of 99.
19 — takes up 1 shelf-space units and gives a usefulness score of 8.
20 — takes up 29 shelf-space units and gives a usefulness score of 37.
21 — takes up 86 shelf-space units and gives a usefulness score of 74.
Let's choose supplies that fit within the 452 units to maximize total usefulness.

Oh, and when you send your pick, please use this simple JSON layout so it’s easy to check programmatically:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a checklist with one entry per item on the supply list: a 1 means ""grab this"" and a 0 means ""leave it for now."" The snippet above is just the shape I need—please return the same key and array format with the actual 0/1 choices for the instance.

Also, please use any item identifiers exactly as they appear in the instance input—no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [1, 94, 19, 82, 4, 16, 12, 71, 63, 48, 25, 9, 57, 24, 60, 69, 85, 50, 1, 29, 86], 'profits': [54, 62, 46, 17, 90, 78, 100, 86, 30, 26, 25, 92, 56, 46, 97, 61, 91, 99, 8, 37, 74], 'capacity': 452, 'solution': [1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0], 'objective': 985, 'solve_time': 0.0002970695495605469, 'n_items': 21, 'R': 100, 'alpha': 0.5, 'instance_idx': 30, 'alpha_idx': 0}","[1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0]",985,"{'problem_type': 'KP', 'capacity': 452, 'n_items': 21, 'items': [{'item_id': 1, 'weight': 1, 'profit': 54}, {'item_id': 2, 'weight': 94, 'profit': 62}, {'item_id': 3, 'weight': 19, 'profit': 46}, {'item_id': 4, 'weight': 82, 'profit': 17}, {'item_id': 5, 'weight': 4, 'profit': 90}, {'item_id': 6, 'weight': 16, 'profit': 78}, {'item_id': 7, 'weight': 12, 'profit': 100}, {'item_id': 8, 'weight': 71, 'profit': 86}, {'item_id': 9, 'weight': 63, 'profit': 30}, {'item_id': 10, 'weight': 48, 'profit': 26}, {'item_id': 11, 'weight': 25, 'profit': 25}, {'item_id': 12, 'weight': 9, 'profit': 92}, {'item_id': 13, 'weight': 57, 'profit': 56}, {'item_id': 14, 'weight': 24, 'profit': 46}, {'item_id': 15, 'weight': 60, 'profit': 97}, {'item_id': 16, 'weight': 69, 'profit': 61}, {'item_id': 17, 'weight': 85, 'profit': 91}, {'item_id': 18, 'weight': 50, 'profit': 99}, {'item_id': 19, 'weight': 1, 'profit': 8}, {'item_id': 20, 'weight': 29, 'profit': 37}, {'item_id': 21, 'weight': 86, 'profit': 74}]}","{'1': 1, '2': 0, '3': 1, '4': 0, '5': 1, '6': 1, '7': 1, '8': 1, '9': 0, '10': 0, '11': 0, '12': 1, '13': 0, '14': 1, '15': 1, '16': 1, '17': 1, '18': 1, '19': 1, '20': 1, '21': 0}",31,nl,1
KP,KP,"I was loading up a rental truck with a stack of couches, tables, and dressers and had to pick which pieces to take so the trip would bring in the most cash — either from resale or from renting them out later. The trick was to add up the price for each chosen item to see how much money the load would make, but keep the total weight of everything on the truck at or below its safe limit. Each piece was one-of-a-kind, so nothing could be loaded twice and every choice was either in the truck or left behind. The exact list of items, their weights and their values appears below.

The truck's safe load capacity was 700.
1: it weighed 15 and would bring in 32 if I took it.
2: it weighed 32 and would bring in 13 if I took it.
3: it weighed 55 and would bring in 90 if I took it.
4: it weighed 80 and would bring in 15 if I took it.
5: it weighed 12 and would bring in 60 if I took it.
6: it weighed 61 and would bring in 24 if I took it.
7: it weighed 30 and would bring in 13 if I took it.
8: it weighed 22 and would bring in 78 if I took it.
9: it weighed 52 and would bring in 15 if I took it.
10: it weighed 42 and would bring in 68 if I took it.
11: it weighed 64 and would bring in 70 if I took it.
12: it weighed 32 and would bring in 7 if I took it.
13: it weighed 83 and would bring in 18 if I took it.
14: it weighed 8 and would bring in 80 if I took it.
15: it weighed 87 and would bring in 51 if I took it.
16: it weighed 3 and would bring in 13 if I took it.
17: it weighed 74 and would bring in 100 if I took it.
18: it weighed 35 and would bring in 27 if I took it.
19: it weighed 39 and would bring in 1 if I took it.
20: it weighed 2 and would bring in 93 if I took it.
21: it weighed 71 and would bring in 2 if I took it.
22: it weighed 17 and would bring in 56 if I took it.
23: it weighed 66 and would bring in 100 if I took it.
24: it weighed 73 and would bring in 58 if I took it.
25: it weighed 85 and would bring in 59 if I took it.
26: it weighed 71 and would bring in 39 if I took it.
27: it weighed 31 and would bring in 13 if I took it.
28: it weighed 74 and would bring in 58 if I took it.
29: it weighed 83 and would bring in 90 if I took it.
I kept the combined weight at or below 700 when choosing what to load.

If you want to hand me your pick, just send it in a tiny JSON snippet like this so it's easy to parse:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a checklist that lines up with the furniture list above — a 1 means ""load this piece on the truck"" and a 0 means ""leave it behind."" This little block is just a sketch of the shape I expect, not the final answer itself.

Also, please make sure all identifiers are used exactly as they appear in the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [15, 32, 55, 80, 12, 61, 30, 22, 52, 42, 64, 32, 83, 8, 87, 3, 74, 35, 39, 2, 71, 17, 66, 73, 85, 71, 31, 74, 83], 'profits': [32, 13, 90, 15, 60, 24, 13, 78, 15, 68, 70, 7, 18, 80, 51, 13, 100, 27, 1, 93, 2, 56, 100, 58, 59, 39, 13, 58, 90], 'capacity': 700, 'solution': [1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1], 'objective': 1105, 'solve_time': 0.00038623809814453125, 'n_items': 29, 'R': 100, 'alpha': 0.5, 'instance_idx': 31, 'alpha_idx': 0}","[1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1]",1105,"{'problem_type': 'KP', 'capacity': 700, 'n_items': 29, 'items': [{'item_id': 1, 'weight': 15, 'profit': 32}, {'item_id': 2, 'weight': 32, 'profit': 13}, {'item_id': 3, 'weight': 55, 'profit': 90}, {'item_id': 4, 'weight': 80, 'profit': 15}, {'item_id': 5, 'weight': 12, 'profit': 60}, {'item_id': 6, 'weight': 61, 'profit': 24}, {'item_id': 7, 'weight': 30, 'profit': 13}, {'item_id': 8, 'weight': 22, 'profit': 78}, {'item_id': 9, 'weight': 52, 'profit': 15}, {'item_id': 10, 'weight': 42, 'profit': 68}, {'item_id': 11, 'weight': 64, 'profit': 70}, {'item_id': 12, 'weight': 32, 'profit': 7}, {'item_id': 13, 'weight': 83, 'profit': 18}, {'item_id': 14, 'weight': 8, 'profit': 80}, {'item_id': 15, 'weight': 87, 'profit': 51}, {'item_id': 16, 'weight': 3, 'profit': 13}, {'item_id': 17, 'weight': 74, 'profit': 100}, {'item_id': 18, 'weight': 35, 'profit': 27}, {'item_id': 19, 'weight': 39, 'profit': 1}, {'item_id': 20, 'weight': 2, 'profit': 93}, {'item_id': 21, 'weight': 71, 'profit': 2}, {'item_id': 22, 'weight': 17, 'profit': 56}, {'item_id': 23, 'weight': 66, 'profit': 100}, {'item_id': 24, 'weight': 73, 'profit': 58}, {'item_id': 25, 'weight': 85, 'profit': 59}, {'item_id': 26, 'weight': 71, 'profit': 39}, {'item_id': 27, 'weight': 31, 'profit': 13}, {'item_id': 28, 'weight': 74, 'profit': 58}, {'item_id': 29, 'weight': 83, 'profit': 90}]}","{'1': 1, '2': 0, '3': 1, '4': 0, '5': 1, '6': 0, '7': 0, '8': 1, '9': 0, '10': 1, '11': 1, '12': 0, '13': 0, '14': 1, '15': 0, '16': 1, '17': 1, '18': 0, '19': 0, '20': 1, '21': 0, '22': 1, '23': 1, '24': 1, '25': 1, '26': 0, '27': 0, '28': 1, '29': 1}",32,nl,1
KP,KP,"I run a tiny corner shop and I’ve been picking which bits from different market stalls to put on a single display shelf. The choice is simple: put some stall items up and leave others out, but the better choice is the one that brings in the most total sales value — calculated by adding the expected sales numbers of every item placed on that shelf. The catch is the shelf can only hold so much weight, and each item is either placed as a whole or not at all, never split or doubled. The exact weights and sales numbers are listed below.

The shelf can hold up to 456 total weight; here are the stall items I'm considering:
Stall item 0 weighs 89 and is expected to bring 16 in sales if I put it on the shelf.
Stall item 1 weighs 42 and is expected to bring 24 in sales if I put it on the shelf.
Stall item 2 weighs 54 and is expected to bring 85 in sales if I put it on the shelf.
Stall item 3 weighs 17 and is expected to bring 88 in sales if I put it on the shelf.
Stall item 4 weighs 63 and is expected to bring 84 in sales if I put it on the shelf.
Stall item 5 weighs 19 and is expected to bring 26 in sales if I put it on the shelf.
Stall item 6 weighs 28 and is expected to bring 62 in sales if I put it on the shelf.
Stall item 7 weighs 73 and is expected to bring 62 in sales if I put it on the shelf.
Stall item 8 weighs 6 and is expected to bring 19 in sales if I put it on the shelf.
Stall item 9 weighs 45 and is expected to bring 56 in sales if I put it on the shelf.
Stall item 10 weighs 60 and is expected to bring 53 in sales if I put it on the shelf.
Stall item 11 weighs 14 and is expected to bring 40 in sales if I put it on the shelf.
Stall item 12 weighs 30 and is expected to bring 76 in sales if I put it on the shelf.
Stall item 13 weighs 35 and is expected to bring 68 in sales if I put it on the shelf.
Stall item 14 weighs 67 and is expected to bring 54 in sales if I put it on the shelf.
Stall item 15 weighs 98 and is expected to bring 73 in sales if I put it on the shelf.
Stall item 16 weighs 84 and is expected to bring 77 in sales if I put it on the shelf.
Stall item 17 weighs 19 and is expected to bring 57 in sales if I put it on the shelf.
Stall item 18 weighs 2 and is expected to bring 27 in sales if I put it on the shelf.
Stall item 19 weighs 6 and is expected to bring 76 in sales if I put it on the shelf.
Stall item 20 weighs 60 and is expected to bring 72 in sales if I put it on the shelf.
I'll choose items that fit within 456 to maximize total expected sales.

If you want the result in a little machine-friendly package, here's the shape I'd use:

{
  ""solution"": [0, 1, 0, 1, ...]
}

It's a simple sketch: ""solution"" is an array that lines up with the list of items above — a 1 means I put that stall item on the shelf, a 0 means I left it out. Think of it like ticking boxes on a form; this JSON just shows the expected layout, not the final choices.

Also, please use the exact identifiers from the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [89, 42, 54, 17, 63, 19, 28, 73, 6, 45, 60, 14, 30, 35, 67, 98, 84, 19, 2, 6, 60], 'profits': [16, 24, 85, 88, 84, 26, 62, 62, 19, 56, 53, 40, 76, 68, 54, 73, 77, 57, 27, 76, 72], 'capacity': 456, 'solution': [0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1], 'objective': 872, 'solve_time': 0.0003039836883544922, 'n_items': 21, 'R': 100, 'alpha': 0.5, 'instance_idx': 32, 'alpha_idx': 0}","[0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1]",872,"{'problem_type': 'KP', 'capacity': 456, 'n_items': 21, 'items': [{'item_id': 0, 'weight': 89, 'profit': 16}, {'item_id': 1, 'weight': 42, 'profit': 24}, {'item_id': 2, 'weight': 54, 'profit': 85}, {'item_id': 3, 'weight': 17, 'profit': 88}, {'item_id': 4, 'weight': 63, 'profit': 84}, {'item_id': 5, 'weight': 19, 'profit': 26}, {'item_id': 6, 'weight': 28, 'profit': 62}, {'item_id': 7, 'weight': 73, 'profit': 62}, {'item_id': 8, 'weight': 6, 'profit': 19}, {'item_id': 9, 'weight': 45, 'profit': 56}, {'item_id': 10, 'weight': 60, 'profit': 53}, {'item_id': 11, 'weight': 14, 'profit': 40}, {'item_id': 12, 'weight': 30, 'profit': 76}, {'item_id': 13, 'weight': 35, 'profit': 68}, {'item_id': 14, 'weight': 67, 'profit': 54}, {'item_id': 15, 'weight': 98, 'profit': 73}, {'item_id': 16, 'weight': 84, 'profit': 77}, {'item_id': 17, 'weight': 19, 'profit': 57}, {'item_id': 18, 'weight': 2, 'profit': 27}, {'item_id': 19, 'weight': 6, 'profit': 76}, {'item_id': 20, 'weight': 60, 'profit': 72}]}","{'0': 0, '1': 0, '2': 1, '3': 1, '4': 1, '5': 0, '6': 1, '7': 1, '8': 1, '9': 1, '10': 0, '11': 1, '12': 1, '13': 1, '14': 0, '15': 0, '16': 0, '17': 1, '18': 1, '19': 1, '20': 1}",33,nl,0
KP,KP,"We’ve got a sunny afternoon planned and only one small basket to carry the spread. The decision is which foods to include so the meal ends up tasting and feeling the best overall — total satisfaction comes from summing the happiness each chosen item brings — but the catch is the basket can only hold so much, so the total bulk must stay under that cap. Every dish can be taken once or left behind (no splitting or grabbing two of the same), and the specific items, their sizes, and satisfaction values are listed below.

- **basket_capacity**: 763

| ingredient_id | bulk_units | satisfaction_score |
|---|---|---|
| 0 | 15 | 99 |
| 1 | 42 | 92 |
| 2 | 93 | 25 |
| 3 | 52 | 22 |
| 4 | 95 | 35 |
| 5 | 2 | 47 |
| 6 | 4 | 88 |
| 7 | 80 | 74 |
| 8 | 36 | 65 |
| 9 | 53 | 88 |
| 10 | 43 | 65 |
| 11 | 41 | 38 |
| 12 | 94 | 42 |
| 13 | 10 | 52 |
| 14 | 78 | 9 |
| 15 | 89 | 75 |
| 16 | 66 | 66 |
| 17 | 40 | 74 |
| 18 | 17 | 54 |
| 19 | 69 | 79 |
| 20 | 47 | 95 |
| 21 | 15 | 57 |
| 22 | 36 | 45 |
| 23 | 97 | 11 |
| 24 | 27 | 78 |
| 25 | 18 | 91 |
| 26 | 69 | 70 |
| 27 | 20 | 87 |
| 28 | 92 | 87 |
| 29 | 86 | 80 |

If you want to send back your pick, just toss it into a tiny JSON sketch like this so it's easy to read by whatever's checking the picnic list:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is the checklist: each entry lines up with an item from the list above, and each number is a simple yes/no — 1 means you put that item in the basket, 0 means you leave it behind. Think of it like ticking boxes on a shopping list; this block is just the shape I need, not the final choices.

Also, please use any item identifiers exactly as they appear in the instance input — no renaming and no new labels. 
For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [15, 42, 93, 52, 95, 2, 4, 80, 36, 53, 43, 41, 94, 10, 78, 89, 66, 40, 17, 69, 47, 15, 36, 97, 27, 18, 69, 20, 92, 86], 'profits': [99, 92, 25, 22, 35, 47, 88, 74, 65, 88, 65, 38, 42, 52, 9, 75, 66, 74, 54, 79, 95, 57, 45, 11, 78, 91, 70, 87, 87, 80], 'capacity': 763, 'solution': [1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0], 'objective': 1517, 'solve_time': 0.0003819465637207031, 'n_items': 30, 'R': 100, 'alpha': 0.5, 'instance_idx': 33, 'alpha_idx': 0}","[1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0]",1517,"{'problem_type': 'KP', 'capacity': 763, 'n_items': 30, 'items': [{'item_id': 0, 'weight': 15, 'profit': 99}, {'item_id': 1, 'weight': 42, 'profit': 92}, {'item_id': 2, 'weight': 93, 'profit': 25}, {'item_id': 3, 'weight': 52, 'profit': 22}, {'item_id': 4, 'weight': 95, 'profit': 35}, {'item_id': 5, 'weight': 2, 'profit': 47}, {'item_id': 6, 'weight': 4, 'profit': 88}, {'item_id': 7, 'weight': 80, 'profit': 74}, {'item_id': 8, 'weight': 36, 'profit': 65}, {'item_id': 9, 'weight': 53, 'profit': 88}, {'item_id': 10, 'weight': 43, 'profit': 65}, {'item_id': 11, 'weight': 41, 'profit': 38}, {'item_id': 12, 'weight': 94, 'profit': 42}, {'item_id': 13, 'weight': 10, 'profit': 52}, {'item_id': 14, 'weight': 78, 'profit': 9}, {'item_id': 15, 'weight': 89, 'profit': 75}, {'item_id': 16, 'weight': 66, 'profit': 66}, {'item_id': 17, 'weight': 40, 'profit': 74}, {'item_id': 18, 'weight': 17, 'profit': 54}, {'item_id': 19, 'weight': 69, 'profit': 79}, {'item_id': 20, 'weight': 47, 'profit': 95}, {'item_id': 21, 'weight': 15, 'profit': 57}, {'item_id': 22, 'weight': 36, 'profit': 45}, {'item_id': 23, 'weight': 97, 'profit': 11}, {'item_id': 24, 'weight': 27, 'profit': 78}, {'item_id': 25, 'weight': 18, 'profit': 91}, {'item_id': 26, 'weight': 69, 'profit': 70}, {'item_id': 27, 'weight': 20, 'profit': 87}, {'item_id': 28, 'weight': 92, 'profit': 87}, {'item_id': 29, 'weight': 86, 'profit': 80}]}","{'0': 1, '1': 1, '2': 0, '3': 0, '4': 0, '5': 1, '6': 1, '7': 0, '8': 1, '9': 1, '10': 1, '11': 1, '12': 0, '13': 1, '14': 0, '15': 0, '16': 1, '17': 1, '18': 1, '19': 1, '20': 1, '21': 1, '22': 1, '23': 0, '24': 1, '25': 1, '26': 1, '27': 1, '28': 1, '29': 0}",34,markdown_table,0
KP,KP,"On a rainy afternoon the book club organizer is packing a tote and has to choose which novels to bring to maximize how much members will enjoy the meeting. To compare options, add up the enjoyment score for each book that’s included — that total is what matters, and selections with higher totals are preferred. The tote has a fixed capacity, so the combined weight of the picked books can’t exceed that limit, and no novel can be included more than once. The concrete book-by-book details are shown below.

{
  ""tote_capacity"": 643,
  ""items"": [
    {
      ""book_id"": ""A"",
      ""book_weight"": 10,
      ""enjoyment_score"": 61
    },
    {
      ""book_id"": ""B"",
      ""book_weight"": 1,
      ""enjoyment_score"": 58
    },
    {
      ""book_id"": ""C"",
      ""book_weight"": 21,
      ""enjoyment_score"": 94
    },
    {
      ""book_id"": ""D"",
      ""book_weight"": 44,
      ""enjoyment_score"": 51
    },
    {
      ""book_id"": ""E"",
      ""book_weight"": 75,
      ""enjoyment_score"": 47
    },
    {
      ""book_id"": ""F"",
      ""book_weight"": 46,
      ""enjoyment_score"": 7
    },
    {
      ""book_id"": ""G"",
      ""book_weight"": 3,
      ""enjoyment_score"": 20
    },
    {
      ""book_id"": ""H"",
      ""book_weight"": 22,
      ""enjoyment_score"": 34
    },
    {
      ""book_id"": ""I"",
      ""book_weight"": 98,
      ""enjoyment_score"": 38
    },
    {
      ""book_id"": ""J"",
      ""book_weight"": 99,
      ""enjoyment_score"": 37
    },
    {
      ""book_id"": ""K"",
      ""book_weight"": 38,
      ""enjoyment_score"": 40
    },
    {
      ""book_id"": ""L"",
      ""book_weight"": 81,
      ""enjoyment_score"": 77
    },
    {
      ""book_id"": ""M"",
      ""book_weight"": 72,
      ""enjoyment_score"": 14
    },
    {
      ""book_id"": ""N"",
      ""book_weight"": 94,
      ""enjoyment_score"": 34
    },
    {
      ""book_id"": ""O"",
      ""book_weight"": 89,
      ""enjoyment_score"": 17
    },
    {
      ""book_id"": ""P"",
      ""book_weight"": 63,
      ""enjoyment_score"": 31
    },
    {
      ""book_id"": ""Q"",
      ""book_weight"": 40,
      ""enjoyment_score"": 69
    },
    {
      ""book_id"": ""R"",
      ""book_weight"": 63,
      ""enjoyment_score"": 5
    },
    {
      ""book_id"": ""S"",
      ""book_weight"": 32,
      ""enjoyment_score"": 34
    },
    {
      ""book_id"": ""T"",
      ""book_weight"": 35,
      ""enjoyment_score"": 3
    },
    {
      ""book_id"": ""U"",
      ""book_weight"": 61,
      ""enjoyment_score"": 96
    },
    {
      ""book_id"": ""V"",
      ""book_weight"": 58,
      ""enjoyment_score"": 73
    },
    {
      ""book_id"": ""W"",
      ""book_weight"": 59,
      ""enjoyment_score"": 25
    },
    {
      ""book_id"": ""X"",
      ""book_weight"": 39,
      ""enjoyment_score"": 20
    },
    {
      ""book_id"": ""Y"",
      ""book_weight"": 41,
      ""enjoyment_score"": 10
    },
    {
      ""book_id"": ""Z"",
      ""book_weight"": 2,
      ""enjoyment_score"": 48
    }
  ]
}

If you want to tell me which novels you decide to pack, just send it back in this simple JSON shape:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here, ""solution"" is just a list of zeros and ones—each position matches a book in the same order the list above gives. A 1 means “toss this book in the tote,” and a 0 means “leave it behind.” Think of it like ticking boxes on a quick checklist rather than filling out a complicated form. This JSON is just a sketch of the shape I expect, not the actual answer itself.

Please make sure any identifiers you use match the instance input exactly — no renaming and no new labels.  
Valid identifiers look like plain numbers such as ""1"" or ""23"", single capital letters like ""A"" or ""B"", or a capital letter followed by digits like ""A1"" or ""X7"".","{'problem_type': 'KP', 'weights': [10, 1, 21, 44, 75, 46, 3, 22, 98, 99, 38, 81, 72, 94, 89, 63, 40, 63, 32, 35, 61, 58, 59, 39, 41, 2], 'profits': [61, 58, 94, 51, 47, 7, 20, 34, 38, 37, 40, 77, 14, 34, 17, 31, 69, 5, 34, 3, 96, 73, 25, 20, 10, 48], 'capacity': 643, 'solution': [1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1], 'objective': 863, 'solve_time': 0.0003380775451660156, 'n_items': 26, 'R': 100, 'alpha': 0.5, 'instance_idx': 34, 'alpha_idx': 0}","[1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1]",863,"{'problem_type': 'KP', 'capacity': 643, 'n_items': 26, 'items': [{'item_id': 'A', 'weight': 10, 'profit': 61}, {'item_id': 'B', 'weight': 1, 'profit': 58}, {'item_id': 'C', 'weight': 21, 'profit': 94}, {'item_id': 'D', 'weight': 44, 'profit': 51}, {'item_id': 'E', 'weight': 75, 'profit': 47}, {'item_id': 'F', 'weight': 46, 'profit': 7}, {'item_id': 'G', 'weight': 3, 'profit': 20}, {'item_id': 'H', 'weight': 22, 'profit': 34}, {'item_id': 'I', 'weight': 98, 'profit': 38}, {'item_id': 'J', 'weight': 99, 'profit': 37}, {'item_id': 'K', 'weight': 38, 'profit': 40}, {'item_id': 'L', 'weight': 81, 'profit': 77}, {'item_id': 'M', 'weight': 72, 'profit': 14}, {'item_id': 'N', 'weight': 94, 'profit': 34}, {'item_id': 'O', 'weight': 89, 'profit': 17}, {'item_id': 'P', 'weight': 63, 'profit': 31}, {'item_id': 'Q', 'weight': 40, 'profit': 69}, {'item_id': 'R', 'weight': 63, 'profit': 5}, {'item_id': 'S', 'weight': 32, 'profit': 34}, {'item_id': 'T', 'weight': 35, 'profit': 3}, {'item_id': 'U', 'weight': 61, 'profit': 96}, {'item_id': 'V', 'weight': 58, 'profit': 73}, {'item_id': 'W', 'weight': 59, 'profit': 25}, {'item_id': 'X', 'weight': 39, 'profit': 20}, {'item_id': 'Y', 'weight': 41, 'profit': 10}, {'item_id': 'Z', 'weight': 2, 'profit': 48}]}","{'A': 1, 'B': 1, 'C': 1, 'D': 1, 'E': 1, 'F': 0, 'G': 1, 'H': 1, 'I': 0, 'J': 0, 'K': 1, 'L': 1, 'M': 0, 'N': 0, 'O': 0, 'P': 1, 'Q': 1, 'R': 0, 'S': 1, 'T': 0, 'U': 1, 'V': 1, 'W': 0, 'X': 1, 'Y': 1, 'Z': 1}",35,json,names
KP,KP,"There’s a limited amount of space on my flash drive and a big folder of great tracks; now comes the tough call about which ones to keep. The winning playlist is the one with the highest total enjoyment, which you get by adding up the enjoyment rating for every song picked, but the total runtime — the sum of the individual song lengths — must stay under the drive’s capacity. Each song can be included only once. Concrete details follow below.

{
  ""flash_drive_capacity"": 578,
  ""items"": [
    {
      ""track_id"": 1,
      ""track_runtime"": 59,
      ""enjoyment_score"": 14
    },
    {
      ""track_id"": 2,
      ""track_runtime"": 89,
      ""enjoyment_score"": 30
    },
    {
      ""track_id"": 3,
      ""track_runtime"": 35,
      ""enjoyment_score"": 32
    },
    {
      ""track_id"": 4,
      ""track_runtime"": 28,
      ""enjoyment_score"": 77
    },
    {
      ""track_id"": 5,
      ""track_runtime"": 48,
      ""enjoyment_score"": 31
    },
    {
      ""track_id"": 6,
      ""track_runtime"": 21,
      ""enjoyment_score"": 88
    },
    {
      ""track_id"": 7,
      ""track_runtime"": 98,
      ""enjoyment_score"": 78
    },
    {
      ""track_id"": 8,
      ""track_runtime"": 19,
      ""enjoyment_score"": 91
    },
    {
      ""track_id"": 9,
      ""track_runtime"": 48,
      ""enjoyment_score"": 11
    },
    {
      ""track_id"": 10,
      ""track_runtime"": 53,
      ""enjoyment_score"": 99
    },
    {
      ""track_id"": 11,
      ""track_runtime"": 6,
      ""enjoyment_score"": 62
    },
    {
      ""track_id"": 12,
      ""track_runtime"": 47,
      ""enjoyment_score"": 99
    },
    {
      ""track_id"": 13,
      ""track_runtime"": 46,
      ""enjoyment_score"": 36
    },
    {
      ""track_id"": 14,
      ""track_runtime"": 26,
      ""enjoyment_score"": 96
    },
    {
      ""track_id"": 15,
      ""track_runtime"": 13,
      ""enjoyment_score"": 59
    },
    {
      ""track_id"": 16,
      ""track_runtime"": 5,
      ""enjoyment_score"": 8
    },
    {
      ""track_id"": 17,
      ""track_runtime"": 1,
      ""enjoyment_score"": 42
    },
    {
      ""track_id"": 18,
      ""track_runtime"": 49,
      ""enjoyment_score"": 14
    },
    {
      ""track_id"": 19,
      ""track_runtime"": 9,
      ""enjoyment_score"": 95
    },
    {
      ""track_id"": 20,
      ""track_runtime"": 96,
      ""enjoyment_score"": 31
    },
    {
      ""track_id"": 21,
      ""track_runtime"": 25,
      ""enjoyment_score"": 23
    },
    {
      ""track_id"": 22,
      ""track_runtime"": 66,
      ""enjoyment_score"": 56
    },
    {
      ""track_id"": 23,
      ""track_runtime"": 68,
      ""enjoyment_score"": 43
    },
    {
      ""track_id"": 24,
      ""track_runtime"": 50,
      ""enjoyment_score"": 10
    },
    {
      ""track_id"": 25,
      ""track_runtime"": 89,
      ""enjoyment_score"": 82
    },
    {
      ""track_id"": 26,
      ""track_runtime"": 12,
      ""enjoyment_score"": 85
    },
    {
      ""track_id"": 27,
      ""track_runtime"": 24,
      ""enjoyment_score"": 75
    },
    {
      ""track_id"": 28,
      ""track_runtime"": 26,
      ""enjoyment_score"": 62
    }
  ]
}

When you send back which songs to keep, just stick to this simple JSON shape so I can read it automatically:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a checklist that lines up with the song list: a 1 means ""keep this track"" and a 0 means ""skip it."" The order should match the order of songs in the instance you were given. This JSON is just a sketch of the shape I expect — not the actual answer.

Please use the exact identifiers from the instance input, with no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [59, 89, 35, 28, 48, 21, 98, 19, 48, 53, 6, 47, 46, 26, 13, 5, 1, 49, 9, 96, 25, 66, 68, 50, 89, 12, 24, 26], 'profits': [14, 30, 32, 77, 31, 88, 78, 91, 11, 99, 62, 99, 36, 96, 59, 8, 42, 14, 95, 31, 23, 56, 43, 10, 82, 85, 75, 62], 'capacity': 578, 'solution': [0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1], 'objective': 1286, 'solve_time': 0.00034689903259277344, 'n_items': 28, 'R': 100, 'alpha': 0.5, 'instance_idx': 35, 'alpha_idx': 0}","[0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1]",1286,"{'problem_type': 'KP', 'capacity': 578, 'n_items': 28, 'items': [{'item_id': 1, 'weight': 59, 'profit': 14}, {'item_id': 2, 'weight': 89, 'profit': 30}, {'item_id': 3, 'weight': 35, 'profit': 32}, {'item_id': 4, 'weight': 28, 'profit': 77}, {'item_id': 5, 'weight': 48, 'profit': 31}, {'item_id': 6, 'weight': 21, 'profit': 88}, {'item_id': 7, 'weight': 98, 'profit': 78}, {'item_id': 8, 'weight': 19, 'profit': 91}, {'item_id': 9, 'weight': 48, 'profit': 11}, {'item_id': 10, 'weight': 53, 'profit': 99}, {'item_id': 11, 'weight': 6, 'profit': 62}, {'item_id': 12, 'weight': 47, 'profit': 99}, {'item_id': 13, 'weight': 46, 'profit': 36}, {'item_id': 14, 'weight': 26, 'profit': 96}, {'item_id': 15, 'weight': 13, 'profit': 59}, {'item_id': 16, 'weight': 5, 'profit': 8}, {'item_id': 17, 'weight': 1, 'profit': 42}, {'item_id': 18, 'weight': 49, 'profit': 14}, {'item_id': 19, 'weight': 9, 'profit': 95}, {'item_id': 20, 'weight': 96, 'profit': 31}, {'item_id': 21, 'weight': 25, 'profit': 23}, {'item_id': 22, 'weight': 66, 'profit': 56}, {'item_id': 23, 'weight': 68, 'profit': 43}, {'item_id': 24, 'weight': 50, 'profit': 10}, {'item_id': 25, 'weight': 89, 'profit': 82}, {'item_id': 26, 'weight': 12, 'profit': 85}, {'item_id': 27, 'weight': 24, 'profit': 75}, {'item_id': 28, 'weight': 26, 'profit': 62}]}","{'1': 0, '2': 0, '3': 1, '4': 1, '5': 0, '6': 1, '7': 1, '8': 1, '9': 0, '10': 1, '11': 1, '12': 1, '13': 0, '14': 1, '15': 1, '16': 1, '17': 1, '18': 0, '19': 1, '20': 0, '21': 0, '22': 1, '23': 0, '24': 0, '25': 1, '26': 1, '27': 1, '28': 1}",36,json,1
KP,KP,"I was planning a picnic and needed to pick groceries so everything that goes in the cooler gives the most nutrition without overflowing it. The choice is about which individual items to buy so the combined nutritional value is as high as possible, and that total is just the sum of the nutrition numbers on each package. Everything packed together must physically fit inside the cooler (total bulk/volume can’t exceed the cooler’s space), and only one package of each product can be bought — no duplicates. The concrete details are shown below.

My cooler holds 546 units of space.
I considered 1, which occupies 55 units and provides 61 nutritional value.
I considered 2, which occupies 53 units and provides 95 nutritional value.
I considered 3, which occupies 17 units and provides 41 nutritional value.
I considered 4, which occupies 9 units and provides 13 nutritional value.
I considered 5, which occupies 26 units and provides 24 nutritional value.
I considered 6, which occupies 46 units and provides 90 nutritional value.
I considered 7, which occupies 17 units and provides 73 nutritional value.
I considered 8, which occupies 11 units and provides 11 nutritional value.
I considered 9, which occupies 86 units and provides 39 nutritional value.
I considered 10, which occupies 38 units and provides 27 nutritional value.
I considered 11, which occupies 59 units and provides 18 nutritional value.
I considered 12, which occupies 53 units and provides 85 nutritional value.
I considered 13, which occupies 74 units and provides 62 nutritional value.
I considered 14, which occupies 74 units and provides 18 nutritional value.
I considered 15, which occupies 30 units and provides 66 nutritional value.
I considered 16, which occupies 85 units and provides 42 nutritional value.
I considered 17, which occupies 38 units and provides 7 nutritional value.
I considered 18, which occupies 84 units and provides 45 nutritional value.
I considered 19, which occupies 41 units and provides 19 nutritional value.
I considered 20, which occupies 12 units and provides 25 nutritional value.
I considered 21, which occupies 77 units and provides 88 nutritional value.
I considered 22, which occupies 4 units and provides 72 nutritional value.
I considered 23, which occupies 78 units and provides 14 nutritional value.
I considered 24, which occupies 5 units and provides 86 nutritional value.
I considered 25, which occupies 21 units and provides 58 nutritional value.
I must choose items so the total occupied volume stays within 546.

If you'd like the answer sent back in a neat format, I can use a tiny JSON snippet like this to show which packages get packed:

{
  ""solution"": [0, 1, 0, 1, ...]
}

""solution"" is just a list that lines up with the items on the grocery list — a 1 means I pack that item, a 0 means I leave it behind. Think of it as a simple checklist form; this block is just the shape I’ll use, not the final filled-in pick.

Please also make sure any item identifiers you refer to are used exactly as they appear in the instance input — don’t rename them or invent new labels.

for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [55, 53, 17, 9, 26, 46, 17, 11, 86, 38, 59, 53, 74, 74, 30, 85, 38, 84, 41, 12, 77, 4, 78, 5, 21], 'profits': [61, 95, 41, 13, 24, 90, 73, 11, 39, 27, 18, 85, 62, 18, 66, 42, 7, 45, 19, 25, 88, 72, 14, 86, 58], 'capacity': 546, 'solution': [1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1], 'objective': 966, 'solve_time': 0.0003285408020019531, 'n_items': 25, 'R': 100, 'alpha': 0.5, 'instance_idx': 36, 'alpha_idx': 0}","[1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1]",966,"{'problem_type': 'KP', 'capacity': 546, 'n_items': 25, 'items': [{'item_id': 1, 'weight': 55, 'profit': 61}, {'item_id': 2, 'weight': 53, 'profit': 95}, {'item_id': 3, 'weight': 17, 'profit': 41}, {'item_id': 4, 'weight': 9, 'profit': 13}, {'item_id': 5, 'weight': 26, 'profit': 24}, {'item_id': 6, 'weight': 46, 'profit': 90}, {'item_id': 7, 'weight': 17, 'profit': 73}, {'item_id': 8, 'weight': 11, 'profit': 11}, {'item_id': 9, 'weight': 86, 'profit': 39}, {'item_id': 10, 'weight': 38, 'profit': 27}, {'item_id': 11, 'weight': 59, 'profit': 18}, {'item_id': 12, 'weight': 53, 'profit': 85}, {'item_id': 13, 'weight': 74, 'profit': 62}, {'item_id': 14, 'weight': 74, 'profit': 18}, {'item_id': 15, 'weight': 30, 'profit': 66}, {'item_id': 16, 'weight': 85, 'profit': 42}, {'item_id': 17, 'weight': 38, 'profit': 7}, {'item_id': 18, 'weight': 84, 'profit': 45}, {'item_id': 19, 'weight': 41, 'profit': 19}, {'item_id': 20, 'weight': 12, 'profit': 25}, {'item_id': 21, 'weight': 77, 'profit': 88}, {'item_id': 22, 'weight': 4, 'profit': 72}, {'item_id': 23, 'weight': 78, 'profit': 14}, {'item_id': 24, 'weight': 5, 'profit': 86}, {'item_id': 25, 'weight': 21, 'profit': 58}]}","{'1': 1, '2': 1, '3': 1, '4': 1, '5': 1, '6': 1, '7': 1, '8': 0, '9': 0, '10': 1, '11': 0, '12': 1, '13': 1, '14': 0, '15': 1, '16': 0, '17': 0, '18': 0, '19': 0, '20': 1, '21': 1, '22': 1, '23': 0, '24': 1, '25': 1}",37,nl,1
KP,KP,"A friend has to decide which apps to keep on a phone that doesn’t have much space. The plan is to pick the combination that delivers the highest combined benefit — add up the benefit numbers of whatever apps are chosen to find the total — but the sum of their storage sizes must stay within the phone’s capacity, and each app can only be installed once. The exact apps, their sizes, and usefulness ratings are listed below.

- **phone_storage_capacity**: 633

| app_id | app_storage_size | app_usefulness_score |
|---|---|---|
| A | 75 | 13 |
| B | 34 | 19 |
| C | 54 | 96 |
| D | 54 | 9 |
| E | 72 | 49 |
| F | 25 | 84 |
| G | 34 | 96 |
| H | 25 | 15 |
| I | 30 | 17 |
| J | 17 | 38 |
| K | 4 | 56 |
| L | 95 | 96 |
| M | 8 | 21 |
| N | 89 | 17 |
| O | 1 | 26 |
| P | 78 | 88 |
| Q | 33 | 4 |
| R | 52 | 39 |
| S | 29 | 12 |
| T | 50 | 16 |
| U | 46 | 92 |
| V | 53 | 1 |
| W | 40 | 33 |
| X | 54 | 92 |
| Y | 83 | 61 |
| Z | 44 | 8 |
| AA | 37 | 47 |
| AB | 14 | 98 |
| AC | 36 | 41 |

Oh, and when you send the pick, please use this simple JSON layout so it's easy to check:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is just a list that matches the apps in the order they're listed above — a 1 means keep that app on the phone, a 0 means remove it. Think of it as ticking boxes next to each app name; this block is just a sketch of the shape I need, not your final selection.

Also, please use the exact identifiers from the instance input — don't rename them or invent new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [75, 34, 54, 54, 72, 25, 34, 25, 30, 17, 4, 95, 8, 89, 1, 78, 33, 52, 29, 50, 46, 53, 40, 54, 83, 44, 37, 14, 36], 'profits': [13, 19, 96, 9, 49, 84, 96, 15, 17, 38, 56, 96, 21, 17, 26, 88, 4, 39, 12, 16, 92, 1, 33, 92, 61, 8, 47, 98, 41], 'capacity': 633, 'solution': [0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1], 'objective': 1065, 'solve_time': 0.0003485679626464844, 'n_items': 29, 'R': 100, 'alpha': 0.5, 'instance_idx': 37, 'alpha_idx': 0}","[0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1]",1065,"{'problem_type': 'KP', 'capacity': 633, 'n_items': 29, 'items': [{'item_id': 'A', 'weight': 75, 'profit': 13}, {'item_id': 'B', 'weight': 34, 'profit': 19}, {'item_id': 'C', 'weight': 54, 'profit': 96}, {'item_id': 'D', 'weight': 54, 'profit': 9}, {'item_id': 'E', 'weight': 72, 'profit': 49}, {'item_id': 'F', 'weight': 25, 'profit': 84}, {'item_id': 'G', 'weight': 34, 'profit': 96}, {'item_id': 'H', 'weight': 25, 'profit': 15}, {'item_id': 'I', 'weight': 30, 'profit': 17}, {'item_id': 'J', 'weight': 17, 'profit': 38}, {'item_id': 'K', 'weight': 4, 'profit': 56}, {'item_id': 'L', 'weight': 95, 'profit': 96}, {'item_id': 'M', 'weight': 8, 'profit': 21}, {'item_id': 'N', 'weight': 89, 'profit': 17}, {'item_id': 'O', 'weight': 1, 'profit': 26}, {'item_id': 'P', 'weight': 78, 'profit': 88}, {'item_id': 'Q', 'weight': 33, 'profit': 4}, {'item_id': 'R', 'weight': 52, 'profit': 39}, {'item_id': 'S', 'weight': 29, 'profit': 12}, {'item_id': 'T', 'weight': 50, 'profit': 16}, {'item_id': 'U', 'weight': 46, 'profit': 92}, {'item_id': 'V', 'weight': 53, 'profit': 1}, {'item_id': 'W', 'weight': 40, 'profit': 33}, {'item_id': 'X', 'weight': 54, 'profit': 92}, {'item_id': 'Y', 'weight': 83, 'profit': 61}, {'item_id': 'Z', 'weight': 44, 'profit': 8}, {'item_id': 'AA', 'weight': 37, 'profit': 47}, {'item_id': 'AB', 'weight': 14, 'profit': 98}, {'item_id': 'AC', 'weight': 36, 'profit': 41}]}","{'A': 0, 'B': 0, 'C': 1, 'D': 0, 'E': 0, 'F': 1, 'G': 1, 'H': 0, 'I': 0, 'J': 1, 'K': 1, 'L': 1, 'M': 1, 'N': 0, 'O': 1, 'P': 1, 'Q': 0, 'R': 0, 'S': 0, 'T': 0, 'U': 1, 'V': 0, 'W': 1, 'X': 1, 'Y': 1, 'Z': 0, 'AA': 1, 'AB': 1, 'AC': 1}",38,markdown_table,names
KP,KP,"There’s a donation drive going on and the plan is to fill a single box with the best combination of toys. The idea is simple: choose toys that, when their happiness points are added together, give the biggest overall happiness, yet the sum of their physical volumes must remain under the box’s limit. No toy can be thrown in twice, and the exact toy list, volumes, and happiness scores are detailed below.

The box volume limit is 727; the chosen toys' combined volumes must not exceed this.
Toy 0 occupies 54 volume and contributes 76 happiness points.
Toy 1 occupies 67 volume and contributes 64 happiness points.
Toy 2 occupies 19 volume and contributes 80 happiness points.
Toy 3 occupies 84 volume and contributes 83 happiness points.
Toy 4 occupies 99 volume and contributes 22 happiness points.
Toy 5 occupies 15 volume and contributes 22 happiness points.
Toy 6 occupies 82 volume and contributes 93 happiness points.
Toy 7 occupies 82 volume and contributes 54 happiness points.
Toy 8 occupies 75 volume and contributes 44 happiness points.
Toy 9 occupies 38 volume and contributes 29 happiness points.
Toy 10 occupies 47 volume and contributes 64 happiness points.
Toy 11 occupies 84 volume and contributes 76 happiness points.
Toy 12 occupies 16 volume and contributes 1 happiness points.
Toy 13 occupies 83 volume and contributes 56 happiness points.
Toy 14 occupies 93 volume and contributes 100 happiness points.
Toy 15 occupies 69 volume and contributes 29 happiness points.
Toy 16 occupies 35 volume and contributes 29 happiness points.
Toy 17 occupies 56 volume and contributes 88 happiness points.
Toy 18 occupies 6 volume and contributes 7 happiness points.
Toy 19 occupies 94 volume and contributes 40 happiness points.
Toy 20 occupies 35 volume and contributes 46 happiness points.
Toy 21 occupies 6 volume and contributes 80 happiness points.
Toy 22 occupies 80 volume and contributes 13 happiness points.
Toy 23 occupies 66 volume and contributes 44 happiness points.
Toy 24 occupies 63 volume and contributes 16 happiness points.
Toy 25 occupies 6 volume and contributes 79 happiness points.
Select toys so the total volume remains within 727.

Oh, and when you send the final pick, just use this simple JSON layout so it’s easy to check automatically:

{
  ""solution"": [0, 1, 0, 1, ...]
}

This is just the shape I want — ""solution"" is an array where each entry corresponds to a toy in the same order they’re listed in the instance: 1 means include that toy in the box, 0 means skip it. Think of it like ticking boxes on a checklist. It’s only a sketch of the expected format, not the actual answer.

Also, please use the exact identifiers as they appear in the instance input — don’t rename items or invent new labels.  
Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [54, 67, 19, 84, 99, 15, 82, 82, 75, 38, 47, 84, 16, 83, 93, 69, 35, 56, 6, 94, 35, 6, 80, 66, 63, 6], 'profits': [76, 64, 80, 83, 22, 22, 93, 54, 44, 29, 64, 76, 1, 56, 100, 29, 29, 88, 7, 40, 46, 80, 13, 44, 16, 79], 'capacity': 727, 'solution': [1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1], 'objective': 1016, 'solve_time': 0.0003390312194824219, 'n_items': 26, 'R': 100, 'alpha': 0.5, 'instance_idx': 38, 'alpha_idx': 0}","[1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1]",1016,"{'problem_type': 'KP', 'capacity': 727, 'n_items': 26, 'items': [{'item_id': 0, 'weight': 54, 'profit': 76}, {'item_id': 1, 'weight': 67, 'profit': 64}, {'item_id': 2, 'weight': 19, 'profit': 80}, {'item_id': 3, 'weight': 84, 'profit': 83}, {'item_id': 4, 'weight': 99, 'profit': 22}, {'item_id': 5, 'weight': 15, 'profit': 22}, {'item_id': 6, 'weight': 82, 'profit': 93}, {'item_id': 7, 'weight': 82, 'profit': 54}, {'item_id': 8, 'weight': 75, 'profit': 44}, {'item_id': 9, 'weight': 38, 'profit': 29}, {'item_id': 10, 'weight': 47, 'profit': 64}, {'item_id': 11, 'weight': 84, 'profit': 76}, {'item_id': 12, 'weight': 16, 'profit': 1}, {'item_id': 13, 'weight': 83, 'profit': 56}, {'item_id': 14, 'weight': 93, 'profit': 100}, {'item_id': 15, 'weight': 69, 'profit': 29}, {'item_id': 16, 'weight': 35, 'profit': 29}, {'item_id': 17, 'weight': 56, 'profit': 88}, {'item_id': 18, 'weight': 6, 'profit': 7}, {'item_id': 19, 'weight': 94, 'profit': 40}, {'item_id': 20, 'weight': 35, 'profit': 46}, {'item_id': 21, 'weight': 6, 'profit': 80}, {'item_id': 22, 'weight': 80, 'profit': 13}, {'item_id': 23, 'weight': 66, 'profit': 44}, {'item_id': 24, 'weight': 63, 'profit': 16}, {'item_id': 25, 'weight': 6, 'profit': 79}]}","{'0': 1, '1': 1, '2': 1, '3': 1, '4': 0, '5': 1, '6': 1, '7': 0, '8': 0, '9': 1, '10': 1, '11': 1, '12': 0, '13': 0, '14': 1, '15': 0, '16': 1, '17': 1, '18': 1, '19': 0, '20': 1, '21': 1, '22': 0, '23': 0, '24': 0, '25': 1}",39,nl,0
KP,KP,"On a sunny afternoon someone decided to style a balcony planter and needed to pick a handful of different plants that together look the best. The winning selection is the one with the greatest combined appeal — just add the appeal numbers of the chosen plants — while the total root-ball space they occupy (the sum of their root-space needs) can’t exceed what the planter holds. No plant type can be used more than once, and each picked plant affects both the total appeal and the total space used. The detailed list of plant sizes and appeal scores is shown below.

{
  ""available_root_space"": 725,
  ""items"": [
    {
      ""plant_id"": ""A"",
      ""root_space"": 50,
      ""appeal_score"": 5
    },
    {
      ""plant_id"": ""B"",
      ""root_space"": 40,
      ""appeal_score"": 99
    },
    {
      ""plant_id"": ""C"",
      ""root_space"": 16,
      ""appeal_score"": 45
    },
    {
      ""plant_id"": ""D"",
      ""root_space"": 93,
      ""appeal_score"": 29
    },
    {
      ""plant_id"": ""E"",
      ""root_space"": 65,
      ""appeal_score"": 90
    },
    {
      ""plant_id"": ""F"",
      ""root_space"": 32,
      ""appeal_score"": 75
    },
    {
      ""plant_id"": ""G"",
      ""root_space"": 42,
      ""appeal_score"": 75
    },
    {
      ""plant_id"": ""H"",
      ""root_space"": 73,
      ""appeal_score"": 28
    },
    {
      ""plant_id"": ""I"",
      ""root_space"": 72,
      ""appeal_score"": 100
    },
    {
      ""plant_id"": ""J"",
      ""root_space"": 47,
      ""appeal_score"": 46
    },
    {
      ""plant_id"": ""K"",
      ""root_space"": 31,
      ""appeal_score"": 54
    },
    {
      ""plant_id"": ""L"",
      ""root_space"": 66,
      ""appeal_score"": 76
    },
    {
      ""plant_id"": ""M"",
      ""root_space"": 66,
      ""appeal_score"": 66
    },
    {
      ""plant_id"": ""N"",
      ""root_space"": 60,
      ""appeal_score"": 18
    },
    {
      ""plant_id"": ""O"",
      ""root_space"": 8,
      ""appeal_score"": 31
    },
    {
      ""plant_id"": ""P"",
      ""root_space"": 48,
      ""appeal_score"": 37
    },
    {
      ""plant_id"": ""Q"",
      ""root_space"": 62,
      ""appeal_score"": 95
    },
    {
      ""plant_id"": ""R"",
      ""root_space"": 96,
      ""appeal_score"": 72
    },
    {
      ""plant_id"": ""S"",
      ""root_space"": 53,
      ""appeal_score"": 37
    },
    {
      ""plant_id"": ""T"",
      ""root_space"": 35,
      ""appeal_score"": 74
    },
    {
      ""plant_id"": ""U"",
      ""root_space"": 56,
      ""appeal_score"": 74
    },
    {
      ""plant_id"": ""V"",
      ""root_space"": 18,
      ""appeal_score"": 40
    },
    {
      ""plant_id"": ""W"",
      ""root_space"": 10,
      ""appeal_score"": 41
    },
    {
      ""plant_id"": ""X"",
      ""root_space"": 68,
      ""appeal_score"": 90
    },
    {
      ""plant_id"": ""Y"",
      ""root_space"": 99,
      ""appeal_score"": 57
    },
    {
      ""plant_id"": ""Z"",
      ""root_space"": 85,
      ""appeal_score"": 15
    },
    {
      ""plant_id"": ""AA"",
      ""root_space"": 59,
      ""appeal_score"": 72
    }
  ]
}

If you want to send your final pick it’s easiest for me to read if you stick to a tiny JSON layout like this:

{
  ""solution"": [0, 1, 0, 1, ...]
}

In this sketch, ""solution"" is a list with one entry for each plant in the list above: a 1 means you’re putting that plant in the planter, a 0 means you’re skipping it. Very much like ticking boxes on a checklist. This is just the shape I expect — a template, not the actual filled-in answer.

Please be sure to use the exact identifiers from the instance input; don’t rename them or invent new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.","{'problem_type': 'KP', 'weights': [50, 40, 16, 93, 65, 32, 42, 73, 72, 47, 31, 66, 66, 60, 8, 48, 62, 96, 53, 35, 56, 18, 10, 68, 99, 85, 59], 'profits': [5, 99, 45, 29, 90, 75, 75, 28, 100, 46, 54, 76, 66, 18, 31, 37, 95, 72, 37, 74, 74, 40, 41, 90, 57, 15, 72], 'capacity': 725, 'solution': [0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1], 'objective': 1153, 'solve_time': 0.0003490447998046875, 'n_items': 27, 'R': 100, 'alpha': 0.5, 'instance_idx': 39, 'alpha_idx': 0}","[0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1]",1153,"{'problem_type': 'KP', 'capacity': 725, 'n_items': 27, 'items': [{'item_id': 'A', 'weight': 50, 'profit': 5}, {'item_id': 'B', 'weight': 40, 'profit': 99}, {'item_id': 'C', 'weight': 16, 'profit': 45}, {'item_id': 'D', 'weight': 93, 'profit': 29}, {'item_id': 'E', 'weight': 65, 'profit': 90}, {'item_id': 'F', 'weight': 32, 'profit': 75}, {'item_id': 'G', 'weight': 42, 'profit': 75}, {'item_id': 'H', 'weight': 73, 'profit': 28}, {'item_id': 'I', 'weight': 72, 'profit': 100}, {'item_id': 'J', 'weight': 47, 'profit': 46}, {'item_id': 'K', 'weight': 31, 'profit': 54}, {'item_id': 'L', 'weight': 66, 'profit': 76}, {'item_id': 'M', 'weight': 66, 'profit': 66}, {'item_id': 'N', 'weight': 60, 'profit': 18}, {'item_id': 'O', 'weight': 8, 'profit': 31}, {'item_id': 'P', 'weight': 48, 'profit': 37}, {'item_id': 'Q', 'weight': 62, 'profit': 95}, {'item_id': 'R', 'weight': 96, 'profit': 72}, {'item_id': 'S', 'weight': 53, 'profit': 37}, {'item_id': 'T', 'weight': 35, 'profit': 74}, {'item_id': 'U', 'weight': 56, 'profit': 74}, {'item_id': 'V', 'weight': 18, 'profit': 40}, {'item_id': 'W', 'weight': 10, 'profit': 41}, {'item_id': 'X', 'weight': 68, 'profit': 90}, {'item_id': 'Y', 'weight': 99, 'profit': 57}, {'item_id': 'Z', 'weight': 85, 'profit': 15}, {'item_id': 'AA', 'weight': 59, 'profit': 72}]}","{'A': 0, 'B': 1, 'C': 1, 'D': 0, 'E': 1, 'F': 1, 'G': 1, 'H': 0, 'I': 1, 'J': 1, 'K': 1, 'L': 1, 'M': 1, 'N': 0, 'O': 1, 'P': 0, 'Q': 1, 'R': 0, 'S': 0, 'T': 1, 'U': 1, 'V': 1, 'W': 1, 'X': 0, 'Y': 0, 'Z': 0, 'AA': 1}",40,json,names
KP,KP,"On a tight copier quota, the TA needs to assemble a course packet from a list of chapters, each with a page count and a usefulness rating; the goal is to get as much total usefulness into the packet as possible without the pages exceeding the copier limit. Each chapter is either put in or left out (no duplicates), and you measure how good a selection is by totaling the usefulness ratings of the chosen chapters and ensuring the sum of their pages fits under the allowed limit. The exact numbers for pages and usefulness are shown below.

Copier page quota: 614 pages.
Chapter 0: 51 pages, usefulness 33.
Chapter 1: 73 pages, usefulness 81.
Chapter 2: 91 pages, usefulness 20.
Chapter 3: 34 pages, usefulness 17.
Chapter 4: 42 pages, usefulness 78.
Chapter 5: 19 pages, usefulness 94.
Chapter 6: 65 pages, usefulness 87.
Chapter 7: 41 pages, usefulness 76.
Chapter 8: 35 pages, usefulness 25.
Chapter 9: 70 pages, usefulness 92.
Chapter 10: 41 pages, usefulness 67.
Chapter 11: 47 pages, usefulness 18.
Chapter 12: 45 pages, usefulness 13.
Chapter 13: 26 pages, usefulness 88.
Chapter 14: 13 pages, usefulness 28.
Chapter 15: 83 pages, usefulness 77.
Chapter 16: 10 pages, usefulness 14.
Chapter 17: 33 pages, usefulness 29.
Chapter 18: 67 pages, usefulness 29.
Chapter 19: 14 pages, usefulness 29.
Chapter 20: 66 pages, usefulness 68.
Chapter 21: 74 pages, usefulness 92.
Chapter 22: 67 pages, usefulness 92.
Chapter 23: 31 pages, usefulness 75.
Chapter 24: 2 pages, usefulness 21.
Chapter 25: 89 pages, usefulness 97.
The TA must keep the total pages at or below 614 when selecting chapters.

Oh, and when you send the selection, you can just use this simple JSON layout:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is a list where each position matches a chapter in the order shown above — 1 means put that chapter in the packet, 0 means leave it out. Think of it as a quick form to fill in, not the final answer itself.

Also make sure you use identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [51, 73, 91, 34, 42, 19, 65, 41, 35, 70, 41, 47, 45, 26, 13, 83, 10, 33, 67, 14, 66, 74, 67, 31, 2, 89], 'profits': [33, 81, 20, 17, 78, 94, 87, 76, 25, 92, 67, 18, 13, 88, 28, 77, 14, 29, 29, 29, 68, 92, 92, 75, 21, 97], 'capacity': 614, 'solution': [0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1], 'objective': 1030, 'solve_time': 0.00034546852111816406, 'n_items': 26, 'R': 100, 'alpha': 0.5, 'instance_idx': 40, 'alpha_idx': 0}","[0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1]",1030,"{'problem_type': 'KP', 'capacity': 614, 'n_items': 26, 'items': [{'item_id': 0, 'weight': 51, 'profit': 33}, {'item_id': 1, 'weight': 73, 'profit': 81}, {'item_id': 2, 'weight': 91, 'profit': 20}, {'item_id': 3, 'weight': 34, 'profit': 17}, {'item_id': 4, 'weight': 42, 'profit': 78}, {'item_id': 5, 'weight': 19, 'profit': 94}, {'item_id': 6, 'weight': 65, 'profit': 87}, {'item_id': 7, 'weight': 41, 'profit': 76}, {'item_id': 8, 'weight': 35, 'profit': 25}, {'item_id': 9, 'weight': 70, 'profit': 92}, {'item_id': 10, 'weight': 41, 'profit': 67}, {'item_id': 11, 'weight': 47, 'profit': 18}, {'item_id': 12, 'weight': 45, 'profit': 13}, {'item_id': 13, 'weight': 26, 'profit': 88}, {'item_id': 14, 'weight': 13, 'profit': 28}, {'item_id': 15, 'weight': 83, 'profit': 77}, {'item_id': 16, 'weight': 10, 'profit': 14}, {'item_id': 17, 'weight': 33, 'profit': 29}, {'item_id': 18, 'weight': 67, 'profit': 29}, {'item_id': 19, 'weight': 14, 'profit': 29}, {'item_id': 20, 'weight': 66, 'profit': 68}, {'item_id': 21, 'weight': 74, 'profit': 92}, {'item_id': 22, 'weight': 67, 'profit': 92}, {'item_id': 23, 'weight': 31, 'profit': 75}, {'item_id': 24, 'weight': 2, 'profit': 21}, {'item_id': 25, 'weight': 89, 'profit': 97}]}","{'0': 0, '1': 0, '2': 0, '3': 0, '4': 1, '5': 1, '6': 1, '7': 1, '8': 0, '9': 1, '10': 1, '11': 0, '12': 0, '13': 1, '14': 1, '15': 0, '16': 1, '17': 0, '18': 0, '19': 1, '20': 0, '21': 1, '22': 1, '23': 1, '24': 1, '25': 1}",41,nl,0
KP,KP,"Recently I had to downsize a home bar and choose which bottles would make the best signature cocktails. The plan was to pick a set of distinct bottles that maximize overall guest enjoyment — you get that overall number by adding each selected bottle’s satisfaction rating — but their total space can’t overflow the cabinet. Nothing repeats, and the specific bottles and their numbers are shown below.

- **cabinet_capacity**: 751

| bottle_id | bottle_space | satisfaction_rating |
|---|---|---|
| A | 55 | 37 |
| B | 71 | 45 |
| C | 77 | 18 |
| D | 96 | 94 |
| E | 59 | 85 |
| F | 62 | 86 |
| G | 75 | 33 |
| H | 26 | 33 |
| I | 31 | 86 |
| J | 63 | 55 |
| K | 7 | 71 |
| L | 33 | 49 |
| M | 72 | 45 |
| N | 98 | 64 |
| O | 52 | 82 |
| P | 40 | 34 |
| Q | 45 | 81 |
| R | 69 | 25 |
| S | 55 | 41 |
| T | 3 | 92 |
| U | 54 | 96 |
| V | 41 | 93 |
| W | 71 | 32 |
| X | 88 | 85 |
| Y | 97 | 94 |
| Z | 62 | 98 |

Also, when I send the final picks I’ll drop them into a tiny JSON sketch so it’s clear which bottles I’m keeping — something simple like this:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Pretty straightforward: ""solution"" is an array with one entry per bottle in the order they were listed; a 1 means I keep that bottle, a 0 means I leave it. This JSON is just a sketch of the expected shape, not the actual answer.

Please make sure to use the exact identifiers from the instance input — no renaming and no new labels. 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [55, 71, 77, 96, 59, 62, 75, 26, 31, 63, 7, 33, 72, 98, 52, 40, 45, 69, 55, 3, 54, 41, 71, 88, 97, 62], 'profits': [37, 45, 18, 94, 85, 86, 33, 33, 86, 55, 71, 49, 45, 64, 82, 34, 81, 25, 41, 92, 96, 93, 32, 85, 94, 98], 'capacity': 751, 'solution': [0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1], 'objective': 1196, 'solve_time': 0.00033664703369140625, 'n_items': 26, 'R': 100, 'alpha': 0.5, 'instance_idx': 41, 'alpha_idx': 0}","[0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1]",1196,"{'problem_type': 'KP', 'capacity': 751, 'n_items': 26, 'items': [{'item_id': 'A', 'weight': 55, 'profit': 37}, {'item_id': 'B', 'weight': 71, 'profit': 45}, {'item_id': 'C', 'weight': 77, 'profit': 18}, {'item_id': 'D', 'weight': 96, 'profit': 94}, {'item_id': 'E', 'weight': 59, 'profit': 85}, {'item_id': 'F', 'weight': 62, 'profit': 86}, {'item_id': 'G', 'weight': 75, 'profit': 33}, {'item_id': 'H', 'weight': 26, 'profit': 33}, {'item_id': 'I', 'weight': 31, 'profit': 86}, {'item_id': 'J', 'weight': 63, 'profit': 55}, {'item_id': 'K', 'weight': 7, 'profit': 71}, {'item_id': 'L', 'weight': 33, 'profit': 49}, {'item_id': 'M', 'weight': 72, 'profit': 45}, {'item_id': 'N', 'weight': 98, 'profit': 64}, {'item_id': 'O', 'weight': 52, 'profit': 82}, {'item_id': 'P', 'weight': 40, 'profit': 34}, {'item_id': 'Q', 'weight': 45, 'profit': 81}, {'item_id': 'R', 'weight': 69, 'profit': 25}, {'item_id': 'S', 'weight': 55, 'profit': 41}, {'item_id': 'T', 'weight': 3, 'profit': 92}, {'item_id': 'U', 'weight': 54, 'profit': 96}, {'item_id': 'V', 'weight': 41, 'profit': 93}, {'item_id': 'W', 'weight': 71, 'profit': 32}, {'item_id': 'X', 'weight': 88, 'profit': 85}, {'item_id': 'Y', 'weight': 97, 'profit': 94}, {'item_id': 'Z', 'weight': 62, 'profit': 98}]}","{'A': 0, 'B': 0, 'C': 0, 'D': 1, 'E': 1, 'F': 1, 'G': 0, 'H': 0, 'I': 1, 'J': 1, 'K': 1, 'L': 1, 'M': 0, 'N': 0, 'O': 1, 'P': 1, 'Q': 1, 'R': 0, 'S': 0, 'T': 1, 'U': 1, 'V': 1, 'W': 0, 'X': 0, 'Y': 1, 'Z': 1}",42,markdown_table,names
KP,KP,"Someone at the store needs to decide which new gadgets get pride of place on the counter. The way to tell if a layout is good is by adding up the expected sales numbers of the chosen items — higher total means a better setup — while ensuring the combined footprint of those items stays within the available shelf space and each product is used only once. The full list of gadgets and the shelf size follow below.

Available countertop display space: 538.
Gadget A: display footprint 75, expected sales 29.
Gadget B: display footprint 100, expected sales 22.
Gadget C: display footprint 77, expected sales 66.
Gadget D: display footprint 24, expected sales 82.
Gadget E: display footprint 77, expected sales 30.
Gadget F: display footprint 11, expected sales 87.
Gadget G: display footprint 49, expected sales 58.
Gadget H: display footprint 63, expected sales 17.
Gadget I: display footprint 46, expected sales 37.
Gadget J: display footprint 70, expected sales 1.
Gadget K: display footprint 25, expected sales 4.
Gadget L: display footprint 61, expected sales 34.
Gadget M: display footprint 65, expected sales 46.
Gadget N: display footprint 64, expected sales 80.
Gadget O: display footprint 29, expected sales 14.
Gadget P: display footprint 31, expected sales 84.
Gadget Q: display footprint 26, expected sales 24.
Gadget R: display footprint 47, expected sales 14.
Gadget S: display footprint 59, expected sales 70.
Gadget T: display footprint 37, expected sales 78.
Gadget U: display footprint 41, expected sales 61.
Ensure the chosen gadgets' combined footprint does not exceed 538.

Oh, and when you send back your pick, just use this simple JSON shape so it's easy to check:

{
  ""solution"": [0, 1, 0, 1, ...]
}

""solution"" is just a list that lines up with the gadget list above — each position matches one gadget in that same order. A 1 means put that gadget on the counter, a 0 means leave it off. This JSON is only a sketch of the expected shape, not the actual answer.

Please use the exact identifiers from the instance input — do not rename items or invent new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [75, 100, 77, 24, 77, 11, 49, 63, 46, 70, 25, 61, 65, 64, 29, 31, 26, 47, 59, 37, 41], 'profits': [29, 22, 66, 82, 30, 87, 58, 17, 37, 1, 4, 34, 46, 80, 14, 84, 24, 14, 70, 78, 61], 'capacity': 538, 'solution': [0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1], 'objective': 773, 'solve_time': 0.0002956390380859375, 'n_items': 21, 'R': 100, 'alpha': 0.5, 'instance_idx': 42, 'alpha_idx': 0}","[0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1]",773,"{'problem_type': 'KP', 'capacity': 538, 'n_items': 21, 'items': [{'item_id': 'A', 'weight': 75, 'profit': 29}, {'item_id': 'B', 'weight': 100, 'profit': 22}, {'item_id': 'C', 'weight': 77, 'profit': 66}, {'item_id': 'D', 'weight': 24, 'profit': 82}, {'item_id': 'E', 'weight': 77, 'profit': 30}, {'item_id': 'F', 'weight': 11, 'profit': 87}, {'item_id': 'G', 'weight': 49, 'profit': 58}, {'item_id': 'H', 'weight': 63, 'profit': 17}, {'item_id': 'I', 'weight': 46, 'profit': 37}, {'item_id': 'J', 'weight': 70, 'profit': 1}, {'item_id': 'K', 'weight': 25, 'profit': 4}, {'item_id': 'L', 'weight': 61, 'profit': 34}, {'item_id': 'M', 'weight': 65, 'profit': 46}, {'item_id': 'N', 'weight': 64, 'profit': 80}, {'item_id': 'O', 'weight': 29, 'profit': 14}, {'item_id': 'P', 'weight': 31, 'profit': 84}, {'item_id': 'Q', 'weight': 26, 'profit': 24}, {'item_id': 'R', 'weight': 47, 'profit': 14}, {'item_id': 'S', 'weight': 59, 'profit': 70}, {'item_id': 'T', 'weight': 37, 'profit': 78}, {'item_id': 'U', 'weight': 41, 'profit': 61}]}","{'A': 0, 'B': 0, 'C': 1, 'D': 1, 'E': 0, 'F': 1, 'G': 1, 'H': 0, 'I': 1, 'J': 0, 'K': 0, 'L': 0, 'M': 1, 'N': 1, 'O': 0, 'P': 1, 'Q': 1, 'R': 0, 'S': 1, 'T': 1, 'U': 1}",43,nl,names
KP,KP,"There’s a sewing getaway coming up and only one small suitcase to fill, so the question becomes: which bolts should go in the bag to maximize how many different outfits can be created once cutting and pairing are done, while keeping the bag under the airline’s weight allowance? Each bolt counts only once — no duplicate bolts — and the best selection is the one that yields the most distinct garment combinations you can make from those fabrics; count each unique outfit when judging a pack. The concrete details appear below.

# suitcase_capacity_kg=568
bolt_id,bolt_weight_kg,bolt_outfit_value
A,12,25
B,40,28
C,46,48
D,100,89
E,29,23
F,20,67
G,95,46
H,16,12
I,3,72
J,43,84
K,41,58
L,62,18
M,88,16
N,94,43
O,29,51
P,99,56
Q,64,25
R,7,51
S,94,30
T,14,69
U,59,80
V,80,66

Oh, and to keep things machine-friendly, please send your final pick in this simple JSON shape so it's easy to read:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Think of ""solution"" as a checklist that goes bolt-by-bolt: a 1 means tuck that bolt into the suitcase, a 0 means leave it behind. This block is just a sketch of the shape I expect — not the real answer yet — so you'll replace that array with the actual 0/1 choices for the instance.

One more thing: use the exact identifiers from the instance input when you refer to items — no renaming, no made-up labels. For example: 
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [12, 40, 46, 100, 29, 20, 95, 16, 3, 43, 41, 62, 88, 94, 29, 99, 64, 7, 94, 14, 59, 80], 'profits': [25, 28, 48, 89, 23, 67, 46, 12, 72, 84, 58, 18, 16, 43, 51, 56, 25, 51, 30, 69, 80, 66], 'capacity': 568, 'solution': [1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1], 'objective': 823, 'solve_time': 0.00031304359436035156, 'n_items': 22, 'R': 100, 'alpha': 0.5, 'instance_idx': 43, 'alpha_idx': 0}","[1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1]",823,"{'problem_type': 'KP', 'capacity': 568, 'n_items': 22, 'items': [{'item_id': 'A', 'weight': 12, 'profit': 25}, {'item_id': 'B', 'weight': 40, 'profit': 28}, {'item_id': 'C', 'weight': 46, 'profit': 48}, {'item_id': 'D', 'weight': 100, 'profit': 89}, {'item_id': 'E', 'weight': 29, 'profit': 23}, {'item_id': 'F', 'weight': 20, 'profit': 67}, {'item_id': 'G', 'weight': 95, 'profit': 46}, {'item_id': 'H', 'weight': 16, 'profit': 12}, {'item_id': 'I', 'weight': 3, 'profit': 72}, {'item_id': 'J', 'weight': 43, 'profit': 84}, {'item_id': 'K', 'weight': 41, 'profit': 58}, {'item_id': 'L', 'weight': 62, 'profit': 18}, {'item_id': 'M', 'weight': 88, 'profit': 16}, {'item_id': 'N', 'weight': 94, 'profit': 43}, {'item_id': 'O', 'weight': 29, 'profit': 51}, {'item_id': 'P', 'weight': 99, 'profit': 56}, {'item_id': 'Q', 'weight': 64, 'profit': 25}, {'item_id': 'R', 'weight': 7, 'profit': 51}, {'item_id': 'S', 'weight': 94, 'profit': 30}, {'item_id': 'T', 'weight': 14, 'profit': 69}, {'item_id': 'U', 'weight': 59, 'profit': 80}, {'item_id': 'V', 'weight': 80, 'profit': 66}]}","{'A': 1, 'B': 1, 'C': 1, 'D': 1, 'E': 1, 'F': 1, 'G': 0, 'H': 1, 'I': 1, 'J': 1, 'K': 1, 'L': 0, 'M': 0, 'N': 0, 'O': 1, 'P': 0, 'Q': 0, 'R': 1, 'S': 0, 'T': 1, 'U': 1, 'V': 1}",44,csv,names
KP,KP,"On my commute I want the most bang for the buck from whatever I can fit in the slim pocket, so I pick titles whose combined reading value is highest. That’s done by totaling the value points of the chosen books and making sure the sum of their thicknesses doesn’t exceed the pocket’s space. Each book is either in or out and can’t be duplicated, and the exact measurements and value ratings follow below.

I have 434 thickness units in the slim pocket; below are each book's measurements and reading value points:
For 1 I note thickness 100 and reading value 77 points.
For 2 I note thickness 3 and reading value 36 points.
For 3 I note thickness 100 and reading value 33 points.
For 4 I note thickness 4 and reading value 79 points.
For 5 I note thickness 52 and reading value 69 points.
For 6 I note thickness 11 and reading value 84 points.
For 7 I note thickness 10 and reading value 91 points.
For 8 I note thickness 69 and reading value 83 points.
For 9 I note thickness 73 and reading value 94 points.
For 10 I note thickness 12 and reading value 42 points.
For 11 I note thickness 98 and reading value 40 points.
For 12 I note thickness 33 and reading value 33 points.
For 13 I note thickness 32 and reading value 24 points.
For 14 I note thickness 30 and reading value 75 points.
For 15 I note thickness 47 and reading value 72 points.
For 16 I note thickness 18 and reading value 81 points.
For 17 I note thickness 43 and reading value 17 points.
For 18 I note thickness 21 and reading value 50 points.
For 19 I note thickness 6 and reading value 23 points.
For 20 I note thickness 37 and reading value 90 points.
For 21 I note thickness 68 and reading value 27 points.
I'll pick the subset whose total thickness stays within 434 to maximize my combined reading value.

Oh, and when you send back which books I actually tuck into the pocket, please use this little JSON layout so it's easy to read:

{
  ""solution"": [0, 1, 0, 1, ...]
}

The ""solution"" array is one entry per book in the same order as the instance: a 1 means I slip that book into the pocket, a 0 means I leave it on the shelf. This block is just a sketch of the shape I want — not the final answer itself.

Please use the exact identifiers from the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [100, 3, 100, 4, 52, 11, 10, 69, 73, 12, 98, 33, 32, 30, 47, 18, 43, 21, 6, 37, 68], 'profits': [77, 36, 33, 79, 69, 84, 91, 83, 94, 42, 40, 33, 24, 75, 72, 81, 17, 50, 23, 90, 27], 'capacity': 434, 'solution': [0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0], 'objective': 1002, 'solve_time': 0.0002892017364501953, 'n_items': 21, 'R': 100, 'alpha': 0.5, 'instance_idx': 44, 'alpha_idx': 0}","[0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0]",1002,"{'problem_type': 'KP', 'capacity': 434, 'n_items': 21, 'items': [{'item_id': 1, 'weight': 100, 'profit': 77}, {'item_id': 2, 'weight': 3, 'profit': 36}, {'item_id': 3, 'weight': 100, 'profit': 33}, {'item_id': 4, 'weight': 4, 'profit': 79}, {'item_id': 5, 'weight': 52, 'profit': 69}, {'item_id': 6, 'weight': 11, 'profit': 84}, {'item_id': 7, 'weight': 10, 'profit': 91}, {'item_id': 8, 'weight': 69, 'profit': 83}, {'item_id': 9, 'weight': 73, 'profit': 94}, {'item_id': 10, 'weight': 12, 'profit': 42}, {'item_id': 11, 'weight': 98, 'profit': 40}, {'item_id': 12, 'weight': 33, 'profit': 33}, {'item_id': 13, 'weight': 32, 'profit': 24}, {'item_id': 14, 'weight': 30, 'profit': 75}, {'item_id': 15, 'weight': 47, 'profit': 72}, {'item_id': 16, 'weight': 18, 'profit': 81}, {'item_id': 17, 'weight': 43, 'profit': 17}, {'item_id': 18, 'weight': 21, 'profit': 50}, {'item_id': 19, 'weight': 6, 'profit': 23}, {'item_id': 20, 'weight': 37, 'profit': 90}, {'item_id': 21, 'weight': 68, 'profit': 27}]}","{'1': 0, '2': 1, '3': 0, '4': 1, '5': 1, '6': 1, '7': 1, '8': 1, '9': 1, '10': 1, '11': 0, '12': 1, '13': 0, '14': 1, '15': 1, '16': 1, '17': 0, '18': 1, '19': 1, '20': 1, '21': 0}",45,nl,1
KP,KP,"A friend asked for help deciding which lenses to take in a single shoulder bag for a wedding — the aim was to get the broadest creative coverage possible without busting the weight limit. The best selection is the one that yields the highest sum of each lens’s creative contribution (just add those numbers), while the total weight of those lenses stays under the bag’s capacity, and you cannot include the same lens more than once. The specific lens weights and values come next below.

# shoulder_bag_capacity=415
lens_id,lens_weight,lens_creative_value
0,57,75
1,88,83
2,92,35
3,10,17
4,33,3
5,16,15
6,31,7
7,54,87
8,29,27
9,7,83
10,52,56
11,6,54
12,23,46
13,1,82
14,9,5
15,44,10
16,86,43
17,78,40
18,10,55
19,4,74
20,34,59
21,66,26

If you want to hand the answer back in a tidy, machine-friendly way, just follow this little JSON sketch so it's easy to parse:

{
  ""solution"": [0, 1, 0, 1, ...]
}

The ""solution"" array is meant to list one entry per lens: 1 meaning ""pack this lens"" and 0 meaning ""leave it behind."" It's just the shape I expect — a lightweight sketch, not the final selection itself.

Also make sure to use the exact lens identifiers from the instance input — no renaming and no extra labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""

Once you fill that array with the actual picks, send it back and we'll be good to go.","{'problem_type': 'KP', 'weights': [57, 88, 92, 10, 33, 16, 31, 54, 29, 7, 52, 6, 23, 1, 9, 44, 86, 78, 10, 4, 34, 66], 'profits': [75, 83, 35, 17, 3, 15, 7, 87, 27, 83, 56, 54, 46, 82, 5, 10, 43, 40, 55, 74, 59, 26], 'capacity': 415, 'solution': [1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0], 'objective': 818, 'solve_time': 0.0003037452697753906, 'n_items': 22, 'R': 100, 'alpha': 0.5, 'instance_idx': 45, 'alpha_idx': 0}","[1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0]",818,"{'problem_type': 'KP', 'capacity': 415, 'n_items': 22, 'items': [{'item_id': 0, 'weight': 57, 'profit': 75}, {'item_id': 1, 'weight': 88, 'profit': 83}, {'item_id': 2, 'weight': 92, 'profit': 35}, {'item_id': 3, 'weight': 10, 'profit': 17}, {'item_id': 4, 'weight': 33, 'profit': 3}, {'item_id': 5, 'weight': 16, 'profit': 15}, {'item_id': 6, 'weight': 31, 'profit': 7}, {'item_id': 7, 'weight': 54, 'profit': 87}, {'item_id': 8, 'weight': 29, 'profit': 27}, {'item_id': 9, 'weight': 7, 'profit': 83}, {'item_id': 10, 'weight': 52, 'profit': 56}, {'item_id': 11, 'weight': 6, 'profit': 54}, {'item_id': 12, 'weight': 23, 'profit': 46}, {'item_id': 13, 'weight': 1, 'profit': 82}, {'item_id': 14, 'weight': 9, 'profit': 5}, {'item_id': 15, 'weight': 44, 'profit': 10}, {'item_id': 16, 'weight': 86, 'profit': 43}, {'item_id': 17, 'weight': 78, 'profit': 40}, {'item_id': 18, 'weight': 10, 'profit': 55}, {'item_id': 19, 'weight': 4, 'profit': 74}, {'item_id': 20, 'weight': 34, 'profit': 59}, {'item_id': 21, 'weight': 66, 'profit': 26}]}","{'0': 1, '1': 1, '2': 0, '3': 1, '4': 0, '5': 1, '6': 0, '7': 1, '8': 1, '9': 1, '10': 1, '11': 1, '12': 1, '13': 1, '14': 1, '15': 0, '16': 0, '17': 0, '18': 1, '19': 1, '20': 1, '21': 0}",46,csv,0
KP,KP,"There’s a small pickup, a pile of renovation gear, and a deadline — the question was which items to toss in so the job gets as far along as possible on that trip. The “how good” of a choice is just the total of each chosen item’s contribution to progress (just add them up), and the “how heavy” is the total of their weights (also add those up); the total weight must sit under the truck bed’s capacity, and each kind of material can only be included once. The concrete details will be shown below.

{
  ""truck_bed_capacity"": 520,
  ""items"": [
    {
      ""material_id"": ""A"",
      ""material_weight"": 76,
      ""progress_contribution"": 83
    },
    {
      ""material_id"": ""B"",
      ""material_weight"": 21,
      ""progress_contribution"": 7
    },
    {
      ""material_id"": ""C"",
      ""material_weight"": 51,
      ""progress_contribution"": 40
    },
    {
      ""material_id"": ""D"",
      ""material_weight"": 54,
      ""progress_contribution"": 70
    },
    {
      ""material_id"": ""E"",
      ""material_weight"": 76,
      ""progress_contribution"": 100
    },
    {
      ""material_id"": ""F"",
      ""material_weight"": 72,
      ""progress_contribution"": 86
    },
    {
      ""material_id"": ""G"",
      ""material_weight"": 47,
      ""progress_contribution"": 14
    },
    {
      ""material_id"": ""H"",
      ""material_weight"": 31,
      ""progress_contribution"": 99
    },
    {
      ""material_id"": ""I"",
      ""material_weight"": 37,
      ""progress_contribution"": 66
    },
    {
      ""material_id"": ""J"",
      ""material_weight"": 42,
      ""progress_contribution"": 18
    },
    {
      ""material_id"": ""K"",
      ""material_weight"": 22,
      ""progress_contribution"": 45
    },
    {
      ""material_id"": ""L"",
      ""material_weight"": 63,
      ""progress_contribution"": 92
    },
    {
      ""material_id"": ""M"",
      ""material_weight"": 21,
      ""progress_contribution"": 40
    },
    {
      ""material_id"": ""N"",
      ""material_weight"": 65,
      ""progress_contribution"": 19
    },
    {
      ""material_id"": ""O"",
      ""material_weight"": 76,
      ""progress_contribution"": 88
    },
    {
      ""material_id"": ""P"",
      ""material_weight"": 97,
      ""progress_contribution"": 96
    },
    {
      ""material_id"": ""Q"",
      ""material_weight"": 12,
      ""progress_contribution"": 98
    },
    {
      ""material_id"": ""R"",
      ""material_weight"": 76,
      ""progress_contribution"": 96
    },
    {
      ""material_id"": ""S"",
      ""material_weight"": 9,
      ""progress_contribution"": 88
    },
    {
      ""material_id"": ""T"",
      ""material_weight"": 34,
      ""progress_contribution"": 46
    },
    {
      ""material_id"": ""U"",
      ""material_weight"": 18,
      ""progress_contribution"": 20
    },
    {
      ""material_id"": ""V"",
      ""material_weight"": 17,
      ""progress_contribution"": 62
    },
    {
      ""material_id"": ""W"",
      ""material_weight"": 18,
      ""progress_contribution"": 23
    },
    {
      ""material_id"": ""X"",
      ""material_weight"": 5,
      ""progress_contribution"": 48
    }
  ]
}

If you want to send back which items you’d load, just follow this simple JSON layout:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is a list that lines up with the items in the story — 1 means you packed that item for the trip, 0 means you left it behind. Think of it as a quick checklist matching the order the instance gives. This is only a sketch of the expected shape, not the actual answer.

When the instance uses identifiers, use them exactly as shown in the input — no renaming and no new labels:
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [76, 21, 51, 54, 76, 72, 47, 31, 37, 42, 22, 63, 21, 65, 76, 97, 12, 76, 9, 34, 18, 17, 18, 5], 'profits': [83, 7, 40, 70, 100, 86, 14, 99, 66, 18, 45, 92, 40, 19, 88, 96, 98, 96, 88, 46, 20, 62, 23, 48], 'capacity': 520, 'solution': [0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1], 'objective': 1015, 'solve_time': 0.0003192424774169922, 'n_items': 24, 'R': 100, 'alpha': 0.5, 'instance_idx': 46, 'alpha_idx': 0}","[0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 1]",1015,"{'problem_type': 'KP', 'capacity': 520, 'n_items': 24, 'items': [{'item_id': 'A', 'weight': 76, 'profit': 83}, {'item_id': 'B', 'weight': 21, 'profit': 7}, {'item_id': 'C', 'weight': 51, 'profit': 40}, {'item_id': 'D', 'weight': 54, 'profit': 70}, {'item_id': 'E', 'weight': 76, 'profit': 100}, {'item_id': 'F', 'weight': 72, 'profit': 86}, {'item_id': 'G', 'weight': 47, 'profit': 14}, {'item_id': 'H', 'weight': 31, 'profit': 99}, {'item_id': 'I', 'weight': 37, 'profit': 66}, {'item_id': 'J', 'weight': 42, 'profit': 18}, {'item_id': 'K', 'weight': 22, 'profit': 45}, {'item_id': 'L', 'weight': 63, 'profit': 92}, {'item_id': 'M', 'weight': 21, 'profit': 40}, {'item_id': 'N', 'weight': 65, 'profit': 19}, {'item_id': 'O', 'weight': 76, 'profit': 88}, {'item_id': 'P', 'weight': 97, 'profit': 96}, {'item_id': 'Q', 'weight': 12, 'profit': 98}, {'item_id': 'R', 'weight': 76, 'profit': 96}, {'item_id': 'S', 'weight': 9, 'profit': 88}, {'item_id': 'T', 'weight': 34, 'profit': 46}, {'item_id': 'U', 'weight': 18, 'profit': 20}, {'item_id': 'V', 'weight': 17, 'profit': 62}, {'item_id': 'W', 'weight': 18, 'profit': 23}, {'item_id': 'X', 'weight': 5, 'profit': 48}]}","{'A': 0, 'B': 0, 'C': 0, 'D': 1, 'E': 1, 'F': 0, 'G': 0, 'H': 1, 'I': 1, 'J': 0, 'K': 1, 'L': 1, 'M': 1, 'N': 0, 'O': 1, 'P': 0, 'Q': 1, 'R': 1, 'S': 1, 'T': 0, 'U': 0, 'V': 1, 'W': 1, 'X': 1}",47,json,names
KP,KP,"Someone organized a drop-off and left a stack of potential donations; the volunteers must choose carefully what to accept. The aim is to end up with the highest possible total benefit for the community by summing the benefit of every accepted piece, but the pile we accept can’t exceed the room’s capacity in size or weight. Each item is a one-time decision: accept it or not, so nothing’s counted more than once. The exact list and figures are shown below.

- **storage_room_capacity**: 634

| donation_id | item_size_or_weight | community_benefit_score |
|---|---|---|
| 0 | 95 | 83 |
| 1 | 29 | 35 |
| 2 | 26 | 57 |
| 3 | 74 | 16 |
| 4 | 1 | 39 |
| 5 | 57 | 76 |
| 6 | 75 | 28 |
| 7 | 56 | 14 |
| 8 | 39 | 53 |
| 9 | 83 | 17 |
| 10 | 38 | 32 |
| 11 | 72 | 46 |
| 12 | 47 | 57 |
| 13 | 3 | 64 |
| 14 | 54 | 68 |
| 15 | 5 | 85 |
| 16 | 94 | 7 |
| 17 | 61 | 37 |
| 18 | 38 | 1 |
| 19 | 49 | 1 |
| 20 | 62 | 22 |
| 21 | 27 | 60 |
| 22 | 29 | 90 |
| 23 | 42 | 78 |
| 24 | 26 | 65 |
| 25 | 76 | 78 |
| 26 | 11 | 18 |

If you'd like to indicate which pieces to accept, just send your choice in this simple JSON shape:

{
  ""solution"": [0, 1, 0, 1, ...]
}

""solution"" is just a checklist: each position corresponds to an item in the pile in the same order they were listed earlier, with 1 meaning ""take this"" and 0 meaning ""leave it."" This is only a sketch of the shape I expect—fill in the actual 0/1 choices for the instance.

Also, please use any identifiers exactly as they appear in the instance input — no renaming and no new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [95, 29, 26, 74, 1, 57, 75, 56, 39, 83, 38, 72, 47, 3, 54, 5, 94, 61, 38, 49, 62, 27, 29, 42, 26, 76, 11], 'profits': [83, 35, 57, 16, 39, 76, 28, 14, 53, 17, 32, 46, 57, 64, 68, 85, 7, 37, 1, 1, 22, 60, 90, 78, 65, 78, 18], 'capacity': 634, 'solution': [1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1], 'objective': 1043, 'solve_time': 0.00033926963806152344, 'n_items': 27, 'R': 100, 'alpha': 0.5, 'instance_idx': 47, 'alpha_idx': 0}","[1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1]",1043,"{'problem_type': 'KP', 'capacity': 634, 'n_items': 27, 'items': [{'item_id': 0, 'weight': 95, 'profit': 83}, {'item_id': 1, 'weight': 29, 'profit': 35}, {'item_id': 2, 'weight': 26, 'profit': 57}, {'item_id': 3, 'weight': 74, 'profit': 16}, {'item_id': 4, 'weight': 1, 'profit': 39}, {'item_id': 5, 'weight': 57, 'profit': 76}, {'item_id': 6, 'weight': 75, 'profit': 28}, {'item_id': 7, 'weight': 56, 'profit': 14}, {'item_id': 8, 'weight': 39, 'profit': 53}, {'item_id': 9, 'weight': 83, 'profit': 17}, {'item_id': 10, 'weight': 38, 'profit': 32}, {'item_id': 11, 'weight': 72, 'profit': 46}, {'item_id': 12, 'weight': 47, 'profit': 57}, {'item_id': 13, 'weight': 3, 'profit': 64}, {'item_id': 14, 'weight': 54, 'profit': 68}, {'item_id': 15, 'weight': 5, 'profit': 85}, {'item_id': 16, 'weight': 94, 'profit': 7}, {'item_id': 17, 'weight': 61, 'profit': 37}, {'item_id': 18, 'weight': 38, 'profit': 1}, {'item_id': 19, 'weight': 49, 'profit': 1}, {'item_id': 20, 'weight': 62, 'profit': 22}, {'item_id': 21, 'weight': 27, 'profit': 60}, {'item_id': 22, 'weight': 29, 'profit': 90}, {'item_id': 23, 'weight': 42, 'profit': 78}, {'item_id': 24, 'weight': 26, 'profit': 65}, {'item_id': 25, 'weight': 76, 'profit': 78}, {'item_id': 26, 'weight': 11, 'profit': 18}]}","{'0': 1, '1': 1, '2': 1, '3': 0, '4': 1, '5': 1, '6': 0, '7': 0, '8': 1, '9': 0, '10': 0, '11': 0, '12': 1, '13': 1, '14': 1, '15': 1, '16': 0, '17': 1, '18': 0, '19': 0, '20': 0, '21': 1, '22': 1, '23': 1, '24': 1, '25': 1, '26': 1}",48,markdown_table,0
KP,KP,"Someone at the store has to decide which seasonal pieces to put out so the window looks irresistible without spilling over the allotted space. The best choice is the one that yields the greatest total appeal (add up the appeal values of the chosen items), provided the total space they occupy stays within the display limit and no single decoration is repeated. The exact item details are shown below.

- **display_space_limit**: 588

| decoration_id | space_occupied | appeal_value |
|---|---|---|
| 0 | 90 | 66 |
| 1 | 10 | 87 |
| 2 | 47 | 19 |
| 3 | 84 | 33 |
| 4 | 48 | 35 |
| 5 | 85 | 37 |
| 6 | 94 | 25 |
| 7 | 48 | 6 |
| 8 | 6 | 53 |
| 9 | 35 | 36 |
| 10 | 22 | 35 |
| 11 | 48 | 27 |
| 12 | 59 | 93 |
| 13 | 47 | 62 |
| 14 | 20 | 42 |
| 15 | 31 | 21 |
| 16 | 68 | 81 |
| 17 | 3 | 89 |
| 18 | 22 | 4 |
| 19 | 90 | 93 |
| 20 | 10 | 70 |
| 21 | 42 | 10 |
| 22 | 21 | 76 |
| 23 | 11 | 11 |
| 24 | 43 | 6 |
| 25 | 53 | 12 |
| 26 | 18 | 46 |
| 27 | 8 | 62 |
| 28 | 14 | 41 |

Oh, and when you send back the chosen set, keep it in a tiny, predictable JSON shape so it's easy to read and check. Something like this:

{
  ""solution"": [0, 1, 0, 1, ...]
}

Here ""solution"" is just a list that lines up with the items shown above — a 1 means ""put this decoration in the window"" and a 0 means ""leave it out."" Super simple, like ticking boxes on a checklist. This JSON is only a sketch of the shape I expect, not the actual selection you should send.

Please also make sure to use the exact identifiers from the instance input — no renaming and no new labels. For example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [90, 10, 47, 84, 48, 85, 94, 48, 6, 35, 22, 48, 59, 47, 20, 31, 68, 3, 22, 90, 10, 42, 21, 11, 43, 53, 18, 8, 14], 'profits': [66, 87, 19, 33, 35, 37, 25, 6, 53, 36, 35, 27, 93, 62, 42, 21, 81, 89, 4, 93, 70, 10, 76, 11, 6, 12, 46, 62, 41], 'capacity': 588, 'solution': [1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1], 'objective': 1078, 'solve_time': 0.0003407001495361328, 'n_items': 29, 'R': 100, 'alpha': 0.5, 'instance_idx': 48, 'alpha_idx': 0}","[1, 1, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1]",1078,"{'problem_type': 'KP', 'capacity': 588, 'n_items': 29, 'items': [{'item_id': 0, 'weight': 90, 'profit': 66}, {'item_id': 1, 'weight': 10, 'profit': 87}, {'item_id': 2, 'weight': 47, 'profit': 19}, {'item_id': 3, 'weight': 84, 'profit': 33}, {'item_id': 4, 'weight': 48, 'profit': 35}, {'item_id': 5, 'weight': 85, 'profit': 37}, {'item_id': 6, 'weight': 94, 'profit': 25}, {'item_id': 7, 'weight': 48, 'profit': 6}, {'item_id': 8, 'weight': 6, 'profit': 53}, {'item_id': 9, 'weight': 35, 'profit': 36}, {'item_id': 10, 'weight': 22, 'profit': 35}, {'item_id': 11, 'weight': 48, 'profit': 27}, {'item_id': 12, 'weight': 59, 'profit': 93}, {'item_id': 13, 'weight': 47, 'profit': 62}, {'item_id': 14, 'weight': 20, 'profit': 42}, {'item_id': 15, 'weight': 31, 'profit': 21}, {'item_id': 16, 'weight': 68, 'profit': 81}, {'item_id': 17, 'weight': 3, 'profit': 89}, {'item_id': 18, 'weight': 22, 'profit': 4}, {'item_id': 19, 'weight': 90, 'profit': 93}, {'item_id': 20, 'weight': 10, 'profit': 70}, {'item_id': 21, 'weight': 42, 'profit': 10}, {'item_id': 22, 'weight': 21, 'profit': 76}, {'item_id': 23, 'weight': 11, 'profit': 11}, {'item_id': 24, 'weight': 43, 'profit': 6}, {'item_id': 25, 'weight': 53, 'profit': 12}, {'item_id': 26, 'weight': 18, 'profit': 46}, {'item_id': 27, 'weight': 8, 'profit': 62}, {'item_id': 28, 'weight': 14, 'profit': 41}]}","{'0': 1, '1': 1, '2': 0, '3': 0, '4': 1, '5': 0, '6': 0, '7': 0, '8': 1, '9': 1, '10': 1, '11': 0, '12': 1, '13': 1, '14': 1, '15': 0, '16': 1, '17': 1, '18': 0, '19': 1, '20': 1, '21': 0, '22': 1, '23': 1, '24': 0, '25': 0, '26': 1, '27': 1, '28': 1}",49,markdown_table,0
KP,KP,"Many people forget how tight stall storage can be, so this time the vendor is carefully choosing recipes so the stall earns the most it can — total earnings equal the sum of chosen recipes’ profits — while the summed ingredient bulk of those recipes stays within the storage limit. Each recipe may be prepared at most once. The full list of recipe bulks and profits appears below.

- **stall_storage_capacity**: 572

| recipe_id | ingredient_bulk | recipe_profit |
|---|---|---|
| 1 | 20 | 93 |
| 2 | 86 | 18 |
| 3 | 97 | 81 |
| 4 | 76 | 98 |
| 5 | 11 | 33 |
| 6 | 82 | 50 |
| 7 | 70 | 54 |
| 8 | 53 | 50 |
| 9 | 15 | 29 |
| 10 | 100 | 98 |
| 11 | 45 | 96 |
| 12 | 5 | 39 |
| 13 | 21 | 81 |
| 14 | 41 | 40 |
| 15 | 7 | 80 |
| 16 | 33 | 59 |
| 17 | 47 | 48 |
| 18 | 95 | 13 |
| 19 | 9 | 66 |
| 20 | 58 | 33 |
| 21 | 92 | 22 |
| 22 | 81 | 20 |

Also, when you’re ready to share which recipes the stall will actually make, just drop it in a tiny JSON blob like this so it’s clear and easy to parse:

{
  ""solution"": [0, 1, 0, 1, ...]
}

The ""solution"" array is a simple row of 0s and 1s that correspond to the recipes listed above — 1 means “make this recipe,” 0 means “skip it.” Think of it like ticking boxes on a shopping list. This JSON is just a sketch of the shape I expect, not the final selection.

Please use the item identifiers exactly as they appear in the instance input — don’t rename them or add new labels.
- for example: ""Valid identifiers look like plain numbers such as “1” or “23”, single capital letters like “A” or “B”, or a capital letter followed by digits like “A1” or “X7”.""","{'problem_type': 'KP', 'weights': [20, 86, 97, 76, 11, 82, 70, 53, 15, 100, 45, 5, 21, 41, 7, 33, 47, 95, 9, 58, 92, 81], 'profits': [93, 18, 81, 98, 33, 50, 54, 50, 29, 98, 96, 39, 81, 40, 80, 59, 48, 13, 66, 33, 22, 20], 'capacity': 572, 'solution': [1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0], 'objective': 964, 'solve_time': 0.0003056526184082031, 'n_items': 22, 'R': 100, 'alpha': 0.5, 'instance_idx': 49, 'alpha_idx': 0}","[1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0]",964,"{'problem_type': 'KP', 'capacity': 572, 'n_items': 22, 'items': [{'item_id': 1, 'weight': 20, 'profit': 93}, {'item_id': 2, 'weight': 86, 'profit': 18}, {'item_id': 3, 'weight': 97, 'profit': 81}, {'item_id': 4, 'weight': 76, 'profit': 98}, {'item_id': 5, 'weight': 11, 'profit': 33}, {'item_id': 6, 'weight': 82, 'profit': 50}, {'item_id': 7, 'weight': 70, 'profit': 54}, {'item_id': 8, 'weight': 53, 'profit': 50}, {'item_id': 9, 'weight': 15, 'profit': 29}, {'item_id': 10, 'weight': 100, 'profit': 98}, {'item_id': 11, 'weight': 45, 'profit': 96}, {'item_id': 12, 'weight': 5, 'profit': 39}, {'item_id': 13, 'weight': 21, 'profit': 81}, {'item_id': 14, 'weight': 41, 'profit': 40}, {'item_id': 15, 'weight': 7, 'profit': 80}, {'item_id': 16, 'weight': 33, 'profit': 59}, {'item_id': 17, 'weight': 47, 'profit': 48}, {'item_id': 18, 'weight': 95, 'profit': 13}, {'item_id': 19, 'weight': 9, 'profit': 66}, {'item_id': 20, 'weight': 58, 'profit': 33}, {'item_id': 21, 'weight': 92, 'profit': 22}, {'item_id': 22, 'weight': 81, 'profit': 20}]}","{'1': 1, '2': 0, '3': 0, '4': 1, '5': 1, '6': 0, '7': 1, '8': 1, '9': 1, '10': 1, '11': 1, '12': 1, '13': 1, '14': 1, '15': 1, '16': 1, '17': 1, '18': 0, '19': 1, '20': 0, '21': 0, '22': 0}",50,markdown_table,1